def __init__(self, signature_bytes=None, vrs=None, backend=None) -> None:
v, r, s = vrs
if v == 27 or v == 28:
v -= 27
vrs = (v, r, s)
Signature.__init__(self, signature_bytes, vrs, backend)
def ecrecover():
sig = "7c1886d96dc50f07a48fa7d72006809ac9f45d6b1c34b7a072ace679674c64a230aac08d000000000000000000000000000000000000000000000000000000000000001c9c88b967e65708ae5b744502ec117fae31b7f787753e63d8cea7047e789bd55d1d5557b6eca94f4f7473c862cfb5488980d7e1e3eb764f5f11b0fe2281931d2e"
pubkey = "0000000000000000000000003f17f1962b36e491b30a40b2405849e597ba5fb5"
sig = Signature(binascii.a2b_hex(sig))
sig.recover_public_key_from_msg()
def ecrecover(signature, message):
message_hash = to_bytes(hexstr=message)
message_hash = solidityKeccak(
['string', 'bytes32'],
['\x19Ethereum Signed Message:\n32', message_hash])
_signature = Signature(to_bytes(hexstr=signature))
public_key = _signature.recover_public_key_from_msg_hash(message_hash)
return public_key.to_checksum_address()
def __init__(self, signature_bytes=None, vrs=None, backend=None) -> None:
"""Initialises SignatureFix object."""
v, r, s = vrs
if v == 27 or v == 28:
v -= 27
vrs = (v, r, s)
Signature.__init__(self, signature_bytes, vrs, backend)
def call_backend_verify(self, pubkey: PublicKey, signature: Signature, msg_hash: bytes) -> bool:
"""
Verifies a hex string signature and message hash are from the provided
public key.
"""
is_valid_sig = signature.verify_msg_hash(msg_hash, pubkey)
sig_pubkey = signature.recover_public_key_from_msg_hash(msg_hash)
return is_valid_sig and (sig_pubkey == pubkey)
def _stamp_has_valid_wallet_signature(self):
signature_bytes = self._evidence_of_decentralized_identity
if signature_bytes is constants.NOT_SIGNED:
return False
else:
signature = EthSignature(signature_bytes)
proper_pubkey = signature.recover_public_key_from_msg(bytes(self.stamp))
proper_address = proper_pubkey.to_checksum_address()
return proper_address == self.checksum_public_address
def test_blockchain_ursula_substantiates_stamp(blockchain_ursulas):
first_ursula = list(blockchain_ursulas)[0]
signature_as_bytes = first_ursula._evidence_of_decentralized_identity
signature = EthSignature(signature_bytes=signature_as_bytes)
proper_public_key_for_first_ursula = signature.recover_public_key_from_msg(bytes(first_ursula.stamp))
proper_address_for_first_ursula = proper_public_key_for_first_ursula.to_checksum_address()
assert proper_address_for_first_ursula == first_ursula.checksum_public_address
# This method is a shortcut for the above.
assert first_ursula._stamp_has_valid_wallet_signature
def get_posw_info(
config: POSWConfig,
header: Header,
stakes: int,
block_cnt: Dict[bytes, int],
stake_per_block: Optional[int] = None,
signer: Optional[bytes] = None,
) -> Optional[PoSWInfo]:
if (not (config.ENABLED and header.create_time >= config.ENABLE_TIMESTAMP)
or header.height == 0):
return None
# evaluate stakes before the to-be-added block
coinbase_recipient = header.coinbase_address.recipient
required_stakes_per_block = stake_per_block or config.TOTAL_STAKE_PER_BLOCK
block_threshold = min(config.WINDOW_SIZE,
stakes // required_stakes_per_block)
cnt = block_cnt.get(coinbase_recipient, 0)
diff = header.difficulty
ret = lambda success: PoSWInfo(
diff // config.get_diff_divider(header.create_time)
if success else diff,
block_threshold,
# mined blocks should include current one, assuming success
posw_mined_blocks=cnt + 1,
)
# fast path
if block_threshold == 0:
return ret(False)
# need to check signature if signer is specified. only applies for root chain
if signer:
check(isinstance(header, RootBlockHeader))
if signer == bytes(20):
return ret(False)
block_sig = Signature(header.signature)
try:
pubk = block_sig.recover_public_key_from_msg_hash(
header.get_hash_for_mining())
except BadSignature:
return ret(False)
if pubk.to_canonical_address() != signer:
return ret(False)
return ret(cnt < block_threshold)
def __init__(
self,
signature_bytes: Optional[bytes] = None,
vrs: Optional[Tuple[int, int, int]] = None,
backend: Optional[Union[BaseECCBackend, Type[BaseECCBackend], str,
None]] = None,
) -> None:
"""Initialises SignatureFix object."""
# can not apply the enforce types decorator on init due to the Signature hacking
v, r, s = vrs
if v == 27 or v == 28:
v -= 27
vrs = (v, r, s)
Signature.__init__(self, signature_bytes, vrs, backend)
def complete(self, identifier: str, account: str, issuer: str,
code: str) -> str:
"""
Completes an attestation with the corresponding code
Parameters:
identifier: str
Attestation identifier (e.g. phone hash)
account: str
Address of the account
issuer: str
The issuer of the attestation
code: str
The code received by the validator (signature)
Returns:
Transaction hash
"""
accounts_contract = self.create_and_get_contract_by_name('Accounts')
attestation_signer = accounts_contract.get_attestation_signer(issuer)
message = self.web3.soliditySha3(['bytes32', 'address'],
[identifier, account]).hex()
message = encode_defunct(hexstr=message)
signer_address = Account.recoverHash(message, signature=code)
if signer_address != attestation_signer:
raise Exception("Signature was not signed by attestation signer")
signature_bytes = HexBytes(code)
signature_bytes_standard = to_standard_signature_bytes(signature_bytes)
signature_obj = Signature(signature_bytes=signature_bytes_standard)
v, r, s = signature_obj.vrs
func_call = self._contract.functions.complete(identifier, v, r, s)
return self.__wallet.send_transaction(func_call)
def validate_attestation_code(self, identifier: str, account: str,
issuer: str, code: str) -> bool:
"""
Validates a given code by the issuer on-chain
Parameters:
identifier: str
Attestation identifier (e.g. phone hash)
account: str
The address of the account which requested attestation
issuer: str
The address of the issuer of the attestation
code: str
The code send by the issuer
"""
accounts_contract = self.create_and_get_contract_by_name('Accounts')
attestation_signer = accounts_contract.get_attestation_signer(issuer)
message = self.web3.soliditySha3(['bytes32', 'address'],
[identifier, account]).hex()
message = encode_defunct(hexstr=message)
signer_address = Account.recoverHash(message, signature=code)
if signer_address != attestation_signer:
raise Exception("Signature was not signed by attestation signer")
signature_bytes = HexBytes(code)
signature_bytes_standard = to_standard_signature_bytes(signature_bytes)
signature_obj = Signature(signature_bytes=signature_bytes_standard)
v, r, s = signature_obj.vrs
result = self._contract.functions.validateAttestationCode(
identifier, account, v, r, s).call()
return result != self.null_address
def getPublicKey(transaction, signature):
s = Signature(signature_bytes=bytes.fromhex(signature))
txID = hashlib.sha256(bytes.fromhex(transaction)).digest()
keys = KeyAPI('eth_keys.backends.NativeECCBackend')
public_key = keys.ecdsa_recover(txID, s)
logger.debug(' PublicKey: {}'.format(public_key))
return public_key
def verify(msghash: bytes, signature, public_key):
"""Verify that data has been signed with Etheruem private key.
:param signature:
:return:
"""
key_api = KeyAPI('eth_keys.backends.NativeECCBackend')
return key_api.ecdsa_verify(msghash, Signature(signature),
PublicKey(public_key))
def ecdsa_sign(self, msg_hash: bytes,
private_key: PrivateKey) -> Signature:
private_key_bytes = private_key.to_bytes()
signature_bytes = self.keys.PrivateKey(
private_key_bytes).sign_recoverable(
msg_hash,
hasher=None,
)
signature = Signature(signature_bytes, backend=self)
return signature
def validate(transaction, signature, public_key):
try:
s = Signature(signature_bytes=signature)
txID = hashlib.sha256(
bytes.fromhex(transaction)
if type(transaction) is str else transaction).digest()
keys = KeyAPI('eth_keys.backends.NativeECCBackend')
publicKey = PublicKey(bytes.fromhex(public_key))
return keys.ecdsa_verify(txID, s, publicKey), txID.hex()
except:
return False, ""
def test_sign():
# 对应智能合约 keccak256(abi.encodePacked(uint40(commitLastBlock), commit));
commitLastBlock = unhexlify('%010x' % 0xb34464) # 和uint40对应
commit = unhexlify(
'24027f1fe6692863385b95ab253f0700a35d03a8967dff8588e2de6b066b44e4')
h = keccak(commitLastBlock + commit)
print(hexlify(h))
#正确keccak结果, 正确是: A5CA2F7474A762F6EA97585911E0CC48FB1282D53A0A602056B61216AF7637FD
sig = '2e608766579a55fffd6d7872e89d56642980358160b877fdb00855e716a8cbeb'
sig += '3faac77026378c125f5ead4bb0cbf303554ba85d9920d158a9aacecfa2ada6a8'
sig += '00' # 27
sig = unhexlify(sig)
sg = Signature(sig)
pubk = sg.recover_public_key_from_msg_hash(h)
print(pubk.to_checksum_address()
) # 正确的应是 0xb00b5ca7ec0502f2f269e99b91ebbccbce9cccec
pass
def recoverHash(message_hash, signature):
"""
:param message_hash: 32-bytes string
:param signature: 130-length string without '0x'
:return:
"""
if isinstance(signature, bytes):
signature = signature.decode()
signature = signature.replace('0x', '')
publick_key = KeyAPI().ecdsa_recover(message_hash, Signature(binascii.a2b_hex(signature)))
return checksum_encode(publick_key.to_address())
def ecdsa_recover(self, msg_hash: bytes,
signature: Signature) -> PublicKey:
signature_bytes = signature.to_bytes()
try:
public_key_bytes = self.keys.PublicKey.from_signature_and_message(
signature_bytes,
msg_hash,
hasher=None,
).format(compressed=False)[1:]
except (ValueError, Exception) as err:
# `coincurve` can raise `ValueError` or `Exception` dependending on
# how the signature is invalid.
raise BadSignature(str(err))
public_key = PublicKey(public_key_bytes, backend=self)
return public_key
def validateHASH(txID, signature, public_key):
s = Signature(signature_bytes=signature)
keys = KeyAPI('eth_keys.backends.NativeECCBackend')
publicKey = PublicKey(bytes.fromhex(public_key))
return keys.ecdsa_verify(txID, s, publicKey)
def ecdsa_sign(self, msg_hash: bytes,
private_key: PrivateKey) -> Signature:
signature_vrs = ecdsa_raw_sign(msg_hash, private_key.to_bytes())
signature = Signature(vrs=signature_vrs, backend=self)
return signature
def __load_signature(self) -> Signature:
try:
return Signature(signature_bytes=self.signature)
except (TypeError, ValidationError, BadSignature):
raise exceptions.InvalidSignatureError(
f'{self.signature} is not a valid signature')
def ecdsa_verify(signature: bytes, data: bytes, address: bytes) -> bool:
signature_obj = Signature(signature)
recovered_pubkey = signature_obj.recover_public_key_from_msg(data)
return recovered_pubkey.to_canonical_address() == address
def recover_public_key(message, signature_bytes):
signature = Signature(signature_bytes)
public_key = signature.recover_public_key_from_msg(message)
return public_key
