def init_signature(sig): if isinstance(sig, str): if sig[0:2] == "0x": sig = sig[2:] sig = bytes.fromhex(sig) return IdleSignature(sig) if isinstance(sig, str): if sig[-2:] != '01' and sig[-2:] != '00': sig = hex(int(sig, 16) - 27) try: sig = KeyAPI.Signature(HexBytes(sig)) except Exception: raise TypeError(str(type(sig)) + "is not verifiable signature") elif isinstance(sig, bytes): if sig[-1] != 1 and sig[-1] != 0: sig = bytestoint(sig) sig -= 27 sig = HexBytes(hex(sig)) try: sig = KeyAPI.Signature(sig) except Exception: raise TypeError(str(type(sig)) + "is not verifiable signature") elif not isinstance(sig, KeyAPI.Signature): raise TypeError(str(type(sig)) + "is not verifiable signature") return sig
def verify_msg_hash(msg_hash, signature, public_key): log.debug('message=%s type %s', msg_hash, type(msg_hash)) log.debug('public_key=%s type %s', public_key, type(public_key)) log.debug('signature=%s type %s', signature, type(signature)) signature = KeyAPI.Signature(bytes.fromhex(signature)) public_key = KeyAPI.PublicKey(bytes.fromhex(public_key)) return signature.verify_msg_hash(msg_hash, public_key)
def verify_signature(message, signature, public_key=None): """ If public_key provided, return true or false if valid If public_key is None, return recovered public key from signature @param message bytes @param signature bytes b'abc\t0\abcd\...' @param public_key bytes b'abc\t0\abcd\...' or None """ # print('message=', message, type(message)) # print('public_key=', public_key, type(public_key)) # print('signature=', signature, type(signature)) signature = signature.decode() if isinstance(message, str): message = message.encode() log.debug('Verify_signature message %s', message) signature = KeyAPI.Signature(bytes.fromhex(signature)) recovered_pk = signature.recover_public_key_from_msg(bytes(message)) recovered_pk = recovered_pk.to_hex() log.debug('Recovered public key %s', recovered_pk) if public_key is None: return recovered_pk return public_key == recovered_pk
def verify_signature(self, public_key: KeyAPI.PublicKey): try: return public_key.verify_msg_hash( self.get_hash(), KeyAPI.Signature(signature_bytes=self.signature) ) except eth_keys.exceptions.BadSignature: return False
def get_publickey_from_address(web3, address): _hash = Web3.sha3(text='verify signature.') signature = split_signature(web3, web3.eth.sign(address, _hash)) signature_vrs = Signature(signature.v % 27, big_endian_to_int(signature.r), big_endian_to_int(signature.s)) prefixed_hash = prepare_prefixed_hash(_hash) pub_key = KeyAPI.PublicKey.recover_from_msg_hash( prefixed_hash, KeyAPI.Signature(vrs=signature_vrs)) assert pub_key.to_checksum_address( ) == address, 'recovered address does not match signing address.' return pub_key
def get_sender(signature, message): """ @param signature bytes @param message bytes """ if isinstance(signature, bytes): signature = KeyAPI.Signature(signature) if not isinstance(message, bytes): message = bytes(message) return signature.recover_public_key_from_msg(message)
def verify_signature(self, recipients): """ Verify whether the signatures are from a list of recipients. Doesn't verify if the transaction is valid on the chain """ if len(recipients) != len(self.sign_list): return False for i in range(len(recipients)): sig = KeyAPI.Signature(signature_bytes=self.sign_list[i]) pub = sig.recover_public_key_from_msg(self.get_hash_unsigned()) if pub.to_canonical_address() != recipients[i]: return False return True
def verify_signature(signature_hex: str, message_bytes: bytes, public_key_hex: str): """Returns True for a valid signature. Args: signature (str) -- hex string message (bytes) public_key (str) -- hex string """ signature_bytes = bytes.fromhex(signature_hex) signature = KeyAPI.Signature(signature_bytes=signature_bytes) pk_bytes = bytes.fromhex(public_key_hex[2:]) pk = KeyAPI.PublicKey(pk_bytes) return signature.verify_msg(message_bytes, pk)
def verify_sig_msg(self, message: bytes, signature: bytes, pubkey: bytes): """ Verifies that message has been signed by pubkey Args: message: bytes of message to verify signature: bytes of signature to verify pubkey: public key that signed this message Returns: Boolean (True if signature is valid) """ log.debug('from verify_sig_msg message=%s type=%s', message, type(message)) public_key = KeyAPI.PublicKey(pubkey) sig = KeyAPI.Signature(signature) return sig.verify_msg(message, public_key)
def get_public_key_from_address(web3, account): """ :param web3: :param account: :return: """ _hash = web3.sha3(text='verify signature.') signature = web3.personal.sign(_hash, account.address, account.password) signature = split_signature(web3, to_bytes(hexstr=signature)) signature_vrs = Signature(signature.v % 27, big_endian_to_int(signature.r), big_endian_to_int(signature.s)) prefixed_hash = prepare_prefixed_hash(_hash) pub_key = KeyAPI.PublicKey.recover_from_msg_hash( prefixed_hash, KeyAPI.Signature(vrs=signature_vrs)) assert pub_key.to_checksum_address() == account.address, \ 'recovered address does not match signing address.' return pub_key
def recover(msg_hash: bytes, sig: bytes) -> bytes: ''' Recover the uncompressed public key from signature. Parameters ---------- msg_hash: bytes The message hash. sig: bytes The signature. Returns ------- bytes public key in uncompressed format. Raises ------ ValueError If the signature is bad, or recovery bit is bad, or cannot recover(sig and msg_hash doesn't match). ''' if not _is_valid_message_hash(msg_hash): raise ValueError('Message Hash must be 32 bytes.') if len(sig) != 65: raise ValueError('Signature must be 65 bytes.') if not (sig[64] == 0 or sig[64] == 1): raise ValueError('Signature last byte must be 0 or 1') pk = KeyAPI().ecdsa_recover(msg_hash, KeyAPI.Signature(signature_bytes=sig)) # uncompressed should have first byte = 04 return bytes([4]) + pk.to_bytes()
def verify_sig_msg_hash(self, msg_hash: bytes, signature: bytes, pubkey: bytes): public_key = KeyAPI.PublicKey(pubkey) sig = KeyAPI.Signature(signature) return sig.verify_msg_hash(msg_hash, public_key)
def extract_pubkey_from_signature(self, message: bytes, signature: bytes): """ Recover pubkey that signed message """ sig = KeyAPI.Signature(signature) recovered_pk = sig.recover_public_key_from_msg(message) return recovered_pk
def verify_sig_msg(self, message: bytes, signature: bytes, pubkey: bytes): """ Verifies that message has been signed by pubkey """ public_key = KeyAPI.PublicKey(pubkey) sig = KeyAPI.Signature(signature) return sig.verify_msg(message, public_key)
apdu += donglePath + encodedTx dongle = getDongle(True) result = dongle.exchange(bytes(apdu)) v = int(result[0]) # Compute parity if (CHAIN_ID * 2 + 35) + 1 > 255: ecc_parity = v - ((CHAIN_ID * 2 + 35) % 256) else: ecc_parity = (v + 1) % 2 v = "%02X" % ecc_parity r = binascii.hexlify(result[1:1 + 32]).decode() s = binascii.hexlify(result[1 + 32:1 + 32 + 32]).decode() msg_to_sign = SIGN_MAGIC + str(len(args.message)).encode() + args.message hash = sha3(msg_to_sign.decode()) signature = KeyAPI.Signature(vrs=(int(v, 16), int(r, 16), int(s, 16))) pubkey = KeyAPI.PublicKey.recover_from_msg_hash(hash, signature) print("[INFO] Hash is: t0", binascii.hexlify(hash).decode(), sep='') print('{') print(' "address": "', pubkey.to_address(), '",', sep='') print(' "msg": "', args.message.decode(), '",', sep='') print(' "sig": "', signature, '",', sep='') print(' "version": "3"') print(' "signed": "ledger"') print('}')
raw_msg = b"123" if __name__ == '__main__': raw_signature = hex(int(eth_signature, 16) - 27) msg = ETHSIGN_HEADER + bytes(str(len(raw_msg)).encode('utf-8')) + raw_msg msghash = keccak(msg) print(msg, HexBytes(msghash).hex()) # print(HexBytes(msg).hex()) print( SignatureVerifier.verify_by_raw_message(eth_signature, raw_msg, signer)) print( SignatureVerifier.verify_by_raw_message(raw_signature, raw_msg, signer)) print( SignatureVerifier.verify_by_hashed_message(eth_signature, msghash, signer)) print( SignatureVerifier.verify_by_hashed_message(raw_signature, msghash, signer)) sig = KeyAPI.Signature(HexBytes(raw_signature)) print(sig.recover_public_key_from_msg(msg).to_checksum_address()) print(sig.recover_public_key_from_msg_hash(msghash).to_checksum_address())
from eth_keys import KeyAPI, keys from eth_utils import keccak enc = 'utf8' message = "2017年の骨学的分析とDNA検査によって女性であることが判明している" pk = keys.PrivateKey(b'\01' * 32) addr = str(pk.public_key.to_checksum_address()) msg_bytes = message.encode(enc) msg_length = str(len(msg_bytes)).encode(enc) msg = b'\x19Ethereum Signed Message:\n' + msg_length + msg_bytes signature = pk.sign_msg(msg).to_hex() print(message) print(addr) print(signature) print('\nChecking Stage:') key_obj = KeyAPI() if '0x' in signature: signature = signature[2:] sign = KeyAPI.Signature(bytearray.fromhex(signature)) pub = key_obj.ecdsa_recover(message_hash=keccak(msg), signature=sign) print(addr == str(pub.to_checksum_address()))
def eth_signature(raw_signature): return KeyAPI.Signature(HexBytes(hex(int(raw_signature, 16) - 27)))
def verify_signature(hash, sig, pub): keys = KeyAPI(NativeECCBackend) sign = keys.Signature(sig) public = keys.PublicKey(pub, base.BaseECCBackend) return keys.ecdsa_verify(hash, sign, public)