def fiat_shamir(fs_state: bytes, data: Union[List[Point], List[Scalar]], nret=2) -> Tuple[bytes, List[Scalar]]: """ Generates nret integer chllange values from the currnet interaction (data) and the previous challenge values (self.fs_state), thus fulfilling the requirement of basing the challenge on the transcript of the prover-verifier communication up to this point """ # Point type if isinstance(data[0], tuple): data_bs: bytes = reduce(lambda acc, x: acc + B.encode_pubkey(x, 'bin'), data, b"") # Scalar type elif isinstance(data[0], int): data_bs: bytes = reduce( lambda acc, x: acc + B.encode_privkey(x, 'bin'), data, b"") else: raise Exception('Invalid `data` param type for fiat_shamir') xb: bytes = hashlib.sha256(fs_state + data_bs).digest() challenges: List[Scalar] = [] for _ in range(nret): challenges.append(B.encode_privkey(xb, 'decimal')) xb = hashlib.sha256(xb).digest() return xb, challenges
def create_wallet(self, method, input, aes_pw): privkey = '' if method == 'wif': fmt = bc.get_privkey_format(input) if fmt == 'wif': privkey = bc.encode_privkey(input, 'hex') elif fmt == 'wif_compressed': privkey = bc.encode_privkey(input, 'hex_compressed') else: raise Exception('Unrecoginized format for private key.') elif method == 'random': privkey = bc.random_key() else: raise Exception('Unsupported method: {0}.'.format(method)) wal_addr = bc.privtoaddr(privkey, self.magic_byte) encr_privkey = wallet.encrypt_privkey(privkey, aes_pw) wallet.create_wallet_file(self.wallet_filename, encr_privkey, wal_addr) # Read back from wallet to ensure consistency encr_privkey2, wal_addr2 = wallet.read_from_wallet_file(self.wallet_filename) privkey2 = wallet.decrypt_privkey(encr_privkey2, aes_pw) if encr_privkey2 != encr_privkey or wal_addr2 != wal_addr: raise Exception('Inconsistency in reading from/writing to wallet!') if privkey2 != privkey: raise Exception('Inconsistency in encrypting/decrypting private key!') return
def to_wif(self): if self._compressed: return encode_privkey( self._ecdsa_private_key.to_string(), 'wif_compressed') else: return b58check_encode( self.to_bin(), version_byte=self.wif_version_byte())
def _decode_private_key(encoded_private_key, encoding_format='wif'): """ Args: encoded_private_key: an encoded private key string encoding_format: string indicating format such as 'wif' Returns: priv (bytes): bytes representation of the private key """ if encoding_format == 'wif': # int to hex string priv = pybitcointools.encode_privkey(encoded_private_key, 'hex') # hex string to bytes try: # check python 3 priv = priv.to_bytes(32, byteorder='big') except AttributeError: priv = binascii.unhexlify(priv) elif encoding_format == 'hex': try: priv = encoded_private_key.to_bytes(32, byteorder='big') except AttributeError: priv = binascii.unhexlify(encoded_private_key) elif encoding_format == 'bytes': priv = encoded_private_key else: raise TypeError("unsupported private key format") return secp256k1.PrivateKey(priv, ctx=__CTX__)
def do_init(config, username=None): if username is None: username = config.get('DEFAULT', 'username') config.set('DEFAULT', 'username', username) print "set username: {}".format(username) save_config(config) wif_filename = config.get('DEFAULT', 'key_file') if wif_filename.endswith(".wif"): addr_filename = wif_filename[0:-len(".wif")] + ".addr" else: addr_filename = wif_filename + ".addr" if not os.path.exists(wif_filename): try: if not os.path.exists(os.path.dirname(wif_filename)): os.makedirs(os.path.dirname(wif_filename)) privkey = pybitcointools.random_key() encoded = pybitcointools.encode_privkey(privkey, 'wif') addr = pybitcointools.privtoaddr(privkey) with open(wif_filename, "w") as wif_fd: print "writing file: {}".format(wif_filename) wif_fd.write(encoded) wif_fd.write("\n") with open(addr_filename, "w") as addr_fd: print "writing file: {}".format(addr_filename) addr_fd.write(addr) addr_fd.write("\n") except IOError, ioe: raise AcException("IOError: {}".format(str(ioe)))
def multiply_privkeys(p1, p2, n): f1, f2 = get_privkey_format(p1), get_privkey_format(p2) p = decode_privkey(p1, f1) while n > 0: p = (p + decode_privkey(p2, f2)) % N n -= 1 return encode_privkey(p, f1)
def _decode_privkey(encoded_privkey, encoding_format='wif'): """ Args: encoded_privkey: an encoded private key string encoding_format: string indicating format such as 'wif' Returns: priv (bytes): bytes representation of the private key """ if encoding_format == 'wif': # int to hex string priv = pybitcointools.encode_privkey(encoded_privkey, 'hex') # hex string to bytes try: # check python 3 priv = priv.to_bytes(32, byteorder='big') except AttributeError: priv = binascii.unhexlify(priv) elif encoding_format == 'hex': try: priv = encoded_privkey.to_bytes(32, byteorder='big') except AttributeError: priv = binascii.unhexlify(encoded_privkey) else: raise TypeError("unsupported private key format") return secp256k1.PrivateKey(priv, ctx=__CTX__)
def create_signup_info(cls, originator_public_key_hash, most_recent_wait_certificate_id): with cls._lock: # First we need to create a public/private key pair for the PoET # enclave to use. cls._poet_private_key = pybitcointools.random_key() cls._poet_public_key = \ pybitcointools.privtopub(cls._poet_private_key) cls._active_wait_timer = None # We are going to fake out the sealing the signup data. signup_data = { 'poet_public_key': pybitcointools.encode_pubkey(cls._poet_public_key, 'hex'), 'poet_private_key': pybitcointools.encode_privkey(cls._poet_private_key, 'hex') } sealed_signup_data = \ pybitcointools.base64.b64encode(dict2json(signup_data)) # Create a fake report report_data = { 'originator_public_key_hash': originator_public_key_hash.upper(), 'poet_public_key': pybitcointools.encode_pubkey(cls._poet_public_key, 'hex').upper() } report = { 'report_data': pybitcointools.sha256(dict2json(report_data)) } # Fake our "proof" data. verification_report = { 'enclave_quote': pybitcointools.base64.b64encode(dict2json(report)), 'pse_manifest_hash': pybitcointools.base64.b64encode( pybitcointools.sha256('manifest destiny')), 'nonce': most_recent_wait_certificate_id } proof_data = { 'verification_report': dict2json(verification_report), 'signature': pybitcointools.ecdsa_sign(dict2json(verification_report), cls._report_private_key) } proof_data_dict = dict2json(proof_data) return \ EnclaveSignupInfo( poet_public_key=signup_data['poet_public_key'], proof_data=proof_data_dict, anti_sybil_id=originator_public_key_hash, sealed_signup_data=sealed_signup_data)
def _encode_privkey(privkey, encoding_format='wif'): try: # check python3 priv = int.from_bytes(privkey.private_key, byteorder='big') except AttributeError: priv = binascii.hexlify(privkey.private_key) encoded = pybitcointools.encode_privkey(priv, encoding_format) return encoded
def get_shared_secret(server_pub_key, private_key): user_pub_key = get_pub_key(private_key) network_code = get_network_code(private_key) uncompressed_user_key = binascii.unhexlify(pybitcointools.decompress(user_pub_key)) uncompressed_server_key = binascii.unhexlify(pybitcointools.decompress(server_pub_key)) user_priv_key_bin = binascii.unhexlify(pybitcointools.encode_privkey(private_key, 'hex', network_code)) user = pyelliptic.ECC(privkey=user_priv_key_bin, pubkey=uncompressed_user_key, curve='secp256k1') shared_secret = user.get_ecdh_key(uncompressed_server_key) return shared_secret
def on_validator_discovered(self, url): # We need a key file for the client, but as soon as the client is # created, we don't need it any more. Then create a new client and # add it to our cadre of clients to use keystring = pybitcointools.encode_privkey( pybitcointools.random_key(), 'wif') self._clients.append(IntegerKeyClient( baseurl=url, keystring=keystring))
def get_wif_privkey(self, pw): if not self.is_wallet_loaded: raise Exception('Tried getting private key when wallet not loaded.') prv = '' try: prv = wallet.decrypt_privkey(self.encr_privkey, pw) except: raise PasswordError("Wrong password!") frm = bc.get_privkey_format(prv) if frm == 'hex': wif_privkey = bc.encode_privkey(prv, 'wif', self.magic_byte) elif frm == 'hex_compressed': wif_privkey = bc.encode_privkey(prv, 'wif_compressed', self.magic_byte) else: raise Exception('Unrecognized private key format: ' + frm) return wif_privkey
def load_config(): home = os.path.expanduser("~") real_user = getpass.getuser() config_file = os.path.join(home, ".sawtooth", "libor.cfg") key_dir = os.path.join(home, ".sawtooth", "keys") config = ConfigParser.SafeConfigParser() config.set('DEFAULT', 'url', 'http://localhost:8800') config.set('DEFAULT', 'key_dir', key_dir) config.set('DEFAULT', 'key_file', '%(key_dir)s/%(username)s.wif') config.set('DEFAULT', 'username', real_user) # If we already have a config file, then read it. Otherwise, # we are going to write a default one. if os.path.exists(config_file): config.read(config_file) else: if not os.path.exists(os.path.dirname(config_file)): os.makedirs(os.path.dirname(config_file)) with open("{}.new".format(config_file), "w") as fd: config.write(fd) os.rename("{}.new".format(config_file), config_file) # If the key file does not already exist, then we are going # to generate one wif_filename = config.get('DEFAULT', 'key_file') if wif_filename.endswith(".wif"): addr_filename = wif_filename[0:-len(".wif")] + ".addr" else: addr_filename = wif_filename + ".addr" if not os.path.exists(wif_filename): try: if not os.path.exists(os.path.dirname(wif_filename)): os.makedirs(os.path.dirname(wif_filename)) private_key = pybitcointools.random_key() encoded_key = pybitcointools.encode_privkey(private_key, 'wif') addr = pybitcointools.privtoaddr(private_key) with open(wif_filename, "w") as wif_fd: wif_fd.write(encoded_key) wif_fd.write("\n") with open(addr_filename, "w") as addr_fd: addr_fd.write(addr) addr_fd.write("\n") except IOError as ioe: raise LIBORClientException("IOError: {}".format(str(ioe))) return config
def test_pbt_match(self): """ Tests matching results between pybitcointools and native ECDSA key recovery """ # This key has a small public key value which tests padding wifstr = '5JtMb6tmM9vT6QHyM7RR8pjMViqccukgMFNCPvG5xhLVf6CMoGx' priv = pbt.encode_privkey(pbt.decode_privkey(wifstr, 'wif'), 'hex') msg = 'foo' sig = pbt.ecdsa_sign(msg, priv) native_recovered = pbct_nativerecover.recover_pubkey(msg, sig) py_recovered = pbt.ecdsa_recover(msg, sig) self.assertEquals(native_recovered, py_recovered)
def bytes_to_xes(b: bytes) -> Tuple[Scalar, Scalar, Scalar, Scalar]: """ Convinient function Converts bytes to a scalar (x), and calculates x, x^2, inv(x), and inv(x^2) """ x: Scalar = B.encode_privkey(b, 'decimal') % B.N x_sq: Scalar = pow(x, 2, B.N) xinv: Scalar = modinv(x, B.N) xinv_sq: Scalar = pow(xinv, 2, B.N) return (x, x_sq, xinv, xinv_sq)
def do_init(args, config): username = config.get('DEFAULT', 'username') if args.username is not None: if len(args.username) < 3 or len(args.username) > 16: raise ClientException( "username must be between 3 and 16 characters") username = args.username config.set('DEFAULT', 'username', username) print "set username: {}".format(username) else: print "Username: {}".format(username) http_url = config.get('DEFAULT', 'url') if args.url is not None: http_url = args.url config.set('DEFAULT', 'url', http_url) print "set url to {}".format(http_url) else: print "Validator url: {}".format(http_url) save_config(config) wif_filename = config.get('DEFAULT', 'key_file') if wif_filename.endswith(".wif"): addr_filename = wif_filename[0:-len(".wif")] + ".addr" else: addr_filename = wif_filename + ".addr" if not os.path.exists(wif_filename): try: if not os.path.exists(os.path.dirname(wif_filename)): os.makedirs(os.path.dirname(wif_filename)) privkey = pybitcointools.random_key() encoded = pybitcointools.encode_privkey(privkey, 'wif') addr = pybitcointools.privtoaddr(privkey) with open(wif_filename, "w") as wif_fd: print "writing file: {}".format(wif_filename) wif_fd.write(encoded) wif_fd.write("\n") with open(addr_filename, "w") as addr_fd: print "writing file: {}".format(addr_filename) addr_fd.write(addr) addr_fd.write("\n") except IOError, ioe: raise ClientException("IOError: {}".format(str(ioe)))
def on_validator_discovered(self, url): # We need a key file for the client, but as soon as the client is # created, we don't need it any more, so a temporary file is # sufficient key_file = NamedTemporaryFile() private_key = pybitcointools.random_key() encoded_key = pybitcointools.encode_privkey(private_key, 'wif') key_file.write(encoded_key) key_file.write('\n') key_file.flush() # Create a new client and add it to our cadre of clients to use self._clients.append(XoClient(url, key_file.name)) # Closing the temporary file will cause it to also be deleted key_file.close()
def test_compressed_keys(self): """ Tests compressed key """ msg = 'foo' priv = pbt.encode_privkey(pbt.random_key(), 'hex_compressed') sig = pbt.ecdsa_sign(msg, priv) # Force old pybitcointools to behave v, r, s = pbt.decode_sig(sig) if v < 31: v += 4 sig = pbt.encode_sig(v, r, s) pub = pbt.compress(pbt.privtopub(priv)) native_recovered = pbct_nativerecover.recover_pubkey(msg, sig) self.assertEquals(native_recovered, pub, "Priv Key that failed: {}".format(priv))
def _create_temporary_key_file(): """ A useful helper method for derived classes. Remember to close the returned temporary file so that it gets deleted. Returns: A NamedTemporaryFile object. """ key_file = NamedTemporaryFile() private_key = pybitcointools.random_key() encoded_key = pybitcointools.encode_privkey(private_key, 'wif') key_file.write(encoded_key) key_file.write('\n') key_file.flush() return key_file
def test_compressed_keys(self): """ Tests compressed key """ msg = 'foo' self.longMessage = True priv = pbt.encode_privkey(pbt.random_key(), 'hex_compressed') sig = pbt.ecdsa_sign(msg, priv) # Force old pybitcointools to behave v, r, s = pbt.decode_sig(sig) if v < 31: v += 4 sig = pbt.encode_sig(v, r, s) pub = pbt.compress(pbt.privtopub(priv)) native_recovered = gossip.signed_object.get_verifying_key(msg, sig) self.assertEquals(native_recovered, pub, "Priv Key that failed: {}".format(priv))
def __init__(self, private_key=None, compressed=False): """ Takes in a private key/secret exponent. """ self._compressed = compressed if not private_key: secret_exponent = random_secret_exponent(self._curve.order) else: secret_exponent = encode_privkey(private_key, 'decimal') if get_privkey_format(private_key).endswith('compressed'): self._compressed = True # make sure that: 1 <= secret_exponent < curve_order if not is_secret_exponent(secret_exponent, self._curve.order): raise IndexError(_errors["EXPONENT_OUTSIDE_CURVE_ORDER"]) self._ecdsa_private_key = ecdsa.keys.SigningKey.from_secret_exponent( secret_exponent, self._curve, self._hash_function )
def setup(self): self.state = mktplace_state.MarketPlaceState(self.urls[0]) with Progress("Creating participants") as p: for i in range(0, self.count): name = "actor-{}".format(i) keyfile = os.path.join(self.testDir, "{}.wif".format(name)) if os.path.exists(keyfile): key = read_key_file(keyfile) else: key = pybitcointools.encode_privkey( pybitcointools.random_key(), 'wif') write_key_file(keyfile, key) url = self.urls[random.randint(0, len(self.urls) - 1)] a = MktActor(name, url, key) self.Actors.append(a) p.step() with Progress("Registering actors assets") as p: for a in self.Actors: # create assets a.register_asset(a.Name + "-asset") p.step() self.wait_for_transaction_commits() with Progress("Registering holdings") as p: for a in self.Actors: a.update() a.offers = [] for a2 in self.Actors: count = 0 if a is a2: # for each iteration we need 1 to pay with and 1 to # give count = 2 * self.count * self.iterations for ast in a2.assets.keys(): a.register_holding(ast, count) p.step() self.wait_for_transaction_commits()
def create_signup_info(cls, originator_public_key): # First we need to create a public/private key pair for the PoET # enclave to use. cls._poet_private_key = pybitcointools.random_key() cls._poet_public_key = pybitcointools.privtopub(cls._poet_private_key) cls._active_wait_timer = None # We are going to fake out the sealing the signup data. signup_data = { 'poet_public_key': pybitcointools.encode_pubkey(cls._poet_public_key, 'hex'), 'poet_private_key': pybitcointools.encode_privkey(cls._poet_private_key, 'hex') } sealed_signup_data = \ pybitcointools.base64.b32encode(dict2json(signup_data)) # Create a fake report report_data = { 'originator_public_key_hash': pybitcointools.sha256( pybitcointools.encode_pubkey(originator_public_key, 'hex')), 'poet_public_key': pybitcointools.encode_pubkey(cls._poet_public_key, 'hex') } report = {'report_data': pybitcointools.sha256(dict2json(report_data))} report = pybitcointools.base64.b32encode(dict2json(report)) # Fake our "proof" data. proof_data = { 'attestation_evidence_payload': pybitcointools.sha256(report), 'attestation_verification_report': pybitcointools.sha256('Shave and a haircut...Two bits!') } return \ EnclaveSignupInfo( anti_sybil_id='Sally Field', poet_public_key=signup_data['poet_public_key'], proof_data=proof_data, sealed_signup_data=sealed_signup_data)
def _decode_privkey(encoded_privkey, encoding_format='wif'): """ Args: encoded_privkey: an encoded private key string encoding_format: string indicating format such as 'wif' Returns: private key object useable with this module """ if encoding_format == 'wif': # base58 to int priv = pybitcointools.decode_privkey(encoded_privkey, encoding_format) # int to hex string priv = pybitcointools.encode_privkey(priv, 'hex') # hex string to bytes try: # check python 3 priv = priv.to_bytes(32, byteorder='big') except AttributeError: priv = binascii.unhexlify(priv) else: raise TypeError("unsupported private key format") return secp256k1.PrivateKey(priv)
def do_init(args, config): username = config.get('DEFAULT', 'username') if args.username is not None: username = args.username config.set('DEFAULT', 'username', username) print "set username: {}".format(username) save_config(config) wif_filename = config.get('DEFAULT', 'key_file') if wif_filename.endswith(".wif"): addr_filename = wif_filename[0:-len(".wif")] + ".addr" else: addr_filename = wif_filename + ".addr" if not os.path.exists(wif_filename): try: if not os.path.exists(os.path.dirname(wif_filename)): os.makedirs(os.path.dirname(wif_filename)) privkey = pybitcointools.random_key() encoded = pybitcointools.encode_privkey(privkey, 'wif') addr = pybitcointools.privtoaddr(privkey) with open(wif_filename, "w") as wif_fd: print "writing file: {}".format(wif_filename) wif_fd.write(encoded) wif_fd.write("\n") with open(addr_filename, "w") as addr_fd: print "writing file: {}".format(addr_filename) addr_fd.write(addr) addr_fd.write("\n") except IOError, ioe: raise XoException("IOError: {}".format(str(ioe)))
import pybitcointools import sys if __name__ == "__main__": if len(sys.argv) >= 2: priv_key = sys.argv[ 1] #"LmB72UZvRmJ5cUPZWpxqYWW5KkCgASa53GZQNhWNTPzJ9J1R4T8x" priv_data = pybitcointools.decode_privkey(priv_key) print(pybitcointools.encode_privkey(priv_data, "wif_compressed")) print(pybitcointools.privtoaddr(priv_key)) else: print("Usage: %s [private_key]" % sys.argv[0])
def main(args=sys.argv[1:]): parser = argparse.ArgumentParser() # The intent is that node_name and keydir both be optional at some # future point, by reading in the appropriate values from the config # file. Therefore, no default is currently set and both are marked # as required so that the future usage of using config values as # defaults can be added without breaking anything. parser.add_argument('node_name', help="name of the node") parser.add_argument('--keydir', help="directory to write key files", required=True) parser.add_argument('-f', '--force', help="overwrite files if they exist", action='store_true') parser.add_argument('-q', '--quiet', help="print no output", action='store_true') options = parser.parse_args(args) base_filename = os.path.join(options.keydir, options.node_name) wif_filename = base_filename + ".wif" addr_filename = base_filename + ".addr" if not os.path.isdir(options.keydir): print >> sys.stderr, "no such directory: {}".format(options.keydir) sys.exit(1) if not options.force: file_exists = False for filename in [wif_filename, addr_filename]: if os.path.exists(filename): file_exists = True print >> sys.stderr, "file exists: {}".format(filename) if file_exists: print >> sys.stderr, \ "rerun with --force to overwrite existing files" sys.exit(1) privkey = pybitcointools.random_key() encoded = pybitcointools.encode_privkey(privkey, 'wif') addr = pybitcointools.privtoaddr(privkey) try: wif_exists = os.path.exists(wif_filename) with open(wif_filename, "w") as wif_fd: if not options.quiet: if wif_exists: print "overwriting file: {}".format(wif_filename) else: print "writing file: {}".format(wif_filename) wif_fd.write(encoded) wif_fd.write("\n") addr_exists = os.path.exists(addr_filename) with open(addr_filename, "w") as addr_fd: if not options.quiet: if addr_exists: print "overwriting file: {}".format(addr_filename) else: print "writing file: {}".format(addr_filename) addr_fd.write(addr) addr_fd.write("\n") except IOError, ioe: print >> sys.stderr, "IOError: {}".format(str(ioe)) sys.exit(1)
from __future__ import print_function import pybitcointools # Generate a random private key valid_private_key = False while not valid_private_key: private_key = pybitcointools.random_key() decoded_private_key = pybitcointools.decode_privkey(private_key, 'hex') valid_private_key = 0 < decoded_private_key < pybitcointools.N print("Private Key (hex) is: ", private_key) print("Private Key (decimal) is: ", decoded_private_key) # Convert private key to WIF format wif_encoded_private_key = pybitcointools.encode_privkey( decoded_private_key, 'wif') print("Private Key (WIF) is: ", wif_encoded_private_key) # Add suffix "01" to indicate a compressed private key compressed_private_key = private_key + '01' print("Private Key Compressed (hex) is: ", compressed_private_key) # Generate a WIF format from the compressed private key (WIF-compressed) wif_compressed_private_key = pybitcointools.encode_privkey( pybitcointools.decode_privkey(compressed_private_key, 'hex'), 'wif_compressed') print("Private Key (WIF-Compressed) is: ", wif_compressed_private_key) # Multiply the EC generator point G with the private key to get a public key point public_key = pybitcointools.fast_multiply(pybitcointools.G, decoded_private_key)
def setUp(self): self.brainwallet_string = 'Here is a brainwallet string for testing purposes' self.private_key = bc.sha256(self.brainwallet_string) self.private_key_wif = bc.encode_privkey(self.private_key, 'wif') self.addr = bc.privkey_to_address(self.private_key)
import pybitcointools # Generate a random private key valid_private_key = False while not valid_private_key: private_key = pybitcointools.random_key() decoded_private_key = pybitcointools.decode_privkey(private_key, 'hex') valid_private_key = 0 < decoded_private_key < pybitcointools.N print "Private Key (hex) is:", private_key print "Private Key (decimal) is:", decoded_private_key # Convert private key to WIF format wif_encoded_private_key = pybitcointools.encode_privkey( decoded_private_key, 'wif') print "Private Key (WIF) is:", wif_encoded_private_key # Add suffix "01" to indicate a compressed private key compressed_private_key = private_key + '01' print "Private Key Compressed (hex) is:", compressed_private_key # Generate a WIF format from the compressed private key (WIF-)
def to_bin(self): if self._compressed: return encode_privkey( self._ecdsa_private_key.to_string(), 'bin_compressed') else: return self._ecdsa_private_key.to_string()
def generate_private_key(): return pybitcointools.encode_privkey(pybitcointools.random_key(), 'wif')
def to_hex(self): if self._compressed: return encode_privkey( self._ecdsa_private_key.to_string(), 'hex_compressed') else: return hexlify(self.to_bin())
def create_signup_info(cls, originator_public_key, validator_network_basename, most_recent_wait_certificate_id): with cls._lock: # First we need to create a public/private key pair for the PoET # enclave to use. cls._poet_private_key = pybitcointools.random_key() cls._poet_public_key = \ pybitcointools.privtopub(cls._poet_private_key) cls._active_wait_timer = None # We are going to fake out the sealing the signup data. signup_data = { 'poet_public_key': pybitcointools.encode_pubkey(cls._poet_public_key, 'hex'), 'poet_private_key': pybitcointools.encode_privkey( cls._poet_private_key, 'hex') } sealed_signup_data = \ pybitcointools.base64.b32encode(dict2json(signup_data)) # Create a fake report report_data = { 'originator_public_key_hash': pybitcointools.sha256( pybitcointools.encode_pubkey( originator_public_key, 'hex')), 'poet_public_key': pybitcointools.encode_pubkey(cls._poet_public_key, 'hex') } report = { 'report_data': pybitcointools.sha256(dict2json(report_data)), 'validator_network_basename': validator_network_basename } # Fake our "proof" data. attestation_evidence_payload = { 'enclave_quote': pybitcointools.base64.b64encode(dict2json(report)), 'pse_manifest': pybitcointools.base64.b64encode( pybitcointools.sha256( 'manifest destiny')), 'nonce': most_recent_wait_certificate_id } attestation_verification_report = { 'attestation_evidence_payload': attestation_evidence_payload, 'anti_sybil_id': cls._anti_sybil_id } proof_data = { 'attestation_verification_report': attestation_verification_report, 'signature': pybitcointools.ecdsa_sign( dict2json(attestation_verification_report), cls._report_private_key) } return \ EnclaveSignupInfo( poet_public_key=signup_data['poet_public_key'], proof_data=proof_data, sealed_signup_data=sealed_signup_data)
def encode_privkey(privkey, encoding_format='wif'): return pybitcointools.encode_privkey(privkey, encoding_format)
def privkey_to_wif(self): return pybitcointools.encode_privkey(self.to_btc_privkey(), "wif")
wif_filename = os.path.join(key_dir, key_name + '.wif') addr_filename = os.path.join(key_dir, key_name + '.addr') if not args.force: file_exists = False for filename in [wif_filename, addr_filename]: if os.path.exists(filename): file_exists = True print >> sys.stderr, 'file exists: {}'.format(filename) if file_exists: raise ClientException( 'files exist, rerun with --force to overwrite existing files') privkey = pybitcointools.random_key() encoded = pybitcointools.encode_privkey(privkey, 'wif') addr = pybitcointools.privtoaddr(privkey) try: wif_exists = os.path.exists(wif_filename) with open(wif_filename, 'w') as wif_fd: if not args.quiet: if wif_exists: print 'overwriting file: {}'.format(wif_filename) else: print 'writing file: {}'.format(wif_filename) wif_fd.write(encoded) wif_fd.write('\n') addr_exists = os.path.exists(addr_filename) with open(addr_filename, 'w') as addr_fd:
wif_filename = os.path.join(key_dir, key_name + '.wif') addr_filename = os.path.join(key_dir, key_name + '.addr') if not args.force: file_exists = False for filename in [wif_filename, addr_filename]: if os.path.exists(filename): file_exists = True print >>sys.stderr, 'file exists: {}'.format(filename) if file_exists: raise ClientException( 'files exist, rerun with --force to overwrite existing files') privkey = pybitcointools.random_key() encoded = pybitcointools.encode_privkey(privkey, 'wif') addr = pybitcointools.privtoaddr(privkey) try: wif_exists = os.path.exists(wif_filename) with open(wif_filename, 'w') as wif_fd: if not args.quiet: if wif_exists: print 'overwriting file: {}'.format(wif_filename) else: print 'writing file: {}'.format(wif_filename) wif_fd.write(encoded) wif_fd.write('\n') addr_exists = os.path.exists(addr_filename) with open(addr_filename, 'w') as addr_fd:
def get_blinding_value() -> Scalar: return B.encode_privkey(os.urandom(32), 'decimal')