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_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_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_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_sign_verify(self, sk_ilp, vk_ilp): message = '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 + 'dummy')) is False assert vk.verify(message + 'dummy', sk.sign(message)) is False vk = VerifyingKey( VerifyingKey.encode( base64_add_padding(vk_ilp[2]['b64']))) assert vk.verify(message, sk.sign(message)) is False
def sign_transaction(transaction, *, public_key, private_key): ed25519 = Ed25519Fulfillment(public_key=public_key) message = json.dumps( transaction, sort_keys=True, separators=(',', ':'), ensure_ascii=False, ) ed25519.sign(message.encode(), Ed25519SigningKey(private_key)) return ed25519.serialize_uri()
def persisted_transfer_dimi_car_to_ewy(dimi_keypair, ewy_pubkey, transactions_api_full_url, persisted_transfer_carol_car_to_dimi): output_txid = persisted_transfer_carol_car_to_dimi['id'] ed25519_ewy = Ed25519Fulfillment(public_key=ewy_pubkey) transaction = { 'asset': { 'id': persisted_transfer_carol_car_to_dimi['asset']['id'] }, 'metadata': None, 'operation': 'TRANSFER', 'outputs': ({ 'amount': 1, 'condition': { 'details': ed25519_ewy.to_dict(), 'uri': ed25519_ewy.condition_uri, }, 'public_keys': (ewy_pubkey, ), }, ), 'inputs': ({ 'fulfillment': None, 'fulfills': { 'output': 0, 'txid': output_txid, }, 'owners_before': (dimi_keypair.public_key, ), }, ), 'version': '0.9', } serialized_transaction_without_id = json.dumps( transaction, sort_keys=True, separators=(',', ':'), ensure_ascii=False, ).encode() transaction['id'] = sha3_256(serialized_transaction_without_id).hexdigest() serialized_transaction_with_id = json.dumps( transaction, sort_keys=True, separators=(',', ':'), ensure_ascii=False, ).encode() ed25519_dimi = Ed25519Fulfillment(public_key=dimi_keypair.public_key) ed25519_dimi.sign(serialized_transaction_with_id, Ed25519SigningKey(dimi_keypair.private_key)) transaction['inputs'][0]['fulfillment'] = ed25519_dimi.serialize_uri() response = requests.post(transactions_api_full_url, json=transaction) return response.json()
def test_fulfill(self, driver, alice_keypair, unsigned_transaction): signed_transaction = driver.transactions.fulfill( unsigned_transaction, private_keys=alice_keypair.sk) unsigned_transaction['inputs'][0]['fulfillment'] = None message = json.dumps( unsigned_transaction, sort_keys=True, separators=(',', ':'), ensure_ascii=False, ).encode() ed25519 = Ed25519Fulfillment(public_key=alice_keypair.vk) ed25519.sign(message, Ed25519SigningKey(alice_keypair.sk)) fulfillment_uri = ed25519.serialize_uri() assert signed_transaction['inputs'][0]['fulfillment'] == fulfillment_uri # noqa
# # # This is to confirm that my company has agreed to and accepted the BigchainDB Entity Contributor Agreement # # at https://www.bigchaindb.com/cla/ and to represent and warrant that I have authority to do so. # # # # USq6mSPklezAirGcWi6ntfAlG2OhEobGhnNIstM6xH4UCZGX5KgXQemE4wLk0R6 # ################################################################################################################ 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.encode(), base58.b58decode(sk.encode())) print(ed25519_fulfillment.condition_uri) # prints 'ni:///sha-256;U1YhFdW0lOI-SVF3PbDP4t_lVefj_-tB5P11yvfBaoE?fpt=ed25519-sha-256&cost=131072' print(ed25519_fulfillment.serialize_uri()) # prints 'pGSAIOwXK5OtXlY79JMscOEkUDTDVGfvLv1NZOv4GWg0Z-K_gUC2IpH62UMvjymLnEpIldvik_b_2hpo2t8Mze9fR6D' \ # 'HISpf6jzal6P0wD6p8uisHOyGpR1FISer26CdG28zHAcK' fulfillment_uri = 'pGSAIOwXK5OtXlY79JMscOEkUDTDVGfvLv1NZOv4GWg0Z-K_gUC2IpH62UMvjymLnEpIldvik_b_' \ '2hpo2t8Mze9fR6DHISpf6jzal6P0wD6p8uisHOyGpR1FISer26CdG28zHAcK' condition_uri = 'ni:///sha-256;U1YhFdW0lOI-SVF3PbDP4t_lVefj_-tB5P11yvfBaoE?fpt=ed25519-sha-256&cost=131072' fulfillment = cc.Fulfillment.from_uri(fulfillment_uri)
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): private_value = SigningKey.decode(sk_ilp['b58']) assert private_value == base64_add_padding(sk_ilp['b64'])
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.to_bytes() == vk_from_sk.to_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']
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.encode(SigningKey.decode(sk_b58)) == sk_b58 assert VerifyingKey.encode(VerifyingKey.decode(vk_b58)) == vk_b58
# condition details were passed around off-chain, needs signing # otherwise load the condition from the condition details in the output of the input_tx fulfillment = \ Fulfillment.from_dict( tx_transfer_custom_condition_signed['outputs'][0]['condition']['details'] ) assert condition.condition_uri == fulfillment.condition_uri # message_to_sign is the serialized transaction without the fulfillments message_to_sign = get_message_to_sign(tx_transfer_custom_fulfillment) # bob & carly create the fulfillment # by signing the message with their private key # fulfillment is updated by reference subcondition_bob = get_subcondition(fulfillment, public_key=bob.public_key) subcondition_bob.sign(message_to_sign, Ed25519SigningKey(bob.private_key)) # not valid yet, still a signature and a secret needed assert condition.validate(message_to_sign) is False subcondition_carly = get_subcondition(fulfillment, public_key=carly.public_key) subcondition_carly.sign(message_to_sign, Ed25519SigningKey(carly.private_key)) # not valid yet, still a secret needed assert condition.validate(message_to_sign) is False # update a subcondition with a new subfulfillment in a nested fulfillment # ie replace the hashlock condition by its secret fulfillment # fulfill_subcondition returns a new fulfillment with the updated subfulfillment fulfillment = \ fulfill_subcondition( fulfillment, condition_uri=get_subcondition(fulfillment, type_id=PreimageSha256Fulfillment.TYPE_ID).serialize_uri(), new_subfulfillment=PreimageSha256Fulfillment(preimage=b'secret')
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_signing_key_init(self, sk_ilp): sk = SigningKey(sk_ilp['b58']) assert sk.to_ascii(encoding='base64') == sk_ilp['b64'] assert sk.to_seed() == sk_ilp['byt']
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 create_transfer(prev_tx, vw_sk, vw_pk, vehicle_id, metadata, asset_id): prev_tx = Transaction.from_dict(prev_tx) # Create asset VW -> [VW, TEL] # Custom crypto condition multisig 1-2 threshold_fulfillment = ThresholdSha256Fulfillment(threshold=1) vw_fulfillment = Ed25519Fulfillment(public_key=vw_pk) tel_fulfillment = Ed25519Fulfillment(public_key=vehicle_id) threshold_fulfillment.add_subfulfillment(vw_fulfillment) threshold_fulfillment.add_subfulfillment(tel_fulfillment) output = { 'amount': 1, 'condition': { 'details': threshold_fulfillment.to_dict(), 'uri': threshold_fulfillment.condition.serialize_uri() }, 'public_keys': [vw_pk, vehicle_id], } # The yet to be fulfilled input: input_ = { 'fulfillment': None, 'fulfills': { 'txid': prev_tx.id, 'output': 0, }, 'owners_before': [vw_pk, vehicle_id], } # Craft the payload: transfer_tx = { 'operation': 'TRANSFER', 'asset': { 'id': asset_id }, 'metadata': metadata, 'outputs': [output], 'inputs': [input_], 'version': '0.9', } # Generate the id, by hashing the encoded json formatted string # representation of the transaction: json_str_tx = json.dumps( transfer_tx, sort_keys=True, separators=(',', ':'), ensure_ascii=False, ) txid = sha3.sha3_256(json_str_tx.encode()).hexdigest() transfer_tx['id'] = txid # Sign the transaction: message = json.dumps( transfer_tx, sort_keys=True, separators=(',', ':'), ensure_ascii=False, ) threshold_fulfillment = ThresholdSha256Fulfillment(threshold=1) vw_fulfillment.sign(message.encode(), private_key=Ed25519SigningKey(vw_sk)) threshold_fulfillment.add_subfulfillment(vw_fulfillment) threshold_fulfillment.add_subcondition(tel_fulfillment.condition) fulfillment_uri = threshold_fulfillment.serialize_uri() transfer_tx['inputs'][0]['fulfillment'] = fulfillment_uri return Transaction.from_dict(transfer_tx)
def test_signing_key_encode(self, sk_ilp): private_value_base58 = SigningKey.encode(base64_add_padding(sk_ilp['b64'])) assert private_value_base58 == sk_ilp['b58']