def test_deteministic_key_pair_is_same(self):
seed = b'm\xea#\xbb\xady\xea\xf5Y\x1fz\xe5\xd0\x9d\x0f&\xee\xfb=$u\x08\x80\x04\xcf\xf1\x14*\xc9\x0e<g'
sk_b58, vk_b58 = ed25519_generate_key_pair(seed)
sk_2_b58, vk_2_b58 = ed25519_generate_key_pair(seed)
assert len(base58.b58decode(sk_b58)) == 32
assert len(base58.b58decode(vk_b58)) == 32
assert SigningKey(sk_b58).encode() == sk_b58
assert VerifyingKey(vk_b58).encode() == vk_b58
assert len(base58.b58decode(sk_2_b58)) == 32
assert len(base58.b58decode(vk_2_b58)) == 32
assert SigningKey(sk_2_b58).encode() == sk_2_b58
assert VerifyingKey(vk_2_b58).encode() == vk_2_b58
assert sk_b58 == sk_2_b58
assert vk_b58 == vk_2_b58
def create_fulfillment_ed25519sha256(self, sk_ilp, vk_ilp):
sk = SigningKey(sk_ilp['b58'])
vk = VerifyingKey(vk_ilp['b58'])
fulfillment = Ed25519Fulfillment(public_key=vk)
fulfillment.sign(MESSAGE, sk)
return fulfillment
def test_to_bytes(self, sk_ilp, vk_ilp):
sk = SigningKey(sk_ilp['b58'])
assert sk.encode(encoding='base58') == sk_ilp['b58']
assert sk.encode(encoding='base64') == sk_ilp['b64']
vk = VerifyingKey(vk_ilp['b58'])
assert vk.encode(encoding='base58') == vk_ilp['b58']
assert vk.encode(encoding='base64') == vk_ilp['b64']
def test_ilp_keys(self, sk_ilp, vk_ilp):
sk = SigningKey(sk_ilp['b58'])
assert sk.encode(encoding='base64') == sk_ilp['b64']
assert binascii.hexlify(
sk.encode(encoding='bytes')[:32]) == sk_ilp['hex']
vk = VerifyingKey(vk_ilp['b58'])
assert vk.encode(encoding='base64') == vk_ilp['b64']
assert binascii.hexlify(vk.encode(encoding='bytes')) == vk_ilp['hex']
def test_sign_verify(self, sk_ilp, vk_ilp):
message = b'Hello World!'
sk = SigningKey(sk_ilp['b58'])
vk = VerifyingKey(vk_ilp['b58'])
assert vk.verify(message, sk.sign(message)) is True
assert vk.verify(message, sk.sign(message + b'dummy')) is False
assert vk.verify(message + b'dummy', sk.sign(message)) is False
vk = VerifyingKey(vk_ilp[2]['b64'], encoding='base64')
assert vk.verify(message, sk.sign(message)) is False
def test_generate_sign_verify(self, vk_ilp):
sk_b58, vk_b58 = ed25519_generate_key_pair()
sk = SigningKey(sk_b58)
vk = VerifyingKey(vk_b58)
message = b'Hello World!'
assert vk.verify(message, sk.sign(message)) is True
assert vk.verify(message, sk.sign(message + b'dummy')) is False
assert vk.verify(message + b'dummy', sk.sign(message)) is False
vk = VerifyingKey(vk_ilp[2]['b64'], encoding='base64')
assert vk.verify(message, sk.sign(message)) is False
def test_serialize_deserialize_fulfillment(self, sk_ilp, vk_ilp):
sk = SigningKey(sk_ilp['b58'])
vk = VerifyingKey(vk_ilp['b58'])
fulfillment = Ed25519Fulfillment(public_key=vk)
fulfillment.sign(MESSAGE, sk)
assert fulfillment.validate(MESSAGE)
deserialized_fulfillment = Fulfillment.from_uri(
fulfillment.serialize_uri())
assert isinstance(deserialized_fulfillment, Ed25519Fulfillment)
assert deserialized_fulfillment.serialize_uri(
) == fulfillment.serialize_uri()
assert deserialized_fulfillment.condition.serialize_uri(
) == fulfillment.condition.serialize_uri()
assert deserialized_fulfillment.public_key.encode(encoding='bytes') == \
fulfillment.public_key.encode(encoding='bytes')
assert deserialized_fulfillment.validate(MESSAGE)
def test_serialize_condition_and_validate_fulfillment(
self, sk_ilp, vk_ilp, fulfillment_ed25519):
sk = SigningKey(sk_ilp['b58'])
vk = VerifyingKey(vk_ilp['b58'])
fulfillment = Ed25519Fulfillment(public_key=vk)
assert fulfillment.condition.serialize_uri(
) == fulfillment_ed25519['condition_uri']
assert binascii.hexlify(fulfillment.condition.hash
) == fulfillment_ed25519['condition_hash']
# ED25519-SHA256 condition not fulfilled
assert fulfillment.validate() == False
# Fulfill an ED25519-SHA256 condition
fulfillment.sign(MESSAGE, sk)
assert fulfillment.serialize_uri(
) == fulfillment_ed25519['fulfillment_uri']
assert fulfillment.validate(MESSAGE)
import binascii
import base58
import cryptoconditions as cc
from cryptoconditions.crypto import Ed25519SigningKey as SigningKey
message = 'Hello World! Conditions are here!'
sk_b58 = base58.b58encode(binascii.unhexlify('833fe62409237b9d62ec77587520911e9a759cec1d19755b7da901b96dca3d42'))
sk = SigningKey(sk_b58)
ed25519_fulfillment = cc.Ed25519Sha256()
ed25519_fulfillment.sign(message, sk)
print(ed25519_fulfillment.condition_uri)
# prints 'cc:4:20:7Bcrk61eVjv0kyxw4SRQNMNUZ-8u_U1k6_gZaDRn4r8:96'
print(ed25519_fulfillment.serialize_uri())
# prints 'cf:4:7Bcrk61eVjv0kyxw4SRQNMNUZ-8u_U1k6_gZaDRn4r-2IpH62UMvjymLnEpIldvik_b_2hpo2t8Mze9fR6DHISpf6jzal6P0wD6p8ui
# 'sHOyGpR1FISer26CdG28zHAcK'
fulfillment_uri = 'cf:4:7Bcrk61eVjv0kyxw4SRQNMNUZ-8u_U1k6_gZaDRn4r-2IpH62UMvjymLnEpIldvik_b_2hpo2t8Mze9fR6DHISpf6jzal' \
'6P0wD6p8uisHOyGpR1FISer26CdG28zHAcK'
condition_uri = 'cc:4:20:7Bcrk61eVjv0kyxw4SRQNMNUZ-8u_U1k6_gZaDRn4r8:96'
fulfillment = cc.Fulfillment.from_uri(fulfillment_uri)
result = fulfillment.validate(message) and condition_uri == fulfillment.condition_uri
print(result)
sk_b58 = base58.b58encode(binascii.unhexlify('1a3ab1a87f000348f391613930cc49529652ecf2d2c7cadfd96e87a7f6de948a'))
sk = SigningKey(sk_b58)
def test_generate_key_pair(self):
sk_b58, vk_b58 = ed25519_generate_key_pair()
assert len(base58.b58decode(sk_b58)) == 32
assert len(base58.b58decode(vk_b58)) == 32
assert SigningKey(sk_b58).encode() == sk_b58
assert VerifyingKey(vk_b58).encode() == vk_b58
def test_get_verifying_key(self, sk_ilp, vk_ilp):
sk = SigningKey(sk_ilp['b58'])
vk = VerifyingKey(vk_ilp['b58'])
vk_from_sk = sk.get_verifying_key()
assert vk.encode(encoding='bytes') == vk_from_sk.encode(
encoding='bytes')
def test_signing_key_decode(self, sk_ilp):
sk = SigningKey(sk_ilp['b58'])
private_value = sk.encode(encoding='base64')
assert private_value == sk_ilp['b64']
def test_signing_key_init(self, sk_ilp):
sk = SigningKey(sk_ilp['b58'])
assert sk.encode(encoding='base64') == sk_ilp['b64']
assert sk.encode(encoding='bytes') == sk_ilp['byt']
def test_signing_key_encode(self, sk_ilp):
sk = SigningKey(sk_ilp['b64'], encoding='base64')
private_value_base58 = sk.encode(encoding="base58")
assert private_value_base58 == sk_ilp['b58']
