def from_hex(cls, hexed): """ :param hexed: A private key previously encoded as hex. :type hexed: ``str`` :rtype: :class:`~core.PrivateKey` """ return PrivateKey(ECPrivateKey.from_hex(hexed))
def generate(cls, xprv=None, prv=None, seed=None, child=None, username=None): mnemonic = Mnemonic('english') # generate 12 word mnemonic seed if not seed and not xprv and not prv: seed = mnemonic.generate(256) private_key = None if seed: # create bitcoin wallet entropy = mnemonic.to_entropy(seed) key = BIP32Key.fromEntropy(entropy) private_key = key.PrivateKey().hex() extended_key = key.ExtendedKey() else: raise Exception('No Seed') if prv: private_key = PrivateKey.from_hex(bytes.fromhex(prv)).to_hex() extended_key = '' if xprv: key = BIP32Key.fromExtendedKey(xprv) private_key = key.PrivateKey().hex() extended_key = key.ExtendedKey() if xprv and child: for x in child: key = key.ChildKey(int(x)) private_key = key.PrivateKey().hex() if not private_key: raise Exception('No key') return cls({ "seed": seed or '', "xprv": extended_key or '', "private_key": private_key, "wif": cls.generate_wif(private_key), "public_key": PublicKey.from_point(key.K.pubkey.point.x(), key.K.pubkey.point.y()).format().hex(), "address": str(key.Address()), "serve_host": "0.0.0.0", "serve_port": 8000, "use_pnp": True, "ssl": False, "origin": '', "polling": 0, "post_peer": False, # "public_ip": "", # TODO "peer_host": "", "peer_port": 8000, "web_server_host": "0.0.0.0", "web_server_port": 5000, "peer": "http://localhost:8000", "callbackurl": "http://0.0.0.0:5000/create-relationship", "fcm_key": "", "database": "yadacoin", "site_database": "yadacoinsite", "mongodb_host": "localhost", "mixpanel": "", "username": username or '', "network": "mainnet" })
def from_seed(self, seed: str = '', subtype: SignerSubType = SignerSubType.MAINNET_REGULAR): """Creates key from seed - for ecdsa, seed = pk - 32 bytes random buffer""" if subtype != SignerSubType.MAINNET_REGULAR: self._subtype = subtype if len(seed) > 64: # Too long seed, trim (could use better scheme for more entropy) seed = seed[:64] elif seed == '': # No seed, use urandom seed = urandom(32) elif len(seed) < 64: # Too short seed, use as PRNG seed random.seed(seed) seed = random.getrandbits(32 * 8).hex() try: key = PrivateKey.from_hex(seed) public_key = key.public_key.format(compressed=True).hex() # print("Public Key", public_key) self._key = key self._private_key = key.to_hex() # == seed self._public_key = public_key except Exception as e: print("Exception {} reading RSA private key".format(e)) # print("identifier", self.identifier().hex()) self._address = self.address()
def create_signed_transaction(self, func_name, args, nonce_offset=0, value=0): tx = self.create_transaction(func_name, args, nonce_offset, value) sign_transaction(tx, self.private_key, self.web3.version.network) pk = PrivateKey.from_hex(self.private_key[2:]) tx.sign(pk.secret) raw_tx = rlp.encode(tx) return self.web3.toHex(raw_tx)
def add_appointment_misbehaving_tower(appointment, user, tower_sk): # This covers a tower signing with invalid keys wrong_sk = PrivateKey.from_hex(get_random_value_hex(32)) wrong_sig = Cryptographer.sign(appointment.serialize(), wrong_sk) response, rcode = add_appointment_success(appointment, user, tower_sk) user["appointments"][appointment.locator]["signature"] = wrong_sig response["signature"] = wrong_sig return response, rcode
def test_sign_ground_truth(): # Generate a signature that has been verified by c-lightning. raw_sk = "24e9a981580d27d9277071a8381542e89a7c124868c4e862a13595dc75c6922f" sk = PrivateKey.from_hex(raw_sk) c_lightning_rpk = "0235293db86c6aaa74aff69ebacad8471d5242901ea9f6a0341a8dca331875e62c" message = b"Test message" sig = Cryptographer.sign(message, sk) rpk = Cryptographer.recover_pk(message, sig) assert c_lightning_rpk == Cryptographer.get_compressed_pk(rpk)
def sign(privkey: str, msg: bytes, v=0) -> bytes: assert isinstance(msg, bytes) assert isinstance(privkey, str) pk = PrivateKey.from_hex(remove_0x_prefix(privkey)) assert len(msg) == 32 sig = pk.sign_recoverable(msg, hasher=None) assert len(sig) == 65 sig = sig[:-1] + bytes([sig[-1] + v]) return sig
def sign(privkey: str, msg: bytes, v=0) -> bytes: assert isinstance(msg, bytes) assert isinstance(privkey, str) pk = PrivateKey.from_hex(remove_0x_prefix(privkey)) assert len(msg) == 32 sig = pk.sign_recoverable(msg, hasher=None) assert len(sig) == 65 sig = sig[:-1] + bytes([sig[-1] + v]) return sig
def populate_token_networks( token_networks: List[TokenNetwork], token_network_contracts: List[Contract], addresses: List[Address], private_keys: List[str], ) -> None: random.seed(NUMBER_OF_CHANNELS) # seed for pseudo-randomness from config constant, that changes from time to time for token_network in token_networks: for channel_id in range(NUMBER_OF_CHANNELS): seed1, seed2 = random.sample(private_keys, 2) private_key_ecdsa1 = PrivateKey.from_hex(remove_0x_prefix(seed1)) private_key_ecdsa2 = PrivateKey.from_hex(remove_0x_prefix(seed2)) address1 = to_checksum_address( public_key_to_address(private_key_ecdsa1.public_key)) address2 = to_checksum_address( public_key_to_address(private_key_ecdsa2.public_key)) fee1 = str(abs(random.gauss(0.0002, 0.0001))).encode() fee2 = str(abs(random.gauss(0.0002, 0.0001))).encode() signature1 = private_key_ecdsa1.sign_recoverable(fee1) signature2 = private_key_ecdsa2.sign_recoverable(fee2) token_network.handle_channel_opened_event(channel_id, address1, address2) # deposit to channels deposit1, deposit2 = random.sample(range(1000), 2) address1, address2 = token_network.channel_id_to_addresses[ channel_id] token_network.handle_channel_new_deposit_event( channel_id, address1, deposit1) token_network.handle_channel_new_deposit_event( channel_id, address2, deposit2) # cuts negative values of probability distribution, fix with > 0 distribution token_network.update_fee(channel_id, fee1, signature1) token_network.update_fee(channel_id, fee2, signature2)
def from_seed(self, seed: str='', subtype: SignerSubType = SignerSubType.MAINNET_REGULAR): print('crw from seed {}'.format(seed)) if subtype != SignerSubType.MAINNET_REGULAR: self._subtype = subtype try: key = PrivateKey.from_hex(seed) public_key = key.public_key.format(compressed=False).hex() print("Public Key", public_key) self._key = key self._private_key = key.to_hex() # == seed self._public_key = public_key except Exception as e: print("Exception {} reading RSA private key".format(e)) print("identifier", self.identifier().hex()) self._address = self.address()
def sign(privkey: str, msg_hash: bytes, v: int = 0) -> bytes: if not isinstance(msg_hash, bytes): raise TypeError("sign(): msg_hash is not an instance of bytes") if len(msg_hash) != 32: raise ValueError("sign(): msg_hash has to be exactly 32 bytes") if not isinstance(privkey, str): raise TypeError("sign(): privkey is not an instance of str") if v not in {0, 27}: raise ValueError(f"sign(): got v = {v} expected 0 or 27.") pk = PrivateKey.from_hex(remove_0x_prefix(privkey)) sig: bytes = pk.sign_recoverable(msg_hash, hasher=None) assert len(sig) == 65 pub = pk.public_key recovered = PublicKey.from_signature_and_message(sig, msg_hash, hasher=None) assert pub == recovered sig = sig[:-1] + bytes([sig[-1] + v]) return sig
def privkey_to_addr(privkey: str) -> str: return to_checksum_address( pubkey_to_addr(PrivateKey.from_hex(remove_0x_prefix(privkey)).public_key) )
def to_pubkey(self) -> bytes: """Computes and sends back pubkey, point(kpar) of current key(kpar)""" kpar = PrivateKey.from_hex(self.seed[:32].hex()) K = kpar.public_key.format(compressed=False) return K
def privatekeyHexToAddress(priv): pk = PrivateKey.from_hex(priv) publ = pk.public_key.format(compressed=False)[1:] return publickeyToAddress(publ)
def privkey_to_addr(privkey: str) -> str: return to_checksum_address( pubkey_to_addr(PrivateKey.from_hex(remove_0x_prefix(privkey)).public_key) )
def generate_signature(self, message, private_key): key = PrivateKey.from_hex(private_key) signature = key.sign(message.encode("utf-8")) return base64.b64encode(signature).decode("utf-8")
def generate(cls, xprv=None, prv=None, seed=None, child=None, username=None, mongodb_host=None, db_name=None): mnemonic = Mnemonic('english') # generate 12 word mnemonic seed if not seed and not xprv and not prv: seed = mnemonic.generate(256) private_key = None if seed: # create new wallet entropy = mnemonic.to_entropy(seed) key = BIP32Key.fromEntropy(entropy) private_key = key.PrivateKey().hex() extended_key = key.ExtendedKey() public_key = PublicKey.from_point( key.K.pubkey.point.x(), key.K.pubkey.point.y()).format().hex() address = str(key.Address()) if prv: key = PrivateKey.from_hex(prv) private_key = key.to_hex() extended_key = '' public_key = key.public_key.format().hex() address = str( P2PKHBitcoinAddress.from_pubkey(bytes.fromhex(public_key))) if xprv: key = BIP32Key.fromExtendedKey(xprv) private_key = key.PrivateKey().hex() extended_key = key.ExtendedKey() public_key = PublicKey.from_point( key.K.pubkey.point.x(), key.K.pubkey.point.y()).format().hex() address = str(key.Address()) if xprv and child: for x in child: key = key.ChildKey(int(x)) private_key = key.PrivateKey().hex() public_key = PublicKey.from_point( key.K.pubkey.point.x(), key.K.pubkey.point.y()).format().hex() address = str(key.Address()) if not private_key: raise Exception('No key') try: u = UPnP(None, None, 200, 0) u.discover() u.selectigd() peer_host = u.externalipaddress() except: try: import urllib.request peer_host = urllib.request.urlopen( 'https://ident.me').read().decode('utf8') except: peer_host = '' return cls({ "modes": ['node', 'web', 'pool'], "root_app": '', "seed": seed or '', "xprv": extended_key or '', "private_key": private_key, "wif": cls.generate_wif(private_key), "public_key": public_key, "address": address, "api_whitelist": [], "serve_host": "0.0.0.0", "serve_port": 8001, "use_pnp": False, "ssl": False, "origin": '', "sia_api_key": '', "post_peer": False, "peer_host": peer_host, "peer_port": 8000, "peer_type": "user", "peer": "http://localhost:8000", "callbackurl": "http://0.0.0.0:8001/create-relationship", "jwt_public_key": None, "fcm_key": "", "database": db_name or "yadacoin", "site_database": db_name + "site" if db_name else "yadacoinsite", "mongodb_host": mongodb_host or "localhost", "mixpanel": "", "username": username or '', "network": "mainnet", "wallet_host_port": 'http://localhost:8001', "credits_per_share": 5, "shares_required": False, "pool_payout": False, "pool_take": .01, "payout_frequency": 6 })
auto_parser.add_argument( '-c', '--create', help='Create a new config file if one does not already exist') auto_parser.add_argument('-m', '--mongo-host', help='Specify a mongodb host') args = parser.parse_args() public_ip = requests.get('https://api.ipify.org').text if args.which == 'new': if args.password.value: num = from_wif(args.password.value) else: num = os.urandom(32).encode('hex') Config.username = args.username pk = PrivateKey.from_hex(num) print generate() elif args.which == 'update': with open(args.config) as f: identity = json.loads(f.read()) pk = PrivateKey.from_hex(identity['private_key']) if 'username' in identity: username = identity['username'] else: username = args.username Config.username = username print generate() elif args.which == 'auto': num = os.urandom(32).encode('hex') pk = PrivateKey.from_hex(num) Config.username = ''
def generate_signature(cls, message): key = PrivateKey.from_hex(Config.private_key) signature = key.sign(message) return base64.b64encode(signature)
def __init__(self, private_key): self.private_key = PvtKey.from_hex(private_key) self.public_key = hexlify( self.private_key.public_key.format()).decode()
def __init__(self, seed): key = PrivateKey.from_hex(seed) self.public_key = key.public_key.format(compressed=True).hex() self.key = key.to_hex() # == seed self.address = self.address()
'--create', help='Create a new config file if one does not already exist') auto_parser.add_argument('-m', '--mongo-host', help='Specify a mongodb host') args = parser.parse_args() """ TODO: add other apis in case this one is down. Allow to override from optional command line param """ public_ip = requests.get('https://api.ipify.org').text if args.which == 'new': if args.password.value: num = from_wif(args.password.value) else: num = os.urandom(32).hex() pk = PrivateKey.from_hex(num) config = Config.generate(pk.to_hex()) config.username = args.username elif args.which == 'update': with open(args.config) as f: identity = json.loads(f.read()) config = Config.generate(xprv=identity['xprv']) if 'username' in identity and identity['username']: username = identity['username'] else: username = args.username config.username = username config.bulletin_secret = config.get_bulletin_secret() print(config.to_json()) elif args.which == 'auto': config = Config.generate()
def sign_data(privkey: str, msg: bytes, v=27): pk = PrivateKey.from_hex(remove_0x_prefix(privkey)) sha3 = lambda x: keccak_256(x).digest() sig = pk.sign_recoverable(msg, hasher=sha3) return sig[:-1] + chr(sig[-1] + v).encode()
""" Test bip32 btc like """ from coincurve import PrivateKey, PublicKey from bip32utils import BIP32Key # seed = os.urandom(32).hex() seed = "8950b1cffcd85b6ad992feed179863da032b2674178127150db25f5208ea8e4a" # TEST ONLY, DO NOT USE FOR REAL print(seed) pk = PrivateKey.from_hex(seed) pkhex = pk.to_hex() print("pkhex", pkhex) # == SEED key = BIP32Key.fromEntropy(seed.encode("utf-8")) private_key = key.PrivateKey().hex() extended_key = key.ExtendedKey() public_key = key.PublicKey().hex() address = key.Address() print("private_key", private_key) print("extended_key", extended_key) print("public_key", public_key) print("address", address) identifier = key.Identifier().hex() print("id", identifier) priv = "d5ba601c19bfc54e109d20736453ba150f624ee03e2b7a5a3875342cd64d2efe" seed = "e8f32e723decf4051aefac8e2c93c9c5b214313817cdb01a1494b917c8436b35"
def private_key_to_address(private_key: str) -> Address: """ Converts a private key to an Ethereum address. """ return to_checksum_address( public_key_to_address( PrivateKey.from_hex(remove_0x_prefix(private_key)).public_key))