From 7aa3228844f45b20aa3e0d21e55f9819a2e2552c Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?J=C3=BCrgen=20Eckel?= Date: Wed, 15 Jun 2022 10:31:29 +0200 Subject: [PATCH] adjusted zenroom integraiton tests MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: Jürgen Eckel --- integration/python/Dockerfile | 4 +- integration/python/src/conftest.py | 76 +++++++--------- integration/python/src/test_zenroom.py | 118 +++++++++++++++---------- 3 files changed, 105 insertions(+), 93 deletions(-) diff --git a/integration/python/Dockerfile b/integration/python/Dockerfile index 65f5e15..bb51e0c 100644 --- a/integration/python/Dockerfile +++ b/integration/python/Dockerfile @@ -12,6 +12,6 @@ RUN pip install --upgrade \ planetmint-driver~=0.9.0 \ pycco \ websocket-client~=0.47.0 \ - git+https://github.com/planetmint/cryptoconditions.git@gitzenroom \ - git+https://github.com/planetmint/planetmint-driver.git@gitzenroom \ + planetmint-cryptoconditions>=0.9.7\ + planetmint-driver>=0.9.2 \ blns \ No newline at end of file diff --git a/integration/python/src/conftest.py b/integration/python/src/conftest.py index 808914b..70614c6 100644 --- a/integration/python/src/conftest.py +++ b/integration/python/src/conftest.py @@ -5,36 +5,40 @@ import pytest -GENERATE_KEYPAIR = \ - """Rule input encoding base58 - Rule output encoding base58 - Scenario 'ecdh': Create the keypair - Given that I am known as 'Pippo' - When I create the ecdh key - When I create the testnet key - Then print data""" - -# secret key to public key -SK_TO_PK = \ - """Rule input encoding base58 - Rule output encoding base58 - Scenario 'ecdh': Create the keypair - Given that I am known as '{}' - Given I have the 'keys' - When I create the ecdh public key - When I create the testnet address - Then print my 'ecdh public key' - Then print my 'testnet address'""" - +CONDITION_SCRIPT = """ + Scenario 'ecdh': create the signature of an object + Given I have the 'keyring' + Given that I have a 'string dictionary' named 'houses' inside 'asset' + When I create the signature of 'houses' + Then print the 'signature'""" + FULFILL_SCRIPT = \ - """Rule input encoding base58 - Rule output encoding base58 - Scenario 'ecdh': Bob verifies the signature from Alice + """Scenario 'ecdh': Bob verifies the signature from Alice Given I have a 'ecdh public key' from 'Alice' Given that I have a 'string dictionary' named 'houses' inside 'asset' - Given I have a 'signature' named 'data.signature' inside 'result' - When I verify the 'houses' has a signature in 'data.signature' by 'Alice' + Given I have a 'signature' named 'signature' inside 'result' + When I verify the 'houses' has a signature in 'signature' by 'Alice' Then print the string 'ok'""" + +SK_TO_PK = \ + """Scenario 'ecdh': Create the keypair + Given that I am known as '{}' + Given I have the 'keyring' + When I create the ecdh public key + When I create the bitcoin address + Then print my 'ecdh public key' + Then print my 'bitcoin address'""" + +GENERATE_KEYPAIR = \ + """Scenario 'ecdh': Create the keypair + Given that I am known as 'Pippo' + When I create the ecdh key + When I create the bitcoin key + Then print data""" + +ZENROOM_DATA = { + 'also': 'more data' +} HOUSE_ASSETS = { "data": { @@ -51,45 +55,31 @@ HOUSE_ASSETS = { } } -ZENROOM_DATA = { - 'also': 'more data' +metadata = { + 'units': 300, + 'type': 'KG' } -CONDITION_SCRIPT = """Rule input encoding base58 - Rule output encoding base58 - Scenario 'ecdh': create the signature of an object - Given I have the 'keys' - Given that I have a 'string dictionary' named 'houses' inside 'asset' - When I create the signature of 'houses' - When I rename the 'signature' to 'data.signature' - Then print the 'data.signature'""" - - @pytest.fixture def gen_key_zencode(): return GENERATE_KEYPAIR - @pytest.fixture def secret_key_to_private_key_zencode(): return SK_TO_PK - @pytest.fixture def fulfill_script_zencode(): return FULFILL_SCRIPT - @pytest.fixture def condition_script_zencode(): return CONDITION_SCRIPT - @pytest.fixture def zenroom_house_assets(): return HOUSE_ASSETS - @pytest.fixture def zenroom_data(): return ZENROOM_DATA diff --git a/integration/python/src/test_zenroom.py b/integration/python/src/test_zenroom.py index 8f749a6..922b917 100644 --- a/integration/python/src/test_zenroom.py +++ b/integration/python/src/test_zenroom.py @@ -1,67 +1,61 @@ -# GOAL: -# In this script I tried to implement the ECDSA signature using zenroom - -# However, the scripts are customizable and so with the same procedure -# we can implement more complex smart contracts - -# PUBLIC IDENTITY -# The public identity of the users in this script (Bob and Alice) -# is the pair (ECDH public key, Testnet address) - import json +import base58 +from hashlib import sha3_256 +from cryptoconditions.types.zenroom import ZenroomSha256 +from planetmint_driver.crypto import generate_keypair +from .helper.hosts import Hosts +import time -from cryptoconditions import ZenroomSha256 -from json.decoder import JSONDecodeError +def test_zenroom_signing(gen_key_zencode, secret_key_to_private_key_zencode, + fulfill_script_zencode, zenroom_data, zenroom_house_assets, + condition_script_zencode): + biolabs = generate_keypair() + version = '2.0' -def test_zenroom(gen_key_zencode, secret_key_to_private_key_zencode, fulfill_script_zencode, - condition_script_zencode, zenroom_data, zenroom_house_assets): - alice = json.loads(ZenroomSha256.run_zenroom(gen_key_zencode).output)['keys'] - bob = json.loads(ZenroomSha256.run_zenroom(gen_key_zencode).output)['keys'] + alice = json.loads(ZenroomSha256.run_zenroom(gen_key_zencode).output)['keyring'] + bob = json.loads(ZenroomSha256.run_zenroom(gen_key_zencode).output)['keyring'] zen_public_keys = json.loads(ZenroomSha256.run_zenroom(secret_key_to_private_key_zencode.format('Alice'), - keys={'keys': alice}).output) + keys={'keyring': alice}).output) zen_public_keys.update(json.loads(ZenroomSha256.run_zenroom(secret_key_to_private_key_zencode.format('Bob'), - keys={'keys': bob}).output)) + keys={'keyring': bob}).output)) - # CRYPTO-CONDITIONS: instantiate an Ed25519 crypto-condition for buyer - zenSha = ZenroomSha256(script=fulfill_script_zencode, keys=zen_public_keys, data=zenroom_data) + + zenroomscpt = ZenroomSha256(script=fulfill_script_zencode, data=zenroom_data, keys=zen_public_keys) + print(F'zenroom is: {zenroomscpt.script}') + # CRYPTO-CONDITIONS: generate the condition uri - condition_uri = zenSha.condition.serialize_uri() + condition_uri_zen = zenroomscpt.condition.serialize_uri() + print(F'\nzenroom condition URI: {condition_uri_zen}') # CRYPTO-CONDITIONS: construct an unsigned fulfillment dictionary - unsigned_fulfillment_dict = { - 'type': zenSha.TYPE_NAME, - 'script': fulfill_script_zencode, - 'keys': zen_public_keys, + unsigned_fulfillment_dict_zen = { + 'type': zenroomscpt.TYPE_NAME, + 'public_key': base58.b58encode(biolabs.public_key).decode(), } - output = { - 'amount': '1000', + 'amount': '10', 'condition': { - 'details': unsigned_fulfillment_dict, - 'uri': condition_uri, - }, - 'data': zenroom_data, - 'script': fulfill_script_zencode, - 'conf': '', - 'public_keys': (zen_public_keys['Alice']['ecdh_public_key'], ), - } + 'details': unsigned_fulfillment_dict_zen, + 'uri': condition_uri_zen, + }, + 'public_keys': [biolabs.public_key,], + } input_ = { 'fulfillment': None, 'fulfills': None, - 'owners_before': (zen_public_keys['Alice']['ecdh_public_key'], ), + 'owners_before': [biolabs.public_key,] } - token_creation_tx = { 'operation': 'CREATE', 'asset': zenroom_house_assets, 'metadata': None, - 'outputs': (output,), - 'inputs': (input_,), - 'version': '2.0', + 'outputs': [output,], + 'inputs': [input_,], + 'version': version, 'id': None, } @@ -73,12 +67,40 @@ def test_zenroom(gen_key_zencode, secret_key_to_private_key_zencode, fulfill_scr ensure_ascii=False, ) - try: - assert(not zenSha.validate(message=message)) - except JSONDecodeError: - pass - except ValueError: - pass + # major workflow: + # we store the fulfill script in the transaction/message (zenroom-sha) + # the condition script is used to fulfill the transaction and create the signature + # + # the server should ick the fulfill script and recreate the zenroom-sha and verify the signature - message = zenSha.sign(message, condition_script_zencode, alice) - assert(zenSha.validate(message=message)) + + + message = zenroomscpt.sign(message, condition_script_zencode, alice) + assert(zenroomscpt.validate(message=message)) + + message = json.loads(message) + fulfillment_uri_zen = zenroomscpt.serialize_uri() + + message['inputs'][0]['fulfillment'] = fulfillment_uri_zen + tx = message + tx['id'] = None + json_str_tx = json.dumps( + tx, + sort_keys=True, + skipkeys=False, + separators=(',', ':') + ) + # SHA3: hash the serialized id-less transaction to generate the id + shared_creation_txid = sha3_256(json_str_tx.encode()).hexdigest() + message['id'] = shared_creation_txid + + hosts = Hosts('/shared/hostnames') + pm_alpha = hosts.get_connection() + + + sent_transfer_tx = pm_alpha.transactions.send_commit(message) + time.sleep(1) + + # Assert that transaction is stored on both planetmint nodes + hosts.assert_transaction(shared_creation_txid) + print( f"\n\nstatus and result : + {sent_transfer_tx}")