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)
