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