This is an automated email from the ASF dual-hosted git repository. sandreoli pushed a commit to branch issue7-schnorr-python-wrapper in repository https://gitbox.apache.org/repos/asf/incubator-milagro-MPC.git
commit 30602c6eb6c805fbdf7dbbd37ddd75a39f602b6b Author: Samuele Andreoli <[email protected]> AuthorDate: Mon Feb 17 17:14:13 2020 +0000 First cleanup and move src into module --- python/CMakeLists.txt | 5 +- python/amcl/CMakeLists.txt | 19 ++++ python/amcl/__init__.py | 0 python/{amcl_mpc.py => amcl/mpc.py} | 134 ++++++++++++++-------------- python/{amcl_schnorr.py => amcl/schnorr.py} | 0 python/bench_mpc.py | 39 ++++---- python/example_dump_keys.py | 67 +++++--------- python/example_ecdsa.py | 94 +++++++++---------- python/example_mta.py | 78 +++++++--------- python/example_r.py | 105 ++++++++-------------- python/example_s.py | 112 ++++++++--------------- python/test_ecdsa.py | 108 +++++++++------------- python/test_mta.py | 43 ++++----- python/test_r.py | 75 ++++++++-------- python/test_s.py | 85 +++++++++--------- python/test_schnorr.py | 20 ++--- 16 files changed, 435 insertions(+), 549 deletions(-) diff --git a/python/CMakeLists.txt b/python/CMakeLists.txt index 4da1c7f..c53f313 100644 --- a/python/CMakeLists.txt +++ b/python/CMakeLists.txt @@ -17,11 +17,8 @@ cmake_minimum_required(VERSION 3.1 FATAL_ERROR) include(PythonSiteDirs) -install(FILES amcl_mpc.py DESTINATION ${PYTHON_SITE_PACKAGES}) -install(FILES amcl_schnorr.py DESTINATION ${PYTHON_SITE_PACKAGES}) +add_subdirectory(amcl) -file(COPY amcl_mpc.py DESTINATION "${PROJECT_BINARY_DIR}/python/") -file(COPY amcl_schnorr.py DESTINATION "${PROJECT_BINARY_DIR}/python/") file(COPY test_mta.py DESTINATION "${PROJECT_BINARY_DIR}/python/") file(COPY test_r.py DESTINATION "${PROJECT_BINARY_DIR}/python/") file(COPY test_s.py DESTINATION "${PROJECT_BINARY_DIR}/python/") diff --git a/python/amcl/CMakeLists.txt b/python/amcl/CMakeLists.txt new file mode 100644 index 0000000..b92ebd8 --- /dev/null +++ b/python/amcl/CMakeLists.txt @@ -0,0 +1,19 @@ +# Licensed to the Apache Software Foundation (ASF) under one or more contributor +# license agreements. See the NOTICE file distributed with this work for +# additional information regarding copyright ownership. The ASF licenses this +# file to you under the Apache License, Version 2.0 (the "License"); you may not +# use this file except in compliance with the License. You may obtain a copy of +# the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT +# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the +# License for the specific language governing permissions and limitations under +# the License. + +file(GLOB SRCS *.py) +file(COPY ${SRCS} DESTINATION "${PROJECT_BINARY_DIR}/python/amcl") + +install(FILES ${SRCS} DESTINATION ${PYTHON_SITE_PACKAGES}/amcl) diff --git a/python/amcl/__init__.py b/python/amcl/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/python/amcl_mpc.py b/python/amcl/mpc.py similarity index 89% rename from python/amcl_mpc.py rename to python/amcl/mpc.py index 48ea776..58af8b1 100644 --- a/python/amcl_mpc.py +++ b/python/amcl/mpc.py @@ -112,17 +112,17 @@ extern void MPC_DUMP_PAILLIER_SK(PAILLIER_private_key *PRIV, octet *P, octet *Q) if (platform.system() == 'Windows'): libamcl_mpc = ffi.dlopen("libamcl_mpc.dll") libamcl_paillier = ffi.dlopen("libamcl_paillier.dll") - libamcl_curve_secp256k1 = ffi.dlopen("libamcl_curve_SECP256K1.dll") + libamcl_curve_secp256k1 = ffi.dlopen("libamcl_curve_SECP256K1.dll") libamcl_core = ffi.dlopen("libamcl_core.dll") elif (platform.system() == 'Darwin'): libamcl_mpc = ffi.dlopen("libamcl_mpc.dylib") - libamcl_paillier = ffi.dlopen("libamcl_paillier.dylib") + libamcl_paillier = ffi.dlopen("libamcl_paillier.dylib") libamcl_curve_secp256k1 = ffi.dlopen("libamcl_curve_SECP256K1.dylib") libamcl_core = ffi.dlopen("libamcl_core.dylib") else: libamcl_mpc = ffi.dlopen("libamcl_mpc.so") libamcl_paillier = ffi.dlopen("libamcl_paillier.so") - libamcl_curve_secp256k1 = ffi.dlopen("libamcl_curve_SECP256K1.so") + libamcl_curve_secp256k1 = ffi.dlopen("libamcl_curve_SECP256K1.so") libamcl_core = ffi.dlopen("libamcl_core.so") @@ -259,15 +259,15 @@ def paillier_key_pair(rng, p=None, q=None): """ if p: p1, p1_val = make_octet(None, p) - q1, q1_val = make_octet(None, q) + q1, q1_val = make_octet(None, q) rng = ffi.NULL else: - p1 = ffi.NULL - q1 = ffi.NULL + p1 = ffi.NULL + q1 = ffi.NULL paillier_pk = ffi.new('PAILLIER_public_key*') - paillier_sk = ffi.new('PAILLIER_private_key*') - + paillier_sk = ffi.new('PAILLIER_private_key*') + libamcl_paillier.PAILLIER_KEY_PAIR(rng, p1, q1, paillier_pk, paillier_sk) return paillier_pk, paillier_sk @@ -288,12 +288,12 @@ def paillier_private_key_kill(paillier_sk): Raises: """ - libamcl_paillier.PAILLIER_PRIVATE_KEY_KILL(PAILLIER_private_key *PRIV); + libamcl_paillier.PAILLIER_PRIVATE_KEY_KILL(paillier_sk) return 0 -def paillier_pk_to_octet(paillier_pk): +def paillier_pk_to_octet(paillier_pk): """Write Paillier public key to byte array Write Paillier public key to byte array @@ -310,14 +310,14 @@ def paillier_pk_to_octet(paillier_pk): """ n1, n1_val = make_octet(FS_4096) - + libamcl_paillier.PAILLIER_PK_toOctet(n1, paillier_pk) n2 = to_str(n1) return n2 -def paillier_pk_from_octet(n): +def paillier_pk_from_octet(n): """Read Paillier public key from byte array Read Paillier public key from byte array @@ -364,18 +364,18 @@ def ecp_secp256k1_key_pair_generate(rng, ecdsa_sk=None): ecdsa_sk1, ecdsa_sk1_val = make_octet(None, ecdsa_sk) rng = ffi.NULL else: - ecdsa_sk1, ecdsa_sk1_val = make_octet(EGS_SECP256K1) + ecdsa_sk1, ecdsa_sk1_val = make_octet(EGS_SECP256K1) - ecdsa_pk1, ecdsa_pk1_val = make_octet(2 * EFS_SECP256K1) + ecdsa_pk1, ecdsa_pk1_val = make_octet(2 * EFS_SECP256K1 + 1) rc = libamcl_curve_secp256k1.ECP_SECP256K1_KEY_PAIR_GENERATE(rng, ecdsa_sk1, ecdsa_pk1) ecdsa_sk2 = to_str(ecdsa_sk1) ecdsa_pk2 = to_str(ecdsa_pk1) - + return rc, ecdsa_pk2, ecdsa_sk2 -def ecp_secp256k1_public_key_validate(ecdsa_pk): +def ecp_secp256k1_public_key_validate(ecdsa_pk): """Validate an ECDSA public key Validate an ECDSA public key @@ -394,7 +394,7 @@ def ecp_secp256k1_public_key_validate(ecdsa_pk): ecdsa_pk1, ecdsa_pk1_val = make_octet(None, ecdsa_pk) rc = libamcl_curve_secp256k1.ECP_SECP256K1_PUBLIC_KEY_VALIDATE(ecdsa_pk1) - + return rc def mpc_mta_client1(rng, paillier_pk, a, r=None): @@ -407,7 +407,7 @@ def mpc_mta_client1(rng, paillier_pk, a, r=None): rng: Pointer to cryptographically secure pseudo-random number generator instance paillier_pk: Pointer to Paillier public keys a: Multiplicative share of secret - r: R value for testing. + r: R value for testing. Returns:: @@ -424,12 +424,12 @@ def mpc_mta_client1(rng, paillier_pk, a, r=None): r1 = ffi.NULL a1, a1_val = make_octet(None, a) - ca1, ca1_val = make_octet(FS_4096) - + ca1, ca1_val = make_octet(FS_4096) + libamcl_mpc.MPC_MTA_CLIENT1(rng, paillier_pk, a1, ca1, r1) ca2 = to_str(ca1) - + return ca2 def mpc_mta_client2(paillier_sk, cb): @@ -450,12 +450,12 @@ def mpc_mta_client2(paillier_sk, cb): """ cb1, cb1_val = make_octet(None, cb) - alpha1, alpha1_val = make_octet(EGS_SECP256K1) - + alpha1, alpha1_val = make_octet(EGS_SECP256K1) + libamcl_mpc.MPC_MTA_CLIENT2(paillier_sk, cb1, alpha1) alpha2 = to_str(alpha1) - + return alpha2 def mpc_mta_server(rng, paillier_pk, b, ca, z=None, r=None): @@ -474,30 +474,30 @@ def mpc_mta_server(rng, paillier_pk, b, ca, z=None, r=None): Returns:: - cb: Ciphertext - beta: Additive share of secret + cb: Ciphertext + beta: Additive share of secret Raises: """ if r: r1, r1_val = make_octet(None, r) - z1, z1_val = make_octet(None, z) + z1, z1_val = make_octet(None, z) rng = ffi.NULL else: - r1 = ffi.NULL - z1 = ffi.NULL + r1 = ffi.NULL + z1 = ffi.NULL b1, b1_val = make_octet(None, b) - ca1, ca1_val = make_octet(None, ca) - beta1, beta1_val = make_octet(EGS_SECP256K1) - cb1, cb1_val = make_octet(FS_4096) - + ca1, ca1_val = make_octet(None, ca) + beta1, beta1_val = make_octet(EGS_SECP256K1) + cb1, cb1_val = make_octet(FS_4096) + libamcl_mpc.MPC_MTA_SERVER(rng, paillier_pk, b1, ca1, z1, r1, cb1, beta1) beta2 = to_str(beta1) - cb2 = to_str(cb1) - + cb2 = to_str(cb1) + return cb2, beta2 def mpc_sum_mta(a, b, alpha, beta): @@ -523,13 +523,13 @@ def mpc_sum_mta(a, b, alpha, beta): b1, b1_val = make_octet(None, b) alpha1, alpha1_val = make_octet(None, alpha) beta1, beta1_val = make_octet(None, beta) - + sum1, sum1_val = make_octet(EGS_SECP256K1) - - libamcl_mpc.MPC_SUM_MTA(a1, b1, alpha1, beta1, sum1); + + libamcl_mpc.MPC_SUM_MTA(a1, b1, alpha1, beta1, sum1) sum2 = to_str(sum1) - + return sum2 def mpc_invkgamma(kgamma1, kgamma2): @@ -550,14 +550,14 @@ def mpc_invkgamma(kgamma1, kgamma2): """ kgamma11, kgamma11_val = make_octet(None, kgamma1) - kgamma21, kgamma21_val = make_octet(None, kgamma2) - + kgamma21, kgamma21_val = make_octet(None, kgamma2) + invkgamma1, invkgamma1_val = make_octet(EGS_SECP256K1) - + libamcl_mpc.MPC_INVKGAMMA(kgamma11, kgamma21, invkgamma1) invkgamma2 = to_str(invkgamma1) - + return invkgamma2 def mpc_r(invkgamma, gammapt1, gammapt2): @@ -581,16 +581,16 @@ def mpc_r(invkgamma, gammapt1, gammapt2): """ invkgamma1, invkgamma1_val = make_octet(None, invkgamma) gammapt11, gammapt11_val = make_octet(None, gammapt1) - gammapt21, gammapt21_val = make_octet(None, gammapt2) - + gammapt21, gammapt21_val = make_octet(None, gammapt2) + r1, r1_val = make_octet(EGS_SECP256K1) rp, rp_val = make_octet(EFS_SECP256K1 + 1) - + rc = libamcl_mpc.MPC_R(invkgamma1, gammapt11, gammapt21, r1, rp) r2 = to_str(r1) rp_str = to_str(rp) - + return rc, r2, rp_str def mpc_hash(message): @@ -604,18 +604,18 @@ def mpc_hash(message): Returns:: - hm: hash of message + hm: hash of message Raises: """ message1, message1_val = make_octet(None, message) hm1, hm1_val = make_octet(SHA256) - + libamcl_mpc.MPC_HASH(SHA256, message1, hm1) hm2 = to_str(hm1) - + return hm2 def mpc_s(hm, r, k, sigma): @@ -641,14 +641,14 @@ def mpc_s(hm, r, k, sigma): hm1, hm1_val = make_octet(None, hm) r1, r1_val = make_octet(None, r) k1, k1_val = make_octet(None, k) - sigma1, sigma1_val = make_octet(None, sigma) + sigma1, sigma1_val = make_octet(None, sigma) s1, s1_val = make_octet(EGS_SECP256K1) - + rc = libamcl_mpc.MPC_S(hm1, r1, k1, sigma1, s1) s2 = to_str(s1) - + return rc, s2 def mpc_ecdsa_verify(hm, pk, r, s): @@ -673,8 +673,8 @@ def mpc_ecdsa_verify(hm, pk, r, s): hm1, hm1_val = make_octet(None, hm) pk1, pk1_val = make_octet(None, pk) r1, r1_val = make_octet(None, r) - s1, s1_val = make_octet(None, s) - + s1, s1_val = make_octet(None, s) + rc = libamcl_mpc.MPC_ECDSA_VERIFY(hm1, pk1, r1, s1) return rc @@ -697,14 +697,14 @@ def mpc_sum_s(s1, s2): """ s11, s11_val = make_octet(None, s1) - s21, s21_val = make_octet(None, s2) - + s21, s21_val = make_octet(None, s2) + s1, s1_val = make_octet(EGS_SECP256K1) - - libamcl_mpc.MPC_SUM_S(s11, s21, s1); + + libamcl_mpc.MPC_SUM_S(s11, s21, s1) s2 = to_str(s1) - + return s2 def mpc_sum_pk(pk1, pk2): @@ -726,14 +726,14 @@ def mpc_sum_pk(pk1, pk2): """ pk11, pk11_val = make_octet(None, pk1) - pk21, pk21_val = make_octet(None, pk2) - + pk21, pk21_val = make_octet(None, pk2) + pk1, pk1_val = make_octet(EFS_SECP256K1 + 1) - rc = libamcl_mpc.MPC_SUM_PK(pk11, pk21, pk1); + rc = libamcl_mpc.MPC_SUM_PK(pk11, pk21, pk1) pk2 = to_str(pk1) - + return rc, pk2 def mpc_dump_paillier_sk(paillier_sk): @@ -747,14 +747,14 @@ def mpc_dump_paillier_sk(paillier_sk): Returns:: - p: Secret prime number - q: Secret prime number + p: Secret prime number + q: Secret prime number Raises: """ p, p_val = make_octet(HFS_2048) - q, q_val = make_octet(HFS_2048) + q, q_val = make_octet(HFS_2048) libamcl_mpc.MPC_DUMP_PAILLIER_SK(paillier_sk, p, q) diff --git a/python/amcl_schnorr.py b/python/amcl/schnorr.py similarity index 100% rename from python/amcl_schnorr.py rename to python/amcl/schnorr.py diff --git a/python/bench_mpc.py b/python/bench_mpc.py index f6aa5b0..d246a1a 100755 --- a/python/bench_mpc.py +++ b/python/bench_mpc.py @@ -9,7 +9,7 @@ to you under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at - http://www.apache.org/licenses/LICENSE-2.0 + http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an @@ -21,12 +21,12 @@ under the License. import time import warnings -import amcl_mpc +from amcl import mpc warnings.filterwarnings("ignore") -def time_func(fncall, n=10): +def time_func(stmt, fncall, n=10): t = time.process_time() for i in range(1,i): fncall @@ -50,28 +50,28 @@ b_hex = "0000000000000000000000000000000000000000000000000000000000000003" if __name__ == "__main__": - seed = bytes.fromhex(seed_hex) + seed = bytes.fromhex(seed_hex) p = bytes.fromhex(P_hex) q = bytes.fromhex(Q_hex) a = bytes.fromhex(a_hex) b = bytes.fromhex(b_hex) ai = int(a_hex, 16) - bi = int(b_hex, 16) - expected = ai * bi % amcl_mpc.curve_order - + bi = int(b_hex, 16) + expected = ai * bi % mpc.curve_order + # random number generator - rng = amcl_mpc.create_csprng(seed) - - paillier_pk, paillier_sk = amcl_mpc.paillier_key_pair(rng) + rng = mpc.create_csprng(seed) + + paillier_pk, paillier_sk = mpc.paillier_key_pair(rng) total_time=0 for i in range(1,nIter): #t = time.process_time() t = time.time() - ca = amcl_mpc.mpc_mta_client1(rng, paillier_pk, a) + ca = mpc.mpc_mta_client1(rng, paillier_pk, a) # elapsed_time = time.process_time() - t - elapsed_time = time.time() - t + elapsed_time = time.time() - t total_time = total_time + elapsed_time iter_time = int ((total_time * 1000) / nIter) print(f"mpc_mta_client1 iteractions: {nIter} total_time: {total_time} iter_time: {iter_time}") @@ -79,7 +79,7 @@ if __name__ == "__main__": total_time=0 for i in range(1,nIter): t = time.time() - cb, beta = amcl_mpc.mpc_mta_server(rng, paillier_pk, b, ca) + cb, beta = mpc.mpc_mta_server(rng, paillier_pk, b, ca) elapsed_time = time.time() - t total_time = total_time + elapsed_time iter_time = int ((total_time * 1000) / nIter) @@ -88,18 +88,17 @@ if __name__ == "__main__": total_time=0 for i in range(1,nIter): t = time.time() - alpha = amcl_mpc.mpc_mta_client2(paillier_sk, cb) + alpha = mpc.mpc_mta_client2(paillier_sk, cb) elapsed_time = time.time() - t total_time = total_time + elapsed_time iter_time = int ((total_time * 1000) / nIter) print(f"mpc_mta_client2 iteractions: {nIter} total_time: {total_time} iter_time: {iter_time}") - + alphai = int(alpha.hex(), 16) betai = int(beta.hex(), 16) - got = ( alphai + betai ) % amcl_mpc.curve_order + got = ( alphai + betai ) % mpc.curve_order - assert got == expected, f"expected {expected.hex()} got {got.hex()}" - - # Clear memory - amcl_mpc.kill_csprng(rng) + assert got == expected, f"expected {hex(expected)} got {hex(got)}" + # Clear memory + mpc.kill_csprng(rng) diff --git a/python/example_dump_keys.py b/python/example_dump_keys.py index 71bff57..8fe5665 100755 --- a/python/example_dump_keys.py +++ b/python/example_dump_keys.py @@ -9,7 +9,7 @@ to you under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at - http://www.apache.org/licenses/LICENSE-2.0 + http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an @@ -19,88 +19,67 @@ specific language governing permissions and limitations under the License. """ -import amcl_mpc - -seed_hex = "78d0fb6705ce77dee47d03eb5b9c5d30" +from amcl import mpc P_hex = "94f689d07ba20cf7c7ca7ccbed22ae6b40c426db74eaee4ce0ced2b6f52a5e136663f5f1ef379cdbb0c4fdd6e4074d6cff21082d4803d43d89e42fd8dfa82b135aa31a8844ffea25f255f956cbc1b9d8631d01baf1010d028a190b94ce40f3b72897e8196df19edf1ff62e6556f2701d52cef1442e3301db7608ecbdcca703db" - Q_hex = "9a9ad73f246df853e129c589925fdad9df05606a61081e62e72be4fb33f6e5ec492cc734f28bfb71fbe2ba9a11e4c02e2c0d103a5cbb0a9d6402c07de63b1b995dd72ac8f29825d66923a088b421fb4d52b0b855d2f5dde2be9b0ca0cee6f7a94e5566735fe6cff1fcad3199602f88528d19aa8d0263adff8f5053c38254a2a3" a_hex = "0000000000000000000000000000000000000000000000000000000000000002" - b_hex = "0000000000000000000000000000000000000000000000000000000000000003" - ca_hex = "19c8b725dbd74b7dcaf72bd9ff2cd207b47cb1095393685906171af9e2f2959e7f68729e0e40f97a22bbca93373d618ad51dd077c0d102938598a8ecc8a656e978ebd14007da99db8e691d85fc18a428097ee8a63dcf95b84b660294474a20ed2edcf2b1b4f305c1cc25860a08d1348c2a4d24cc1a97b51f920e2985b8108b3392a5eafc443cf3449e288eb49dbde2228a56233afa5a6643e5ae6ec6aa8937a666ef74a30625c35bb22c3cc57b700f8eae7690f8d37edbfd27ccb2e882f70d0d85e0cc825347453a28e98e877ab1eeaa6efa09f034bc8976bffb86420106978066ff52221b315f71eb32cbf608d2b72cfa [...] - R_hex = "000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 [...] cb_hex = "1f1f087e749c85aacdacaace8659a33b53baad5eec1e56628435d335a8b150f96865d6e090f53146e120e7089b6f4a91c762622b24d0d2fba0e703301170a0b826a1336d4d6bb83dccd29ad9ef0936614bf14e992ea4daa202c63ace9bd3f95b9a8a6edd7949e89ec165541e7c01bd41395baf3e2fe7f3a9611af8b5ed8639c02a2bfc236c17a136bef6d09f966db718f3df9d6f4f40b618b4b6058b4e4ec241e6c2424404d0aee0ef5cd666e5c4253a62ae9deb09289fb84657109e0b933f58871ba7ea77190d6ea45a04be68360478adf43a85851cf583c5575543578635996d2dcd020aeceabf18be6ff8b45e4ecd63 [...] +z_hex = "0000000000000000000000000000000000000000000000000000000000000004" +beta_hex = "fffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd036413d" -z_hex = "0000000000000000000000000000000000000000000000000000000000000004"; - -beta_hex = "fffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd036413d"; - -alpha_hex = "000000000000000000000000000000000000000000000000000000000000000a"; +alpha_hex = "000000000000000000000000000000000000000000000000000000000000000a" if __name__ == "__main__": - - seed = bytes.fromhex(seed_hex) p0 = bytes.fromhex(P_hex) q0 = bytes.fromhex(Q_hex) a = bytes.fromhex(a_hex) b = bytes.fromhex(b_hex) - z = bytes.fromhex(z_hex) + z = bytes.fromhex(z_hex) r = bytes.fromhex(R_hex) ai = int(a_hex, 16) - bi = int(b_hex, 16) - expected = ai * bi % amcl_mpc.curve_order + bi = int(b_hex, 16) + expected = ai * bi % mpc.curve_order print(f"expected {hex(expected)}") - - # random number generator - rng = amcl_mpc.create_csprng(seed) # Deterministic - - paillier_pk1, paillier_sk1 = amcl_mpc.paillier_key_pair(rng, p0, q0) + paillier_pk1, paillier_sk1 = mpc.paillier_key_pair(None, p0, q0) # Dump and load Paillier public key - - n = amcl_mpc.paillier_pk_to_octet(paillier_pk1) + + n = mpc.paillier_pk_to_octet(paillier_pk1) print(f"paillier_pk1.n {n.hex()}") - paillier_pk2 = amcl_mpc.paillier_pk_from_octet(n) + paillier_pk2 = mpc.paillier_pk_from_octet(n) # Dump and load Paillier secret key - p, q = amcl_mpc.mpc_dump_paillier_sk(paillier_sk1) + p, q = mpc.mpc_dump_paillier_sk(paillier_sk1) print(f"paillier_sk1.p {p.hex()}") print(f"paillier_sk1.q {q.hex()}") - paillier_pk3, paillier_sk2 = amcl_mpc.paillier_key_pair(rng, p, q) - - ca = amcl_mpc.mpc_mta_client1(rng, paillier_pk2, a, r) + paillier_pk3, paillier_sk2 = mpc.paillier_key_pair(None, p, q) + ca = mpc.mpc_mta_client1(None, paillier_pk2, a, r) ca1_hex = ca.hex() - assert ca_hex == ca1_hex, f"expected {ca_hex} got {ca1_hex}" - - cb, beta = amcl_mpc.mpc_mta_server(rng, paillier_pk2, b, ca, z, r) + assert ca_hex == ca1_hex, f"expected {ca_hex} got {ca1_hex}" + cb, beta = mpc.mpc_mta_server(None, paillier_pk2, b, ca, z, r) cb1_hex = cb.hex() - assert cb_hex == cb1_hex, f"expected {cb_hex} got {cb1_hex}" + assert cb_hex == cb1_hex, f"expected {cb_hex} got {cb1_hex}" - alpha = amcl_mpc.mpc_mta_client2(paillier_sk2, cb) + alpha = mpc.mpc_mta_client2(paillier_sk2, cb) print(f"alpha {alpha.hex()}") print(f"beta {beta.hex()}") - + alphai = int(alpha.hex(), 16) betai = int(beta.hex(), 16) - got = ( alphai + betai ) % amcl_mpc.curve_order - print(f"got {hex(got)}") - - assert got == expected, f"expected {expected.hex()} got {got.hex()}" - - # Clear memory - amcl_mpc.kill_csprng(rng) - + got = ( alphai + betai ) % mpc.curve_order + print(f"got {hex(got)}") + assert got == expected, f"expected {hex(expected)} got {hex(got)}" diff --git a/python/example_ecdsa.py b/python/example_ecdsa.py index 6c99a72..39c5607 100755 --- a/python/example_ecdsa.py +++ b/python/example_ecdsa.py @@ -9,7 +9,7 @@ to you under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at - http://www.apache.org/licenses/LICENSE-2.0 + http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an @@ -19,124 +19,116 @@ specific language governing permissions and limitations under the License. """ -import amcl_mpc +from amcl import mpc seed_hex = "78d0fb6705ce77dee47d03eb5b9c5d30" if __name__ == "__main__": - - seed = bytes.fromhex(seed_hex) + seed = bytes.fromhex(seed_hex) # random number generator - rng = amcl_mpc.create_csprng(seed) + rng = mpc.create_csprng(seed) # Paillier keys - paillier_pk1, paillier_sk1 = amcl_mpc.paillier_key_pair(rng) - paillier_pk2, paillier_sk2 = amcl_mpc.paillier_key_pair(rng) + paillier_pk1, paillier_sk1 = mpc.paillier_key_pair(rng) + paillier_pk2, paillier_sk2 = mpc.paillier_key_pair(rng) # ECDSA keys - rc, PK1, W1 = amcl_mpc.ecp_secp256k1_key_pair_generate(rng) - rc = amcl_mpc.ecp_secp256k1_public_key_validate(PK1) + rc, PK1, W1 = mpc.ecp_secp256k1_key_pair_generate(rng) + rc = mpc.ecp_secp256k1_public_key_validate(PK1) assert rc == 0, f"Invalid ECDSA public key" - rc, PK2, W2 = amcl_mpc.ecp_secp256k1_key_pair_generate(rng) - rc = amcl_mpc.ecp_secp256k1_public_key_validate(PK2) + rc, PK2, W2 = mpc.ecp_secp256k1_key_pair_generate(rng) + rc = mpc.ecp_secp256k1_public_key_validate(PK2) assert rc == 0, f"Invalid ECDSA public key" # Gamma values - rc, GAMMAPT1, GAMMA1 = amcl_mpc.ecp_secp256k1_key_pair_generate(rng) - rc, GAMMAPT2, GAMMA2 = amcl_mpc.ecp_secp256k1_key_pair_generate(rng) + rc, GAMMAPT1, GAMMA1 = mpc.ecp_secp256k1_key_pair_generate(rng) + rc, GAMMAPT2, GAMMA2 = mpc.ecp_secp256k1_key_pair_generate(rng) # K values - rc, TMP1, K1 = amcl_mpc.ecp_secp256k1_key_pair_generate(rng) - rc, TMP2, K2 = amcl_mpc.ecp_secp256k1_key_pair_generate(rng) + rc, TMP1, K1 = mpc.ecp_secp256k1_key_pair_generate(rng) + rc, TMP2, K2 = mpc.ecp_secp256k1_key_pair_generate(rng) # Message M = b'test message' - - # ALPHA1 + BETA2 = K1 * GAMMA2 - - CA11 = amcl_mpc.mpc_mta_client1(rng, paillier_pk1, K1) - CB12, BETA2 = amcl_mpc.mpc_mta_server(rng, paillier_pk1, GAMMA2, CA11) - - ALPHA1 = amcl_mpc.mpc_mta_client2(paillier_sk1, CB12) + # ALPHA1 + BETA2 = K1 * GAMMA2 + CA11 = mpc.mpc_mta_client1(rng, paillier_pk1, K1) + CB12, BETA2 = mpc.mpc_mta_server(rng, paillier_pk1, GAMMA2, CA11) + ALPHA1 = mpc.mpc_mta_client2(paillier_sk1, CB12) # ALPHA2 + BETA1 = K2 * GAMMA1 - - CA22 = amcl_mpc.mpc_mta_client1(rng, paillier_pk2, K2) - - CB21, BETA1 = amcl_mpc.mpc_mta_server(rng, paillier_pk2, GAMMA1, CA22) - - ALPHA2 = amcl_mpc.mpc_mta_client2(paillier_sk2, CB21) + CA22 = mpc.mpc_mta_client1(rng, paillier_pk2, K2) + CB21, BETA1 = mpc.mpc_mta_server(rng, paillier_pk2, GAMMA1, CA22) + ALPHA2 = mpc.mpc_mta_client2(paillier_sk2, CB21) # sum = K1.GAMMA1 + alpha1 + beta1 - SUM1 = amcl_mpc.mpc_sum_mta(K1, GAMMA1, ALPHA1, BETA1) + SUM1 = mpc.mpc_sum_mta(K1, GAMMA1, ALPHA1, BETA1) # sum = K2.GAMMA2 + alpha2 + beta2 - SUM2 = amcl_mpc.mpc_sum_mta(K2, GAMMA2, ALPHA2, BETA2) + SUM2 = mpc.mpc_sum_mta(K2, GAMMA2, ALPHA2, BETA2) # Calculate the inverse of kgamma - INVKGAMMA = amcl_mpc.mpc_invkgamma(SUM1, SUM2) + INVKGAMMA = mpc.mpc_invkgamma(SUM1, SUM2) # Calculate the R signature component - rc, SIG_R, _ = amcl_mpc.mpc_r(INVKGAMMA, GAMMAPT1, GAMMAPT2) + rc, SIG_R, _ = mpc.mpc_r(INVKGAMMA, GAMMAPT1, GAMMAPT2) + # ALPHA1 + BETA2 = K1 * W2 - # ALPHA1 + BETA2 = K1 * W2 + CA11 = mpc.mpc_mta_client1(rng, paillier_pk1, K1) - CA11 = amcl_mpc.mpc_mta_client1(rng, paillier_pk1, K1) + CB12, BETA2 = mpc.mpc_mta_server(rng, paillier_pk1, W2, CA11) - CB12, BETA2 = amcl_mpc.mpc_mta_server(rng, paillier_pk1, W2, CA11) + ALPHA1 = mpc.mpc_mta_client2(paillier_sk1, CB12) - ALPHA1 = amcl_mpc.mpc_mta_client2(paillier_sk1, CB12) - # ALPHA2 + BETA1 = K2 * W1 - CA22 = amcl_mpc.mpc_mta_client1(rng, paillier_pk2, K2) - - CB21, BETA1 = amcl_mpc.mpc_mta_server(rng, paillier_pk2, W1, CA22) + CA22 = mpc.mpc_mta_client1(rng, paillier_pk2, K2) + + CB21, BETA1 = mpc.mpc_mta_server(rng, paillier_pk2, W1, CA22) - ALPHA2 = amcl_mpc.mpc_mta_client2(paillier_sk2, CB21) + ALPHA2 = mpc.mpc_mta_client2(paillier_sk2, CB21) # sum = K1.W1 + alpha1 + beta1 - SUM1 = amcl_mpc.mpc_sum_mta(K1, W1, ALPHA1, BETA1) + SUM1 = mpc.mpc_sum_mta(K1, W1, ALPHA1, BETA1) # sum = K2.W2 + alpha2 + beta2 - SUM2 = amcl_mpc.mpc_sum_mta(K2, W2, ALPHA2, BETA2) + SUM2 = mpc.mpc_sum_mta(K2, W2, ALPHA2, BETA2) # Calculate the message hash - - HM = amcl_mpc.mpc_hash(M) + + HM = mpc.mpc_hash(M) # Calculate the S1 signature component - rc, SIG_S1 = amcl_mpc.mpc_s(HM, SIG_R, K1, SUM1) + rc, SIG_S1 = mpc.mpc_s(HM, SIG_R, K1, SUM1) # Calculate the S2 signature component - rc, SIG_S2 = amcl_mpc.mpc_s(HM, SIG_R, K2, SUM2) + rc, SIG_S2 = mpc.mpc_s(HM, SIG_R, K2, SUM2) # Sum S signature component - SIG_S = amcl_mpc.mpc_sum_s(SIG_S1, SIG_S2) + SIG_S = mpc.mpc_sum_s(SIG_S1, SIG_S2) print(f"r component {SIG_R.hex()}") - print(f"s component {SIG_S.hex()}") + print(f"s component {SIG_S.hex()}") # Sum ECDSA public keys - rc, PK = amcl_mpc.mpc_sum_pk(PK1, PK2) + rc, PK = mpc.mpc_sum_pk(PK1, PK2) # Verify final signature - rc = amcl_mpc.mpc_ecdsa_verify(HM, PK, SIG_R, SIG_S) + rc = mpc.mpc_ecdsa_verify(HM, PK, SIG_R, SIG_S) assert rc == 0, f"Invalid ECDSA signature" print("SUCCESS") diff --git a/python/example_mta.py b/python/example_mta.py index 18f2d9a..1491120 100755 --- a/python/example_mta.py +++ b/python/example_mta.py @@ -9,7 +9,7 @@ to you under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at - http://www.apache.org/licenses/LICENSE-2.0 + http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an @@ -19,94 +19,82 @@ specific language governing permissions and limitations under the License. """ -import amcl_mpc +from amcl import mpc seed_hex = "78d0fb6705ce77dee47d03eb5b9c5d30" P_hex = "94f689d07ba20cf7c7ca7ccbed22ae6b40c426db74eaee4ce0ced2b6f52a5e136663f5f1ef379cdbb0c4fdd6e4074d6cff21082d4803d43d89e42fd8dfa82b135aa31a8844ffea25f255f956cbc1b9d8631d01baf1010d028a190b94ce40f3b72897e8196df19edf1ff62e6556f2701d52cef1442e3301db7608ecbdcca703db" - Q_hex = "9a9ad73f246df853e129c589925fdad9df05606a61081e62e72be4fb33f6e5ec492cc734f28bfb71fbe2ba9a11e4c02e2c0d103a5cbb0a9d6402c07de63b1b995dd72ac8f29825d66923a088b421fb4d52b0b855d2f5dde2be9b0ca0cee6f7a94e5566735fe6cff1fcad3199602f88528d19aa8d0263adff8f5053c38254a2a3" a_hex = "0000000000000000000000000000000000000000000000000000000000000002" - b_hex = "0000000000000000000000000000000000000000000000000000000000000003" - ca_hex = "19c8b725dbd74b7dcaf72bd9ff2cd207b47cb1095393685906171af9e2f2959e7f68729e0e40f97a22bbca93373d618ad51dd077c0d102938598a8ecc8a656e978ebd14007da99db8e691d85fc18a428097ee8a63dcf95b84b660294474a20ed2edcf2b1b4f305c1cc25860a08d1348c2a4d24cc1a97b51f920e2985b8108b3392a5eafc443cf3449e288eb49dbde2228a56233afa5a6643e5ae6ec6aa8937a666ef74a30625c35bb22c3cc57b700f8eae7690f8d37edbfd27ccb2e882f70d0d85e0cc825347453a28e98e877ab1eeaa6efa09f034bc8976bffb86420106978066ff52221b315f71eb32cbf608d2b72cfa [...] - R_hex = "000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 [...] cb_hex = "1f1f087e749c85aacdacaace8659a33b53baad5eec1e56628435d335a8b150f96865d6e090f53146e120e7089b6f4a91c762622b24d0d2fba0e703301170a0b826a1336d4d6bb83dccd29ad9ef0936614bf14e992ea4daa202c63ace9bd3f95b9a8a6edd7949e89ec165541e7c01bd41395baf3e2fe7f3a9611af8b5ed8639c02a2bfc236c17a136bef6d09f966db718f3df9d6f4f40b618b4b6058b4e4ec241e6c2424404d0aee0ef5cd666e5c4253a62ae9deb09289fb84657109e0b933f58871ba7ea77190d6ea45a04be68360478adf43a85851cf583c5575543578635996d2dcd020aeceabf18be6ff8b45e4ecd63 [...] +z_hex = "0000000000000000000000000000000000000000000000000000000000000004" +beta_hex = "fffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd036413d" -z_hex = "0000000000000000000000000000000000000000000000000000000000000004"; - -beta_hex = "fffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd036413d"; - -alpha_hex = "000000000000000000000000000000000000000000000000000000000000000a"; +alpha_hex = "000000000000000000000000000000000000000000000000000000000000000a" if __name__ == "__main__": - - seed = bytes.fromhex(seed_hex) + seed = bytes.fromhex(seed_hex) p = bytes.fromhex(P_hex) q = bytes.fromhex(Q_hex) a = bytes.fromhex(a_hex) b = bytes.fromhex(b_hex) - z = bytes.fromhex(z_hex) + z = bytes.fromhex(z_hex) r = bytes.fromhex(R_hex) ai = int(a_hex, 16) - bi = int(b_hex, 16) - expected = ai * bi % amcl_mpc.curve_order + bi = int(b_hex, 16) + expected = ai * bi % mpc.curve_order print(f"expected {hex(expected)}") - + # random number generator - rng = amcl_mpc.create_csprng(seed) + rng = mpc.create_csprng(seed) # Deterministic + paillier_pk, paillier_sk = mpc.paillier_key_pair(None, p, q) - paillier_pk, paillier_sk = amcl_mpc.paillier_key_pair(rng, p, q) - - ca = amcl_mpc.mpc_mta_client1(rng, paillier_pk, a, r) - + ca = mpc.mpc_mta_client1(rng, paillier_pk, a, r) ca1_hex = ca.hex() - assert ca_hex == ca1_hex, f"expected {ca_hex} got {ca1_hex}" - - cb, beta = amcl_mpc.mpc_mta_server(rng, paillier_pk, b, ca, z, r) + assert ca_hex == ca1_hex, f"expected {ca_hex} got {ca1_hex}" + cb, beta = mpc.mpc_mta_server(rng, paillier_pk, b, ca, z, r) cb1_hex = cb.hex() - assert cb_hex == cb1_hex, f"expected {cb_hex} got {cb1_hex}" + assert cb_hex == cb1_hex, f"expected {cb_hex} got {cb1_hex}" - alpha = amcl_mpc.mpc_mta_client2(paillier_sk, cb) + alpha = mpc.mpc_mta_client2(paillier_sk, cb) print(f"alpha {alpha.hex()}") print(f"beta {beta.hex()}") - + alphai = int(alpha.hex(), 16) betai = int(beta.hex(), 16) - got = ( alphai + betai ) % amcl_mpc.curve_order - print(f"got {hex(got)}") + got = ( alphai + betai ) % mpc.curve_order - assert got == expected, f"expected {expected.hex()} got {got.hex()}" - - # Random - - paillier_pk, paillier_sk = amcl_mpc.paillier_key_pair(rng) - ca = amcl_mpc.mpc_mta_client1(rng, paillier_pk, a) + print(f"got {hex(got)}") - cb, beta = amcl_mpc.mpc_mta_server(rng, paillier_pk, b, ca) + assert got == expected, f"expected {hex(expected)} got {hex(got)}" - alpha = amcl_mpc.mpc_mta_client2(paillier_sk, cb) + # Random + paillier_pk, paillier_sk = mpc.paillier_key_pair(rng) + ca = mpc.mpc_mta_client1(rng, paillier_pk, a) + cb, beta = mpc.mpc_mta_server(rng, paillier_pk, b, ca) + alpha = mpc.mpc_mta_client2(paillier_sk, cb) print(f"alpha {alpha.hex()}") print(f"beta {beta.hex()}") - + alphai = int(alpha.hex(), 16) betai = int(beta.hex(), 16) - got = ( alphai + betai ) % amcl_mpc.curve_order - print(f"got {hex(got)}") + got = ( alphai + betai ) % mpc.curve_order - assert got == expected, f"expected {expected.hex()} got {got.hex()}" + print(f"got {hex(got)}") - - # Clear memory - amcl_mpc.kill_csprng(rng) + assert got == expected, f"expected {hex(expected)} got {hex(got)}" + # Clear memory + mpc.kill_csprng(rng) + mpc.paillier_private_key_kill(paillier_sk) diff --git a/python/example_r.py b/python/example_r.py index fbed92e..7f55ce0 100755 --- a/python/example_r.py +++ b/python/example_r.py @@ -9,7 +9,7 @@ to you under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at - http://www.apache.org/licenses/LICENSE-2.0 + http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an @@ -19,68 +19,53 @@ specific language governing permissions and limitations under the License. """ -import amcl_mpc +from amcl import mpc seed_hex = "78d0fb6705ce77dee47d03eb5b9c5d30" P1_hex = "94f689d07ba20cf7c7ca7ccbed22ae6b40c426db74eaee4ce0ced2b6f52a5e136663f5f1ef379cdbb0c4fdd6e4074d6cff21082d4803d43d89e42fd8dfa82b135aa31a8844ffea25f255f956cbc1b9d8631d01baf1010d028a190b94ce40f3b72897e8196df19edf1ff62e6556f2701d52cef1442e3301db7608ecbdcca703db" - Q1_hex = "9a9ad73f246df853e129c589925fdad9df05606a61081e62e72be4fb33f6e5ec492cc734f28bfb71fbe2ba9a11e4c02e2c0d103a5cbb0a9d6402c07de63b1b995dd72ac8f29825d66923a088b421fb4d52b0b855d2f5dde2be9b0ca0cee6f7a94e5566735fe6cff1fcad3199602f88528d19aa8d0263adff8f5053c38254a2a3" K1_hex = "52b7fe8435a2532b79ee252e5444c6a7178757f29a7ff17176ed9098ad168883" - GAMMA2_hex = "2f595fbef2fa542fd1d20d07f02c7d4c50b4abb2d1f76b4952219edf59f3ccf7" CA11GOLDEN_hex = "159a663e0aea1bcd6a9caf1a2a6d2b868459cb65081f133d510b46863d1658894cdd93c0b325252f2c681c15acbad6a30eef0a05babe6bc1d9267f3268d84387c13348afa0bce0a9795008cf1d81a39ab8483cebacf4ae9bb617bdcce3b3864a36838a88357b74ea38cad34650d0d3fea2bfdd2949ee9bd58f529b2c0b717c3ced1c9ddcfa85abeaffc78b5ed6a8dd54aef7cfb9dabaa78d0c3dbc2b58fc682a52ada4628c3c3e004f2fdc9b8f15392c6d4acaa93b6eb1f7a0807e3ce905ea58ff7ba778737c001765117367723626a82c8f3c89deed8157a13ec30adeb8eba000ca5e7a72ffa045de558a1515 [...] - R11_hex = "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 [...] CB12GOLDEN_hex = "1d7a81d4c53465b04668d95e16c75382fefa7942b7142c2758c9f386d6611151b9740d2c3402c3637c89a49b4166c5c16448f04bd1a6c06558e96bccabd322d6990e03ce0c0d78228af32ec185c281a1eae026d332690b49e5182db4a70df419cb57bdf29055e6242d3ba49e494ab60690c314aa0f1e4b4683344fed6080464733afe19e65565f569be80343b23b7d22e7ab157c311ed601e03ac480b0a6d1eacea71ecc1f6290a7ecd3b3b7de1b50174c5ca9f9d27e2c8fd5017ff72e9e4ca44725cecd2ee6ced380655d0e9febdee53c61a25322a217ad61b1486600791d3952dbf3f33cb762ce04a3653e82 [...] - R12_hex = "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 [...] - Z12_hex = "0207c724d58036400bcb7d99286aeb835745711fcf18c124fedb14bb252870bc" - BETA2GOLDEN_hex = "fdf838db2a7fc9bff4348266d795147b63696bc6e02fdf16c0f749d1ab0dd085" ALPHA1GOLDEN_hex = "a43803ffcc7aa295dff0ede560973c151ef9f9c8160500bbcda7e18d0c2eac03" P2_hex = "c227a6d88ef469ceb323bcd95a18ab41d9cde9b349c093e7273e7d05f1636c517a21890f22785d45aeeb892da40a69267d3e2f1bd7e0f164cb23306402122512ed70d1cbb20c470d0c03a54adc47abfcc9eadff2ba175bb29aea70464f31f7804a8fc9c9fed60c505e11c594c9415fc96e1b44a3e5f437772bbce91e063827bf" - Q2_hex = "e729b4e468f6076ad00dc9af0b820158be147727f4ead55b4d6268647d53c8f65e92338af9b24b819de20244e404800f659ce8595a8020ba941cf116b30ee31b0dc6367721714e511abae6157b3de5241ffd28ad309a70b9c316b5a40571808b85db4e00d82d80da4e7b5b6b37b10fd5c2c3815b7429f6eabddcd284d927352f" K2_hex = "6f6aa64cdf2f28bb081ec019b3a8e2eed89052441626172daf106f523b0b44cc" - GAMMA1_hex = "0f757744e20d00dce6763b71ecb95f9fa9d4e788cfb9e39775d133e5e350ea93" CA22GOLDEN_hex = "3192b9daade647a4d17b5e2e0f08e6e3d0666fac576ff8e20be4a1072b23e0202195cb9738bf7d4f5784577d23071bec7c326b6ddf25bb2f4a415cb5a95b89c5a42d4d31a740f72576d798746d30078e15ba1a91d1687563bee2af7b4eceac2f0f13184df619a5ecde5caf9e88b123438afe73d4cc9c2c50ffde42f713cd9384b5cba6cda395d03383e7f8335ac61852fd18ea7012480c49aafc27f035045303f46d0a40fe4e7fce17facbc16e55a418c18256bb30216613a2590edcc0fbe1b18d0f6507273def2e2b740b04a880648d9dc5a5225884fc07bcdaec34d91b6f84ada7c274ba960f316c04765d0e [...] - R22_hex = "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 [...] CB21GOLDEN_hex = "17b2dfb8b37675e4551f557c807a5f94950a0902b8627bb7840c37a054070da1028089b822e55df859dd2d95cd790691e2c27c08603d17bbb016fa159023776651befd64bc7e28bcdfcbeaf6b524fdaf8787217764b4d9385c922c76fd54118fbc7a897a7fc3288c813302f91424b7671b223aa9958f42dbc3dd3b600b57aa76998c68ef668af138bce9332d2983cffb25add049fc4a1be85410bcd17c9ba001c817a2a03802b85d7583a386650ea65fcbf243d8e5a66f2e79afbfaa2e42abcf8200f8f74a9aed2628bdb5c3dd3dcfe3a3f2f4dc7c23a12981e9637c5237c826bd445a3265b775e3c8d0e738f7 [...] - R21_hex = "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 [...] - Z21_hex = "101c7abf2665c3f311a11c988798476216b28d576657fe0e7795e7024086051a" - BETA1GOLDEN_hex = "efe38540d99a3c0cee5ee3677867b89ca3fc4f8f48f0a22d483c778a8fb03c27" ALPHA2GOLDEN_hex = "945a07ddc50b23d9421aca78b7192d5647856a7e9c3cf951f149d3431273b5ff" SUM1GOLDEN_hex = "7d8436ceb1b37b1eb9829968350c721c70f3aa2eeee57c35442dc41c9a519abe" - SUM2GOLDEN_hex = "c2cce80b56c443c5ead466b586e67bf490214bba39a3f484327d7d1de9bbc6d8" INVKGAMMAGOLDEN_hex = "f9419b11580cdc098cbcbfd3ac06e70d2d4827447353f64bd97daa5667b34ef9" GAMMAPT1_hex = "04206b7c7ae7ecf8fe79ac581d8de90b9a12a27f79732268649fb0ae109faade73385833cafe293b42e33097a79397c77c94a7d12a32304514a890a0c2d747a40d" - GAMMAPT2_hex = "04fc86f69384e2b0cc3d563dc24ebb3a7ca0ac12dfa671e4cda4abdec35f33ed326fdc2404c8e236d5bea82bcbe4aeeb7545c8b5d0a19a39e00bacf8a7143800a9" SIG_RGOLDEN_hex = "8adf50a4f51443cac2b4d488092ab49925da09e3feb57a1fc03b5b917ca6de9f" if __name__ == "__main__": - seed = bytes.fromhex(seed_hex) P1 = bytes.fromhex(P1_hex) Q1 = bytes.fromhex(Q1_hex) @@ -98,80 +83,66 @@ if __name__ == "__main__": Z21 = bytes.fromhex(Z21_hex) GAMMAPT1 = bytes.fromhex(GAMMAPT1_hex) GAMMAPT2 = bytes.fromhex(GAMMAPT2_hex) - + # random number generator - rng = amcl_mpc.create_csprng(seed) + rng = mpc.create_csprng(seed) # Deterministic # Paillier key pairs - paillier_pk1, paillier_sk1 = amcl_mpc.paillier_key_pair(rng, P1, Q1) - paillier_pk2, paillier_sk2 = amcl_mpc.paillier_key_pair(rng, P2, Q2) - - # ALPHA1 + BETA2 = K1 * GAMMA2 - - CA11 = amcl_mpc.mpc_mta_client1(rng, paillier_pk1, K1, R11) + paillier_pk1, paillier_sk1 = mpc.paillier_key_pair(None, P1, Q1) + paillier_pk2, paillier_sk2 = mpc.paillier_key_pair(None, P2, Q2) + # ALPHA1 + BETA2 = K1 * GAMMA2 + CA11 = mpc.mpc_mta_client1(rng, paillier_pk1, K1, R11) CA11_hex = CA11.hex() - assert CA11GOLDEN_hex == CA11_hex, f"expected {CA11GOLDEN_hex} got {CA11_hex}" - - CB12, BETA2 = amcl_mpc.mpc_mta_server(rng, paillier_pk1, GAMMA2, CA11, Z12, R12) + assert CA11GOLDEN_hex == CA11_hex, f"expected {CA11GOLDEN_hex} got {CA11_hex}" + CB12, BETA2 = mpc.mpc_mta_server(rng, paillier_pk1, GAMMA2, CA11, Z12, R12) CB12_hex = CB12.hex() - assert CB12GOLDEN_hex == CB12_hex, f"expected {CB12GOLDEN_hex} got {CB12_hex}" - - BETA2_hex = BETA2.hex() - assert BETA2GOLDEN_hex == BETA2_hex, f"expected {BETA2GOLDEN_hex} got {BETA2_hex}" + assert CB12GOLDEN_hex == CB12_hex, f"expected {CB12GOLDEN_hex} got {CB12_hex}" - ALPHA1 = amcl_mpc.mpc_mta_client2(paillier_sk1, CB12) + BETA2_hex = BETA2.hex() + assert BETA2GOLDEN_hex == BETA2_hex, f"expected {BETA2GOLDEN_hex} got {BETA2_hex}" - ALPHA1_hex = ALPHA1.hex() + ALPHA1 = mpc.mpc_mta_client2(paillier_sk1, CB12) + ALPHA1_hex = ALPHA1.hex() assert ALPHA1GOLDEN_hex == ALPHA1_hex, f"expected {ALPHA1GOLDEN_hex} got {ALPHA1_hex}" - - # ALPHA2 + BETA1 = K2 * GAMMA1 - - CA22 = amcl_mpc.mpc_mta_client1(rng, paillier_pk2, K2, R22) + # ALPHA2 + BETA1 = K2 * GAMMA1 + CA22 = mpc.mpc_mta_client1(rng, paillier_pk2, K2, R22) CA22_hex = CA22.hex() - assert CA22GOLDEN_hex == CA22_hex, f"expected {CA22GOLDEN_hex} got {CA22_hex}" - - CB21, BETA1 = amcl_mpc.mpc_mta_server(rng, paillier_pk2, GAMMA1, CA22, Z21, R21) + assert CA22GOLDEN_hex == CA22_hex, f"expected {CA22GOLDEN_hex} got {CA22_hex}" + CB21, BETA1 = mpc.mpc_mta_server(rng, paillier_pk2, GAMMA1, CA22, Z21, R21) CB21_hex = CB21.hex() - assert CB21GOLDEN_hex == CB21_hex, f"expected {CB21GOLDEN_hex} got {CB21_hex}" - - BETA1_hex = BETA1.hex() - assert BETA1GOLDEN_hex == BETA1_hex, f"expected {BETA1GOLDEN_hex} got {BETA1_hex}" + assert CB21GOLDEN_hex == CB21_hex, f"expected {CB21GOLDEN_hex} got {CB21_hex}" - ALPHA2 = amcl_mpc.mpc_mta_client2(paillier_sk2, CB21) + BETA1_hex = BETA1.hex() + assert BETA1GOLDEN_hex == BETA1_hex, f"expected {BETA1GOLDEN_hex} got {BETA1_hex}" - ALPHA2_hex = ALPHA2.hex() - assert ALPHA2GOLDEN_hex == ALPHA2_hex, f"expected {ALPHA2GOLDEN_hex} got {ALPHA2_hex}" - # sum = K1.GAMMA1 + alpha1 + beta1 + ALPHA2 = mpc.mpc_mta_client2(paillier_sk2, CB21) + ALPHA2_hex = ALPHA2.hex() + assert ALPHA2GOLDEN_hex == ALPHA2_hex, f"expected {ALPHA2GOLDEN_hex} got {ALPHA2_hex}" - SUM1 = amcl_mpc.mpc_sum_mta(K1, GAMMA1, ALPHA1, BETA1) - - SUM1_hex = SUM1.hex() - assert SUM1GOLDEN_hex == SUM1_hex, f"expected {SUM1GOLDEN_hex} got {SUM1_hex}" + # sum = K1.GAMMA1 + alpha1 + beta1 + SUM1 = mpc.mpc_sum_mta(K1, GAMMA1, ALPHA1, BETA1) + SUM1_hex = SUM1.hex() + assert SUM1GOLDEN_hex == SUM1_hex, f"expected {SUM1GOLDEN_hex} got {SUM1_hex}" # sum = K2.GAMMA2 + alpha2 + beta2 - - SUM2 = amcl_mpc.mpc_sum_mta(K2, GAMMA2, ALPHA2, BETA2) - - SUM2_hex = SUM2.hex() - assert SUM2GOLDEN_hex == SUM2_hex, f"expected {SUM2GOLDEN_hex} got {SUM2_hex}" + SUM2 = mpc.mpc_sum_mta(K2, GAMMA2, ALPHA2, BETA2) + SUM2_hex = SUM2.hex() + assert SUM2GOLDEN_hex == SUM2_hex, f"expected {SUM2GOLDEN_hex} got {SUM2_hex}" # Calculate the inverse of kgamma + INVKGAMMA = mpc.mpc_invkgamma(SUM1, SUM2) + INVKGAMMA_hex = INVKGAMMA.hex() + assert INVKGAMMAGOLDEN_hex == INVKGAMMA_hex, f"expected {INVKGAMMAGOLDEN_hex} got {INVKGAMMA_hex}" - INVKGAMMA = amcl_mpc.mpc_invkgamma(SUM1, SUM2) - - INVKGAMMA_hex = INVKGAMMA.hex() - assert INVKGAMMAGOLDEN_hex == INVKGAMMA_hex, f"expected {INVKGAMMAGOLDEN_hex} got {INVKGAMMA_hex}" # Calculate the R signature component + rc, SIG_R, _ = mpc.mpc_r(INVKGAMMA, GAMMAPT1, GAMMAPT2) + SIG_R_hex = SIG_R.hex() + assert SIG_RGOLDEN_hex == SIG_R_hex, f"expected {SIG_RGOLDEN_hex} got {SIG_R_hex}" - rc, SIG_R, _ = amcl_mpc.mpc_r(INVKGAMMA, GAMMAPT1, GAMMAPT2) - - SIG_R_hex = SIG_R.hex() - assert SIG_RGOLDEN_hex == SIG_R_hex, f"expected {SIG_RGOLDEN_hex} got {SIG_R_hex}" - print(f"r component {SIG_R_hex}") diff --git a/python/example_s.py b/python/example_s.py index f3029d0..011a437 100755 --- a/python/example_s.py +++ b/python/example_s.py @@ -19,56 +19,43 @@ specific language governing permissions and limitations under the License. """ -import amcl_mpc +from amcl import mpc seed_hex = "78d0fb6705ce77dee47d03eb5b9c5d30" P1_hex = "94f689d07ba20cf7c7ca7ccbed22ae6b40c426db74eaee4ce0ced2b6f52a5e136663f5f1ef379cdbb0c4fdd6e4074d6cff21082d4803d43d89e42fd8dfa82b135aa31a8844ffea25f255f956cbc1b9d8631d01baf1010d028a190b94ce40f3b72897e8196df19edf1ff62e6556f2701d52cef1442e3301db7608ecbdcca703db" - Q1_hex = "9a9ad73f246df853e129c589925fdad9df05606a61081e62e72be4fb33f6e5ec492cc734f28bfb71fbe2ba9a11e4c02e2c0d103a5cbb0a9d6402c07de63b1b995dd72ac8f29825d66923a088b421fb4d52b0b855d2f5dde2be9b0ca0cee6f7a94e5566735fe6cff1fcad3199602f88528d19aa8d0263adff8f5053c38254a2a3" K1_hex = "52b7fe8435a2532b79ee252e5444c6a7178757f29a7ff17176ed9098ad168883" - W2_hex = "0aec8feb32fd8bbb4526b6d5af6681519e195874ada7474255c89926efe53291" CA11GOLDEN_hex = "159a663e0aea1bcd6a9caf1a2a6d2b868459cb65081f133d510b46863d1658894cdd93c0b325252f2c681c15acbad6a30eef0a05babe6bc1d9267f3268d84387c13348afa0bce0a9795008cf1d81a39ab8483cebacf4ae9bb617bdcce3b3864a36838a88357b74ea38cad34650d0d3fea2bfdd2949ee9bd58f529b2c0b717c3ced1c9ddcfa85abeaffc78b5ed6a8dd54aef7cfb9dabaa78d0c3dbc2b58fc682a52ada4628c3c3e004f2fdc9b8f15392c6d4acaa93b6eb1f7a0807e3ce905ea58ff7ba778737c001765117367723626a82c8f3c89deed8157a13ec30adeb8eba000ca5e7a72ffa045de558a1515 [...] - R11_hex = "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 [...] CB12GOLDEN_hex = "09c9e0fe1ba09663cafa368daa6b404df6e719646a7d4ade95909e7513086cc947e3d5dfc14e22d3cdf842df917617e6a79997b5cca3c0d45894e3d6aeef854d8c10ed5abaeb40c9e35142cb4acdbcbfc51e72d259cb5a26efe77626ba21922d6a09897c8ac3eb080de36f7b622f09c4d70a6315bbed69fff3aa7406358f6c588cd01fc1c5abf9899e76ed8da9fda4d323687d9746ff35e46cc64947b25f25f6d9ae9365cb8a019d508ef76f02673a6dee9376a8ac2aef9c1045966e856e5e08de3f93aeb7ea1fa2fe9adf2587ea5e12f245cb30859293c36eb27e41c35db18df8743fd14f76e581c518add321 [...] - R12_hex = "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 [...] - Z12_hex = "0207c724d58036400bcb7d99286aeb835745711fcf18c124fedb14bb252870bc" - BETA2GOLDEN_hex = "fdf838db2a7fc9bff4348266d795147b63696bc6e02fdf16c0f749d1ab0dd085" ALPHA1GOLDEN_hex = "a0e312daab26f391796f16c358dba05ca8da9dad5ecaeccbb0433a95049bd390" P2_hex = "c227a6d88ef469ceb323bcd95a18ab41d9cde9b349c093e7273e7d05f1636c517a21890f22785d45aeeb892da40a69267d3e2f1bd7e0f164cb23306402122512ed70d1cbb20c470d0c03a54adc47abfcc9eadff2ba175bb29aea70464f31f7804a8fc9c9fed60c505e11c594c9415fc96e1b44a3e5f437772bbce91e063827bf" - Q2_hex = "e729b4e468f6076ad00dc9af0b820158be147727f4ead55b4d6268647d53c8f65e92338af9b24b819de20244e404800f659ce8595a8020ba941cf116b30ee31b0dc6367721714e511abae6157b3de5241ffd28ad309a70b9c316b5a40571808b85db4e00d82d80da4e7b5b6b37b10fd5c2c3815b7429f6eabddcd284d927352f" K2_hex = "6f6aa64cdf2f28bb081ec019b3a8e2eed89052441626172daf106f523b0b44cc" - W1_hex = "248ea4e0ce968bdd1febd48e2d246f7268070eb468eca0c1e911cc1642bd8041" CA22GOLDEN_hex = "3192b9daade647a4d17b5e2e0f08e6e3d0666fac576ff8e20be4a1072b23e0202195cb9738bf7d4f5784577d23071bec7c326b6ddf25bb2f4a415cb5a95b89c5a42d4d31a740f72576d798746d30078e15ba1a91d1687563bee2af7b4eceac2f0f13184df619a5ecde5caf9e88b123438afe73d4cc9c2c50ffde42f713cd9384b5cba6cda395d03383e7f8335ac61852fd18ea7012480c49aafc27f035045303f46d0a40fe4e7fce17facbc16e55a418c18256bb30216613a2590edcc0fbe1b18d0f6507273def2e2b740b04a880648d9dc5a5225884fc07bcdaec34d91b6f84ada7c274ba960f316c04765d0e [...] - R22_hex = "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 [...] CB21GOLDEN_hex = "195a0cb5a5677bd8b22606346aa2c80e42be21442119079d56ee169eb6ee84b54e8f8c5b1196edc133520c9b60f6735ea444880e9c47eabe41b409cf3a1ac9e51e1b48e855e47f92c7395f825ad2c82648c0b4e303d02345130b6c7df80fe8da0df632ea61bfb4b2373587cc59c37810eee25ec4e74db801729b32134e03e9df04edbc354c42ee9bee52f5939f12783854ed221bcb7e3ce366843c3b40b7396574bffdd2e5ad6d85487f95e62858cedf91e14fe31e922603303a4da6190f1940243539bdfd833920071aaefe5e719310bf4e99bff85154a19dac944a395ad0c820bfe8ead7a3a80aa32cd2a601 [...] - R21_hex = "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 [...] - Z21_hex = "101c7abf2665c3f311a11c988798476216b28d576657fe0e7795e7024086051a" - BETA1GOLDEN_hex = "efe38540d99a3c0cee5ee3677867b89ca3fc4f8f48f0a22d483c778a8fb03c27" ALPHA2GOLDEN_hex = "75cf36d1b9c257313412185bc75b86f158dfd7d09c8584a98aa3a3ee852f512e" SUM1GOLDEN_hex = "68891b7166cf16ec847db1ce65c472d8978dbdb1fc01089330e151f4face11b4" - SUM2GOLDEN_hex = "3231b07d70de00c4e250f7b545bfbfebe19f71f6a7e85ffefc2dc19b8ba4aeee" SIG_R_hex = "8adf50a4f51443cac2b4d488092ab49925da09e3feb57a1fc03b5b917ca6de9f" @@ -76,13 +63,10 @@ SIG_R_hex = "8adf50a4f51443cac2b4d488092ab49925da09e3feb57a1fc03b5b917ca6de9f" M_hex = "74657374206d657373616765" SIG_S1GOLDEN_hex = "d14b16fbbd346f5a9f184a064c351eca2d516a2e88ed3aab5713fea9766aa2b1" - SIG_S2GOLDEN_hex = "44548a9ba59d1459a047a7ae5095b0cc70f7d1de6cd5730730cdd762619d8c9a" - SIG_SGOLDEN_hex = "159fa19762d183b43f5ff1b49ccacf97e39a5f26467a0d76c80f777f07d1ee0a" if __name__ == "__main__": - seed = bytes.fromhex(seed_hex) P1 = bytes.fromhex(P1_hex) Q1 = bytes.fromhex(Q1_hex) @@ -99,91 +83,73 @@ if __name__ == "__main__": R21 = bytes.fromhex(R21_hex) Z21 = bytes.fromhex(Z21_hex) M = bytes.fromhex(M_hex) - SIG_R = bytes.fromhex(SIG_R_hex) - + SIG_R = bytes.fromhex(SIG_R_hex) + # random number generator - rng = amcl_mpc.create_csprng(seed) + rng = mpc.create_csprng(seed) # Deterministic # Paillier key pairs - paillier_pk1, paillier_sk1 = amcl_mpc.paillier_key_pair(rng, P1, Q1) - paillier_pk2, paillier_sk2 = amcl_mpc.paillier_key_pair(rng, P2, Q2) - - # ALPHA1 + BETA2 = K1 * W2 - CA11 = amcl_mpc.mpc_mta_client1(rng, paillier_pk1, K1, R11) + paillier_pk1, paillier_sk1 = mpc.paillier_key_pair(None, P1, Q1) + paillier_pk2, paillier_sk2 = mpc.paillier_key_pair(None, P2, Q2) + # ALPHA1 + BETA2 = K1 * W2 + CA11 = mpc.mpc_mta_client1(rng, paillier_pk1, K1, R11) CA11_hex = CA11.hex() - assert CA11GOLDEN_hex == CA11_hex, f"expected {CA11GOLDEN_hex} got {CA11_hex}" - - CB12, BETA2 = amcl_mpc.mpc_mta_server(rng, paillier_pk1, W2, CA11, Z12, R12) + assert CA11GOLDEN_hex == CA11_hex, f"expected {CA11GOLDEN_hex} got {CA11_hex}" + CB12, BETA2 = mpc.mpc_mta_server(rng, paillier_pk1, W2, CA11, Z12, R12) CB12_hex = CB12.hex() - assert CB12GOLDEN_hex == CB12_hex, f"expected {CB12GOLDEN_hex} got {CB12_hex}" - - BETA2_hex = BETA2.hex() - assert BETA2GOLDEN_hex == BETA2_hex, f"expected {BETA2GOLDEN_hex} got {BETA2_hex}" + assert CB12GOLDEN_hex == CB12_hex, f"expected {CB12GOLDEN_hex} got {CB12_hex}" - ALPHA1 = amcl_mpc.mpc_mta_client2(paillier_sk1, CB12) + BETA2_hex = BETA2.hex() + assert BETA2GOLDEN_hex == BETA2_hex, f"expected {BETA2GOLDEN_hex} got {BETA2_hex}" - ALPHA1_hex = ALPHA1.hex() + ALPHA1 = mpc.mpc_mta_client2(paillier_sk1, CB12) + ALPHA1_hex = ALPHA1.hex() assert ALPHA1GOLDEN_hex == ALPHA1_hex, f"expected {ALPHA1GOLDEN_hex} got {ALPHA1_hex}" - - # ALPHA2 + BETA1 = K2 * W1 - CA22 = amcl_mpc.mpc_mta_client1(rng, paillier_pk2, K2, R22) + # ALPHA2 + BETA1 = K2 * W1 + CA22 = mpc.mpc_mta_client1(rng, paillier_pk2, K2, R22) CA22_hex = CA22.hex() - assert CA22GOLDEN_hex == CA22_hex, f"expected {CA22GOLDEN_hex} got {CA22_hex}" - - CB21, BETA1 = amcl_mpc.mpc_mta_server(rng, paillier_pk2, W1, CA22, Z21, R21) + assert CA22GOLDEN_hex == CA22_hex, f"expected {CA22GOLDEN_hex} got {CA22_hex}" + CB21, BETA1 = mpc.mpc_mta_server(rng, paillier_pk2, W1, CA22, Z21, R21) CB21_hex = CB21.hex() - assert CB21GOLDEN_hex == CB21_hex, f"expected {CB21GOLDEN_hex} got {CB21_hex}" - - BETA1_hex = BETA1.hex() - assert BETA1GOLDEN_hex == BETA1_hex, f"expected {BETA1GOLDEN_hex} got {BETA1_hex}" + assert CB21GOLDEN_hex == CB21_hex, f"expected {CB21GOLDEN_hex} got {CB21_hex}" - ALPHA2 = amcl_mpc.mpc_mta_client2(paillier_sk2, CB21) + BETA1_hex = BETA1.hex() + assert BETA1GOLDEN_hex == BETA1_hex, f"expected {BETA1GOLDEN_hex} got {BETA1_hex}" - ALPHA2_hex = ALPHA2.hex() + ALPHA2 = mpc.mpc_mta_client2(paillier_sk2, CB21) + ALPHA2_hex = ALPHA2.hex() assert ALPHA2GOLDEN_hex == ALPHA2_hex, f"expected {ALPHA2GOLDEN_hex} got {ALPHA2_hex}" - - # sum = K1.W1 + alpha1 + beta1 - - SUM1 = amcl_mpc.mpc_sum_mta(K1, W1, ALPHA1, BETA1) - SUM1_hex = SUM1.hex() - assert SUM1GOLDEN_hex == SUM1_hex, f"expected {SUM1GOLDEN_hex} got {SUM1_hex}" + # sum = K1.W1 + alpha1 + beta1 + SUM1 = mpc.mpc_sum_mta(K1, W1, ALPHA1, BETA1) + SUM1_hex = SUM1.hex() + assert SUM1GOLDEN_hex == SUM1_hex, f"expected {SUM1GOLDEN_hex} got {SUM1_hex}" # sum = K2.W2 + alpha2 + beta2 - - SUM2 = amcl_mpc.mpc_sum_mta(K2, W2, ALPHA2, BETA2) - - SUM2_hex = SUM2.hex() - assert SUM2GOLDEN_hex == SUM2_hex, f"expected {SUM2GOLDEN_hex} got {SUM2_hex}" + SUM2 = mpc.mpc_sum_mta(K2, W2, ALPHA2, BETA2) + SUM2_hex = SUM2.hex() + assert SUM2GOLDEN_hex == SUM2_hex, f"expected {SUM2GOLDEN_hex} got {SUM2_hex}" # Calculate the message hash - - HM = amcl_mpc.mpc_hash(M) + HM = mpc.mpc_hash(M) # Calculate the S1 signature component - - rc, SIG_S1 = amcl_mpc.mpc_s(HM, SIG_R, K1, SUM1) - - SIG_S1_hex = SIG_S1.hex() + rc, SIG_S1 = mpc.mpc_s(HM, SIG_R, K1, SUM1) + SIG_S1_hex = SIG_S1.hex() assert SIG_S1GOLDEN_hex == SIG_S1_hex, f"expected {SIG_S1GOLDEN_hex} got {SIG_S1_hex}" # Calculate the S2 signature component - - rc, SIG_S2 = amcl_mpc.mpc_s(HM, SIG_R, K2, SUM2) - - SIG_S2_hex = SIG_S2.hex() + rc, SIG_S2 = mpc.mpc_s(HM, SIG_R, K2, SUM2) + SIG_S2_hex = SIG_S2.hex() assert SIG_S2GOLDEN_hex == SIG_S2_hex, f"expected {SIG_S2GOLDEN_hex} got {SIG_S2_hex}" # Sum S signature component - - SIG_S = amcl_mpc.mpc_sum_s(SIG_S1, SIG_S2) - - SIG_S_hex = SIG_S.hex() - assert SIG_SGOLDEN_hex == SIG_S_hex, f"expected {SIG_SGOLDEN_hex} got {SIG_S_hex}" - + SIG_S = mpc.mpc_sum_s(SIG_S1, SIG_S2) + SIG_S_hex = SIG_S.hex() + assert SIG_SGOLDEN_hex == SIG_S_hex, f"expected {SIG_SGOLDEN_hex} got {SIG_S_hex}" diff --git a/python/test_ecdsa.py b/python/test_ecdsa.py index 98c85a0..1c60bfd 100755 --- a/python/test_ecdsa.py +++ b/python/test_ecdsa.py @@ -21,128 +21,102 @@ under the License. import unittest import json import os -import amcl_mpc +from amcl import mpc class TestECDSA(unittest.TestCase): """Tests MPC ECDSA""" - def setUp(self): - None - def test_1(self): """test_1 Test MPC ECDSA""" for i in range(1,11): print(f"Test {i}") seed = os.urandom(16) - rng = amcl_mpc.create_csprng(seed) - + rng = mpc.create_csprng(seed) + # Paillier keys - paillier_pk1, paillier_sk1 = amcl_mpc.paillier_key_pair(rng) - paillier_pk2, paillier_sk2 = amcl_mpc.paillier_key_pair(rng) + paillier_pk1, paillier_sk1 = mpc.paillier_key_pair(rng) + paillier_pk2, paillier_sk2 = mpc.paillier_key_pair(rng) # ECDSA keys - rc, PK1, W1 = amcl_mpc.ecp_secp256k1_key_pair_generate(rng) - rc = amcl_mpc.ecp_secp256k1_public_key_validate(PK1) + rc, PK1, W1 = mpc.ecp_secp256k1_key_pair_generate(rng) + rc = mpc.ecp_secp256k1_public_key_validate(PK1) assert rc == 0, f"Invalid ECDSA public key" - rc, PK2, W2 = amcl_mpc.ecp_secp256k1_key_pair_generate(rng) - rc = amcl_mpc.ecp_secp256k1_public_key_validate(PK2) + rc, PK2, W2 = mpc.ecp_secp256k1_key_pair_generate(rng) + rc = mpc.ecp_secp256k1_public_key_validate(PK2) assert rc == 0, f"Invalid ECDSA public key" # Gamma values - rc, GAMMAPT1, GAMMA1 = amcl_mpc.ecp_secp256k1_key_pair_generate(rng) - rc, GAMMAPT2, GAMMA2 = amcl_mpc.ecp_secp256k1_key_pair_generate(rng) + rc, GAMMAPT1, GAMMA1 = mpc.ecp_secp256k1_key_pair_generate(rng) + rc, GAMMAPT2, GAMMA2 = mpc.ecp_secp256k1_key_pair_generate(rng) # K values - rc, TMP1, K1 = amcl_mpc.ecp_secp256k1_key_pair_generate(rng) - rc, TMP2, K2 = amcl_mpc.ecp_secp256k1_key_pair_generate(rng) + rc, _, K1 = mpc.ecp_secp256k1_key_pair_generate(rng) + rc, _, K2 = mpc.ecp_secp256k1_key_pair_generate(rng) # Message M = b'test message' - - # ALPHA1 + BETA2 = K1 * GAMMA2 - - CA11 = amcl_mpc.mpc_mta_client1(rng, paillier_pk1, K1) - CB12, BETA2 = amcl_mpc.mpc_mta_server(rng, paillier_pk1, GAMMA2, CA11) - - ALPHA1 = amcl_mpc.mpc_mta_client2(paillier_sk1, CB12) + # ALPHA1 + BETA2 = K1 * GAMMA2 + CA11 = mpc.mpc_mta_client1(rng, paillier_pk1, K1) + CB12, BETA2 = mpc.mpc_mta_server(rng, paillier_pk1, GAMMA2, CA11) + ALPHA1 = mpc.mpc_mta_client2(paillier_sk1, CB12) # ALPHA2 + BETA1 = K2 * GAMMA1 - - CA22 = amcl_mpc.mpc_mta_client1(rng, paillier_pk2, K2) - - CB21, BETA1 = amcl_mpc.mpc_mta_server(rng, paillier_pk2, GAMMA1, CA22) - - ALPHA2 = amcl_mpc.mpc_mta_client2(paillier_sk2, CB21) + CA22 = mpc.mpc_mta_client1(rng, paillier_pk2, K2) + CB21, BETA1 = mpc.mpc_mta_server(rng, paillier_pk2, GAMMA1, CA22) + ALPHA2 = mpc.mpc_mta_client2(paillier_sk2, CB21) # sum = K1.GAMMA1 + alpha1 + beta1 - - SUM1 = amcl_mpc.mpc_sum_mta(K1, GAMMA1, ALPHA1, BETA1) + SUM1 = mpc.mpc_sum_mta(K1, GAMMA1, ALPHA1, BETA1) # sum = K2.GAMMA2 + alpha2 + beta2 - - SUM2 = amcl_mpc.mpc_sum_mta(K2, GAMMA2, ALPHA2, BETA2) + SUM2 = mpc.mpc_sum_mta(K2, GAMMA2, ALPHA2, BETA2) # Calculate the inverse of kgamma - - INVKGAMMA = amcl_mpc.mpc_invkgamma(SUM1, SUM2) + INVKGAMMA = mpc.mpc_invkgamma(SUM1, SUM2) # Calculate the R signature component + rc, SIG_R, _ = mpc.mpc_r(INVKGAMMA, GAMMAPT1, GAMMAPT2) - rc, SIG_R, _ = amcl_mpc.mpc_r(INVKGAMMA, GAMMAPT1, GAMMAPT2) - - # ALPHA1 + BETA2 = K1 * W2 - - CA11 = amcl_mpc.mpc_mta_client1(rng, paillier_pk1, K1) + # ALPHA1 + BETA2 = K1 * W2 + CA11 = mpc.mpc_mta_client1(rng, paillier_pk1, K1) + CB12, BETA2 = mpc.mpc_mta_server(rng, paillier_pk1, W2, CA11) + ALPHA1 = mpc.mpc_mta_client2(paillier_sk1, CB12) - CB12, BETA2 = amcl_mpc.mpc_mta_server(rng, paillier_pk1, W2, CA11) - - ALPHA1 = amcl_mpc.mpc_mta_client2(paillier_sk1, CB12) - # ALPHA2 + BETA1 = K2 * W1 - - CA22 = amcl_mpc.mpc_mta_client1(rng, paillier_pk2, K2) - - CB21, BETA1 = amcl_mpc.mpc_mta_server(rng, paillier_pk2, W1, CA22) - - ALPHA2 = amcl_mpc.mpc_mta_client2(paillier_sk2, CB21) + CA22 = mpc.mpc_mta_client1(rng, paillier_pk2, K2) + CB21, BETA1 = mpc.mpc_mta_server(rng, paillier_pk2, W1, CA22) + ALPHA2 = mpc.mpc_mta_client2(paillier_sk2, CB21) # sum = K1.W1 + alpha1 + beta1 - - SUM1 = amcl_mpc.mpc_sum_mta(K1, W1, ALPHA1, BETA1) + SUM1 = mpc.mpc_sum_mta(K1, W1, ALPHA1, BETA1) # sum = K2.W2 + alpha2 + beta2 - - SUM2 = amcl_mpc.mpc_sum_mta(K2, W2, ALPHA2, BETA2) + SUM2 = mpc.mpc_sum_mta(K2, W2, ALPHA2, BETA2) # Calculate the message hash - - HM = amcl_mpc.mpc_hash(M) + HM = mpc.mpc_hash(M) # Calculate the S1 signature component - - rc, SIG_S1 = amcl_mpc.mpc_s(HM, SIG_R, K1, SUM1) + rc, SIG_S1 = mpc.mpc_s(HM, SIG_R, K1, SUM1) # Calculate the S2 signature component - - rc, SIG_S2 = amcl_mpc.mpc_s(HM, SIG_R, K2, SUM2) + rc, SIG_S2 = mpc.mpc_s(HM, SIG_R, K2, SUM2) # Sum S signature component - - SIG_S = amcl_mpc.mpc_sum_s(SIG_S1, SIG_S2) + SIG_S = mpc.mpc_sum_s(SIG_S1, SIG_S2) # Sum ECDSA public keys - - rc, PK = amcl_mpc.mpc_sum_pk(PK1, PK2) + rc, PK = mpc.mpc_sum_pk(PK1, PK2) # Verify final signature + rc = mpc.mpc_ecdsa_verify(HM, PK, SIG_R, SIG_S) + + self.assertEqual(rc, 0) - rc = amcl_mpc.mpc_ecdsa_verify(HM, PK, SIG_R, SIG_S) - self.assertEqual(rc, 0) - if __name__ == '__main__': # Run tests diff --git a/python/test_mta.py b/python/test_mta.py index 02c3396..8a74971 100755 --- a/python/test_mta.py +++ b/python/test_mta.py @@ -20,39 +20,42 @@ under the License. """ import unittest import json -import amcl_mpc +from amcl import mpc class TestMtA(unittest.TestCase): """Tests MPC MtA""" def setUp(self): - seed_hex = "78d0fb6705ce77dee47d03eb5b9c5d30" - seed = bytes.fromhex(seed_hex) - self.rng = amcl_mpc.create_csprng(seed) + with open("MTA.json", "r") as f: + self.tv = json.load(f) + + for vector in self.tv: + for key, val in vector.items(): + if key != "TEST": + vector[key] = bytes.fromhex(val) def test_1(self): """test_1 Test Vector test""" - with open("MTA.json", "r") as f: - vectors = json.load(f) - for vector in vectors: + + for vector in self.tv: print(f"Test vector {vector['TEST']}") - test = {} - for key, val in vector.items(): - if key != "TEST": - # print(f"{key} = {val}\n") - test[key] = bytes.fromhex(val) - paillier_pk, paillier_sk = amcl_mpc.paillier_key_pair(self.rng, test['P'], test['Q']) - ca = amcl_mpc.mpc_mta_client1(self.rng, paillier_pk, test['A'], test['R1']) - self.assertEqual(vector['CA'], ca.hex()) + paillier_pk, paillier_sk = mpc.paillier_key_pair(None, vector['P'], vector['Q']) + + ca = mpc.mpc_mta_client1(None, paillier_pk, vector['A'], vector['R1']) + + self.assertEqual(vector['CA'], ca) + + cb, beta = mpc.mpc_mta_server(None, paillier_pk, vector['B'], vector['CA'], vector['Z'], vector['R2']) + + self.assertEqual(vector['CB'], cb) + self.assertEqual(vector['BETA'], beta) + + alpha = mpc.mpc_mta_client2(paillier_sk, vector['CB']) - cb, beta = amcl_mpc.mpc_mta_server(self.rng, paillier_pk, test['B'], test['CA'], test['Z'], test['R2']) - self.assertEqual(vector['CB'], cb.hex()) - self.assertEqual(vector['BETA'], beta.hex()) + self.assertEqual(vector['ALPHA'], alpha) - alpha = amcl_mpc.mpc_mta_client2(paillier_sk, test['CB']) - self.assertEqual(vector['ALPHA'], alpha.hex()) if __name__ == '__main__': # Run tests diff --git a/python/test_r.py b/python/test_r.py index f3175ea..2b53ca6 100755 --- a/python/test_r.py +++ b/python/test_r.py @@ -18,70 +18,71 @@ KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. """ + import unittest import json -import amcl_mpc +from amcl import mpc class TestR(unittest.TestCase): """Tests MPC R""" def setUp(self): - seed_hex = "78d0fb6705ce77dee47d03eb5b9c5d30" - seed = bytes.fromhex(seed_hex) - self.rng = amcl_mpc.create_csprng(seed) + with open("R.json", "r") as f: + self.tv = json.load(f) + + for vector in self.tv: + for key, val in vector.items(): + if key != "TEST": + vector[key] = bytes.fromhex(val) def test_1(self): """test_1 Test Vector test""" - with open("R.json", "r") as f: - vectors = json.load(f) - for vector in vectors: + + for vector in self.tv: print(f"Test vector {vector['TEST']}") - test = {} - for key, val in vector.items(): - if key != "TEST": - # print(f"{key} = {val}\n") - test[key] = bytes.fromhex(val) - PUB1, PRIV1 = amcl_mpc.paillier_key_pair(self.rng, test['P1'], test['Q1']) - PUB2, PRIV2 = amcl_mpc.paillier_key_pair(self.rng, test['P2'], test['Q2']) + + PUB1, PRIV1 = mpc.paillier_key_pair(None, vector['P1'], vector['Q1']) + PUB2, PRIV2 = mpc.paillier_key_pair(None, vector['P2'], vector['Q2']) # ALPHA1 + BETA2 = A1 * B2 - ca11 = amcl_mpc.mpc_mta_client1(self.rng, PUB1, test['A1'], test['R11']) - cb12, beta2 = amcl_mpc.mpc_mta_server(self.rng, PUB1, test['B2'], ca11, test['Z12'], test['R12']) - alpha1 = amcl_mpc.mpc_mta_client2(PRIV1, cb12) - - self.assertEqual(vector['ALPHA1'], alpha1.hex()) - self.assertEqual(vector['BETA2'], beta2.hex()) + ca11 = mpc.mpc_mta_client1(None, PUB1, vector['A1'], vector['R11']) + cb12, beta2 = mpc.mpc_mta_server(None, PUB1, vector['B2'], ca11, vector['Z12'], vector['R12']) + alpha1 = mpc.mpc_mta_client2(PRIV1, cb12) + + self.assertEqual(vector['ALPHA1'], alpha1) + self.assertEqual(vector['BETA2'], beta2) # ALPHA2 + BETA1 = A2 * B1 - ca22 = amcl_mpc.mpc_mta_client1(self.rng, PUB2, test['A2'], test['R22']) - cb21, beta1 = amcl_mpc.mpc_mta_server(self.rng, PUB2, test['B1'], ca22, test['Z21'], test['R21']) - alpha2 = amcl_mpc.mpc_mta_client2(PRIV2, cb21) - - self.assertEqual(vector['ALPHA2'], alpha2.hex()) - self.assertEqual(vector['BETA1'], beta1.hex()) + ca22 = mpc.mpc_mta_client1(None, PUB2, vector['A2'], vector['R22']) + cb21, beta1 = mpc.mpc_mta_server(None, PUB2, vector['B1'], ca22, vector['Z21'], vector['R21']) + alpha2 = mpc.mpc_mta_client2(PRIV2, cb21) + + self.assertEqual(vector['ALPHA2'], alpha2) + self.assertEqual(vector['BETA1'], beta1) # sum1 = A1.B1 + alpha1 + beta1 + sum1 = mpc.mpc_sum_mta(vector['A1'], vector['B1'], alpha1, beta1) - sum1 = amcl_mpc.mpc_sum_mta(test['A1'], test['B1'], alpha1, beta1) - self.assertEqual(vector['SUM1'], sum1.hex()) + self.assertEqual(vector['SUM1'], sum1) # sum2 = A2.B2 + alpha2 + beta2 + sum2 = mpc.mpc_sum_mta(vector['A2'], vector['B2'], alpha2, beta2) + + self.assertEqual(vector['SUM2'], sum2) - sum2 = amcl_mpc.mpc_sum_mta(test['A2'], test['B2'], alpha2, beta2) - self.assertEqual(vector['SUM2'], sum2.hex()) - # Calculate the inverse of kgamma + invkgamma= mpc.mpc_invkgamma(sum1, sum2) - invkgamma= amcl_mpc.mpc_invkgamma(sum1, sum2) - self.assertEqual(vector['INVKGAMMA'], invkgamma.hex()) + self.assertEqual(vector['INVKGAMMA'], invkgamma) # Calculate the R signature component + rc, sig_r, _ = mpc.mpc_r(invkgamma, vector['GAMMAPT1'], vector['GAMMAPT2']) + + self.assertEqual(vector['SIG_R'], sig_r) + self.assertEqual(rc, 0) + - rc, sig_r, _ = amcl_mpc.mpc_r(invkgamma, test['GAMMAPT1'], test['GAMMAPT2']) - self.assertEqual(vector['SIG_R'], sig_r.hex()) - self.assertEqual(rc, 0) - if __name__ == '__main__': # Run tests unittest.main() diff --git a/python/test_s.py b/python/test_s.py index 79fa928..ed07453 100755 --- a/python/test_s.py +++ b/python/test_s.py @@ -18,81 +18,78 @@ KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. """ + import unittest import json -import amcl_mpc +from amcl import mpc class TestS(unittest.TestCase): """Tests MPC S""" def setUp(self): - seed_hex = "78d0fb6705ce77dee47d03eb5b9c5d30" - seed = bytes.fromhex(seed_hex) - self.rng = amcl_mpc.create_csprng(seed) + with open("S.json", "r") as f: + self.tv = json.load(f) + + for vector in self.tv: + for key, val in vector.items(): + if key != "TEST": + vector[key] = bytes.fromhex(val) def test_1(self): """test_1 Test Vector test""" - with open("S.json", "r") as f: - vectors = json.load(f) - for vector in vectors: + + for vector in self.tv: print(f"Test vector {vector['TEST']}") - test = {} - for key, val in vector.items(): - if key != "TEST": - #print(f"{key} = {val}\n") - test[key] = bytes.fromhex(val) - PUB1, PRIV1 = amcl_mpc.paillier_key_pair(self.rng, test['P1'], test['Q1']) - PUB2, PRIV2 = amcl_mpc.paillier_key_pair(self.rng, test['P2'], test['Q2']) + + PUB1, PRIV1 = mpc.paillier_key_pair(None, vector['P1'], vector['Q1']) + PUB2, PRIV2 = mpc.paillier_key_pair(None, vector['P2'], vector['Q2']) # ALPHA1 + BETA2 = K1 * W2 - ca11 = amcl_mpc.mpc_mta_client1(self.rng, PUB1, test['K1'], test['R11']) - cb12, beta2 = amcl_mpc.mpc_mta_server(self.rng, PUB1, test['W2'], ca11, test['Z12'], test['R12']) - alpha1 = amcl_mpc.mpc_mta_client2(PRIV1, cb12) - - self.assertEqual(vector['ALPHA1'], alpha1.hex()) - self.assertEqual(vector['BETA2'], beta2.hex()) + ca11 = mpc.mpc_mta_client1(None, PUB1, vector['K1'], vector['R11']) + cb12, beta2 = mpc.mpc_mta_server(None, PUB1, vector['W2'], ca11, vector['Z12'], vector['R12']) + alpha1 = mpc.mpc_mta_client2(PRIV1, cb12) + + self.assertEqual(vector['ALPHA1'], alpha1) + self.assertEqual(vector['BETA2'], beta2) # ALPHA2 + BETA1 = K2 * W1 - ca22 = amcl_mpc.mpc_mta_client1(self.rng, PUB2, test['K2'], test['R22']) - cb21, beta1 = amcl_mpc.mpc_mta_server(self.rng, PUB2, test['W1'], ca22, test['Z21'], test['R21']) - alpha2 = amcl_mpc.mpc_mta_client2(PRIV2, cb21) - - self.assertEqual(vector['ALPHA2'], alpha2.hex()) - self.assertEqual(vector['BETA1'], beta1.hex()) + ca22 = mpc.mpc_mta_client1(None, PUB2, vector['K2'], vector['R22']) + cb21, beta1 = mpc.mpc_mta_server(None, PUB2, vector['W1'], ca22, vector['Z21'], vector['R21']) + alpha2 = mpc.mpc_mta_client2(PRIV2, cb21) + + self.assertEqual(vector['ALPHA2'], alpha2) + self.assertEqual(vector['BETA1'], beta1) # sum1 = K1.W1 + alpha1 + beta1 + SUM1 = mpc.mpc_sum_mta(vector['K1'], vector['W1'], alpha1, beta1) - SUM1 = amcl_mpc.mpc_sum_mta(test['K1'], test['W1'], alpha1, beta1) - self.assertEqual(vector['SUM1'], SUM1.hex()) + self.assertEqual(vector['SUM1'], SUM1) # sum2 = K2.W2 + alpha2 + beta2 + SUM2 = mpc.mpc_sum_mta(vector['K2'], vector['W2'], alpha2, beta2) - SUM2 = amcl_mpc.mpc_sum_mta(test['K2'], test['W2'], alpha2, beta2) - self.assertEqual(vector['SUM2'], SUM2.hex()) + self.assertEqual(vector['SUM2'], SUM2) # Calculate the message hash - - HM = amcl_mpc.mpc_hash(test['M']) + HM = mpc.mpc_hash(vector['M']) # Calculate the S1 signature component - - rc, SIG_S1 = amcl_mpc.mpc_s(HM, test['SIG_R'], test['K1'], SUM1) - self.assertEqual(vector['SIG_S1'], SIG_S1.hex()) - self.assertEqual(rc, 0) + rc, SIG_S1 = mpc.mpc_s(HM, vector['SIG_R'], vector['K1'], SUM1) + self.assertEqual(vector['SIG_S1'], SIG_S1) + self.assertEqual(rc, 0) # Calculate the S2 signature component - - rc, SIG_S2 = amcl_mpc.mpc_s(HM, test['SIG_R'], test['K2'], SUM2) - self.assertEqual(vector['SIG_S2'], SIG_S2.hex()) - self.assertEqual(rc, 0) + rc, SIG_S2 = mpc.mpc_s(HM, vector['SIG_R'], vector['K2'], SUM2) + self.assertEqual(vector['SIG_S2'], SIG_S2) + self.assertEqual(rc, 0) # Sum S signature component + SIG_S = mpc.mpc_sum_s(SIG_S1, SIG_S2) + self.assertEqual(vector['SIG_S'], SIG_S) + self.assertEqual(rc, 0) + - SIG_S = amcl_mpc.mpc_sum_s(SIG_S1, SIG_S2) - self.assertEqual(vector['SIG_S'], SIG_S.hex()) - self.assertEqual(rc, 0) - if __name__ == '__main__': # Run tests unittest.main() diff --git a/python/test_schnorr.py b/python/test_schnorr.py index 1392acb..e6b1b84 100755 --- a/python/test_schnorr.py +++ b/python/test_schnorr.py @@ -21,7 +21,7 @@ under the License. import unittest import json -import amcl_schnorr +from amcl import schnorr class TestCommit(unittest.TestCase): @@ -31,7 +31,7 @@ class TestCommit(unittest.TestCase): # Deterministic PRNG for testing purposes seed_hex = "78d0fb6705ce77dee47d03eb5b9c5d30" seed = bytes.fromhex(seed_hex) - self.rng = amcl_schnorr.create_csprng(seed) + self.rng = schnorr.create_csprng(seed) r_hex = "e8a04212cc20520429d854a5bb02b51b4281e663c90a4a4ec0b505171f9bc26a" C_hex = "028fe6cafe6e6cef6c47be31cb449faa9495d22a6cb47e057b91c97d807882c439" @@ -48,7 +48,7 @@ class TestCommit(unittest.TestCase): r_golden = bytes.fromhex(vector["R"]) C_golden = bytes.fromhex(vector["C"]) - r, C = amcl_schnorr.commit(None, r_golden) + r, C = schnorr.commit(None, r_golden) self.assertEqual(r, r_golden) self.assertEqual(C, C_golden) @@ -56,7 +56,7 @@ class TestCommit(unittest.TestCase): def test_random(self): """ Test using pseudo random r """ - r, C = amcl_schnorr.commit(self.rng) + r, C = schnorr.commit(self.rng) self.assertEqual(r, self.r_golden) self.assertEqual(C, self.C_golden) @@ -78,7 +78,7 @@ class TestChallenge(unittest.TestCase): e_golden = bytes.fromhex(vector["E"]) - e = amcl_schnorr.challenge(V, C) + e = schnorr.challenge(V, C) self.assertEqual(e, e_golden) @@ -100,7 +100,7 @@ class TestProve(unittest.TestCase): p_golden = bytes.fromhex(vector["P"]) - p = amcl_schnorr.prove(r, e, x) + p = schnorr.prove(r, e, x) self.assertEqual(p, p_golden) @@ -121,9 +121,9 @@ class TestVerify(unittest.TestCase): e = bytes.fromhex(vector["E"]) p = bytes.fromhex(vector["P"]) - ec = amcl_schnorr.verify(V, C, e, p) + ec = schnorr.verify(V, C, e, p) - self.assertEqual(ec, amcl_schnorr.OK) + self.assertEqual(ec, schnorr.OK) def test_error_code(self): """ Test error codes are propagated """ @@ -135,9 +135,9 @@ class TestVerify(unittest.TestCase): e = bytes.fromhex(vector["E"]) p = bytes.fromhex(vector["P"]) - ec = amcl_schnorr.verify(V, C, e, p) + ec = schnorr.verify(V, C, e, p) - self.assertEqual(ec, amcl_schnorr.FAIL) + self.assertEqual(ec, schnorr.FAIL) if __name__ == '__main__':
