This is an automated email from the ASF dual-hosted git repository. sandreoli pushed a commit to branch issue18-add-python-flow-example in repository https://gitbox.apache.org/repos/asf/incubator-milagro-MPC.git
commit c0edc6e8d403f7afc714597895b124fb07630fc5 Author: Samuele Andreoli <[email protected]> AuthorDate: Wed Feb 26 16:23:32 2020 +0000 Wrap custom functions for keys and k generation. Lint code --- python/amcl/mpc.py | 128 ++++++++++++++++++++++++++++++++++++--- python/examples/example_ecdsa.py | 12 ++-- python/test/test_ecdsa.py | 17 ++---- 3 files changed, 133 insertions(+), 24 deletions(-) diff --git a/python/amcl/mpc.py b/python/amcl/mpc.py index a77f1a8..c0f5ec7 100644 --- a/python/amcl/mpc.py +++ b/python/amcl/mpc.py @@ -28,6 +28,24 @@ from . import core_utils _ffi = core_utils._ffi _ffi.cdef(""" +#define EFS_SECP256K1 32 + +typedef signed int sign32; +typedef long unsigned int BIG_256_56[5]; + +typedef struct +{ + BIG_256_56 g; + sign32 XES; +} FP_SECP256K1; + +typedef struct +{ + FP_SECP256K1 x; + FP_SECP256K1 y; + FP_SECP256K1 z; +} ECP_SECP256K1; + typedef struct { BIG_512_60 n[8]; @@ -54,14 +72,15 @@ extern void PAILLIER_PRIVATE_KEY_KILL(PAILLIER_private_key *PRIV); extern void PAILLIER_PK_toOctet(octet *PK, PAILLIER_public_key *PUB); extern void PAILLIER_PK_fromOctet(PAILLIER_public_key *PUB, octet *PK); -extern int ECP_SECP256K1_KEY_PAIR_GENERATE(csprng *R,octet *s,octet *W); -extern int ECP_SECP256K1_PUBLIC_KEY_VALIDATE(octet *W); +extern int ECP_SECP256K1_PUBLIC_KEY_VALIDATE(octet *W); +extern void MPC_ECDSA_KEY_PAIR_GENERATE(csprng *RNG, octet *S, octet *W); extern int MPC_ECDSA_VERIFY(octet *HM,octet *PK, octet *R,octet *S); extern void MPC_MTA_CLIENT1(csprng *RNG, PAILLIER_public_key* PUB, octet* A, octet* CA, octet* R); extern void MPC_MTA_CLIENT2(PAILLIER_private_key *PRIV, octet* CB, octet *ALPHA); extern void MPC_MTA_SERVER(csprng *RNG, PAILLIER_public_key *PUB, octet *B, octet *CA, octet *Z, octet *R, octet *CB, octet *BETA); extern void MPC_SUM_MTA(octet *A, octet *B, octet *ALPHA, octet *BETA, octet *SUM); +extern void MPC_K_GENERATE(csprng *RNG, octet *K); extern void MPC_INVKGAMMA(octet *KGAMMA1, octet *KGAMMA2, octet *INVKGAMMA); extern extern int MPC_R(octet *INVKGAMMA, octet *GAMMAPT1, octet *GAMMAPT2, octet *R, octet *RP); extern void MPC_HASH(int sha, octet *M, octet *HM); @@ -85,7 +104,7 @@ else: _libamcl_curve_secp256k1 = _ffi.dlopen("libamcl_curve_SECP256K1.so") # Constants -FS_2048 = 256 # Size of an FF_2048 in bytes +FS_2048 = 256 # Size of an FF_2048 in bytes HFS_2048 = 128 # Half-suze of an FF_2048 in bytes FS_4096 = 512 # Size of an FF_4096 in bytes EGS_SECP256K1 = 32 # Size of an element of Z/qZ in bytes @@ -117,6 +136,7 @@ def paillier_key_pair(rng, p=None, q=None): if p: p1, p1_val = core_utils.make_octet(None, p) q1, q1_val = core_utils.make_octet(None, q) + _ = p1_val, q1_val rng = _ffi.NULL else: p1 = _ffi.NULL @@ -127,8 +147,15 @@ def paillier_key_pair(rng, p=None, q=None): _libamcl_paillier.PAILLIER_KEY_PAIR(rng, p1, q1, paillier_pk, paillier_sk) + if p1 is not _ffi.NULL: + core_utils.clear_octet(p1) + + if q1 is not _ffi.NULL: + core_utils.clear_octet(q1) + return paillier_pk, paillier_sk + def paillier_private_key_kill(paillier_sk): """Kill a Paillier secret key @@ -167,6 +194,7 @@ def paillier_pk_to_octet(paillier_pk): """ n1, n1_val = core_utils.make_octet(FS_4096) + _ = n1_val _libamcl_paillier.PAILLIER_PK_toOctet(n1, paillier_pk) @@ -174,6 +202,7 @@ def paillier_pk_to_octet(paillier_pk): return n2 + def paillier_pk_from_octet(n): """Read Paillier public key from byte array @@ -193,12 +222,14 @@ def paillier_pk_from_octet(n): paillier_pk = _ffi.new('PAILLIER_public_key*') n1, n1_val = core_utils.make_octet(None, n) + _ = n1_val _libamcl_paillier.PAILLIER_PK_fromOctet(paillier_pk, n1) return paillier_pk -def ecp_secp256k1_key_pair_generate(rng, ecdsa_sk=None): + +def mpc_ecdsa_key_pair_generate(rng, ecdsa_sk=None): """Generate ECDSA key pair Generate ECDSA key pair @@ -212,7 +243,6 @@ def ecp_secp256k1_key_pair_generate(rng, ecdsa_sk=None): ecdsa_sk: ECDSA secret key ecdsa_pk: ECDSA public key - rc: Zero for success or else an error code Raises: @@ -224,13 +254,17 @@ def ecp_secp256k1_key_pair_generate(rng, ecdsa_sk=None): ecdsa_sk1, ecdsa_sk1_val = core_utils.make_octet(EGS_SECP256K1) ecdsa_pk1, ecdsa_pk1_val = core_utils.make_octet(2 * EFS_SECP256K1 + 1) + _ = ecdsa_pk1_val, ecdsa_sk1_val # Suppress warnings - rc = _libamcl_curve_secp256k1.ECP_SECP256K1_KEY_PAIR_GENERATE(rng, ecdsa_sk1, ecdsa_pk1) + _libamcl_mpc.MPC_ECDSA_KEY_PAIR_GENERATE(rng, ecdsa_sk1, ecdsa_pk1) ecdsa_sk2 = core_utils.to_str(ecdsa_sk1) ecdsa_pk2 = core_utils.to_str(ecdsa_pk1) - return rc, ecdsa_pk2, ecdsa_sk2 + core_utils.clear_octet(ecdsa_sk1) + + return ecdsa_pk2, ecdsa_sk2 + def ecp_secp256k1_public_key_validate(ecdsa_pk): """Validate an ECDSA public key @@ -249,11 +283,13 @@ def ecp_secp256k1_public_key_validate(ecdsa_pk): """ ecdsa_pk1, ecdsa_pk1_val = core_utils.make_octet(None, ecdsa_pk) + _ = ecdsa_pk1_val rc = _libamcl_curve_secp256k1.ECP_SECP256K1_PUBLIC_KEY_VALIDATE(ecdsa_pk1) return rc + def mpc_mta_client1(rng, paillier_pk, a, r=None): """Client MTA first pass @@ -276,19 +312,28 @@ def mpc_mta_client1(rng, paillier_pk, a, r=None): """ if r: r1, r1_val = core_utils.make_octet(None, r) + _ = r1_val rng = _ffi.NULL else: r1 = _ffi.NULL a1, a1_val = core_utils.make_octet(None, a) ca1, ca1_val = core_utils.make_octet(FS_4096) + _ = a1_val, ca1_val _libamcl_mpc.MPC_MTA_CLIENT1(rng, paillier_pk, a1, ca1, r1) ca2 = core_utils.to_str(ca1) + # Clear memory + core_utils.clear_octet(a1) + + if r1 is not _ffi.NULL: + core_utils.clear_octet(r1) + return ca2 + def mpc_mta_client2(paillier_sk, cb): """Client MtA second pass @@ -308,13 +353,16 @@ def mpc_mta_client2(paillier_sk, cb): """ cb1, cb1_val = core_utils.make_octet(None, cb) alpha1, alpha1_val = core_utils.make_octet(EGS_SECP256K1) + _ = cb1_val, alpha1_val # Suppress warnings _libamcl_mpc.MPC_MTA_CLIENT2(paillier_sk, cb1, alpha1) alpha2 = core_utils.to_str(alpha1) + core_utils.clear_octet(alpha1) return alpha2 + def mpc_mta_server(rng, paillier_pk, b, ca, z=None, r=None): """Server MtA @@ -340,6 +388,7 @@ def mpc_mta_server(rng, paillier_pk, b, ca, z=None, r=None): if r: r1, r1_val = core_utils.make_octet(None, r) z1, z1_val = core_utils.make_octet(None, z) + _ = r1_val, z1_val rng = _ffi.NULL else: r1 = _ffi.NULL @@ -349,14 +398,26 @@ def mpc_mta_server(rng, paillier_pk, b, ca, z=None, r=None): ca1, ca1_val = core_utils.make_octet(None, ca) beta1, beta1_val = core_utils.make_octet(EGS_SECP256K1) cb1, cb1_val = core_utils.make_octet(FS_4096) + _ = b1_val, ca1_val, beta1_val, cb1_val _libamcl_mpc.MPC_MTA_SERVER(rng, paillier_pk, b1, ca1, z1, r1, cb1, beta1) beta2 = core_utils.to_str(beta1) cb2 = core_utils.to_str(cb1) + # Clear memory + core_utils.clear_octet(b1) + core_utils.clear_octet(beta1) + + if r1 is not _ffi.NULL: + core_utils.clear_octet(r1) + + if z1 is not _ffi.NULL: + core_utils.clear_octet(z1) + return cb2, beta2 + def mpc_sum_mta(a, b, alpha, beta): """Sum of secret shares @@ -382,13 +443,43 @@ def mpc_sum_mta(a, b, alpha, beta): beta1, beta1_val = core_utils.make_octet(None, beta) sum1, sum1_val = core_utils.make_octet(EGS_SECP256K1) + _ = a1_val, b1_val, alpha1_val, beta1_val, sum1_val # Suppress warnings _libamcl_mpc.MPC_SUM_MTA(a1, b1, alpha1, beta1, sum1) sum2 = core_utils.to_str(sum1) + core_utils.clear_octet(a1) + core_utils.clear_octet(b1) + return sum2 + +def mpc_k_generate(rng): + """ Generate random k mod curve order + + Args:: + + rng: pointer to a cryptographically secure prng + + Returns:: + + k: a random value modulo the curve order + + Raises: + + """ + k, k_val = core_utils.make_octet(EGS_SECP256K1) + _ = k_val + + _libamcl_mpc.MPC_K_GENERATE(rng, k) + + k_str = core_utils.to_str(k) + core_utils.clear_octet(k) + + return k_str + + def mpc_invkgamma(kgamma1, kgamma2): """Calculate the inverse of the sum of kgamma values @@ -410,6 +501,7 @@ def mpc_invkgamma(kgamma1, kgamma2): kgamma21, kgamma21_val = core_utils.make_octet(None, kgamma2) invkgamma1, invkgamma1_val = core_utils.make_octet(EGS_SECP256K1) + _ = kgamma11_val, kgamma21_val, invkgamma1_val # Suppress warnings _libamcl_mpc.MPC_INVKGAMMA(kgamma11, kgamma21, invkgamma1) @@ -417,6 +509,7 @@ def mpc_invkgamma(kgamma1, kgamma2): return invkgamma2 + def mpc_r(invkgamma, gammapt1, gammapt2): """R component @@ -442,6 +535,7 @@ def mpc_r(invkgamma, gammapt1, gammapt2): r1, r1_val = core_utils.make_octet(EGS_SECP256K1) rp, rp_val = core_utils.make_octet(EFS_SECP256K1 + 1) + _ = invkgamma1_val, gammapt11_val, gammapt21_val, r1_val, rp_val rc = _libamcl_mpc.MPC_R(invkgamma1, gammapt11, gammapt21, r1, rp) @@ -450,6 +544,7 @@ def mpc_r(invkgamma, gammapt1, gammapt2): return rc, r2, rp_str + def mpc_hash(message): """Hash the message value @@ -468,6 +563,7 @@ def mpc_hash(message): """ message1, message1_val = core_utils.make_octet(None, message) hm1, hm1_val = core_utils.make_octet(SHA256) + _ = message1_val, hm1_val _libamcl_mpc.MPC_HASH(SHA256, message1, hm1) @@ -475,6 +571,7 @@ def mpc_hash(message): return hm2 + def mpc_s(hm, r, k, sigma): """S component @@ -501,13 +598,17 @@ def mpc_s(hm, r, k, sigma): sigma1, sigma1_val = core_utils.make_octet(None, sigma) s1, s1_val = core_utils.make_octet(EGS_SECP256K1) + _ = hm1_val, r1_val, k1_val, sigma1_val, s1_val rc = _libamcl_mpc.MPC_S(hm1, r1, k1, sigma1, s1) s2 = core_utils.to_str(s1) + core_utils.clear_octet(k1) + return rc, s2 + def mpc_ecdsa_verify(hm, pk, r, s): """ECDSA Verify signature @@ -531,11 +632,13 @@ def mpc_ecdsa_verify(hm, pk, r, s): pk1, pk1_val = core_utils.make_octet(None, pk) r1, r1_val = core_utils.make_octet(None, r) s1, s1_val = core_utils.make_octet(None, s) + _ = hm1_val, pk1_val, r1_val, s1_val rc = _libamcl_mpc.MPC_ECDSA_VERIFY(hm1, pk1, r1, s1) return rc + def mpc_sum_s(s1, s2): """Sum of ECDSA s components @@ -557,6 +660,7 @@ def mpc_sum_s(s1, s2): s21, s21_val = core_utils.make_octet(None, s2) s1, s1_val = core_utils.make_octet(EGS_SECP256K1) + _ = s11_val, s21_val, s1_val _libamcl_mpc.MPC_SUM_S(s11, s21, s1) @@ -564,6 +668,7 @@ def mpc_sum_s(s1, s2): return s2 + def mpc_sum_pk(pk1, pk2): """Sum of ECDSA public key shares @@ -586,6 +691,7 @@ def mpc_sum_pk(pk1, pk2): pk21, pk21_val = core_utils.make_octet(None, pk2) pk1, pk1_val = core_utils.make_octet(EFS_SECP256K1 + 1) + _ = pk11_val, pk21_val, pk1_val rc = _libamcl_mpc.MPC_SUM_PK(pk11, pk21, pk1) @@ -593,6 +699,7 @@ def mpc_sum_pk(pk1, pk2): return rc, pk2 + def mpc_dump_paillier_sk(paillier_sk): """Write Paillier public key to byte array @@ -612,10 +719,17 @@ def mpc_dump_paillier_sk(paillier_sk): """ p, p_val = core_utils.make_octet(HFS_2048) q, q_val = core_utils.make_octet(HFS_2048) + _ = p_val, q_val _libamcl_mpc.MPC_DUMP_PAILLIER_SK(paillier_sk, p, q) p2 = core_utils.to_str(p) q2 = core_utils.to_str(q) + # Clear memory + core_utils.clear_octet(p) + core_utils.clear_octet(q) + core_utils.clear_octet(p2) + core_utils.clear_octet(q2) + return p2, q2 diff --git a/python/examples/example_ecdsa.py b/python/examples/example_ecdsa.py index 3f984fb..f098223 100755 --- a/python/examples/example_ecdsa.py +++ b/python/examples/example_ecdsa.py @@ -40,21 +40,21 @@ if __name__ == "__main__": paillier_pk2, paillier_sk2 = amcl.mpc.paillier_key_pair(rng) # ECDSA keys - rc, PK1, W1 = amcl.mpc.ecp_secp256k1_key_pair_generate(rng) + PK1, W1 = amcl.mpc.mpc_ecdsa_key_pair_generate(rng) rc = amcl.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) + PK2, W2 = amcl.mpc.mpc_ecdsa_key_pair_generate(rng) rc = amcl.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) + GAMMAPT1, GAMMA1 = amcl.mpc.mpc_ecdsa_key_pair_generate(rng) + GAMMAPT2, GAMMA2 = amcl.mpc.mpc_ecdsa_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) + K1 = amcl.mpc.mpc_k_generate(rng) + K2 = amcl.mpc.mpc_k_generate(rng) # Message M = b'test message' diff --git a/python/test/test_ecdsa.py b/python/test/test_ecdsa.py index 1a21470..64fb1ae 100755 --- a/python/test/test_ecdsa.py +++ b/python/test/test_ecdsa.py @@ -45,21 +45,16 @@ class TestECDSA(unittest.TestCase): paillier_pk2, paillier_sk2 = mpc.paillier_key_pair(rng) # ECDSA keys - 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 = mpc.ecp_secp256k1_key_pair_generate(rng) - rc = mpc.ecp_secp256k1_public_key_validate(PK2) - assert rc == 0, f"Invalid ECDSA public key" + PK1, W1 = mpc.mpc_ecdsa_key_pair_generate(rng) + PK2, W2 = mpc.mpc_ecdsa_key_pair_generate(rng) # Gamma values - rc, GAMMAPT1, GAMMA1 = mpc.ecp_secp256k1_key_pair_generate(rng) - rc, GAMMAPT2, GAMMA2 = mpc.ecp_secp256k1_key_pair_generate(rng) + GAMMAPT1, GAMMA1 = mpc.mpc_ecdsa_key_pair_generate(rng) + GAMMAPT2, GAMMA2 = mpc.mpc_ecdsa_key_pair_generate(rng) # K values - rc, _, K1 = mpc.ecp_secp256k1_key_pair_generate(rng) - rc, _, K2 = mpc.ecp_secp256k1_key_pair_generate(rng) + K1 = mpc.mpc_k_generate(rng) + K2 = mpc.mpc_k_generate(rng) # Message M = b'test message'
