moving to new, fixed-size encoding of public and private ECC keys everywhere, also improving ECC API to better support ECRS/GADS operations

5 files changed, 121 insertions, 50 deletions

diff --git a/src/fs/fs_api.h b/src/fs/fs_api.h
index f3daeb85a..2fe38f604 100644
--- a/src/fs/fs_api.h
+++ b/src/fs/fs_api.h
@@ -125,7 +125,7 @@ struct Location
   /**
    * Identity of the peer sharing the file.
    */
-  struct GNUNET_CRYPTO_EccPublicKeyBinaryEncoded peer;
+  struct GNUNET_CRYPTO_EccPublicKey peer;
 
   /**
    * Time when this location URI expires.
diff --git a/src/fs/fs_pseudonym.c b/src/fs/fs_pseudonym.c
index 49a084199..36eaab6fa 100644
--- a/src/fs/fs_pseudonym.c
+++ b/src/fs/fs_pseudonym.c
@@ -104,9 +104,8 @@ static struct GNUNET_FS_pseudonym_DiscoveryHandle *disco_head;
 static struct GNUNET_FS_pseudonym_DiscoveryHandle *disco_tail;
 
 /**
- * Pointer to indiate 'anonymous' pseudonym (global static, all
- * zeros).  We actually use pointer comparisson to detect the
- * "anonymous" pseudonym handle.
+ * Pointer to indiate 'anonymous' pseudonym (global static, 
+ * d=1, public key = G (generator).
  */
 static struct GNUNET_FS_PseudonymHandle anonymous;
 
@@ -1019,6 +1018,68 @@ GNUNET_FS_pseudonym_create_from_existing_file (const char *filename)
 struct GNUNET_FS_PseudonymHandle *
 GNUNET_FS_pseudonym_get_anonymous_pseudonym_handle ()
 {
+  static int once;
+  gcry_mpi_t d;
+  size_t size;
+  gcry_ctx_t ctx;
+  int rc;
+  gcry_mpi_t g_x;
+  gcry_mpi_t g_y;
+  gcry_mpi_point_t g;
+
+  if (once)
+    return &anonymous;
+  d = gcry_mpi_new (1);
+  gcry_mpi_set_ui (d, 1);
+  size = sizeof (anonymous.d);
+  GNUNET_assert (0 ==
+                 gcry_mpi_print (GCRYMPI_FMT_USG, anonymous.d, size, &size,
+                                 d));
+  gcry_mpi_release (d);
+  adjust (anonymous.d, size, sizeof (anonymous.d));
+  
+  /* create basic ECC context */
+  if (0 != (rc = gcry_mpi_ec_new (&ctx, NULL, "NIST P-256")))
+  {
+    LOG_GCRY (GNUNET_ERROR_TYPE_ERROR, 
+              "gcry_mpi_ec_new", rc);
+    return NULL;
+  }  
+
+  g = gcry_mpi_ec_get_point ("g", ctx, 0);
+  g_x = gcry_mpi_new (256);
+  g_y = gcry_mpi_new (256);
+  gcry_mpi_ec_get_affine (g_x, g_y, g, ctx);
+  gcry_mpi_point_release (g);
+  gcry_ctx_release (ctx);
+
+  /* store g_x/g_y in public key */
+  size = sizeof (anonymous.public_key.q_x);  
+  if (0 !=
+      gcry_mpi_print (GCRYMPI_FMT_USG, anonymous.public_key.q_x, size, &size,
+                      g_x))
+  {
+    LOG_GCRY (GNUNET_ERROR_TYPE_ERROR, "gcry_mpi_print", rc);
+    gcry_mpi_release (g_x);
+    gcry_mpi_release (g_y);
+    return NULL;
+  }
+  adjust (anonymous.public_key.q_x, size, sizeof (anonymous.public_key.q_x));
+  gcry_mpi_release (g_x);
+
+  size = sizeof (anonymous.public_key.q_y);  
+  if (0 !=
+      gcry_mpi_print (GCRYMPI_FMT_USG, anonymous.public_key.q_y, size, &size,
+                      g_y))
+  {
+    LOG_GCRY (GNUNET_ERROR_TYPE_ERROR, "gcry_mpi_print", rc);
+    gcry_mpi_release (g_y);
+    return NULL;
+  }
+  adjust (anonymous.public_key.q_y, size, sizeof (anonymous.public_key.q_y));
+  gcry_mpi_release (g_y);
+
+  once = 1;
   return &anonymous;
 }
 
@@ -1122,21 +1183,13 @@ GNUNET_FS_pseudonym_sign (struct GNUNET_FS_PseudonymHandle *ph,
   int rc;
 
   /* get private key 'd' from pseudonym */
-  if (&anonymous == ph)
-  {
-    d = gcry_mpi_new (0);
-    gcry_mpi_set_ui (d, 0);
-  }
-  else
+  size = sizeof (ph->d);
+  if (0 != (rc = gcry_mpi_scan (&d, GCRYMPI_FMT_USG,
+                                &ph->d,
+                                size, &size)))
   {
-    size = sizeof (ph->d);
-    if (0 != (rc = gcry_mpi_scan (&d, GCRYMPI_FMT_USG,
-                                  &ph->d,
-                                  size, &size)))
-    {
-      LOG_GCRY (GNUNET_ERROR_TYPE_ERROR, "gcry_mpi_scan", rc);
-      return GNUNET_SYSERR;
-    }
+    LOG_GCRY (GNUNET_ERROR_TYPE_ERROR, "gcry_mpi_scan", rc);
+    return GNUNET_SYSERR;
   }
   /* get 'x' value from signing key */
   size = sizeof (struct GNUNET_HashCode);
@@ -1159,9 +1212,9 @@ GNUNET_FS_pseudonym_sign (struct GNUNET_FS_PseudonymHandle *ph,
     return GNUNET_SYSERR;
   }
 
-  /* calculate dx = d + h mod n */
+  /* calculate dh = d * h mod n */
   dh = gcry_mpi_new (256);
-  gcry_mpi_addm (dh, d, h, n);  
+  gcry_mpi_mulm (dh, d, h, n);
   gcry_mpi_release (d);
   gcry_mpi_release (h);
   gcry_mpi_release (n);
@@ -1297,7 +1350,7 @@ get_context_from_pseudonym (struct GNUNET_FS_PseudonymIdentifier *pseudonym)
       LOG_GCRY (GNUNET_ERROR_TYPE_ERROR, "gcry_mpi_ec_new", rc);  /* erroff gives more info */
       return NULL;
     }  
-    /* initialize 'ctx' with 'q' = 0 */
+    /* FIXME: initialize 'ctx' with 'q' = G */
     zero = gcry_mpi_new (0);
     gcry_mpi_set_ui (zero, 0);
     q = gcry_mpi_point_new (0);
@@ -1346,7 +1399,7 @@ get_context_from_pseudonym (struct GNUNET_FS_PseudonymIdentifier *pseudonym)
  * @param pseudonym the public key (dQ in ECDSA)
  * @param signing_key input to derive 'h' (see section 2.4 of #2564)
  * @param verification_key resulting public key to verify the signature
- *        created from the '(d+h)' of 'pseudonym' and the 'signing_key';
+ *        created from the '(d*h)' of 'pseudonym' and the 'signing_key';
  *        the value stored here can then be given to GNUNET_FS_pseudonym_verify.
  * @return GNUNET_OK on success, GNUNET_SYSERR on error
  */
@@ -1359,12 +1412,12 @@ GNUNET_FS_pseudonym_derive_verification_key (struct GNUNET_FS_PseudonymIdentifie
   size_t size;
   int rc;
   gcry_ctx_t ctx;
-  gcry_mpi_point_t g;
   gcry_mpi_point_t q;
-  gcry_mpi_point_t hg;
   gcry_mpi_point_t v;
   gcry_mpi_t v_x;
   gcry_mpi_t v_y;
+  gcry_mpi_t h_mod_n;
+  gcry_mpi_t n; /* n from P-256 */
 
   /* get 'h' value from signing key */
   size = sizeof (struct GNUNET_HashCode);
@@ -1381,22 +1434,26 @@ GNUNET_FS_pseudonym_derive_verification_key (struct GNUNET_FS_PseudonymIdentifie
     gcry_mpi_release (h);
     return GNUNET_SYSERR;
   }
-  /* get G */  
-  g = gcry_mpi_ec_get_point ("g", ctx, 0);
-
-  /* then call the 'multiply' function, to compute the product hG */
-  hg = gcry_mpi_point_new (0);
-  gcry_mpi_ec_mul (hg, h, g, ctx);
-  gcry_mpi_point_release (g);
+  /* initialize 'n' from P-256; hex copied from libgcrypt code */
+  if (0 != (rc = gcry_mpi_scan (&n, GCRYMPI_FMT_HEX,
+                                "0xffffffff00000000ffffffffffffffffbce6faada7179e84f3b9cac2fc632551", 0, NULL)))
+  {
+    LOG_GCRY (GNUNET_ERROR_TYPE_ERROR, "gcry_mpi_scan", rc);
+  gcry_mpi_release (h);
+    return GNUNET_SYSERR;
+  }
+  h_mod_n = gcry_mpi_new (0);
+  gcry_mpi_mod (h_mod_n, h, n);
   gcry_mpi_release (h);
 
   /* get Q = dG from 'pseudonym' */
   q = gcry_mpi_ec_get_point ("q", ctx, 0);
-  /* calculate V = Q + hG = dG + hG = (d + h)G*/
+  /* calculate V = hQ = hdG */
   v = gcry_mpi_point_new (0);
-  gcry_mpi_ec_add (v, q, hg, ctx);
-  gcry_mpi_point_release (hg);
   
+  gcry_mpi_ec_mul (v, h_mod_n, q, ctx);
+  gcry_mpi_release (h_mod_n);
+
   /* store 'v' point in "verification_key" */
   v_x = gcry_mpi_new (256);
   v_y = gcry_mpi_new (256);
@@ -1566,11 +1623,8 @@ void
 GNUNET_FS_pseudonym_get_identifier (struct GNUNET_FS_PseudonymHandle *ph,
                                     struct GNUNET_FS_PseudonymIdentifier *pseudonym)
 {
-  if (&anonymous == ph)
-    memset (pseudonym, 0, sizeof (struct GNUNET_FS_PseudonymIdentifier));
-  else
-    memcpy (pseudonym, &ph->public_key,
-            sizeof (struct GNUNET_FS_PseudonymIdentifier));
+  memcpy (pseudonym, &ph->public_key,
+          sizeof (struct GNUNET_FS_PseudonymIdentifier));
 }
 
 
diff --git a/src/fs/fs_publish_ksk.c b/src/fs/fs_publish_ksk.c
index 3b0f1d4fb..10512af5f 100644
--- a/src/fs/fs_publish_ksk.c
+++ b/src/fs/fs_publish_ksk.c
@@ -177,23 +177,35 @@ publish_ksk_cont (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
   struct UBlock *ub_dst;
 
   pkc->ksk_task = GNUNET_SCHEDULER_NO_TASK;
-  if ((pkc->i == pkc->ksk_uri->data.ksk.keywordCount) || (NULL == pkc->dsh))
+  if ( (pkc->i == pkc->ksk_uri->data.ksk.keywordCount) ||
+       (NULL == pkc->dsh) )
   {
     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "KSK PUT operation complete\n");
     pkc->cont (pkc->cont_cls, pkc->ksk_uri, NULL);
     GNUNET_FS_publish_ksk_cancel (pkc);
     return;
   }
+  keyword = pkc->ksk_uri->data.ksk.keywords[pkc->i++];
+  pkc->sks_task = GNUNET_FS_publish_sks (pkc->h,
+                                         anonymous,
+                                         keyword, NULL,
+                                         pkc->meta,
+                                         pkc->uri,
+                                         &pkc->bo,
+                                         pkc->options,
+                                         &publish_ksk_cont, pkc);
+                                         
+
   /* derive signing seed from plaintext */
   GNUNET_CRYPTO_hash (&pkc->ub[1],
                       1 + pkc->slen + pkc->mdsize,
                       &seed);
-  keyword = pkc->ksk_uri->data.ksk.keywords[pkc->i++];
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Publishing under keyword `%s'\n",
               &keyword[1]);  
   /* first character of keyword indicates if it is
    * mandatory or not -- ignore for hashing */
   GNUNET_CRYPTO_hash (&keyword[1], strlen (&keyword[1]), &key);
+
   GNUNET_CRYPTO_hash_to_aes_key (&key, &skey, &iv);
   ub_dst = pkc->cpy;
   GNUNET_CRYPTO_aes_encrypt (&pkc->ub[1], 
@@ -202,8 +214,9 @@ publish_ksk_cont (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
                              &ub_dst[1]);
   ph = GNUNET_FS_pseudonym_get_anonymous_pseudonym_handle ();
   GNUNET_CRYPTO_hash (&key, sizeof (key), &signing_key);
-  ub_dst->purpose.size = htonl (1 + pkc->slen + pkc->mdsize + sizeof (struct UBlock)
-                                  - sizeof (struct GNUNET_FS_PseudonymSignature));
+  ub_dst->purpose.size = htonl (1 + pkc->slen + pkc->mdsize + 
+                                sizeof (struct UBlock)
+                                - sizeof (struct GNUNET_FS_PseudonymSignature));
   ub_dst->purpose.purpose = htonl (GNUNET_SIGNATURE_PURPOSE_FS_UBLOCK);
   
   GNUNET_FS_pseudonym_get_identifier (ph, &pseudonym);
diff --git a/src/fs/fs_uri.c b/src/fs/fs_uri.c
index 48c347a52..78b5459fd 100644
--- a/src/fs/fs_uri.c
+++ b/src/fs/fs_uri.c
@@ -117,7 +117,7 @@ GNUNET_FS_uri_to_key (const struct GNUNET_FS_Uri *uri, struct GNUNET_HashCode *
   case GNUNET_FS_URI_LOC:
     GNUNET_CRYPTO_hash (&uri->data.loc.fi,
                         sizeof (struct FileIdentifier) +
-                        sizeof (struct GNUNET_CRYPTO_EccPublicKeyBinaryEncoded),
+                        sizeof (struct GNUNET_CRYPTO_EccPublicKey),
                         key);
     break;
   default:
@@ -520,7 +520,7 @@ struct LocUriAssembly
 
   struct FileIdentifier fi;
 
-  struct GNUNET_CRYPTO_EccPublicKeyBinaryEncoded peer;
+  struct GNUNET_CRYPTO_EccPublicKey peer;
 
 };
 
@@ -591,7 +591,7 @@ uri_loc_parse (const char *s, char **emsg)
   npos++;
   ret =
       enc2bin (&s[npos], &ass.peer,
-               sizeof (struct GNUNET_CRYPTO_EccPublicKeyBinaryEncoded));
+               sizeof (struct GNUNET_CRYPTO_EccPublicKey));
   if (ret == -1)
   {
     *emsg =
@@ -828,7 +828,7 @@ GNUNET_FS_uri_loc_get_peer_identity (const struct GNUNET_FS_Uri *uri,
   if (uri->type != GNUNET_FS_URI_LOC)
     return GNUNET_SYSERR;
   GNUNET_CRYPTO_hash (&uri->data.loc.peer,
-                      sizeof (struct GNUNET_CRYPTO_EccPublicKeyBinaryEncoded),
+                      sizeof (struct GNUNET_CRYPTO_EccPublicKey),
                       &peer->hashPubKey);
   return GNUNET_OK;
 }
@@ -884,7 +884,7 @@ GNUNET_FS_uri_loc_create (const struct GNUNET_FS_Uri *baseUri,
 {
   struct GNUNET_FS_Uri *uri;
   struct GNUNET_CRYPTO_EccPrivateKey *my_private_key;
-  struct GNUNET_CRYPTO_EccPublicKeyBinaryEncoded my_public_key;
+  struct GNUNET_CRYPTO_EccPublicKey my_public_key;
   char *keyfile;
   struct LocUriAssembly ass;
 
@@ -1307,7 +1307,7 @@ GNUNET_FS_uri_test_equal (const struct GNUNET_FS_Uri *u1,
     if (memcmp
         (&u1->data.loc, &u2->data.loc,
          sizeof (struct FileIdentifier) +
-         sizeof (struct GNUNET_CRYPTO_EccPublicKeyBinaryEncoded) +
+         sizeof (struct GNUNET_CRYPTO_EccPublicKey) +
          sizeof (struct GNUNET_TIME_Absolute) + sizeof (unsigned short) +
          sizeof (unsigned short)) != 0)
       return GNUNET_NO;
@@ -2049,7 +2049,7 @@ uri_loc_to_string (const struct GNUNET_FS_Uri *uri)
   GNUNET_CRYPTO_hash_to_enc (&uri->data.loc.fi.chk.query, &queryhash);
   peerId =
       bin2enc (&uri->data.loc.peer,
-               sizeof (struct GNUNET_CRYPTO_EccPublicKeyBinaryEncoded));
+               sizeof (struct GNUNET_CRYPTO_EccPublicKey));
   peerSig =
       bin2enc (&uri->data.loc.contentSignature,
                sizeof (struct GNUNET_CRYPTO_EccSignature));
diff --git a/src/fs/test_fs_defaults.conf b/src/fs/test_fs_defaults.conf
index 7d87c0e2f..dd0d729e2 100644
--- a/src/fs/test_fs_defaults.conf
+++ b/src/fs/test_fs_defaults.conf
@@ -92,3 +92,7 @@ AUTOSTART = NO
 
 [consensus]
 AUTOSTART = NO
+
+[mesh]
+REFRESH_PATH_TIME = 30 min
+