def stealth_generate(filename): #Check to see if file is valid and does not already exist if type(filename) != str or len(filename) == 0: print("Stealth Address Generation Failed!") print("Please enter valid filename!") return if os.path.exists(filename): print("Stealth Address Generation Failed!") print("File \"" + filename + "\" already exists!") return #Get password for new keypair password = getpass() #Generate private keys print("Generating stealth address key pair...", end="") rng = SystemRandom() scan_key = (rng.getrandbits(256) % secp256k1.N).to_bytes(32, "big") pub_scan_key = secp256k1.privtopub(scan_key) js_scan = create_keyfile_json(scan_key, bytes(password, 'utf')) del scan_key spend_key = (rng.getrandbits(256) % secp256k1.N).to_bytes(32, "big") pub_spend_key = secp256k1.privtopub(spend_key) js_spend = create_keyfile_json(spend_key, bytes(password, 'utf')) del spend_key del password #Calculate Stealth Address and write to file with key pairs stealth_address = int.from_bytes( GetStealthAddressFromKeys(pub_scan_key, pub_spend_key), 'big') print("DONE!") print("New Stealth Address: " + hex(stealth_address)) print("Writing keystore file \"" + filename + "\"...", end="") with open(filename, mode='w') as file: js = "{\"stealth_address\":\"" + hex(stealth_address) + "\"," js += "\"scan_key\":" file.write(js) json.dump(js_scan, file) js = ",\"spend_key\":" file.write(js) json.dump(js_spend, file) js = "}" file.write(js) print("Done!")
def stealth_receive(directory): #Import Scan and Spend Key wallet = GetKeysFromFile(directory + 'wallet.json') scan_key = wallet['scan_key'] spend_key = wallet['spend_key'] del wallet pub_scan_key = secp256k1.privtopub(scan_key) pub_spend_key = secp256k1.privtopub(spend_key) stealth_address = GetStealthAddressFromKeys(pub_scan_key, pub_spend_key) print("Stealth Address Imported: " + hex(int.from_bytes(stealth_address, 'big'))) #Import Inputs File input_json = json.load(open(directory + "input.json")) print() print("Input Count: " + str(len(input_json["keys"]))) for key in input_json["keys"]: #Extract and pad address and key fields addr = key["address"][2:] while len(addr) < 40: addr = "0" + addr addr = bytes.fromhex(addr) key = key["key"][2:] while len(key) < 66: key = "0" + key key = bytes.fromhex(key) print("Testing " + hex(int.from_bytes(addr, 'big')) + " ... ", end="") point = ExpandPoint(key) ss = GetSharedSecret(point, scan_key) addr_exp = GetAddrFromSharedSecret(ss, pub_spend_key) if addr == addr_exp: print("HIT!") priv_key = GetPrivKeyFromSharedSecret(ss, spend_key) filename = "Keystore--" + hex(int.from_bytes(addr_exp, 'big'))[2:] + ".json" print("Creating " + filename + " ... ", end="") filename = directory + filename with open(filename, mode='w') as file: js = create_keyfile_json(int.to_bytes(priv_key, 32, 'big'), bytes(password, 'utf')) json.dump(js, file) print("COMPLETE!") else: print("MISS!") del scan_key del spend_key
def priv_to_addr(k): k = normalize_key(k) x, y = privtopub(k) addr = bytearray(sha3(encode_int32(x) + encode_int32(y))[12:]) addr[0] &= 0x0f addr[0] |= 0x10 return bytes(addr)
def get_pubkey(privkey): """Derives a public key from a private one. Args: privkey (int|bytes): the private key to derive the public one from. Returns: bytes: the corresponding public key """ # Checking key format if isinstance(privkey, int): privkey = privkey.to_bytes(sizeof(privkey), 'big') elif not isinstance(privkey, bytes): raise ValueError("Private key must be passed as int or bytes") # Checking key compression compressed = len(privkey) == 33 if compressed: privkey = privkey[:32] # Derivating key points (x, y) = secp256k1.privtopub(privkey) # Returning key in corresponding format if not compressed: pk = 0x04.to_bytes(1, 'big') + x.to_bytes(sizeof(x), 'big') + y.to_bytes(sizeof(y), 'big') else: if y%2: # y is odd, so point is greater than the midpoint pk = 0x03.to_bytes(1, 'big') + x.to_bytes(sizeof(x), 'big') else: # point is less than the midpoint pk = 0x02.to_bytes(1, 'big') + x.to_bytes(sizeof(x), 'big') return pk # type : bytes
def prestart(self): super().prestart() # geth is locked to user home home = os.path.expanduser("~") dagfile = os.path.join(home, '.ethash', 'full-R23-0000000000000000') if not os.path.exists(dagfile): raise Exception("Missing DAG {}. run {} makedag 0 {} to initialise ethminer before tests can be run".format( dagfile, self.geth_server, os.path.join(home, '.ethash'))) if self.settings['rpcport'] is None: self.settings['rpcport'] = get_unused_port() if self.settings['node_key'] is None: self.settings['node_key'] = "{:0>64}".format(binascii.b2a_hex(os.urandom(32)).decode('ascii')) if self.settings['ws'] is not None: self.settings['wsport'] = get_unused_port() pub_x, pub_y = privtopub(binascii.a2b_hex(self.settings['node_key'])) pub = encode_int32(pub_x) + encode_int32(pub_y) self.public_key = "{:0>128}".format(binascii.b2a_hex(pub).decode('ascii')) # write chain file write_chain_file(self.version, self.chainfile, self.author, self.difficulty) p = subprocess.Popen([self.geth_server, '--datadir', self.get_data_directory(), 'init', self.chainfile], stdout=subprocess.PIPE, stderr=subprocess.PIPE) outs, errs = p.communicate(timeout=15) with open(os.path.join(self.get_data_directory(), 'keystore', 'UTC--2017-02-06T16-16-34.720321115Z--de3d2d9dd52ea80f7799ef4791063a5458d13913'), 'w') as inf: inf.write('''{"address":"de3d2d9dd52ea80f7799ef4791063a5458d13913","crypto":{"cipher":"aes-128-ctr","ciphertext":"8d6528acfb366722d9c98f64435bb151f5671f9e4623e546cc7206382a1d54f7","cipherparams":{"iv":"de95c854face9aa50686370cc47d6025"},"kdf":"scrypt","kdfparams":{"dklen":32,"n":262144,"p":1,"r":8,"salt":"6baa74518f9cc34575c981e027154e9c714b400710478c587043c900a37a89b8"},"mac":"37b6d35ea394b129f07e9a90a09b8cc1356d731590201e84405f4592013b4333"},"id":"ce658bd4-6910-4eef-aa39-b32000c38ccc","version":3}''')
def get_pubkey_points(privkey): """Derives a public key from a private one. Args: privkey (int|bytes): the private key to derive the public one from. Returns: tuple: the points (x, y) of the public key on the secp256k1 curve """ if isinstance(privkey, int): if sizeof(privkey) == 33: # If compressed privkey = int.from_bytes(privkey.to_bytes(33, 'big')[:32], 'big') (x, y) = secp256k1.privtopub(privkey.to_bytes(sizeof(privkey), 'big')) elif isinstance(privkey, bytes): if len(privkey) == 33: # If compressed privkey = privkey[:32] (x, y) = secp256k1.privtopub(privkey) else: raise ValueError("privkey must be int or bytes") return (x, y)
def ecdsa_priv2pub(privkey: bytes, to_bytes: bool = True) -> Union[bytes, Tuple[int]]: """ Returns the public component of an ECDSA private key. :param privkey: Private key as an int or bytestring :param to_bytes: Serialize to bytes or not? :return: Byte encoded or Tuple[int] ECDSA pubkey """ pubkey = privtopub(privkey) if to_bytes: return ecdsa_pub2bytes(pubkey) return pubkey
def prestart(self): super(ParityServer, self).prestart() if self.settings['jsonrpc_port'] is None: self.settings['jsonrpc_port'] = get_unused_port() if self.version < (1, 7, 0) and self.settings[ 'no_dapps'] is False and self.settings['dapps_port'] is None: self.settings['dapps_port'] = get_unused_port() if self.settings['node_key'] is None: self.settings['node_key'] = "{:0>64}".format( binascii.b2a_hex(os.urandom(32)).decode('ascii')) pub_x, pub_y = privtopub(binascii.a2b_hex(self.settings['node_key'])) pub = encode_int32(pub_x) + encode_int32(pub_y) self.public_key = "{:0>128}".format( binascii.b2a_hex(pub).decode('ascii')) # write chain file write_chain_file(self.version, self.chainfile, self.faucet, self.difficulty)
def priv_to_pub(k): k = normalize_key(k) x, y = privtopub(k) return bytes(encode_int32(x) + encode_int32(y))
def ec_random_keys(): priv_key = random.randint(0, 2 ** 256).to_bytes(32, "big") pub_key = privtopub(priv_key) return priv_key, pub_key
def test_privtopub(): assert privtopub(priv) == pub
def priv_to_pub(priv): x, y = privtopub(priv) return x, y
def privkey_to_addr(key): key = normalize_key(key) x, y = privtopub(key) return sha3_256(encode_int32(x) + encode_int32(y))[12:]
def privToPub(priv): priv = int(priv, 16).to_bytes(32, 'big') res = secp256k1.privtopub(priv) x = res[0].to_bytes(32, 'big') y = res[1].to_bytes(32, 'big') return x + y
from py_ecc.secp256k1 import privtopub, ecdsa_raw_sign, ecdsa_raw_recover import binascii priv = binascii.unhexlify( '792eca682b890b31356247f2b04662bff448b6bb19ea1c8ab48da222c894ef9b') pub = ( 20033694065814990006010338153307081985267967222430278129327181081381512401190L, 72089573118161052907088366229362685603474623289048716349537937839432544970413L ) assert privtopub(priv) == pub v, r, s = ecdsa_raw_sign(b'\x35' * 32, priv) assert ecdsa_raw_recover(b'\x35' * 32, (v, r, s)) == pub print('secp256k1 tests passed')
def privtoaddr(k): k = normalize_key(k) x, y = privtopub(k) return sha3(encode_int32(x) + encode_int32(y))[12:]
def private_key_to_address(privkey): k = normalize_key(privkey) x, y = privtopub(k) return sha3.keccak_256(encode_int32(x) + encode_int32(y)).digest()[12:]