def test_id_nonce_signing(private_key, id_nonce):
signature = V4IdentityScheme.create_id_nonce_signature(
id_nonce=id_nonce,
private_key=private_key,
)
signature_object = NonRecoverableSignature(signature)
assert signature_object.verify_msg(id_nonce, PrivateKey(private_key).public_key)
def test_id_nonce_signing(private_key, id_nonce, ephemeral_key):
ephemeral_public_key = PrivateKey(ephemeral_key).public_key.to_bytes()
signature = V4IdentityScheme.create_id_nonce_signature(
id_nonce=id_nonce,
private_key=private_key,
ephemeral_public_key=ephemeral_public_key,
)
signature_object = NonRecoverableSignature(signature)
message_hash = sha256(ID_NONCE_SIGNATURE_PREFIX + id_nonce + ephemeral_public_key).digest()
assert signature_object.verify_msg_hash(message_hash, PrivateKey(private_key).public_key)
def validate_signature(cls, enr: "ENR") -> None:
public_key = PublicKey.from_compressed_bytes(
enr[cls.public_key_enr_key])
message = enr.get_signing_message()
try:
signature = NonRecoverableSignature(enr.signature)
except BadSignature:
is_valid = False
else:
is_valid = signature.verify_msg(message, public_key)
if not is_valid:
raise ValidationError("Invalid signature")
def validate_signature(cls, *, message: bytes, signature: bytes,
public_key: bytes) -> None:
public_key_object = PublicKey.from_compressed_bytes(public_key)
try:
signature_object = NonRecoverableSignature(signature)
except BadSignature:
is_valid = False
else:
is_valid = signature_object.verify_msg(message, public_key_object)
if not is_valid:
raise ValidationError(
f"Signature {encode_hex(signature)} is not valid for message {encode_hex(message)} "
f"and public key {encode_hex(public_key)}")
def test_id_nonce_signing(private_key, iv, header, who_are_you, ephemeral_key,
recipient_node_id):
ephemeral_public_key = PrivateKey(ephemeral_key).public_key.to_bytes()
signature = V4HandshakeScheme.create_id_nonce_signature(
signature_inputs=SignatureInputs(iv, header, who_are_you,
ephemeral_public_key,
recipient_node_id),
private_key=private_key,
)
signature_object = NonRecoverableSignature(signature)
message_hash = sha256(ID_NONCE_SIGNATURE_PREFIX + iv +
header.to_wire_bytes() +
who_are_you.to_wire_bytes() + ephemeral_public_key +
recipient_node_id).digest()
assert signature_object.verify_msg_hash(message_hash,
PrivateKey(private_key).public_key)
def test_enr_signing():
private_key = PrivateKey(b"\x11" * 32)
unsigned_enr = UnsignedENR(0, {
b"id": b"v4",
b"secp256k1": private_key.public_key.to_compressed_bytes(),
b"key1": b"value1",
})
signature = V4IdentityScheme.create_enr_signature(unsigned_enr, private_key.to_bytes())
message_hash = keccak(unsigned_enr.get_signing_message())
assert private_key.public_key.verify_msg_hash(message_hash, NonRecoverableSignature(signature))
def ecdsa_sign_non_recoverable(
self, msg_hash: bytes,
private_key: PrivateKey) -> NonRecoverableSignature:
private_key_bytes = private_key.to_bytes()
der_encoded_signature = self.keys.PrivateKey(private_key_bytes).sign(
msg_hash,
hasher=None,
)
rs = der.two_int_sequence_decoder(der_encoded_signature)
signature = NonRecoverableSignature(rs=rs, backend=self)
return signature
