def _generate_new_keypair(self):
secret = str(random.randrange(2 ** 256))
self.secret = hashlib.sha256(secret).hexdigest()
self.pubkey = privkey_to_pubkey(self.secret)
self.privkey = random_key()
self.btc_pubkey = privkey_to_pubkey(self.privkey)
print 'PUBLIC KEY: ', self.btc_pubkey
# Generate SIN
sha_hash = hashlib.sha256()
sha_hash.update(self.pubkey)
ripe_hash = hashlib.new('ripemd160')
ripe_hash.update(sha_hash.digest())
self.guid = ripe_hash.hexdigest()
self.sin = obelisk.EncodeBase58Check('\x0F\x02%s' % ripe_hash.digest())
newsettings = {
"secret": self.secret,
"pubkey": self.pubkey,
"privkey": self.privkey,
"guid": self.guid,
"sin": self.sin
}
self.db.updateEntries("settings", newsettings, {"market_id": self.market_id})
self.settings.update(newsettings)
def _generate_new_keypair(self):
secret = str(random.randrange(2**256))
self.secret = hashlib.sha256(secret).hexdigest()
self.pubkey = privkey_to_pubkey(self.secret)
self.privkey = random_key()
self.btc_pubkey = privkey_to_pubkey(self.privkey)
print 'PUBLIC KEY: ', self.btc_pubkey
# Generate SIN
sha_hash = hashlib.sha256()
sha_hash.update(self.pubkey)
ripe_hash = hashlib.new('ripemd160')
ripe_hash.update(sha_hash.digest())
self.guid = ripe_hash.hexdigest()
self.sin = obelisk.EncodeBase58Check('\x0F\x02%s' % ripe_hash.digest())
newsettings = {
"secret": self.secret,
"pubkey": self.pubkey,
"privkey": self.privkey,
"guid": self.guid,
"sin": self.sin
}
self.db.updateEntries("settings", newsettings,
{"market_id": self.market_id})
self.settings.update(newsettings)
def mk_stealth_tx_outputs(stealth_addr,
value,
ephem_privkey,
nonce,
network='btc'):
scan_pubkey, spend_pubkey = basic_stealth_address_to_pubkeys(stealth_addr)
if network == 'btc':
btc_magic_byte = 42
if stealth_addr != pubkeys_to_basic_stealth_address(
scan_pubkey, spend_pubkey, btc_magic_byte):
raise Exception('Invalid btc mainnet stealth address: ' +
stealth_addr)
magic_byte_addr = 0
elif network == 'testnet':
testnet_magic_byte = 43
if stealth_addr != pubkeys_to_basic_stealth_address(
scan_pubkey, spend_pubkey, testnet_magic_byte):
raise Exception('Invalid testnet stealth address: ' + stealth_addr)
magic_byte_addr = 111
ephem_pubkey = main.privkey_to_pubkey(ephem_privkey)
output0 = {
'script': mk_stealth_metadata_script(ephem_pubkey, nonce),
'value': 0
}
pay_pubkey = uncover_pay_pubkey_sender(scan_pubkey, spend_pubkey,
ephem_privkey)
pay_addr = main.pubkey_to_address(pay_pubkey, magic_byte_addr)
output1 = {'address': pay_addr, 'value': value}
return [output0, output1]
def get_settings(self):
"""Get local settings"""
self.log.info("Getting settings info for Market %s",
self.transport.market_id)
settings = self.db.getOrCreate("settings",
{"market_id": self.transport.market_id})
if settings['arbiter'] == 1:
settings['arbiter'] = True
if settings['notary'] == 1:
settings['notary'] = True
for key in ('notaries', 'trustedArbiters'):
# Fix key not found, None and empty string
value = settings.get(key) or '[]'
settings[key] = ast.literal_eval(value)
if 'secret' not in settings:
settings['privkey'] = ''
settings['btc_pubkey'] = privkey_to_pubkey(settings.get('privkey'))
settings['secret'] = settings.get('secret')
if settings:
return settings
else:
return {}
def get_settings(self):
"""Get local settings"""
self.log.info(
"Getting settings info for Market %s", self.transport.market_id)
settings = self.db.getOrCreate(
"settings",
{"market_id": self.transport.market_id})
if settings['arbiter'] == 1:
settings['arbiter'] = True
if settings['notary'] == 1:
settings['notary'] = True
for key in ('notaries', 'trustedArbiters'):
# Fix key not found, None and empty string
value = settings.get(key) or '[]'
settings[key] = ast.literal_eval(value)
if 'secret' not in settings:
settings['privkey'] = ''
settings['btc_pubkey'] = privkey_to_pubkey(settings.get('privkey'))
settings['secret'] = settings.get('secret')
if settings:
return settings
else:
return {}
def mk_stealth_tx_outputs(stealth_addr,
value,
ephem_privkey,
nonce,
network='btc'):
scan_pubkey, spend_pubkey = basic_stealth_address_to_pubkeys(stealth_addr)
if network == 'btc':
btc_magic_byte = 42
if stealth_addr != pubkeys_to_basic_stealth_address(
scan_pubkey, spend_pubkey, btc_magic_byte):
raise Exception('Invalid btc mainnet stealth address: ' +
stealth_addr)
magic_byte_addr = 0
elif network == 'testnet':
testnet_magic_byte = 43
if stealth_addr != pubkeys_to_basic_stealth_address(
scan_pubkey, spend_pubkey, testnet_magic_byte):
raise Exception('Invalid testnet stealth address: ' + stealth_addr)
magic_byte_addr = 111
ephem_pubkey = main.privkey_to_pubkey(ephem_privkey)
output0 = {'script': mk_stealth_metadata_script(ephem_pubkey, nonce),
'value': 0}
pay_pubkey = uncover_pay_pubkey_sender(scan_pubkey, spend_pubkey,
ephem_privkey)
pay_addr = main.pubkey_to_address(pay_pubkey, magic_byte_addr)
output1 = {'address': pay_addr, 'value': value}
return [output0, output1]
def __init__(self, pubkey_hex=None, privkey_hex=None):
"""
Convert the keys and initialize the cryptor implementation.
@param pubkey_hex: Uncompressed BTC public key in hex format.
@type pubkey_hex: str
@param privkey_hex: Compressed BTC private key in hex format.
@type privkey_hex: str
"""
if privkey_hex is None and pubkey_hex is None:
raise ValueError("Neither public nor private key was specified.")
if pubkey_hex is None:
pubkey_hex = arithmetic.privkey_to_pubkey(privkey_hex)
pubkey_bin = pubkey_to_pyelliptic(pubkey_hex)
self.has_privkey = privkey_hex is not None
if self.has_privkey:
privkey_bin = privkey_to_pyelliptic(privkey_hex)
else:
privkey_bin = None
self._ec = ec.ECC(
curve=BTC_CURVE,
pubkey=pubkey_bin,
privkey=privkey_bin
)
def getPubKey(privKey):
key = []
n = len(privKey)
for i in range(n):
pubKey = btc.privkey_to_pubkey(privKey[i])
key.append(pubKey)
return key
def __init__(self, pubkey_hex=None, privkey_hex=None):
"""
Convert the keys and initialize the cryptor implementation.
@param pubkey_hex: Uncompressed BTC public key in hex format.
@type pubkey_hex: str
@param privkey_hex: Compressed BTC private key in hex format.
@type privkey_hex: str
"""
if privkey_hex is None and pubkey_hex is None:
raise ValueError("Neither public nor private key was specified.")
if pubkey_hex is None:
pubkey_hex = arithmetic.privkey_to_pubkey(privkey_hex)
pubkey_bin = pubkey_to_pyelliptic(pubkey_hex)
self.has_privkey = privkey_hex is not None
if self.has_privkey:
privkey_bin = privkey_to_pyelliptic(privkey_hex)
else:
privkey_bin = None
self._ec = ec.ECC(curve=BTC_CURVE,
pubkey=pubkey_bin,
privkey=privkey_bin)
def setUpClass(cls):
cls.privkey_hex = (
'e9873d79c6d87dc0fb6a5778633389f4453213303da61f20bd67fc233aa33262')
cls.privkey_bin = crypto_util.privkey_to_pyelliptic(cls.privkey_hex)
cls.pubkey_hex = arithmetic.privkey_to_pubkey(cls.privkey_hex)
cls.pubkey_bin = crypto_util.pubkey_to_pyelliptic(cls.pubkey_hex)
cls.pubkey_hex_strip = cls.pubkey_hex[2:]
cls.plaintext = "YELLOW SUBMARINE"
def setUpClass(cls):
cls.privkey_hex = (
'e9873d79c6d87dc0fb6a5778633389f4453213303da61f20bd67fc233aa33262'
)
cls.privkey_bin = crypto_util.privkey_to_pyelliptic(cls.privkey_hex)
cls.pubkey_hex = arithmetic.privkey_to_pubkey(cls.privkey_hex)
cls.pubkey_bin = crypto_util.pubkey_to_pyelliptic(cls.pubkey_hex)
cls.pubkey_hex_strip = cls.pubkey_hex[2:]
cls.plaintext = "YELLOW SUBMARINE"
def _setup_settings(self):
try:
self.settings = self.db.selectEntries("settings", {"market_id": self.market_id})
except (OperationalError, DatabaseError) as e:
print e
raise SystemExit("database file %s corrupt or empty - cannot continue" % self.db.db_path)
if len(self.settings) == 0:
self.settings = {"market_id": self.market_id, "welcome": "enable"}
self.db.insertEntry("settings", self.settings)
else:
self.settings = self.settings[0]
# Generate PGP key during initial setup or if previous PGP gen failed
if not self.settings.get('PGPPubKey'):
try:
self.log.info('Generating PGP keypair. This may take several minutes...')
print 'Generating PGP keypair. This may take several minutes...'
gpg = gnupg.GPG()
input_data = gpg.gen_key_input(key_type="RSA",
key_length=2048,
name_email='*****@*****.**',
name_comment="Autogenerated by Open Bazaar",
passphrase="P@ssw0rd")
assert input_data is not None
key = gpg.gen_key(input_data)
assert key is not None
pubkey_text = gpg.export_keys(key.fingerprint)
newsettings = {"PGPPubKey": pubkey_text, "PGPPubkeyFingerprint": key.fingerprint}
self.db.updateEntries("settings", newsettings, {"market_id": self.market_id})
self.settings.update(newsettings)
self.log.info('PGP keypair generated.')
except Exception as e:
sys.exit("Encountered a problem with GPG: %s" % e)
if not self.settings.get('pubkey'):
# Generate Bitcoin keypair
self._generate_new_keypair()
if not self.settings.get('nickname'):
newsettings = {'nickname': 'Default'}
self.db.updateEntries('settings', newsettings, {"market_id": self.market_id})
self.settings.update(newsettings)
self.nickname = self.settings.get('nickname', '')
self.secret = self.settings.get('secret', '')
self.pubkey = self.settings.get('pubkey', '')
self.privkey = self.settings.get('privkey')
self.btc_pubkey = privkey_to_pubkey(self.privkey)
self.guid = self.settings.get('guid', '')
self.sin = self.settings.get('sin', '')
self.bitmessage = self.settings.get('bitmessage', '')
if not self.settings.get('bitmessage'):
# Generate Bitmessage address
if self.bitmessage_api is not None:
self._generate_new_bitmessage_address()
self.cryptor = Cryptor(pubkey_hex=self.pubkey, privkey_hex=self.secret)
# In case user wants to override with command line passed bitmessage values
if self.ob_ctx.bm_user is not None and \
self.ob_ctx.bm_pass is not None and \
self.ob_ctx.bm_port is not None:
self._connect_to_bitmessage()
# Address (m/1/0/0)
prv0100 = det.bip32_extract_key(xPrv0100)
pub0100 = det.bip32_extract_key(xPub0100)
adr0100 = btc.pubkey_to_address(pub0100, 0x00) # Depth-3의 공개키로 주소를 생성한다
# 결과 출력
print("\nDepth-3 (m/1/0/0) :")
print("\nxPrivate Key =", xPrv0100)
print("\nxPublic Key =", xPub0100)
print("\nPrivate Key =", prv0100)
print("Public Key =", pub0100)
print("Address =", adr0100)
# Depth-3의 공개키는 Private key로 생성한 것이 아님. Depth-2의 공개키로 생성한 것임.
# 그럼에도 불구하고 아래 관계가 성립해야함.
# prv0100 --> pub0100 관계를 확인한다.
pubKey = btc.privkey_to_pubkey(prv0100)
if pubKey == pub0100:
print("\nPrivate Key --> Public Key 관계가 잘 성립함.")
else:
print("\nPrivate Key --> Public Key 관계가 성립하지 않음.")
# Depth-3 (m/1/0/1~5)
print("\nDepth-3의 지갑 주소는 개인키 없이도 무수히 만들어 낼 수 있음.")
for i in range(1, 8):
xPub_i = det.bip32_ckd(xPub010, i)
pubKey_i = det.bip32_extract_key(xPub_i)
adr_i = btc.pubkey_to_address(pubKey_i, 0x00)
print("m/1/0/%d : %s" % (i, adr_i))
# 파이썬 실습 파일: 4-5.Bech32Address.py
# https://github.com/sipa/bech32/blob/master/ref/python/segwit_addr.py
# 배포용 실습 코드의 bitcoin 폴더가 있는 곳에서 실행한다.
import binascii
import bitcoin.main as btc
import bitcoin.segwit_addr as bech32
# 개인키를 생성한다
while (1):
privKey = btc.random_key() # 256 bit Random number를 생성한다
dPrivKey = btc.decode_privkey(privKey, 'hex') # 16진수 문자열을 10진수 숫자로 변환한다
if dPrivKey < btc.N: # secp256k1 의 N 보다 작으면 OK
break
privKey='860ef116221744a5299c99a0ed726c15a2148a21a341fe522399c84a59771cfe01'
# 개인키로 공개키를 생성한다. Compressed format.
pubKey = btc.privkey_to_pubkey(privKey)
cPubKey = btc.compress(pubKey)
# 공개키로 160-bit public key hash를 생성한다
witprog = btc.bin_hash160(binascii.unhexlify(cPubKey))
# BIP-173 주소를 생성한다. (Base32 address format for native v0-16 witness outputs)
# P2WPKH
mainnetAddr = bech32.encode('bc', 0, witprog)
testnetAddr = bech32.encode('tb', 0, witprog)
# 결과
print("\n\n공개키 :", cPubKey)
print("Bech32 주소 (Mainnet P2WPKH) :", mainnetAddr)
print("Bech32 주소 (Testnet P2WPKH) :", testnetAddr)
def _setup_settings(self):
try:
self.settings = self.db.selectEntries(
"settings", {"market_id": self.market_id})
except (OperationalError, DatabaseError) as e:
print e
raise SystemExit(
"database file %s corrupt or empty - cannot continue" %
self.db.db_path)
if len(self.settings) == 0:
self.settings = {"market_id": self.market_id, "welcome": "enable"}
self.db.insertEntry("settings", self.settings)
else:
self.settings = self.settings[0]
# Generate PGP key during initial setup or if previous PGP gen failed
if not self.settings.get('PGPPubKey'):
try:
self.log.info(
'Generating PGP keypair. This may take several minutes...')
print 'Generating PGP keypair. This may take several minutes...'
gpg = gnupg.GPG()
input_data = gpg.gen_key_input(
key_type="RSA",
key_length=2048,
name_email='*****@*****.**',
name_comment="Autogenerated by Open Bazaar",
passphrase="P@ssw0rd")
assert input_data is not None
key = gpg.gen_key(input_data)
assert key is not None
pubkey_text = gpg.export_keys(key.fingerprint)
newsettings = {
"PGPPubKey": pubkey_text,
"PGPPubkeyFingerprint": key.fingerprint
}
self.db.updateEntries("settings", newsettings,
{"market_id": self.market_id})
self.settings.update(newsettings)
self.log.info('PGP keypair generated.')
except Exception as e:
sys.exit("Encountered a problem with GPG: %s" % e)
if not self.settings.get('pubkey'):
# Generate Bitcoin keypair
self._generate_new_keypair()
if not self.settings.get('nickname'):
newsettings = {'nickname': 'Default'}
self.db.updateEntries('settings', newsettings,
{"market_id": self.market_id})
self.settings.update(newsettings)
self.nickname = self.settings.get('nickname', '')
self.secret = self.settings.get('secret', '')
self.pubkey = self.settings.get('pubkey', '')
self.privkey = self.settings.get('privkey')
self.btc_pubkey = privkey_to_pubkey(self.privkey)
self.guid = self.settings.get('guid', '')
self.sin = self.settings.get('sin', '')
self.bitmessage = self.settings.get('bitmessage', '')
if not self.settings.get('bitmessage'):
# Generate Bitmessage address
if self.bitmessage_api is not None:
self._generate_new_bitmessage_address()
self.cryptor = Cryptor(pubkey_hex=self.pubkey, privkey_hex=self.secret)
# In case user wants to override with command line passed bitmessage values
if self.ob_ctx.bm_user is not None and \
self.ob_ctx.bm_pass is not None and \
self.ob_ctx.bm_port is not None:
self._connect_to_bitmessage()
# package : pybitcointools (https://pypi.python.org/pypi/bitcoin written by vitalik
# you have to install bitcoin package using "pip install bitcoin
# ECDSA Test by wkim, 2019. 11. 09
import bitcoin.main as btc
d = btc.random_key()
Q = btc.privkey_to_pubkey(d)
G = btc.getG()
Gx = int(G[0])
Gy = int(G[1])
print("\n === d * G(x,y) = Q (x,y) ===\n")
print("\n ===Random_key : Private Key(d)=== \n\n", d,
"\n\n ===PrivKey Length(hexa)===\n", len(d))
print("\n ===Gx == \n", Gx)
print("\n ===Generator(Gx)=== \n", G[0])
#print("\n ===Len Gx===", len(Gx))
print("\n ===Generator(Gy)=== \n", G[1])
#print("\n ===Len Gy===", int(len(G[1])))
print("\n ===Public Key Q=d*G=== \n", Q, "\n\n ===Pubkey Len(hexa)===", len(Q))
message = "The input text message for testing ECDSA"
en_m = message.encode()
print("\n ===the result to encode this message===\n", en_m)
v, r, s = btc.ecdsa_raw_sign(btc.electrum_sig_hash(en_m), d)
print("\n ===ECDSA raw Signature Result(v)=== \n", v)
print("\n ===ECDSA raw Signature Result(r)=== \n", r)
print("\n ===ECDSA Signature Result(s)=== \n", s)
