def test_signature_recoverable(self): private_key = PrivateKey(PRIVATE_KEY_BYTES) assert (private_key.public_key.format() == PublicKey( recover( MESSAGE, deserialize_recoverable( private_key.sign_recoverable(MESSAGE)))).format())
class Credentials: def __init__(self, private_key): if private_key.startswith("0x"): private_key = private_key[2:] self.private_key = PrivateKey(bytes(bytearray.fromhex(private_key))) @property def address(self): keccak_hash = keccak.new(digest_bits=256) keccak_hash.update( self.private_key.public_key.format(compressed=False, )[1:]) return to_checksum_address(keccak_hash.digest()[-20:]) def sign(self, message): msg_hash = bytes(bytearray.fromhex(remove_0x_prefix(message))) signature_bytes = self.private_key.sign_recoverable(msg_hash, hasher=None) assert len(signature_bytes) == 65 r = "0x" + format(big_endian_to_int(signature_bytes[0:32]), "x") s = "0x" + format(big_endian_to_int(signature_bytes[32:64]), "x") v = hex(ord(signature_bytes[64:65]) + 27) return {"r": r, "s": s, "v": v}
def check_and_fill_order(self, order): if not order or not order.fromToken or not order.toToken or not order.tx: return "error" if not self.order_exists(order): return "unknown" if not self.order_ready(order): return None gas_price = self.w3.eth.generateGasPrice() logger.debug("Loaded raw gas price {}".format(gas_price)) gas_price = int(gas_price * float(self.gas_multiplier)) nonce = self.pull_nonce() logger.debug("Using nonce {}, gasprice {}".format(nonce, gas_price)) secret_pk = PrivateKey(order.secret) keccak_hash = keccak.new(digest_bits=256) keccak_hash.update(bytearray.fromhex(self.account.address.replace('0x', ''))) witnesses = secret_pk.sign_recoverable(bytes(bytearray.fromhex(keccak_hash.hexdigest())), hasher=None) logger.debug("Signed order {} witnesses {}".format(order.tx, witnesses.hex())) calc_witness = Account.privateKeyToAccount(order.secret.hex().replace('0x', '')).address if calc_witness != order.witness: logger.warn("Witness missmatch order {} witness {} order witness {}".format(order.tx, calc_witness, order.witness)) return "error" logger.debug("Sending tx for order {}".format(order.tx)) transaction = self.uniswap_ex.functions.executeOrder( order.fromToken, order.toToken, order.minReturn, order.fee, order.owner, witnesses ).buildTransaction({ 'gasPrice': gas_price, 'nonce': nonce, 'from': self.account.address }) if order.fromToken.lower() not in self.whitelisted_tokens and order.toToken.lower() not in self.whitelisted_tokens and transaction['gas'] * gas_price > order.fee: logger.debug("Order {} fee is not enought, cost {} vs {} -> {} * {}".format(order.tx, order.fee, transaction['gas'] * gas_price, transaction['gas'], gas_price)) return None signed_txn = self.w3.eth.account.signTransaction(transaction, private_key=self.account.privateKey) logger.debug("Signed tx for order {}".format(order.tx)) tx = Web3.toHex(self.w3.eth.sendRawTransaction(signed_txn.rawTransaction)) logger.info("Relayed order {} tx {}".format(order.tx, tx)) return tx
def send_handshake(self, peer): self._sc.log.debug('send_handshake %s', peer._address) peer._mx.acquire() try: # TODO: Drain peer._recv_messages if not peer._recv_messages.empty(): self._sc.log.warning( 'send_handshake %s - Receive queue dumped.', peer._address) while not peer._recv_messages.empty(): peer._recv_messages.get(False) msg = MsgHandshake() msg._timestamp = int(time.time()) key_r = rfc6979_hmac_sha256_generate(self._csprng, 32) k = PrivateKey(key_r) msg._ephem_pk = PublicKey.from_secret(key_r).format() self.check_handshake_ephem_key(peer, msg._timestamp, msg._ephem_pk) ss = k.ecdh(peer._pubkey) hashed = hashlib.sha512( ss + struct.pack('>Q', msg._timestamp)).digest() peer._ke = hashed[:32] peer._km = hashed[32:] nonce = peer._km[24:] payload = self._sc._version nk = PrivateKey(self._network_key) sig = nk.sign_recoverable(peer._km) payload += sig aad = msg.encode_aad() aad += nonce cipher = ChaCha20_Poly1305.new(key=peer._ke, nonce=nonce) cipher.update(aad) msg._ct, msg._mac = cipher.encrypt_and_digest(payload) peer._sent_nonce = hashlib.sha256(nonce + msg._mac).digest() peer._recv_nonce = hashlib.sha256(peer._km).digest() # Init nonce peer._last_handshake_at = msg._timestamp peer._ready = False # Wait for peer to complete handshake self.send_msg(peer, msg) finally: peer._mx.release()
def signCompact(self, k, message): message_hash = hashlib.sha256(bytes(message, 'utf-8')).digest() privkey = PrivateKey(k) return privkey.sign_recoverable(message_hash, hasher=None)[:64]