splitting 'struct GNUNET_CRYPTO_EccPublicKey' into one struct for signing and another for encryption

9 files changed, 40 insertions, 40 deletions

diff --git a/src/fs/fs_api.h b/src/fs/fs_api.h
index 441e4fa9b..1700b469b 100644
--- a/src/fs/fs_api.h
+++ b/src/fs/fs_api.h
@@ -120,7 +120,7 @@ struct Location
   /**
    * Identity of the peer sharing the file.
    */
-  struct GNUNET_CRYPTO_EccPublicKey peer;
+  struct GNUNET_CRYPTO_EccPublicSignKey peer;
 
   /**
    * Time when this location URI expires.
@@ -198,7 +198,7 @@ struct GNUNET_FS_Uri
       /**
        * Identifier of the namespace.
        */
-      struct GNUNET_CRYPTO_EccPublicKey ns;
+      struct GNUNET_CRYPTO_EccPublicSignKey ns;
 
       /**
        * Human-readable identifier chosen for this entry in the
@@ -1461,7 +1461,7 @@ struct SearchRequestEntry
   /**
    * Derived public key, hashes to 'uquery'.
    */ 
-  struct GNUNET_CRYPTO_EccPublicKey dpub;
+  struct GNUNET_CRYPTO_EccPublicSignKey dpub;
 
   /**
    * The original keyword, used to derive the
diff --git a/src/fs/fs_namespace.c b/src/fs/fs_namespace.c
index 526ebbdfc..2fe1de7e2 100644
--- a/src/fs/fs_namespace.c
+++ b/src/fs/fs_namespace.c
@@ -131,7 +131,7 @@ get_update_information_directory (struct GNUNET_FS_Handle *h,
 {
   char *dn;
   char *ret;
-  struct GNUNET_CRYPTO_EccPublicKey pub;
+  struct GNUNET_CRYPTO_EccPublicSignKey pub;
   struct GNUNET_HashCode hc;
   struct GNUNET_CRYPTO_HashAsciiEncoded enc;
 
@@ -143,7 +143,7 @@ get_update_information_directory (struct GNUNET_FS_Handle *h,
                                "fs", "UPDATE_DIR");
     return NULL;
   }
-  GNUNET_CRYPTO_ecc_key_get_public (ns, &pub);
+  GNUNET_CRYPTO_ecc_key_get_public_for_signature (ns, &pub);
   GNUNET_CRYPTO_hash (&pub, sizeof (pub), &hc);
   GNUNET_CRYPTO_hash_to_enc (&hc,
                              &enc);
@@ -448,7 +448,7 @@ GNUNET_FS_publish_sks (struct GNUNET_FS_Handle *h,
   sks_uri = GNUNET_new (struct GNUNET_FS_Uri);
   sks_uri->type = GNUNET_FS_URI_SKS;
   sks_uri->data.sks.identifier = GNUNET_strdup (identifier);
-  GNUNET_CRYPTO_ecc_key_get_public (ns,
+  GNUNET_CRYPTO_ecc_key_get_public_for_signature (ns,
                                     &sks_uri->data.sks.ns);
 
   psc = GNUNET_new (struct GNUNET_FS_PublishSksContext);
diff --git a/src/fs/fs_publish_ublock.c b/src/fs/fs_publish_ublock.c
index e45808793..252268e24 100644
--- a/src/fs/fs_publish_ublock.c
+++ b/src/fs/fs_publish_ublock.c
@@ -46,7 +46,7 @@ static void
 derive_ublock_encryption_key (struct GNUNET_CRYPTO_AesSessionKey *skey,
                               struct GNUNET_CRYPTO_AesInitializationVector *iv,
                               const char *label,
-                              const struct GNUNET_CRYPTO_EccPublicKey *pub)
+                              const struct GNUNET_CRYPTO_EccPublicSignKey *pub)
 {
   struct GNUNET_HashCode key;
 
@@ -73,7 +73,7 @@ derive_ublock_encryption_key (struct GNUNET_CRYPTO_AesSessionKey *skey,
 void
 GNUNET_FS_ublock_decrypt_ (const void *input,
                            size_t input_len,
-                           const struct GNUNET_CRYPTO_EccPublicKey *ns,
+                           const struct GNUNET_CRYPTO_EccPublicSignKey *ns,
                            const char *label,
                            void *output)
 {
@@ -170,7 +170,7 @@ GNUNET_FS_publish_ublock_ (struct GNUNET_FS_Handle *h,
   struct GNUNET_CRYPTO_AesInitializationVector iv;
   struct GNUNET_CRYPTO_AesSessionKey skey;
   struct GNUNET_CRYPTO_EccPrivateKey *nsd;
-  struct GNUNET_CRYPTO_EccPublicKey pub;
+  struct GNUNET_CRYPTO_EccPublicSignKey pub;
   char *uris;
   size_t size;
   char *kbe;
@@ -225,7 +225,7 @@ GNUNET_FS_publish_ublock_ (struct GNUNET_FS_Handle *h,
               "Publishing under identifier `%s'\n",
               label);
   /* get public key of the namespace */
-  GNUNET_CRYPTO_ecc_key_get_public (ns,
+  GNUNET_CRYPTO_ecc_key_get_public_for_signature (ns,
                                     &pub);
   derive_ublock_encryption_key (&skey, &iv,
                                 label, &pub);
@@ -243,7 +243,7 @@ GNUNET_FS_publish_ublock_ (struct GNUNET_FS_Handle *h,
 
   /* derive signing-key from 'label' and public key of the namespace */
   nsd = GNUNET_CRYPTO_ecc_key_derive (ns, label, "fs-ublock");
-  GNUNET_CRYPTO_ecc_key_get_public (nsd,
+  GNUNET_CRYPTO_ecc_key_get_public_for_signature (nsd,
                                     &ub_enc->verification_key);
   GNUNET_assert (GNUNET_OK ==
                  GNUNET_CRYPTO_ecc_sign (nsd,
diff --git a/src/fs/fs_publish_ublock.h b/src/fs/fs_publish_ublock.h
index 9a2db54ac..1a7d338d2 100644
--- a/src/fs/fs_publish_ublock.h
+++ b/src/fs/fs_publish_ublock.h
@@ -46,7 +46,7 @@
 void
 GNUNET_FS_ublock_decrypt_ (const void *input,
                            size_t input_len,
-                           const struct GNUNET_CRYPTO_EccPublicKey *ns,
+                           const struct GNUNET_CRYPTO_EccPublicSignKey *ns,
                            const char *label,
                            void *output);
 
diff --git a/src/fs/fs_search.c b/src/fs/fs_search.c
index 38bd55caa..09c260000 100644
--- a/src/fs/fs_search.c
+++ b/src/fs/fs_search.c
@@ -679,20 +679,20 @@ process_sks_result (struct GNUNET_FS_SearchContext *sc, const char *id_update,
  */
 static int
 decrypt_block_with_keyword (const struct GNUNET_FS_SearchContext *sc,
-                            const struct GNUNET_CRYPTO_EccPublicKey *dpub,
+                            const struct GNUNET_CRYPTO_EccPublicSignKey *dpub,
                             const void *edata,
                             size_t edata_size,
                             char *data)
 { 
   const struct GNUNET_CRYPTO_EccPrivateKey *anon;
-  struct GNUNET_CRYPTO_EccPublicKey anon_pub;
+  struct GNUNET_CRYPTO_EccPublicSignKey anon_pub;
   unsigned int i;
 
   /* find key */
   for (i = 0; i < sc->uri->data.ksk.keywordCount; i++)
     if (0 == memcmp (dpub,
                      &sc->requests[i].dpub,
-                     sizeof (struct GNUNET_CRYPTO_EccPublicKey)))
+                     sizeof (struct GNUNET_CRYPTO_EccPublicSignKey)))
       break;
   if (i == sc->uri->data.ksk.keywordCount)
   {
@@ -702,7 +702,7 @@ decrypt_block_with_keyword (const struct GNUNET_FS_SearchContext *sc,
   }
   /* decrypt */
   anon = GNUNET_CRYPTO_ecc_key_get_anonymous ();
-  GNUNET_CRYPTO_ecc_key_get_public (anon, &anon_pub);
+  GNUNET_CRYPTO_ecc_key_get_public_for_signature (anon, &anon_pub);
   GNUNET_FS_ublock_decrypt_ (edata, edata_size,
                              &anon_pub,
                              sc->requests[i].keyword,
@@ -1035,7 +1035,7 @@ transmit_search_request (void *cls, size_t size, void *buf)
   struct MessageBuilderContext mbc;
   size_t msize;
   struct SearchMessage *sm;
-  struct GNUNET_CRYPTO_EccPublicKey dpub;
+  struct GNUNET_CRYPTO_EccPublicSignKey dpub;
   unsigned int sqms;
   uint32_t options;
 
@@ -1272,7 +1272,7 @@ GNUNET_FS_search_start_searching_ (struct GNUNET_FS_SearchContext *sc)
   unsigned int i;
   const char *keyword;
   const struct GNUNET_CRYPTO_EccPrivateKey *anon;
-  struct GNUNET_CRYPTO_EccPublicKey anon_pub;
+  struct GNUNET_CRYPTO_EccPublicSignKey anon_pub;
   struct SearchRequestEntry *sre;
 
   GNUNET_assert (NULL == sc->client);
@@ -1280,7 +1280,7 @@ GNUNET_FS_search_start_searching_ (struct GNUNET_FS_SearchContext *sc)
   {
     GNUNET_assert (0 != sc->uri->data.ksk.keywordCount);
     anon = GNUNET_CRYPTO_ecc_key_get_anonymous ();
-    GNUNET_CRYPTO_ecc_key_get_public (anon, &anon_pub);
+    GNUNET_CRYPTO_ecc_key_get_public_for_signature (anon, &anon_pub);
     sc->requests =
         GNUNET_malloc (sizeof (struct SearchRequestEntry) *
                        sc->uri->data.ksk.keywordCount);
@@ -1294,7 +1294,7 @@ GNUNET_FS_search_start_searching_ (struct GNUNET_FS_SearchContext *sc)
                                            "fs-ublock",
                                            &sre->dpub);
       GNUNET_CRYPTO_hash (&sre->dpub, 
-                          sizeof (struct GNUNET_CRYPTO_EccPublicKey), 
+                          sizeof (struct GNUNET_CRYPTO_EccPublicSignKey), 
                           &sre->uquery);
       sre->mandatory = (sc->uri->data.ksk.keywords[i][0] == '+');
       if (sre->mandatory)
diff --git a/src/fs/fs_unindex.c b/src/fs/fs_unindex.c
index 5a956b0b5..6c4ee6696 100644
--- a/src/fs/fs_unindex.c
+++ b/src/fs/fs_unindex.c
@@ -554,8 +554,8 @@ GNUNET_FS_unindex_do_remove_kblocks_ (struct GNUNET_FS_UnindexContext *uc)
 {
   const char *keyword;
   const struct GNUNET_CRYPTO_EccPrivateKey *anon;
-  struct GNUNET_CRYPTO_EccPublicKey anon_pub;
-  struct GNUNET_CRYPTO_EccPublicKey dpub;
+  struct GNUNET_CRYPTO_EccPublicSignKey anon_pub;
+  struct GNUNET_CRYPTO_EccPublicSignKey dpub;
 
   if (NULL == uc->dsh)
     uc->dsh = GNUNET_DATASTORE_connect (uc->h->cfg);
@@ -574,7 +574,7 @@ GNUNET_FS_unindex_do_remove_kblocks_ (struct GNUNET_FS_UnindexContext *uc)
     return;
   }
   anon = GNUNET_CRYPTO_ecc_key_get_anonymous ();
-  GNUNET_CRYPTO_ecc_key_get_public (anon, &anon_pub);
+  GNUNET_CRYPTO_ecc_key_get_public_for_signature (anon, &anon_pub);
   keyword = &uc->ksk_uri->data.ksk.keywords[uc->ksk_offset][1];
   GNUNET_CRYPTO_ecc_public_key_derive (&anon_pub,
                                        keyword,
diff --git a/src/fs/fs_uri.c b/src/fs/fs_uri.c
index 23a368261..67ce6d530 100644
--- a/src/fs/fs_uri.c
+++ b/src/fs/fs_uri.c
@@ -118,7 +118,7 @@ GNUNET_FS_uri_to_key (const struct GNUNET_FS_Uri *uri,
   case GNUNET_FS_URI_LOC:
     GNUNET_CRYPTO_hash (&uri->data.loc.fi,
                         sizeof (struct FileIdentifier) +
-                        sizeof (struct GNUNET_CRYPTO_EccPublicKey),
+                        sizeof (struct GNUNET_CRYPTO_EccPublicSignKey),
                         key);
     break;
   default:
@@ -357,7 +357,7 @@ static struct GNUNET_FS_Uri *
 uri_sks_parse (const char *s, char **emsg)
 {
   struct GNUNET_FS_Uri *ret;
-  struct GNUNET_CRYPTO_EccPublicKey ns;
+  struct GNUNET_CRYPTO_EccPublicSignKey ns;
   size_t pos;
   char *end;
 
@@ -532,7 +532,7 @@ struct LocUriAssembly
   /**
    * Peer offering the file.
    */ 
-  struct GNUNET_CRYPTO_EccPublicKey peer;
+  struct GNUNET_CRYPTO_EccPublicSignKey peer;
 
 };
 GNUNET_NETWORK_STRUCT_END
@@ -604,7 +604,7 @@ uri_loc_parse (const char *s, char **emsg)
   npos++;
   ret =
       enc2bin (&s[npos], &ass.peer,
-               sizeof (struct GNUNET_CRYPTO_EccPublicKey));
+               sizeof (struct GNUNET_CRYPTO_EccPublicSignKey));
   if (ret == -1)
   {
     *emsg =
@@ -841,7 +841,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_EccPublicKey),
+                      sizeof (struct GNUNET_CRYPTO_EccPublicSignKey),
                       &peer->hashPubKey);
   return GNUNET_OK;
 }
@@ -897,7 +897,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_EccPublicKey my_public_key;
+  struct GNUNET_CRYPTO_EccPublicSignKey my_public_key;
   char *keyfile;
   struct LocUriAssembly ass;
   struct GNUNET_TIME_Absolute et;
@@ -922,7 +922,7 @@ GNUNET_FS_uri_loc_create (const struct GNUNET_FS_Uri *baseUri,
   GNUNET_free (keyfile);
   /* we round expiration time to full seconds for SKS URIs */
   et.abs_value_us = (expiration_time.abs_value_us / 1000000LL) * 1000000LL;
-  GNUNET_CRYPTO_ecc_key_get_public (my_private_key, &my_public_key);
+  GNUNET_CRYPTO_ecc_key_get_public_for_signature (my_private_key, &my_public_key);
   ass.purpose.size = htonl (sizeof (struct LocUriAssembly));
   ass.purpose.purpose = htonl (GNUNET_SIGNATURE_PURPOSE_PEER_PLACEMENT);
   ass.exptime = GNUNET_TIME_absolute_hton (et);
@@ -949,7 +949,7 @@ GNUNET_FS_uri_loc_create (const struct GNUNET_FS_Uri *baseUri,
  * @return an FS URI for the given namespace and identifier
  */
 struct GNUNET_FS_Uri *
-GNUNET_FS_uri_sks_create (const struct GNUNET_CRYPTO_EccPublicKey *ns, 
+GNUNET_FS_uri_sks_create (const struct GNUNET_CRYPTO_EccPublicSignKey *ns, 
                           const char *id)
 {
   struct GNUNET_FS_Uri *ns_uri;
@@ -1260,7 +1260,7 @@ GNUNET_FS_uri_test_equal (const struct GNUNET_FS_Uri *u1,
   case GNUNET_FS_URI_SKS:
     if ((0 ==
          memcmp (&u1->data.sks.ns, &u2->data.sks.ns,
-                 sizeof (struct GNUNET_CRYPTO_EccPublicKey))) &&
+                 sizeof (struct GNUNET_CRYPTO_EccPublicSignKey))) &&
         (0 == strcmp (u1->data.sks.identifier, u2->data.sks.identifier)))
 
       return GNUNET_YES;
@@ -1287,7 +1287,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_EccPublicKey) +
+         sizeof (struct GNUNET_CRYPTO_EccPublicSignKey) +
          sizeof (struct GNUNET_TIME_Absolute) + sizeof (unsigned short) +
          sizeof (unsigned short)) != 0)
       return GNUNET_NO;
@@ -1321,7 +1321,7 @@ GNUNET_FS_uri_test_sks (const struct GNUNET_FS_Uri *uri)
  */
 int
 GNUNET_FS_uri_sks_get_namespace (const struct GNUNET_FS_Uri *uri,
-                                 struct GNUNET_CRYPTO_EccPublicKey *pseudonym)
+                                 struct GNUNET_CRYPTO_EccPublicSignKey *pseudonym)
 {
   if (!GNUNET_FS_uri_test_sks (uri))
   {
@@ -1896,7 +1896,7 @@ uri_sks_to_string (const struct GNUNET_FS_Uri *uri)
   if (GNUNET_FS_URI_SKS != uri->type)
     return NULL;
   ret = GNUNET_STRINGS_data_to_string (&uri->data.sks.ns,
-                                       sizeof (struct GNUNET_CRYPTO_EccPublicKey),
+                                       sizeof (struct GNUNET_CRYPTO_EccPublicSignKey),
                                        buf,
                                        sizeof (buf));
   GNUNET_assert (NULL != ret);
@@ -2001,7 +2001,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_EccPublicKey));
+               sizeof (struct GNUNET_CRYPTO_EccPublicSignKey));
   peerSig =
       bin2enc (&uri->data.loc.contentSignature,
                sizeof (struct GNUNET_CRYPTO_EccSignature));
diff --git a/src/fs/test_fs_namespace.c b/src/fs/test_fs_namespace.c
index 680d1b61b..11c611e04 100644
--- a/src/fs/test_fs_namespace.c
+++ b/src/fs/test_fs_namespace.c
@@ -29,7 +29,7 @@
 #include "gnunet_fs_service.h"
 
 
-static struct GNUNET_CRYPTO_EccPublicKey nsid;
+static struct GNUNET_CRYPTO_EccPublicSignKey nsid;
 
 static struct GNUNET_FS_Uri *sks_expect_uri;
 
@@ -255,7 +255,7 @@ adv_cont (void *cls, const struct GNUNET_FS_Uri *uri, const char *emsg)
   bo.replication_level = 0;
   bo.expiration_time =
       GNUNET_TIME_relative_to_absolute (GNUNET_TIME_UNIT_MINUTES);
-  GNUNET_CRYPTO_ecc_key_get_public (ns, &nsid);
+  GNUNET_CRYPTO_ecc_key_get_public_for_signature (ns, &nsid);
   GNUNET_FS_publish_sks (fs, ns, "this", "next", meta, uri,
                          &bo, GNUNET_FS_PUBLISH_OPTION_NONE, &sks_cont, NULL);
   GNUNET_CONTAINER_meta_data_destroy (meta);
diff --git a/src/fs/test_fs_uri.c b/src/fs/test_fs_uri.c
index 0d3aeaf41..1e1bd8fb8 100644
--- a/src/fs/test_fs_uri.c
+++ b/src/fs/test_fs_uri.c
@@ -164,7 +164,7 @@ testNamespace (int i)
   struct GNUNET_FS_Uri *ret;
   char *emsg;
   struct GNUNET_CRYPTO_EccPrivateKey *ph;
-  struct GNUNET_CRYPTO_EccPublicKey id;
+  struct GNUNET_CRYPTO_EccPublicSignKey id;
   char buf[1024];
   char ubuf[1024];
   char *sret;
@@ -194,7 +194,7 @@ testNamespace (int i)
   }
   GNUNET_free (emsg);
   ph = GNUNET_CRYPTO_ecc_key_create ();
-  GNUNET_CRYPTO_ecc_key_get_public (ph, &id);
+  GNUNET_CRYPTO_ecc_key_get_public_for_signature (ph, &id);
   sret = GNUNET_STRINGS_data_to_string (&id, sizeof (id),
                                         ubuf, sizeof (ubuf) - 1);
   GNUNET_assert (NULL != sret);