refactor smc and ec crypto functions and ad 0og zkp

1 files changed, 49 insertions, 214 deletions

diff --git a/crypto.c b/crypto.c
index 55ab26a..b4f71e4 100644
--- a/crypto.c
+++ b/crypto.c
@@ -34,8 +34,10 @@ struct brandt_ec_pkey {
         unsigned char q_y[256 / 8];
 };
 
-gcry_mpi_point_t ec_gen;
 gcry_ctx_t       ec_ctx;
+gcry_mpi_point_t ec_gen;
+gcry_mpi_point_t ec_zero;
+gcry_mpi_t       ec_n;
 
 /**
  * brandt_crypto_init
@@ -49,10 +51,19 @@ brandt_crypto_init ()
 
         rc = gcry_mpi_ec_new (&ec_ctx, NULL, CURVE);
         brandt_assert_gpgerr (rc);
+
         ec_gen = gcry_mpi_ec_get_point ("g", ec_ctx, 0);
         brandt_assert (NULL != ec_gen);
+
+        ec_zero = gcry_mpi_point_new (0);
+        brandt_assert (NULL != ec_zero);
+        gcry_mpi_ec_sub (ec_zero, ec_gen, ec_gen, ec_ctx);
+
+        ec_n = gcry_mpi_ec_get_mpi ("n", ec_ctx, 1);
+        brandt_assert (NULL != ec_n);
 }
 
+
 /* --- RANDOM --- */
 
 void
@@ -64,6 +75,7 @@ brandt_rand_poll ()
                 gcry_fast_random_poll ();
 }
 
+
 /* --- HASHING --- */
 
 /**
@@ -79,6 +91,7 @@ brandt_hash (const void *block, size_t size, struct brandt_hash_code *ret)
         gcry_md_hash_buffer (GCRY_MD_SHA512, ret, block, size);
 }
 
+
 /* --- MPI --- */
 
 /**
@@ -101,6 +114,7 @@ adjust (void *buf, size_t size, size_t target)
         }
 }
 
+
 /**
  * Output the given MPI value to the given buffer in
  * network byte order.
@@ -141,6 +155,7 @@ brandt_mpi_print_unsigned (void *buf, size_t size, gcry_mpi_t val)
         }
 }
 
+
 /**
  * Convert data buffer into MPI value.
  * The buffer is interpreted as network
@@ -159,6 +174,7 @@ brandt_mpi_scan_unsigned (gcry_mpi_t *result, const void *data, size_t size)
         brandt_assert_gpgerr (rc);
 }
 
+
 //gcry_mpi_point_t
 //deserialize_point(const struct brandt_point* data, const int len)
 //{
@@ -185,73 +201,18 @@ brandt_mpi_scan_unsigned (gcry_mpi_t *result, const void *data, size_t size)
 /* --- EC --- */
 
 /**
- * Extract values from an S-expression.
- *
- * @param array where to store the result(s)
- * @param sexp S-expression to parse
- * @param topname top-level name in the S-expression that is of interest
- * @param elems names of the elements to extract
- * @return 0 on success
- */
-static int
-key_from_sexp (gcry_mpi_t *array, gcry_sexp_t sexp, const char *topname,
-               const char *elems)
-{
-        gcry_sexp_t  list;
-        gcry_sexp_t  l2;
-        const char   *s;
-        unsigned int i;
-        unsigned int idx;
-
-        list = gcry_sexp_find_token (sexp, topname, 0);
-        if (!list)
-                return 1;
-        l2 = gcry_sexp_cadr (list);
-        gcry_sexp_release (list);
-        list = l2;
-        if (!list)
-                return 2;
-        idx = 0;
-        for (s = elems; *s; s++, idx++)
-        {
-                l2 = gcry_sexp_find_token (list, s, 1);
-                if (!l2)
-                {
-                        for (i = 0; i < idx; i++)
-                        {
-                                gcry_free (array[i]);
-                                array[i] = NULL;
-                        }
-                        gcry_sexp_release (list);
-                        return 3;                 /* required parameter not found */
-                }
-                array[idx] = gcry_sexp_nth_mpi (l2, 1, GCRYMPI_FMT_USG);
-                gcry_sexp_release (l2);
-                if (!array[idx])
-                {
-                        for (i = 0; i < idx; i++)
-                        {
-                                gcry_free (array[i]);
-                                array[i] = NULL;
-                        }
-                        gcry_sexp_release (list);
-                        return 4;                 /* required parameter is invalid */
-                }
-        }
-        gcry_sexp_release (list);
-        return 0;
-}
-
-/**
  * brandt_ec_skey_create
  *
  * @param[out] skey where to store the generated secret key
  */
 void
-brandt_ec_skey_create (gcry_mpi_t *skey)
+brandt_ec_skey_create (gcry_mpi_t skey)
 {
+        gcry_mpi_t   ret;
         gcry_sexp_t  s_keyparam;
         gcry_sexp_t  priv_sexp;
+        gcry_sexp_t  priv_key;
+        gcry_sexp_t  priv_key2;
         gcry_error_t rc;
 
         rc = gcry_sexp_build (&s_keyparam, NULL, "(genkey(ecc(curve \"" CURVE "\")"
@@ -262,24 +223,22 @@ brandt_ec_skey_create (gcry_mpi_t *skey)
         brandt_assert_gpgerr (rc);
         gcry_sexp_release (s_keyparam);
 
-        rc = key_from_sexp (skey, priv_sexp, "private-key", "d");
-        brandt_assert_gpgerr (rc);
-
+        priv_key = gcry_sexp_find_token (priv_sexp, "private-key", 11);
+        brandt_assert (NULL != priv_key);
         gcry_sexp_release (priv_sexp);
-}
 
-/**
- * brandt_ec_pkey_compute
- *
- * @param pkey TODO
- * @param skey TODO
- */
-void
-brandt_ec_pkey_compute (gcry_mpi_point_t *pkey, const gcry_mpi_t skey)
-{
+        priv_key2 = gcry_sexp_find_token (priv_key, "d", 1);
+        brandt_assert (NULL != priv_key2);
+        gcry_sexp_release (priv_key);
 
+        ret = gcry_sexp_nth_mpi (priv_key2, 1, GCRYMPI_FMT_USG);
+        brandt_assert (NULL != ret);
+        gcry_sexp_release (priv_key2);
+
+        gcry_mpi_snatch (skey, ret);
 }
 
+
 /**
  * brandt_ec_keypair_create
  *
@@ -287,33 +246,16 @@ brandt_ec_pkey_compute (gcry_mpi_point_t *pkey, const gcry_mpi_t skey)
  * @param[out] skey where to store the generated secret key
  */
 void
-brandt_ec_keypair_create (gcry_mpi_point_t *pkey, gcry_mpi_t *skey)
+brandt_ec_keypair_create (gcry_mpi_point_t pkey, gcry_mpi_t skey)
 {
-        gcry_ctx_t   ctx;
-        gcry_sexp_t  s_keyparam;
-        gcry_sexp_t  priv_sexp;
-        gcry_error_t rc;
-
-        rc = gcry_sexp_build (&s_keyparam, NULL, "(genkey(ecc(curve \"" CURVE "\")"
-                              "(flags)))");
-        brandt_assert_gpgerr (rc);
-
-        rc = gcry_pk_genkey (&priv_sexp, s_keyparam);
-        brandt_assert_gpgerr (rc);
-        gcry_sexp_release (s_keyparam);
-
-        rc = key_from_sexp (skey, priv_sexp, "private-key", "d");
-        brandt_assert_gpgerr (rc);
-
-        rc = gcry_mpi_ec_new (&ctx, priv_sexp, NULL);
-        brandt_assert_gpgerr (rc);
-        gcry_sexp_release (priv_sexp);
+        brandt_assert (NULL != pkey);
+        brandt_assert (NULL != skey);
 
-        *pkey = gcry_mpi_ec_get_point ("q", ctx, 0);
-        brandt_assert (NULL != *pkey);
-        gcry_ctx_release (ctx);
+        brandt_ec_skey_create (skey);
+        gcry_mpi_ec_mul (pkey, skey, ec_gen, ec_ctx);
 }
 
+
 /**
  * brandt_ec_keypair_create_base
  *
@@ -322,16 +264,19 @@ brandt_ec_keypair_create (gcry_mpi_point_t *pkey, gcry_mpi_t *skey)
  * @param[in] base which base point should be used to calculate the public key
  */
 void
-brandt_ec_keypair_create_base (gcry_mpi_point_t *pkey, gcry_mpi_t *skey,
+brandt_ec_keypair_create_base (gcry_mpi_point_t       pkey,
+                               gcry_mpi_t             skey,
                                const gcry_mpi_point_t base)
 {
+        brandt_assert (NULL != pkey);
+        brandt_assert (NULL != skey);
+        brandt_assert (NULL != base);
+
         brandt_ec_skey_create (skey);
-        brandt_assert (*skey);
-        *pkey = gcry_mpi_point_new (0);
-        brandt_assert (*pkey);
-        gcry_mpi_ec_mul (*pkey, *skey, base, ec_ctx);
+        gcry_mpi_ec_mul (pkey, skey, base, ec_ctx);
 }
 
+
 /**
  * brandt_ec_point_cmp compares two curve points
  *
@@ -356,8 +301,8 @@ brandt_ec_point_cmp (const gcry_mpi_point_t a, const gcry_mpi_point_t b)
                 return 1;
         }
 
-        if (!gcry_mpi_ec_get_affine (ax, ay, a, ec_ctx)
-            && !gcry_mpi_ec_get_affine (bx, by, b, ec_ctx))
+        if (!gcry_mpi_ec_get_affine (ax, ay, a, ec_ctx) &&
+            !gcry_mpi_ec_get_affine (bx, by, b, ec_ctx))
         {
                 ret = gcry_mpi_cmp (ax, bx) || gcry_mpi_cmp (ay, by);
         }
@@ -369,117 +314,6 @@ brandt_ec_point_cmp (const gcry_mpi_point_t a, const gcry_mpi_point_t b)
         return ret;
 }
 
-/**
- * Convert the given private key from the network format to the
- * S-expression that can be used by libgcrypt.
- *
- * @param priv private key to decode
- * @return NULL on error
- */
-static gcry_sexp_t
-decode_private_ecdhe_key (const struct brandt_ec_skey *priv)
-{
-        gcry_sexp_t  result;
-        gcry_error_t rc;
-
-        rc = gcry_sexp_build (&result, NULL,
-                              "(private-key(ecc(curve \"" CURVE "\")"
-                              "(d %b)))",
-                              (int)sizeof (priv->d), priv->d);
-        brandt_assert_gpgerr (rc);
-        return result;
-}
-
-/**
- * Extract the public key for the given private key.
- *
- * @param priv the private key
- * @param pub where to write the public key
- */
-void
-brandt_ecdhe_key_get_public (const struct brandt_ec_skey *priv,
-                             struct brandt_ec_pkey       *pub)
-{
-        gcry_sexp_t  sexp;
-        gcry_ctx_t   ctx;
-        gcry_mpi_t   q;
-        gcry_error_t rc;
-
-        sexp = decode_private_ecdhe_key (priv);
-        brandt_assert (NULL != sexp);
-        rc = gcry_mpi_ec_new (&ctx, sexp, NULL);
-        brandt_assert_gpgerr (rc);
-        gcry_sexp_release (sexp);
-        q = gcry_mpi_ec_get_mpi ("q@eddsa", ctx, 0);
-        brandt_assert (NULL != q);
-        brandt_mpi_print_unsigned (pub->q_y, sizeof (pub->q_y), q);
-        gcry_mpi_release (q);
-        gcry_ctx_release (ctx);
-}
-
-/**
- * Derive key material from a public and a private ECDHE key.
- *
- * @param priv private key to use for the ECDH (x)
- * @param pub public key to use for the ECDH (yG)
- * @param key_material where to write the key material (xyG)
- * @return 0 on error, 1 on success
- */
-int
-brandt_ecdhe (const struct brandt_ec_skey *priv,
-              const struct brandt_ec_pkey *pub,
-              struct brandt_hash_code     *key_material)
-{
-        gcry_error_t     rc;
-        int              rc2;
-        gcry_mpi_point_t result;
-        gcry_mpi_point_t q;
-        gcry_mpi_t       d;
-        gcry_ctx_t       ctx;
-        gcry_sexp_t      pub_sexpr;
-        gcry_mpi_t       result_x;
-        unsigned char    xbuf[256 / 8];
-        size_t           rsize;
-
-        /* first, extract the q = dP value from the public key */
-        if (0 != gcry_sexp_build (&pub_sexpr, NULL,
-                                  "(public-key(ecc(curve " CURVE ")(q %b)))",
-                                  (int)sizeof (pub->q_y), pub->q_y))
-                return 0;
-        rc = gcry_mpi_ec_new (&ctx, pub_sexpr, NULL);
-        brandt_assert_gpgerr (rc);
-        gcry_sexp_release (pub_sexpr);
-        q = gcry_mpi_ec_get_point ("q", ctx, 0);
-
-        /* second, extract the d value from our private key */
-        brandt_mpi_scan_unsigned (&d, priv->d, sizeof (priv->d));
-
-        /* then call the 'multiply' function, to compute the product */
-        result = gcry_mpi_point_new (0);
-        gcry_mpi_ec_mul (result, d, q, ctx);
-        gcry_mpi_point_release (q);
-        gcry_mpi_release (d);
-
-        /* finally, convert point to string for hashing */
-        result_x = gcry_mpi_new (256);
-        rc = gcry_mpi_ec_get_affine (result_x, NULL, result, ctx);
-        brandt_assert (0 == rc);
-        gcry_mpi_point_release (result);
-        gcry_ctx_release (ctx);
-
-        rsize = sizeof (xbuf);
-        rc2 = gcry_mpi_get_flag (result_x, GCRYMPI_FLAG_OPAQUE);
-        brandt_assert (0 == rc2);
-        /* result_x can be negative here, so we do not use 'brandt_mpi_print_unsigned'
-         * as that does not include the sign bit; x should be a 255-bit
-         * value, so with the sign it should fit snugly into the 256-bit
-         * xbuf */
-        rc = gcry_mpi_print (GCRYMPI_FMT_STD, xbuf, rsize, &rsize, result_x);
-        brandt_assert_gpgerr (rc);
-        brandt_hash (xbuf, rsize, key_material);
-        gcry_mpi_release (result_x);
-        return 1;
-}
 
 /**
  * Clear memory that was used to store a private key.
@@ -492,6 +326,7 @@ brandt_ec_key_clear (struct brandt_ec_skey *skey)
         memset (skey, 0, sizeof (struct brandt_ec_skey));
 }
 
+
 /**
  * Generate a random value mod n.
  *