def verify_signature(self, tx: 'Transaction'):
sign_verifier = SignVerifier.from_address(tx.from_address.hex_xx())
try:
sign_verifier.verify_hash(tx.hash, tx.signature)
except Exception as e:
exception = RuntimeError(f"tx({tx}) invalid signature\n" f"{e}")
self._handle_exceptions(exception)
def verify(self):
hash_ = self.to_hash(**self.origin_args())
sign_verifier = SignVerifier.from_address(self.rep.hex_hx())
try:
sign_verifier.verify_hash(hash_, self.signature)
except Exception as e:
raise RuntimeError(f"Invalid vote signature. {self}"
f"{e}")
def verify_signature(self, tx: 'Transaction'):
if self._allow_unsigned and not tx.is_signed():
return
sign_verifier = SignVerifier.from_address(tx.signer_address.hex_xx())
try:
sign_verifier.verify_hash(tx.hash, tx.signature)
except Exception as e:
exception = TransactionInvalidSignatureError(tx, message=str(e))
self._handle_exceptions(exception)
def verify_signature(self, block: 'Block'):
sign_verifier = SignVerifier.from_address(
block.header.peer_id.hex_xx())
try:
sign_verifier.verify_hash(block.header.hash,
block.header.signature)
except Exception as e:
exception = RuntimeError(
f"Block({block.header.height}, {block.header.hash.hex()}, "
f"Invalid Signature\n"
f"{e}")
self._handle_exception(exception)
def setUpClass(cls) -> None:
cls.temp_dir = tempfile.TemporaryDirectory()
# Private Key
cls.private_key = ec.generate_private_key(ec.SECP256K1, default_backend())
cls.private_der_path = os.path.join(cls.temp_dir.name, "private.der")
with open(cls.private_der_path, "wb") as private_der_file:
private_der_file.write(
cls.private_key.private_bytes(
encoding=serialization.Encoding.DER,
format=serialization.PrivateFormat.PKCS8,
encryption_algorithm=serialization.BestAvailableEncryption(b"TEST")
)
)
cls.private_pem_path = os.path.join(cls.temp_dir.name, "private.pem")
with open(cls.private_pem_path, "wb") as private_pem_file:
private_pem_file.write(
cls.private_key.private_bytes(
encoding=serialization.Encoding.PEM,
format=serialization.PrivateFormat.PKCS8,
encryption_algorithm=serialization.BestAvailableEncryption(b"TEST")
)
)
key_info = keys.PrivateKeyInfo.load(cls.private_key.private_bytes(
encoding=serialization.Encoding.DER,
format=serialization.PrivateFormat.PKCS8,
encryption_algorithm=serialization.NoEncryption()
))
cls.private_key_bytes = long_to_bytes(key_info['private_key'].native['private_key'])
# Public Key
cls.public_key = cls.private_key.public_key()
cls.public_der_path = os.path.join(cls.temp_dir.name, "public.der")
with open(cls.public_der_path, "wb") as public_der_file:
public_der_file.write(
cls.public_key.public_bytes(
encoding=serialization.Encoding.DER,
format=serialization.PublicFormat.SubjectPublicKeyInfo
)
)
cls.public_pem_path = os.path.join(cls.temp_dir.name, "public.pem")
with open(cls.public_pem_path, "wb") as public_pem_file:
public_pem_file.write(
cls.public_key.public_bytes(
encoding=serialization.Encoding.PEM,
format=serialization.PublicFormat.SubjectPublicKeyInfo
)
)
key_info = keys.PublicKeyInfo.load(
cls.public_key.public_bytes(
encoding=serialization.Encoding.DER,
format=serialization.PublicFormat.SubjectPublicKeyInfo
)
)
cls.public_key_bytes = key_info['public_key'].native
cls.signer_private_key_bytes = Signer.from_prikey(cls.private_key_bytes)
cls.signer_private_key_der = Signer.from_prikey_file(cls.private_der_path, b"TEST")
cls.signer_private_key_pem = Signer.from_prikey_file(cls.private_pem_path, b"TEST")
cls.sign_verifier_private_key_bytes = SignVerifier.from_prikey(cls.private_key_bytes)
cls.sign_verifier_private_key_der = SignVerifier.from_prikey_file(cls.private_der_path, b"TEST")
cls.sign_verifier_private_key_pem = SignVerifier.from_prikey_file(cls.private_pem_path, b"TEST")
cls.sign_verifier_public_key_bytes = SignVerifier.from_pubkey(cls.public_key_bytes)
cls.sign_verifier_public_key_der = SignVerifier.from_pubkey_file(cls.public_der_path)
cls.sign_verifier_public_key_pem = SignVerifier.from_pubkey_file(cls.public_pem_path)