def verify_signature(self, vk: VerifyingKey):
try:
vk.verify(bytes.fromhex(self.signature),
self.display().encode("utf-8"))
return True
except BadSignatureError:
return False
def verify_original_data(self, verifier: VerifyingKey) -> bool:
"""
original_dataをVerify
:param verifier:
:return:
"""
#print(self.original_data_with_signature)
#print(self.signature)
return verifier.verify(self.signature, self.original_data, hashlib.sha256, sigdecode=sigdecode_der)
def verify(
verifying_key: VerifyingKey,
message_digest_bytes: bytes,
signature_bytes: bytes,
) -> bool:
return verifying_key.verify(
signature_bytes,
message_digest_bytes,
hashfunc=IdentityHash,
sigdecode=sigdecode_der,
)
def verify_signature(public_key: ecdsa.VerifyingKey, signature_base64: str,
message: str):
"""
Verify the given bas64-encoded signature with the base64-encoded public
key and serialized message. The message should not contain any whitespaces.
Raise ValidationError if unsuccessful.
"""
signature = base64.b64decode(signature_base64)
msg_bytes = bytearray(message, "utf-8")
return public_key.verify(signature, msg_bytes, hashfunc=hashlib.sha256)
def verify(cls, encoded, key: VerifyingKey, external_aad: bytes):
decoded = loads(encoded)
tag = decoded.tag
(protected, unprotected, payload, signature) = decoded.value
sign_structure = Signature1Message.sign_structure(
"Signature1", protected, payload, external_aad)
to_verify = dumps(sign_structure)
if not key.verify(signature,
to_verify,
hashlib.sha256,
sigdecode=util.sigdecode_string):
raise SignatureVerificationFailed()
return payload
def verify_message(public_key: ecdsa.VerifyingKey, message: str, _signature: str) -> bool:
"""verifies message and signature against public_key"""
signature = binascii.unhexlify(_signature)
return public_key.verify(signature, bytes(message, "utf-8"))
