-switching GNS from RSA to ECC

author: Christian Grothoff <christian@grothoff.org> 2013-05-29 08:18:55 +0000
committer: Christian Grothoff <christian@grothoff.org> 2013-05-29 08:18:55 +0000
commit: 022002438e4047d235a688cfd9da7b63ab990103 (patch)
tree: 8d0cb444a3ab376b5a8f614fb87bdeb31e7b3327
parent: b62eb443ee3af84f87030fad9fd11a948b1a2503 (diff)
download: gnunet-022002438e4047d235a688cfd9da7b63ab990103.tar.gz
gnunet-022002438e4047d235a688cfd9da7b63ab990103.zip
62 files changed, 647 insertions, 637 deletions
diff --git a/src/Makefile.am b/src/Makefile.am
index 0d056100e..6819ec90b 100644
--- a/src/Makefile.am
+++ b/src/Makefile.am
@@ -3,7 +3,7 @@
 #endif
 if HAVE_EXPERIMENTAL
- EXP_DIR = gns chat consensus dv set experimentation
+ EXP_DIR = gns consensus dv set experimentation
 endif
 if LINUX
diff --git a/src/dns/plugin_block_dns.c b/src/dns/plugin_block_dns.c
index 8ac1ef2b5..d8f3cbb6f 100644
--- a/src/dns/plugin_block_dns.c
+++ b/src/dns/plugin_block_dns.c
@@ -75,13 +75,13 @@ block_plugin_dns_evaluate (void *cls, enum GNUNET_BLOCK_Type type,
    if (ntohl (rec->purpose.size) !=
        sizeof (struct GNUNET_DNS_Record) -
-        sizeof (struct GNUNET_CRYPTO_RsaSignature))
+        sizeof (struct GNUNET_CRYPTO_EccSignature))
    {
      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                  "DNS-Block is invalid: rec->purpose.size=%d != %d\n",
                  ntohl (rec->purpose.size),
                  sizeof (struct GNUNET_DNS_Record) -
-                  sizeof (struct GNUNET_CRYPTO_RsaSignature));
+                  sizeof (struct GNUNET_CRYPTO_EccSignature));
      return GNUNET_BLOCK_EVALUATION_RESULT_INVALID;
    }
@@ -94,7 +94,7 @@ block_plugin_dns_evaluate (void *cls, enum GNUNET_BLOCK_Type type,
    }
    if (GNUNET_OK !=
-        GNUNET_CRYPTO_rsa_verify (htonl (GNUNET_SIGNATURE_PURPOSE_DNS_RECORD),
+        GNUNET_CRYPTO_ecc_verify (htonl (GNUNET_SIGNATURE_PURPOSE_DNS_RECORD),
                                  &rec->purpose, &rec->signature, &rec->peer))
    {
      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
diff --git a/src/gns/Makefile.am b/src/gns/Makefile.am
index 03eab7b4e..bb8f0bf41 100644
--- a/src/gns/Makefile.am
+++ b/src/gns/Makefile.am
@@ -224,9 +224,11 @@ check_PROGRAMS = \
 if ENABLE_TEST_RUN
 if LINUX
+if HAVE_SQLITE
 TESTS = $(check_PROGRAMS)
 endif
 endif
+endif
 #test_gns_proxy_SOURCES = \
diff --git a/src/gns/gns_api.c b/src/gns/gns_api.c
index 1e3cb0169..fe378a922 100644
--- a/src/gns/gns_api.c
+++ b/src/gns/gns_api.c
@@ -823,7 +823,7 @@ GNUNET_GNS_lookup_zone (struct GNUNET_GNS_Handle *handle,
                        struct GNUNET_CRYPTO_ShortHashCode *zone,
                        enum GNUNET_GNS_RecordType type,
                        int only_cached,
-                        struct GNUNET_CRYPTO_RsaPrivateKey *shorten_key,
+                        struct GNUNET_CRYPTO_EccPrivateKey *shorten_key,
                        GNUNET_GNS_LookupResultProcessor proc,
                        void *proc_cls)
 {
@@ -832,7 +832,7 @@ GNUNET_GNS_lookup_zone (struct GNUNET_GNS_Handle *handle,
  struct GNUNET_GNS_LookupRequest *lr;
  size_t msize;
  struct PendingMessage *pending;
-  struct GNUNET_CRYPTO_RsaPrivateKeyBinaryEncoded *pkey_enc;
+  struct GNUNET_CRYPTO_EccPrivateKeyBinaryEncoded *pkey_enc;
  size_t key_len;
  char* pkey_tmp;
@@ -843,9 +843,9 @@ GNUNET_GNS_lookup_zone (struct GNUNET_GNS_Handle *handle,
  } 
  if (NULL != shorten_key)
  {
-    pkey_enc = GNUNET_CRYPTO_rsa_encode_key (shorten_key);
+    pkey_enc = GNUNET_CRYPTO_ecc_encode_key (shorten_key);
    GNUNET_assert (pkey_enc != NULL);
-    key_len = ntohs (pkey_enc->len);
+    key_len = ntohs (pkey_enc->size);
  }
  else
  {
@@ -927,7 +927,7 @@ GNUNET_GNS_lookup (struct GNUNET_GNS_Handle *handle,
                   const char *name,
                   enum GNUNET_GNS_RecordType type,
                   int only_cached,
-                   struct GNUNET_CRYPTO_RsaPrivateKey *shorten_key,
+                   struct GNUNET_CRYPTO_EccPrivateKey *shorten_key,
                   GNUNET_GNS_LookupResultProcessor proc,
                   void *proc_cls)
 {
diff --git a/src/gns/gnunet-gns-fcfsd.c b/src/gns/gnunet-gns-fcfsd.c
index d55396459..9ea69a87d 100644
--- a/src/gns/gnunet-gns-fcfsd.c
+++ b/src/gns/gnunet-gns-fcfsd.c
@@ -199,7 +199,7 @@ static struct GNUNET_CRYPTO_ShortHashCode fcfsd_zone;
 /**
 * Private key for the fcfsd zone.
 */
-static struct GNUNET_CRYPTO_RsaPrivateKey *fcfs_zone_pkey;
+static struct GNUNET_CRYPTO_EccPrivateKey *fcfs_zone_pkey;
                        
 /**
@@ -229,12 +229,12 @@ run_httpd_now ()
 static void
 iterate_cb (void *cls,
-                const struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded *zone_key,
+                const struct GNUNET_CRYPTO_EccPublicKeyBinaryEncoded *zone_key,
                struct GNUNET_TIME_Absolute expire,
                const char *name,
                unsigned int rd_len,
                const struct GNUNET_NAMESTORE_RecordData *rd,
-                const struct GNUNET_CRYPTO_RsaSignature *signature)
+                const struct GNUNET_CRYPTO_EccSignature *signature)
 {
  struct ZoneinfoRequest *zr = cls;
  struct MHD_Response *response;
@@ -506,12 +506,12 @@ put_continuation (void *cls,
 */
 static void 
 zone_to_name_cb (void *cls,
-                 const struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded *zone_key,
+                 const struct GNUNET_CRYPTO_EccPublicKeyBinaryEncoded *zone_key,
                 struct GNUNET_TIME_Absolute expire,                        
                 const char *name,
                 unsigned int rd_count,
                 const struct GNUNET_NAMESTORE_RecordData *rd,
-                 const struct GNUNET_CRYPTO_RsaSignature *signature)
+                 const struct GNUNET_CRYPTO_EccSignature *signature)
 {
  struct Request *request = cls;
  struct GNUNET_NAMESTORE_RecordData r;
@@ -565,12 +565,12 @@ zone_to_name_cb (void *cls,
 */
 static void 
 lookup_result_processor (void *cls,
-                         const struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded *zone_key,
+                         const struct GNUNET_CRYPTO_EccPublicKeyBinaryEncoded *zone_key,
                         struct GNUNET_TIME_Absolute expire,                        
                         const char *name,
                         unsigned int rd_count,
                         const struct GNUNET_NAMESTORE_RecordData *rd,
-                         const struct GNUNET_CRYPTO_RsaSignature *signature)
+                         const struct GNUNET_CRYPTO_EccSignature *signature)
 {
  struct Request *request = cls;
  struct GNUNET_CRYPTO_ShortHashCode pub;
@@ -862,7 +862,7 @@ do_shutdown (void *cls,
  }
  if (NULL != fcfs_zone_pkey)
  {
-    GNUNET_CRYPTO_rsa_key_free (fcfs_zone_pkey);
+    GNUNET_CRYPTO_ecc_key_free (fcfs_zone_pkey);
    fcfs_zone_pkey = NULL;
  }
 }
@@ -882,7 +882,7 @@ run (void *cls, char *const *args, const char *cfgfile,
 {
  char *keyfile;
  unsigned long long port;
-  struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded pub;
+  struct GNUNET_CRYPTO_EccPublicKeyBinaryEncoded pub;
  if (GNUNET_OK !=
      GNUNET_CONFIGURATION_get_value_number (cfg,
@@ -904,7 +904,7 @@ run (void *cls, char *const *args, const char *cfgfile,
                               "fcfsd", "ZONEKEY");
    return;
  }
-  fcfs_zone_pkey = GNUNET_CRYPTO_rsa_key_create_from_file (keyfile);
+  fcfs_zone_pkey = GNUNET_CRYPTO_ecc_key_create_from_file (keyfile);
  GNUNET_free (keyfile);
  if (NULL == fcfs_zone_pkey)
  {
@@ -912,7 +912,7 @@ run (void *cls, char *const *args, const char *cfgfile,
                _("Failed to read or create private zone key\n"));
    return;
  }
-  GNUNET_CRYPTO_rsa_key_get_public (fcfs_zone_pkey,
+  GNUNET_CRYPTO_ecc_key_get_public (fcfs_zone_pkey,
                                    &pub);
  GNUNET_CRYPTO_short_hash (&pub, sizeof (pub), &fcfsd_zone);
  ns = GNUNET_NAMESTORE_connect (cfg);
diff --git a/src/gns/gnunet-gns-helper-service-w32.c b/src/gns/gnunet-gns-helper-service-w32.c
index 72956c854..44ae87b84 100644
--- a/src/gns/gnunet-gns-helper-service-w32.c
+++ b/src/gns/gnunet-gns-helper-service-w32.c
@@ -63,7 +63,7 @@ static struct GNUNET_GNS_Handle *gns;
 static struct GNUNET_CRYPTO_ShortHashCode *zone = NULL;
 static struct GNUNET_CRYPTO_ShortHashCode user_zone;
-struct GNUNET_CRYPTO_RsaPrivateKey *shorten_key = NULL;
+struct GNUNET_CRYPTO_EccPrivateKey *shorten_key = NULL;
 /**
@@ -670,8 +670,8 @@ run (void *cls, struct GNUNET_SERVER_Handle *server,
  };
  char* keyfile;
-  struct GNUNET_CRYPTO_RsaPrivateKey *key = NULL;
+  struct GNUNET_CRYPTO_EccPrivateKey *key = NULL;
-  struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded pkey;
+  struct GNUNET_CRYPTO_EccPublicKeyBinaryEncoded pkey;
  struct GNUNET_CRYPTO_ShortHashAsciiEncoded zonename;
  if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_filename (cfg, "gns",
@@ -685,16 +685,16 @@ run (void *cls, struct GNUNET_SERVER_Handle *server,
  {
    if (GNUNET_YES == GNUNET_DISK_file_test (keyfile))
    {
-      key = GNUNET_CRYPTO_rsa_key_create_from_file (keyfile);
+      key = GNUNET_CRYPTO_ecc_key_create_from_file (keyfile);
-      GNUNET_CRYPTO_rsa_key_get_public (key, &pkey);
+      GNUNET_CRYPTO_ecc_key_get_public (key, &pkey);
      GNUNET_CRYPTO_short_hash(&pkey,
-                         sizeof(struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded),
+                         sizeof(struct GNUNET_CRYPTO_EccPublicKeyBinaryEncoded),
                         &user_zone);
      zone = &user_zone;
      GNUNET_CRYPTO_short_hash_to_enc (zone, &zonename);
      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                  "Using zone: %s!\n", &zonename);
-      GNUNET_CRYPTO_rsa_key_free(key);
+      GNUNET_CRYPTO_ecc_key_free(key);
    }
    GNUNET_free(keyfile);
  }
@@ -710,7 +710,7 @@ run (void *cls, struct GNUNET_SERVER_Handle *server,
  {
    if (GNUNET_YES == GNUNET_DISK_file_test (keyfile))
    {
-      shorten_key = GNUNET_CRYPTO_rsa_key_create_from_file (keyfile);
+      shorten_key = GNUNET_CRYPTO_ecc_key_create_from_file (keyfile);
    }
    GNUNET_free(keyfile);
  }
diff --git a/src/gns/gnunet-gns-proxy.c b/src/gns/gnunet-gns-proxy.c
index 7b783787b..0135fea34 100644
--- a/src/gns/gnunet-gns-proxy.c
+++ b/src/gns/gnunet-gns-proxy.c
@@ -459,7 +459,7 @@ static struct GNUNET_NETWORK_Handle *mhd_unix_socket;
 #endif
 /* Shorten zone private key */
-static struct GNUNET_CRYPTO_RsaPrivateKey *shorten_zonekey;
+static struct GNUNET_CRYPTO_EccPrivateKey *shorten_zonekey;
 /**
@@ -3188,8 +3188,8 @@ static int
 load_local_zone_key (const struct GNUNET_CONFIGURATION_Handle *cfg)
 {
  char *keyfile;
-  struct GNUNET_CRYPTO_RsaPrivateKey *key;
+  struct GNUNET_CRYPTO_EccPrivateKey *key;
-  struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded pkey;
+  struct GNUNET_CRYPTO_EccPublicKeyBinaryEncoded pkey;
  struct GNUNET_CRYPTO_ShortHashCode *zone;
  struct GNUNET_CRYPTO_ShortHashAsciiEncoded zonename;
@@ -3209,17 +3209,17 @@ load_local_zone_key (const struct GNUNET_CONFIGURATION_Handle *cfg)
    return GNUNET_NO;
  }
-  key = GNUNET_CRYPTO_rsa_key_create_from_file (keyfile);
+  key = GNUNET_CRYPTO_ecc_key_create_from_file (keyfile);
-  GNUNET_CRYPTO_rsa_key_get_public (key, &pkey);
+  GNUNET_CRYPTO_ecc_key_get_public (key, &pkey);
  local_gns_zone = GNUNET_malloc (sizeof (struct GNUNET_CRYPTO_ShortHashCode));
  GNUNET_CRYPTO_short_hash(&pkey,
-                           sizeof(struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded),
+                           sizeof(struct GNUNET_CRYPTO_EccPublicKeyBinaryEncoded),
                           local_gns_zone);
  zone = local_gns_zone;
  GNUNET_CRYPTO_short_hash_to_enc (zone, &zonename);
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Using zone: %s!\n", &zonename);
-  GNUNET_CRYPTO_rsa_key_free(key);
+  GNUNET_CRYPTO_ecc_key_free(key);
  GNUNET_free(keyfile);
  keyfile = NULL;
@@ -3238,16 +3238,16 @@ load_local_zone_key (const struct GNUNET_CONFIGURATION_Handle *cfg)
  }
  else
  {
-    key = GNUNET_CRYPTO_rsa_key_create_from_file (keyfile);
+    key = GNUNET_CRYPTO_ecc_key_create_from_file (keyfile);
-    GNUNET_CRYPTO_rsa_key_get_public (key, &pkey);
+    GNUNET_CRYPTO_ecc_key_get_public (key, &pkey);
    local_private_zone = GNUNET_malloc (sizeof (struct GNUNET_CRYPTO_ShortHashCode));
    GNUNET_CRYPTO_short_hash(&pkey,
-                             sizeof(struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded),
+                             sizeof(struct GNUNET_CRYPTO_EccPublicKeyBinaryEncoded),
                             local_private_zone);
    GNUNET_CRYPTO_short_hash_to_enc (zone, &zonename);
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Using private zone: %s!\n", &zonename);
-    GNUNET_CRYPTO_rsa_key_free(key);
+    GNUNET_CRYPTO_ecc_key_free(key);
    GNUNET_free(keyfile);
  }
  keyfile = NULL;
@@ -3267,16 +3267,16 @@ load_local_zone_key (const struct GNUNET_CONFIGURATION_Handle *cfg)
  }
  else
  {
-    key = GNUNET_CRYPTO_rsa_key_create_from_file (keyfile);
+    key = GNUNET_CRYPTO_ecc_key_create_from_file (keyfile);
-    GNUNET_CRYPTO_rsa_key_get_public (key, &pkey);
+    GNUNET_CRYPTO_ecc_key_get_public (key, &pkey);
    local_shorten_zone = GNUNET_malloc (sizeof (struct GNUNET_CRYPTO_ShortHashCode));
    GNUNET_CRYPTO_short_hash(&pkey,
-                             sizeof(struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded),
+                             sizeof(struct GNUNET_CRYPTO_EccPublicKeyBinaryEncoded),
                             local_shorten_zone);
    GNUNET_CRYPTO_short_hash_to_enc (zone, &zonename);
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Using shorten zone: %s!\n", &zonename);
-    GNUNET_CRYPTO_rsa_key_free(key);
+    GNUNET_CRYPTO_ecc_key_free(key);
    GNUNET_free(keyfile);
  }
diff --git a/src/gns/gnunet-gns.c b/src/gns/gnunet-gns.c
index 74212d4fc..542a8106d 100644
--- a/src/gns/gnunet-gns.c
+++ b/src/gns/gnunet-gns.c
@@ -204,13 +204,13 @@ run (void *cls, char *const *args, const char *cfgfile,
     const struct GNUNET_CONFIGURATION_Handle *cfg)
 {
  char* keyfile;
-  struct GNUNET_CRYPTO_RsaPrivateKey *key = NULL;
+  struct GNUNET_CRYPTO_EccPrivateKey *key = NULL;
-  struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded pkey;
+  struct GNUNET_CRYPTO_EccPublicKeyBinaryEncoded pkey;
  struct GNUNET_CRYPTO_ShortHashCode *zone = NULL;
  struct GNUNET_CRYPTO_ShortHashCode user_zone;
  struct GNUNET_CRYPTO_ShortHashAsciiEncoded zonename;
-  struct GNUNET_CRYPTO_RsaPrivateKey *shorten_key = NULL;
+  struct GNUNET_CRYPTO_EccPrivateKey *shorten_key = NULL;
-  struct GNUNET_CRYPTO_RsaPrivateKey *private_key = NULL;
+  struct GNUNET_CRYPTO_EccPrivateKey *private_key = NULL;
  struct GNUNET_CRYPTO_ShortHashCode *private_zone = NULL;
  struct GNUNET_CRYPTO_ShortHashCode *shorten_zone = NULL;
@@ -230,17 +230,17 @@ run (void *cls, char *const *args, const char *cfgfile,
  }
  else
  {
-    key = GNUNET_CRYPTO_rsa_key_create_from_file (keyfile);
+    key = GNUNET_CRYPTO_ecc_key_create_from_file (keyfile);
-    GNUNET_CRYPTO_rsa_key_get_public (key, &pkey);
+    GNUNET_CRYPTO_ecc_key_get_public (key, &pkey);
    GNUNET_CRYPTO_short_hash (&pkey,
-                              sizeof(struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded),
+                              sizeof(struct GNUNET_CRYPTO_EccPublicKeyBinaryEncoded),
                              &user_zone);
    zone = &user_zone;
    GNUNET_CRYPTO_short_hash_to_enc (zone, &zonename);
    if (!raw)
      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                  "Using zone: %s!\n", &zonename);
-    GNUNET_CRYPTO_rsa_key_free (key);  
+    GNUNET_CRYPTO_ecc_key_free (key);  
    GNUNET_free(keyfile);
  }
  
@@ -253,11 +253,11 @@ run (void *cls, char *const *args, const char *cfgfile,
  }
  else
  {
-    shorten_key = GNUNET_CRYPTO_rsa_key_create_from_file (keyfile);
+    shorten_key = GNUNET_CRYPTO_ecc_key_create_from_file (keyfile);
-    GNUNET_CRYPTO_rsa_key_get_public (shorten_key, &pkey);
+    GNUNET_CRYPTO_ecc_key_get_public (shorten_key, &pkey);
    shorten_zone = GNUNET_malloc (sizeof (struct GNUNET_CRYPTO_ShortHashCode));
    GNUNET_CRYPTO_short_hash(&pkey,
-                             sizeof(struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded),
+                             sizeof(struct GNUNET_CRYPTO_EccPublicKeyBinaryEncoded),
                             shorten_zone);
    GNUNET_CRYPTO_short_hash_to_enc (shorten_zone, &zonename);
    if (! raw)
@@ -275,17 +275,17 @@ run (void *cls, char *const *args, const char *cfgfile,
  }
  else
  {
-    private_key = GNUNET_CRYPTO_rsa_key_create_from_file (keyfile);
+    private_key = GNUNET_CRYPTO_ecc_key_create_from_file (keyfile);
-    GNUNET_CRYPTO_rsa_key_get_public (private_key, &pkey);
+    GNUNET_CRYPTO_ecc_key_get_public (private_key, &pkey);
    private_zone = GNUNET_malloc (sizeof (struct GNUNET_CRYPTO_ShortHashCode));
    GNUNET_CRYPTO_short_hash(&pkey,
-                             sizeof(struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded),
+                             sizeof(struct GNUNET_CRYPTO_EccPublicKeyBinaryEncoded),
                             private_zone);
    GNUNET_CRYPTO_short_hash_to_enc (private_zone, &zonename);
    if (! raw)
      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                  "Using private zone: %s!\n", &zonename);
-    GNUNET_CRYPTO_rsa_key_free (private_key);
+    GNUNET_CRYPTO_ecc_key_free (private_key);
  }
  
  if (NULL != lookup_type)
@@ -321,7 +321,7 @@ run (void *cls, char *const *args, const char *cfgfile,
  }
  if (NULL != shorten_key)
-    GNUNET_CRYPTO_rsa_key_free (shorten_key);
+    GNUNET_CRYPTO_ecc_key_free (shorten_key);
  if (NULL != shorten_zone)
    GNUNET_free (shorten_zone);
  if (NULL != private_zone)
diff --git a/src/gns/gnunet-service-gns.c b/src/gns/gnunet-service-gns.c
index 16887c62d..517722643 100644
--- a/src/gns/gnunet-service-gns.c
+++ b/src/gns/gnunet-service-gns.c
@@ -168,7 +168,7 @@ struct ClientLookupHandle
  /**
   * optional zone private key used for shorten
   */
-  struct GNUNET_CRYPTO_RsaPrivateKey *shorten_key;
+  struct GNUNET_CRYPTO_EccPrivateKey *shorten_key;
  /**
   * the name to look up
@@ -205,7 +205,7 @@ static struct GNUNET_DHT_Handle *dht_handle;
 /**
 * Our zone's private key
 */
-static struct GNUNET_CRYPTO_RsaPrivateKey *zone_key;
+static struct GNUNET_CRYPTO_EccPrivateKey *zone_key;
 /**
 * Our handle to the namestore service
@@ -382,12 +382,12 @@ publish_zone_dht_start (void *cls,
 */
 static void
 put_gns_record (void *cls,
-                const struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded *key,
+                const struct GNUNET_CRYPTO_EccPublicKeyBinaryEncoded *key,
                struct GNUNET_TIME_Absolute expiration,
                const char *name,
                unsigned int rd_count,
                const struct GNUNET_NAMESTORE_RecordData *rd,
-                const struct GNUNET_CRYPTO_RsaSignature *signature)
+                const struct GNUNET_CRYPTO_EccSignature *signature)
 {  
  struct GNSNameRecordBlock *nrb;
  struct GNUNET_CRYPTO_ShortHashCode zhash;
@@ -475,7 +475,7 @@ put_gns_record (void *cls,
  nrb_data += namelen;
  rd_payload_length += sizeof(struct GNSNameRecordBlock) + namelen;
  GNUNET_CRYPTO_short_hash (key,
-                            sizeof (struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded),
+                            sizeof (struct GNUNET_CRYPTO_EccPublicKeyBinaryEncoded),
                            &zhash);
  if (-1 == GNUNET_NAMESTORE_records_serialize (rd_count,
                                                rd,
@@ -626,12 +626,12 @@ send_shorten_response (void* cls, const char* name)
 */
 static void
 process_shorten_in_private_zone_lookup (void *cls,
-                                        const struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded *key,
+                                        const struct GNUNET_CRYPTO_EccPublicKeyBinaryEncoded *key,
                                        struct GNUNET_TIME_Absolute expiration,
                                        const char *name,
                                        unsigned int rd_count,
                                        const struct GNUNET_NAMESTORE_RecordData *rd,
-                                        const struct GNUNET_CRYPTO_RsaSignature *signature)
+                                        const struct GNUNET_CRYPTO_EccSignature *signature)
 {
  struct ClientShortenHandle *csh = cls;
  struct GNUNET_CRYPTO_ShortHashCode *szone = &csh->shorten_zone;
@@ -682,12 +682,12 @@ process_shorten_in_private_zone_lookup (void *cls,
 */
 static void
 process_shorten_in_root_zone_lookup (void *cls,
-                                     const struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded *key,
+                                     const struct GNUNET_CRYPTO_EccPublicKeyBinaryEncoded *key,
                                     struct GNUNET_TIME_Absolute expiration,
                                     const char *name,
                                     unsigned int rd_count,
                                     const struct GNUNET_NAMESTORE_RecordData *rd,
-                                     const struct GNUNET_CRYPTO_RsaSignature *signature)
+                                     const struct GNUNET_CRYPTO_EccSignature *signature)
 {
  struct ClientShortenHandle *csh = cls;
  struct GNUNET_CRYPTO_ShortHashCode *szone = &csh->shorten_zone;
@@ -738,12 +738,12 @@ process_shorten_in_root_zone_lookup (void *cls,
 */
 static void
 process_private_in_root_zone_lookup (void *cls,
-                                     const struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded *key,
+                                     const struct GNUNET_CRYPTO_EccPublicKeyBinaryEncoded *key,
                                     struct GNUNET_TIME_Absolute expiration,
                                     const char *name,
                                     unsigned int rd_count,
                                     const struct GNUNET_NAMESTORE_RecordData *rd,
-                                     const struct GNUNET_CRYPTO_RsaSignature *signature)
+                                     const struct GNUNET_CRYPTO_EccSignature *signature)
 {
  struct ClientShortenHandle *csh = cls;
@@ -1036,7 +1036,7 @@ send_lookup_response (void* cls,
  GNUNET_free(clh->name);
  
  if (NULL != clh->shorten_key)
-    GNUNET_CRYPTO_rsa_key_free (clh->shorten_key);
+    GNUNET_CRYPTO_ecc_key_free (clh->shorten_key);
  GNUNET_free (clh);
  GNUNET_STATISTICS_update (statistics,
                            "Completed lookups", 1, GNUNET_NO);
@@ -1064,8 +1064,8 @@ handle_lookup (void *cls,
  char* nameptr = name;
  const char *utf_in;
  int only_cached;
-  struct GNUNET_CRYPTO_RsaPrivateKey *key;
+  struct GNUNET_CRYPTO_EccPrivateKey *key;
-  struct GNUNET_CRYPTO_RsaPrivateKeyBinaryEncoded *pkey;
+  struct GNUNET_CRYPTO_EccPrivateKeyBinaryEncoded *pkey;
  char* tmp_pkey;
  uint16_t msg_size;
  const struct GNUNET_GNS_ClientLookupMessage *sh_msg;
@@ -1083,10 +1083,11 @@ handle_lookup (void *cls,
  GNUNET_SERVER_notification_context_add (nc, client);
  if (GNUNET_YES == ntohl (sh_msg->have_key))
  {
-    pkey = (struct GNUNET_CRYPTO_RsaPrivateKeyBinaryEncoded *) &sh_msg[1];
+    pkey = (struct GNUNET_CRYPTO_EccPrivateKeyBinaryEncoded *) &sh_msg[1];
    tmp_pkey = (char*) &sh_msg[1];
-    key = GNUNET_CRYPTO_rsa_decode_key (tmp_pkey, ntohs (pkey->len));
+    key = GNUNET_CRYPTO_ecc_decode_key (tmp_pkey, ntohs (pkey->size),
-    GNUNET_STRINGS_utf8_tolower (&tmp_pkey[ntohs (pkey->len)], &nameptr);
+                                        GNUNET_NO);
+    GNUNET_STRINGS_utf8_tolower (&tmp_pkey[ntohs (pkey->size)], &nameptr);
  }
  else
  {
@@ -1184,7 +1185,7 @@ run (void *cls, struct GNUNET_SERVER_Handle *server,
    {&handle_get_authority, NULL, GNUNET_MESSAGE_TYPE_GNS_GET_AUTH, 0}
  };
  char* keyfile;
-  struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded pkey;
+  struct GNUNET_CRYPTO_EccPublicKeyBinaryEncoded pkey;
  unsigned long long max_parallel_bg_queries = 0;
  int ignore_pending = GNUNET_NO;
@@ -1203,10 +1204,10 @@ run (void *cls, struct GNUNET_SERVER_Handle *server,
  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
             "Using keyfile %s for root zone.\n", keyfile);
-  zone_key = GNUNET_CRYPTO_rsa_key_create_from_file (keyfile);
+  zone_key = GNUNET_CRYPTO_ecc_key_create_from_file (keyfile);
-  GNUNET_CRYPTO_rsa_key_get_public (zone_key, &pkey);
+  GNUNET_CRYPTO_ecc_key_get_public (zone_key, &pkey);
  GNUNET_CRYPTO_short_hash(&pkey,
-                     sizeof(struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded),
+                     sizeof(struct GNUNET_CRYPTO_EccPublicKeyBinaryEncoded),
                     &zone_hash);
  GNUNET_free(keyfile);
  namestore_handle = GNUNET_NAMESTORE_connect (c);
diff --git a/src/gns/gnunet-service-gns_interceptor.c b/src/gns/gnunet-service-gns_interceptor.c
index cbacc318d..affa0f5d6 100644
--- a/src/gns/gnunet-service-gns_interceptor.c
+++ b/src/gns/gnunet-service-gns_interceptor.c
@@ -66,7 +66,7 @@ static struct GNUNET_CRYPTO_ShortHashCode our_zone;
 /**
 * Our priv key
 */
-static struct GNUNET_CRYPTO_RsaPrivateKey *our_key;
+static struct GNUNET_CRYPTO_EccPrivateKey *our_key;
 /**
 * Default timeout
@@ -344,7 +344,7 @@ handle_dns_request (void *cls,
 */
 int
 gns_interceptor_init (struct GNUNET_CRYPTO_ShortHashCode zone,
-                      struct GNUNET_CRYPTO_RsaPrivateKey *key,
+                      struct GNUNET_CRYPTO_EccPrivateKey *key,
                      const struct GNUNET_CONFIGURATION_Handle *c)
 {
  GNUNET_log(GNUNET_ERROR_TYPE_INFO,
diff --git a/src/gns/gnunet-service-gns_interceptor.h b/src/gns/gnunet-service-gns_interceptor.h
index 613ce8cdc..a1da4938b 100644
--- a/src/gns/gnunet-service-gns_interceptor.h
+++ b/src/gns/gnunet-service-gns_interceptor.h
@@ -37,7 +37,7 @@
 */
 int
 gns_interceptor_init (struct GNUNET_CRYPTO_ShortHashCode zone,
-                      struct GNUNET_CRYPTO_RsaPrivateKey *key,
+                      struct GNUNET_CRYPTO_EccPrivateKey *key,
                      const struct GNUNET_CONFIGURATION_Handle *c);
 /**
diff --git a/src/gns/gnunet-service-gns_resolver.c b/src/gns/gnunet-service-gns_resolver.c
index 37f12ff6e..f20cd24c9 100644
--- a/src/gns/gnunet-service-gns_resolver.c
+++ b/src/gns/gnunet-service-gns_resolver.c
@@ -224,7 +224,7 @@ free_get_pseu_authority_handle (struct GetPseuAuthorityHandle *gph)
 {
  gph->namestore_task = NULL;
  GNUNET_free (gph->auth);
-  GNUNET_CRYPTO_rsa_key_free (gph->key);
+  GNUNET_CRYPTO_ecc_key_free (gph->key);
  GNUNET_CONTAINER_DLL_remove (gph_head, gph_tail, gph);
  GNUNET_free (gph);
 }
@@ -270,11 +270,11 @@ create_pkey_cont (void* cls, int32_t success, const char* emsg)
 */
 static void
 process_pseu_lookup_ns (void* cls,
-                        const struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded *key,
+                        const struct GNUNET_CRYPTO_EccPublicKeyBinaryEncoded *key,
                        struct GNUNET_TIME_Absolute expiration,
                        const char *name, unsigned int rd_count,
                        const struct GNUNET_NAMESTORE_RecordData *rd,
-                        const struct GNUNET_CRYPTO_RsaSignature *signature)
+                        const struct GNUNET_CRYPTO_EccSignature *signature)
 {
  struct GetPseuAuthorityHandle* gph = cls;
  struct GNUNET_NAMESTORE_RecordData new_pkey;
@@ -463,12 +463,12 @@ process_auth_discovery_dht_result (void* cls,
 */
 static void
 process_auth_discovery_ns_result (void* cls,
-                      const struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded *key,
+                      const struct GNUNET_CRYPTO_EccPublicKeyBinaryEncoded *key,
                      struct GNUNET_TIME_Absolute expiration,
                      const char *name,
                      unsigned int rd_count,
                      const struct GNUNET_NAMESTORE_RecordData *rd,
-                      const struct GNUNET_CRYPTO_RsaSignature *signature)
+                      const struct GNUNET_CRYPTO_EccSignature *signature)
 {
  struct GetPseuAuthorityHandle* gph = cls;
  struct GNUNET_HashCode lookup_key;
@@ -536,12 +536,12 @@ process_auth_discovery_ns_result (void* cls,
 */
 static void
 process_zone_to_name_discover (void *cls,
-                 const struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded *zone_key,
+                 const struct GNUNET_CRYPTO_EccPublicKeyBinaryEncoded *zone_key,
                 struct GNUNET_TIME_Absolute expire,
                 const char *name,
                 unsigned int rd_len,
                 const struct GNUNET_NAMESTORE_RecordData *rd,
-                 const struct GNUNET_CRYPTO_RsaSignature *signature)
+                 const struct GNUNET_CRYPTO_EccSignature *signature)
 {
  struct GetPseuAuthorityHandle* gph = cls;
  
@@ -592,31 +592,33 @@ shorten_authority_chain (struct GetPseuAuthorityHandle *gph)
 */
 static void
 start_shorten (struct AuthorityChain *auth,
-               const struct GNUNET_CRYPTO_RsaPrivateKey *key)
+               const struct GNUNET_CRYPTO_EccPrivateKey *key)
 {
  struct GetPseuAuthorityHandle *gph;
-  struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded pkey;
+  struct GNUNET_CRYPTO_EccPublicKeyBinaryEncoded pkey;
-  struct GNUNET_CRYPTO_RsaPrivateKeyBinaryEncoded *pb_key;
+  struct GNUNET_CRYPTO_EccPrivateKeyBinaryEncoded *pb_key;
  
-  GNUNET_CRYPTO_rsa_key_get_public (key, &pkey);
+  GNUNET_CRYPTO_ecc_key_get_public (key, &pkey);
-  if (NULL == (pb_key = GNUNET_CRYPTO_rsa_encode_key (key)))
+  if (NULL == (pb_key = GNUNET_CRYPTO_ecc_encode_key (key)))
  {
    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
-                "Failed to encode RSA key on shorten\n");
+                "Failed to encode ECC key on shorten\n");
    return;
  }
-  gph = GNUNET_malloc (sizeof (struct GetPseuAuthorityHandle));
+  gph = GNUNET_new (struct GetPseuAuthorityHandle);
-  gph->key = GNUNET_CRYPTO_rsa_decode_key ((const char*) pb_key, ntohs (pb_key->len));
+  gph->key = GNUNET_CRYPTO_ecc_decode_key ((const char*) pb_key, 
+                                           ntohs (pb_key->size),
+                                           GNUNET_YES);
  GNUNET_free (pb_key);
  if (NULL == gph->key)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
-                "Failed to decode RSA key on shorten\n");
+                "Failed to decode ECC key on shorten\n");
    GNUNET_free (gph);
    return;
  }
  GNUNET_CRYPTO_short_hash (&pkey,
-                        sizeof (struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded),
+                        sizeof (struct GNUNET_CRYPTO_EccPublicKeyBinaryEncoded),
                        &gph->our_zone);
  gph->auth = GNUNET_malloc (sizeof (struct AuthorityChain));
  memcpy (gph->auth, auth, sizeof (struct AuthorityChain));
@@ -1154,11 +1156,11 @@ resolve_record_dht (struct ResolverHandle *rh)
 */
 static void
 process_record_result_ns (void* cls,
-                          const struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded *key,
+                          const struct GNUNET_CRYPTO_EccPublicKeyBinaryEncoded *key,
                          struct GNUNET_TIME_Absolute expiration,
                          const char *name, unsigned int rd_count,
                          const struct GNUNET_NAMESTORE_RecordData *rd,
-                          const struct GNUNET_CRYPTO_RsaSignature *signature)
+                          const struct GNUNET_CRYPTO_EccSignature *signature)
 {
  struct ResolverHandle *rh = cls;
  struct RecordLookupHandle *rlh = rh->proc_cls;
@@ -1169,7 +1171,7 @@ process_record_result_ns (void* cls,
  rh->namestore_task = NULL;
  GNUNET_CRYPTO_short_hash (key,
-                            sizeof (struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded),
+                            sizeof (struct GNUNET_CRYPTO_EccPublicKeyBinaryEncoded),
                            &zone);
  remaining_time = GNUNET_TIME_absolute_get_remaining (expiration);
  rh->status = 0;
@@ -2034,12 +2036,12 @@ handle_delegation_ns (void* cls, struct ResolverHandle *rh,
 */
 static void
 process_pkey_revocation_result_ns (void *cls,
-                                   const struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded *key,
+                                   const struct GNUNET_CRYPTO_EccPublicKeyBinaryEncoded *key,
                                   struct GNUNET_TIME_Absolute expiration,
                                   const char *name,
                                   unsigned int rd_count,
                                   const struct GNUNET_NAMESTORE_RecordData *rd,
-                                   const struct GNUNET_CRYPTO_RsaSignature *signature)
+                                   const struct GNUNET_CRYPTO_EccSignature *signature)
 {
  struct ResolverHandle *rh = cls;
  struct GNUNET_TIME_Relative remaining_time;
@@ -3063,12 +3065,12 @@ handle_delegation_ns (void* cls, struct ResolverHandle *rh,
 */
 static void
 process_delegation_result_ns (void* cls,
-                              const struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded *key,
+                              const struct GNUNET_CRYPTO_EccPublicKeyBinaryEncoded *key,
                              struct GNUNET_TIME_Absolute expiration,
                              const char *name,
                              unsigned int rd_count,
                              const struct GNUNET_NAMESTORE_RecordData *rd,
-                              const struct GNUNET_CRYPTO_RsaSignature *signature)
+                              const struct GNUNET_CRYPTO_EccSignature *signature)
 {
  struct ResolverHandle *rh = cls;
  struct GNUNET_TIME_Relative remaining_time;
@@ -3080,7 +3082,7 @@ process_delegation_result_ns (void* cls,
 
  rh->namestore_task = NULL;
  GNUNET_CRYPTO_short_hash (key,
-                            sizeof (struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded),
+                            sizeof (struct GNUNET_CRYPTO_EccPublicKeyBinaryEncoded),
                            &zone);
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "GNS_PHASE_DELEGATE_NS-%llu: Got %d records from authority lookup for `%s' in zone %s\n",
@@ -3326,7 +3328,7 @@ gns_resolver_lookup_record (struct GNUNET_CRYPTO_ShortHashCode zone,
                            struct GNUNET_CRYPTO_ShortHashCode pzone,
                            uint32_t record_type,
                            const char* name,
-                            struct GNUNET_CRYPTO_RsaPrivateKey *key,
+                            struct GNUNET_CRYPTO_EccPrivateKey *key,
                            struct GNUNET_TIME_Relative timeout,
                            int only_cached,
                            RecordLookupProcessor proc,
@@ -3509,12 +3511,12 @@ finish_shorten (struct ResolverHandle *rh,
 */
 static void
 process_zone_to_name_shorten_root (void *cls,
-                 const struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded *zone_key,
+                 const struct GNUNET_CRYPTO_EccPublicKeyBinaryEncoded *zone_key,
                 struct GNUNET_TIME_Absolute expire,
                 const char *name,
                 unsigned int rd_len,
                 const struct GNUNET_NAMESTORE_RecordData *rd,
-                 const struct GNUNET_CRYPTO_RsaSignature *signature);
+                 const struct GNUNET_CRYPTO_EccSignature *signature);
 /**
@@ -3531,12 +3533,12 @@ process_zone_to_name_shorten_root (void *cls,
 */
 static void
 process_zone_to_name_shorten_shorten (void *cls,
-                 const struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded *zone_key,
+                 const struct GNUNET_CRYPTO_EccPublicKeyBinaryEncoded *zone_key,
                 struct GNUNET_TIME_Absolute expire,
                 const char *name,
                 unsigned int rd_len,
                 const struct GNUNET_NAMESTORE_RecordData *rd,
-                 const struct GNUNET_CRYPTO_RsaSignature *signature)
+                 const struct GNUNET_CRYPTO_EccSignature *signature)
 {
  struct ResolverHandle *rh = cls;
  struct NameShortenHandle* nsh = rh->proc_cls;
@@ -3647,12 +3649,12 @@ process_zone_to_name_shorten_shorten (void *cls,
 */
 static void
 process_zone_to_name_shorten_private (void *cls,
-                 const struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded *zone_key,
+                 const struct GNUNET_CRYPTO_EccPublicKeyBinaryEncoded *zone_key,
                 struct GNUNET_TIME_Absolute expire,
                 const char *name,
                 unsigned int rd_len,
                 const struct GNUNET_NAMESTORE_RecordData *rd,
-                 const struct GNUNET_CRYPTO_RsaSignature *signature)
+                 const struct GNUNET_CRYPTO_EccSignature *signature)
 {
  struct ResolverHandle *rh = cls;
  struct NameShortenHandle* nsh = rh->proc_cls;
@@ -3762,12 +3764,12 @@ process_zone_to_name_shorten_private (void *cls,
 */
 static void
 process_zone_to_name_shorten_root (void *cls,
-                 const struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded *zone_key,
+                 const struct GNUNET_CRYPTO_EccPublicKeyBinaryEncoded *zone_key,
                 struct GNUNET_TIME_Absolute expire,
                 const char *name,
                 unsigned int rd_len,
                 const struct GNUNET_NAMESTORE_RecordData *rd,
-                 const struct GNUNET_CRYPTO_RsaSignature *signature)
+                 const struct GNUNET_CRYPTO_EccSignature *signature)
 {
  struct ResolverHandle *rh = cls;
  struct NameShortenHandle* nsh = rh->proc_cls;
@@ -3985,12 +3987,12 @@ handle_delegation_ns_shorten (void* cls,
 */
 static void
 process_zone_to_name_zkey(void *cls,
-                 const struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded *zone_key,
+                 const struct GNUNET_CRYPTO_EccPublicKeyBinaryEncoded *zone_key,
                 struct GNUNET_TIME_Absolute expire,
                 const char *name,
                 unsigned int rd_len,
                 const struct GNUNET_NAMESTORE_RecordData *rd,
-                 const struct GNUNET_CRYPTO_RsaSignature *signature)
+                 const struct GNUNET_CRYPTO_EccSignature *signature)
 {
  struct ResolverHandle *rh = cls;
  struct NameShortenHandle *nsh = rh->proc_cls;
diff --git a/src/gns/gnunet-service-gns_resolver.h b/src/gns/gnunet-service-gns_resolver.h
index c4b6a8aa2..1d236b427 100644
--- a/src/gns/gnunet-service-gns_resolver.h
+++ b/src/gns/gnunet-service-gns_resolver.h
@@ -327,7 +327,7 @@ struct ResolverHandle
   * private key of an/our authoritative zone
   * can be NULL but automatical PKEY import will not work
   */
-  struct GNUNET_CRYPTO_RsaPrivateKey *priv_key;
+  struct GNUNET_CRYPTO_EccPrivateKey *priv_key;
  /**
   * the heap node associated with this lookup, null if timeout is set
@@ -484,7 +484,7 @@ struct GetPseuAuthorityHandle
  /**
   * the private key of the zone to store the pseu in 
   */
-  struct GNUNET_CRYPTO_RsaPrivateKey *key;
+  struct GNUNET_CRYPTO_EccPrivateKey *key;
  /**
   * a handle for dht lookups. should be NULL if no lookups are in progress 
@@ -573,7 +573,7 @@ gns_resolver_lookup_record (struct GNUNET_CRYPTO_ShortHashCode zone,
                            struct GNUNET_CRYPTO_ShortHashCode pzone,
                            uint32_t record_type,
                            const char* name,
-                            struct GNUNET_CRYPTO_RsaPrivateKey *key,
+                            struct GNUNET_CRYPTO_EccPrivateKey *key,
                            struct GNUNET_TIME_Relative timeout,
                            int only_cached,
                            RecordLookupProcessor proc,
diff --git a/src/gns/plugin_block_gns.c b/src/gns/plugin_block_gns.c
index 50ad01215..72149ef4f 100644
--- a/src/gns/plugin_block_gns.c
+++ b/src/gns/plugin_block_gns.c
@@ -237,7 +237,7 @@ block_plugin_gns_get_key (void *cls, enum GNUNET_BLOCK_Type type,
    return GNUNET_SYSERR; 
  }
  GNUNET_CRYPTO_short_hash (&nrb->public_key,
-                            sizeof (struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded),
+                            sizeof (struct GNUNET_CRYPTO_EccPublicKeyBinaryEncoded),
                            &pkey_hash);
  GNUNET_GNS_get_key_for_record (name, &pkey_hash, key);
  return GNUNET_OK;
diff --git a/src/gns/test_gns_cname_lookup.c b/src/gns/test_gns_cname_lookup.c
index 6870e897a..4d15175e1 100644
--- a/src/gns/test_gns_cname_lookup.c
+++ b/src/gns/test_gns_cname_lookup.c
@@ -334,9 +334,9 @@ do_check (void *cls,
          const struct GNUNET_CONFIGURATION_Handle *ccfg,
          struct GNUNET_TESTING_Peer *peer)
 {
-  struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded alice_pkey;
+  struct GNUNET_CRYPTO_EccPublicKeyBinaryEncoded alice_pkey;
-  struct GNUNET_CRYPTO_RsaPrivateKey *alice_key;
+  struct GNUNET_CRYPTO_EccPrivateKey *alice_key;
-  struct GNUNET_CRYPTO_RsaPrivateKey *bob_key;
+  struct GNUNET_CRYPTO_EccPrivateKey *bob_key;
  char* alice_keyfile;
  struct GNUNET_NAMESTORE_RecordData rd;
  const char* ip = TEST_IP_PLUS;
@@ -365,11 +365,11 @@ do_check (void *cls,
    return;
  }
-  alice_key = GNUNET_CRYPTO_rsa_key_create_from_file (alice_keyfile);
+  alice_key = GNUNET_CRYPTO_ecc_key_create_from_file (alice_keyfile);
-  GNUNET_CRYPTO_rsa_key_get_public (alice_key, &alice_pkey);
+  GNUNET_CRYPTO_ecc_key_get_public (alice_key, &alice_pkey);
  GNUNET_free(alice_keyfile);
-  bob_key = GNUNET_CRYPTO_rsa_key_create_from_file (KEYFILE_BOB);
+  bob_key = GNUNET_CRYPTO_ecc_key_create_from_file (KEYFILE_BOB);
  rd.expiration_time = UINT64_MAX;
  GNUNET_assert(1 == inet_pton (AF_INET, ip, &web));
@@ -429,8 +429,8 @@ do_check (void *cls,
                                  &rd,
                                  &commence_testing,
                                  NULL);
-  GNUNET_CRYPTO_rsa_key_free(alice_key);
+  GNUNET_CRYPTO_ecc_key_free(alice_key);
-  GNUNET_CRYPTO_rsa_key_free(bob_key);
+  GNUNET_CRYPTO_ecc_key_free(bob_key);
 }
diff --git a/src/gns/test_gns_dht_delegated_lookup.c b/src/gns/test_gns_dht_delegated_lookup.c
index 1eb77d821..ded45ecb0 100644
--- a/src/gns/test_gns_dht_delegated_lookup.c
+++ b/src/gns/test_gns_dht_delegated_lookup.c
@@ -65,10 +65,10 @@ static struct GNUNET_DHT_Handle *dht_handle;
 static const struct GNUNET_CONFIGURATION_Handle *cfg;
-static struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded alice_pkey;
+static struct GNUNET_CRYPTO_EccPublicKeyBinaryEncoded alice_pkey;
-static struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded bob_pkey;
+static struct GNUNET_CRYPTO_EccPublicKeyBinaryEncoded bob_pkey;
-static struct GNUNET_CRYPTO_RsaPrivateKey *alice_key;
+static struct GNUNET_CRYPTO_EccPrivateKey *alice_key;
-static struct GNUNET_CRYPTO_RsaPrivateKey *bob_key;
+static struct GNUNET_CRYPTO_EccPrivateKey *bob_key;
 /**
@@ -216,7 +216,7 @@ put_dht(void *cls, int32_t success, const char *emsg)
  struct GNUNET_HashCode zone_hash_double;
  uint32_t rd_payload_length;
  char* nrb_data = NULL;
-  struct GNUNET_CRYPTO_RsaSignature *sig;
+  struct GNUNET_CRYPTO_EccSignature *sig;
  struct GNUNET_NAMESTORE_RecordData rd;
  char* ip = TEST_IP;
  struct in_addr *web = GNUNET_malloc(sizeof(struct in_addr));
@@ -262,7 +262,7 @@ put_dht(void *cls, int32_t success, const char *emsg)
  }
  GNUNET_CRYPTO_short_hash(TEST_RECORD_NAME, strlen(TEST_RECORD_NAME), &name_hash);
  GNUNET_CRYPTO_short_hash(&bob_pkey,
-                     sizeof(struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded),
+                     sizeof(struct GNUNET_CRYPTO_EccPublicKeyBinaryEncoded),
                     &zone_hash);
  GNUNET_CRYPTO_short_hash_double(&zone_hash, &zone_hash_double);
  GNUNET_CRYPTO_short_hash_double(&name_hash, &name_hash_double);
@@ -330,13 +330,13 @@ do_check (void *cls,
    return;
  }
-  alice_key = GNUNET_CRYPTO_rsa_key_create_from_file (alice_keyfile);
+  alice_key = GNUNET_CRYPTO_ecc_key_create_from_file (alice_keyfile);
-  bob_key = GNUNET_CRYPTO_rsa_key_create_from_file (KEYFILE_BOB);
+  bob_key = GNUNET_CRYPTO_ecc_key_create_from_file (KEYFILE_BOB);
  
  GNUNET_free(alice_keyfile);
-  GNUNET_CRYPTO_rsa_key_get_public (alice_key, &alice_pkey);
+  GNUNET_CRYPTO_ecc_key_get_public (alice_key, &alice_pkey);
-  GNUNET_CRYPTO_rsa_key_get_public (bob_key, &bob_pkey);
+  GNUNET_CRYPTO_ecc_key_get_public (bob_key, &bob_pkey);
  GNUNET_CRYPTO_short_hash(&bob_pkey, sizeof(bob_pkey), &bob_hash);
  struct GNUNET_NAMESTORE_RecordData rd;
diff --git a/src/gns/test_gns_dht_three_peers.c b/src/gns/test_gns_dht_three_peers.c
index ee2c36e3b..227ca4606 100644
--- a/src/gns/test_gns_dht_three_peers.c
+++ b/src/gns/test_gns_dht_three_peers.c
@@ -308,8 +308,8 @@ static int
 setup_dave (const struct GNUNET_CONFIGURATION_Handle * cfg)
 {
  char* keyfile;
-  struct GNUNET_CRYPTO_RsaPrivateKey *key;
+  struct GNUNET_CRYPTO_EccPrivateKey *key;
-  struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded pkey;
+  struct GNUNET_CRYPTO_EccPublicKeyBinaryEncoded pkey;
  struct in_addr *web;
  struct GNUNET_NAMESTORE_RecordData rd;
@@ -324,7 +324,7 @@ setup_dave (const struct GNUNET_CONFIGURATION_Handle * cfg)
    return GNUNET_SYSERR;
  }
-  key = GNUNET_CRYPTO_rsa_key_create_from_file (keyfile);
+  key = GNUNET_CRYPTO_ecc_key_create_from_file (keyfile);
  if (NULL == key)
  {
@@ -336,12 +336,12 @@ setup_dave (const struct GNUNET_CONFIGURATION_Handle * cfg)
  if (NULL == nh[0])
  {
    GNUNET_log(GNUNET_ERROR_TYPE_ERROR, "Failed to connect to namestore\n");
-    GNUNET_CRYPTO_rsa_key_free (key);
+    GNUNET_CRYPTO_ecc_key_free (key);
    GNUNET_free (keyfile);
    return GNUNET_SYSERR;
  }
-  GNUNET_CRYPTO_rsa_key_get_public (key, &pkey);
+  GNUNET_CRYPTO_ecc_key_get_public (key, &pkey);
  GNUNET_CRYPTO_short_hash(&pkey, sizeof(pkey), &dave_hash);
  rd.expiration_time = UINT64_MAX;
@@ -362,7 +362,7 @@ setup_dave (const struct GNUNET_CONFIGURATION_Handle * cfg)
  GNUNET_NAMESTORE_record_create (nh[0], key, GNUNET_GNS_MASTERZONE_STR, &rd, &cont_ns, nh[0]);
-  GNUNET_CRYPTO_rsa_key_free(key);
+  GNUNET_CRYPTO_ecc_key_free(key);
  GNUNET_free(keyfile);
  GNUNET_free(web);
  dave_is_setup = GNUNET_YES;
@@ -374,8 +374,8 @@ static int
 setup_bob (const struct GNUNET_CONFIGURATION_Handle * cfg)
 {
  char* keyfile;
-  struct GNUNET_CRYPTO_RsaPrivateKey *key;
+  struct GNUNET_CRYPTO_EccPrivateKey *key;
-  struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded pkey;
+  struct GNUNET_CRYPTO_EccPublicKeyBinaryEncoded pkey;
  struct GNUNET_NAMESTORE_RecordData rd;
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Setting up bob\n");
@@ -389,7 +389,7 @@ setup_bob (const struct GNUNET_CONFIGURATION_Handle * cfg)
    return GNUNET_SYSERR;
  }
-  key = GNUNET_CRYPTO_rsa_key_create_from_file (keyfile);
+  key = GNUNET_CRYPTO_ecc_key_create_from_file (keyfile);
  if (NULL == key)
  {
@@ -402,12 +402,12 @@ setup_bob (const struct GNUNET_CONFIGURATION_Handle * cfg)
  if (NULL == nh[1])
  {
    GNUNET_log(GNUNET_ERROR_TYPE_ERROR, "Failed to connect to namestore\n");
-    GNUNET_CRYPTO_rsa_key_free (key);
+    GNUNET_CRYPTO_ecc_key_free (key);
    GNUNET_free (keyfile);
    return GNUNET_SYSERR;
  }
  
-  GNUNET_CRYPTO_rsa_key_get_public (key, &pkey);
+  GNUNET_CRYPTO_ecc_key_get_public (key, &pkey);
  GNUNET_CRYPTO_short_hash(&pkey, sizeof(pkey), &bob_hash);
  rd.expiration_time = UINT64_MAX;
@@ -418,7 +418,7 @@ setup_bob (const struct GNUNET_CONFIGURATION_Handle * cfg)
  GNUNET_NAMESTORE_record_create (nh[1], key, "buddy", &rd, &cont_ns, nh[1]);
-  GNUNET_CRYPTO_rsa_key_free(key);
+  GNUNET_CRYPTO_ecc_key_free(key);
  GNUNET_free(keyfile);
  bob_is_setup = GNUNET_YES;
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Setting up bob done\n");
@@ -429,7 +429,7 @@ static int
 setup_alice (const struct GNUNET_CONFIGURATION_Handle * cfg)
 {
  char* keyfile;
-  struct GNUNET_CRYPTO_RsaPrivateKey *key;
+  struct GNUNET_CRYPTO_EccPrivateKey *key;
  struct GNUNET_NAMESTORE_RecordData rd;
  cfg_handles[2] = GNUNET_CONFIGURATION_dup (cfg);
@@ -442,7 +442,7 @@ setup_alice (const struct GNUNET_CONFIGURATION_Handle * cfg)
    return GNUNET_SYSERR;
  }
-  key = GNUNET_CRYPTO_rsa_key_create_from_file (keyfile);
+  key = GNUNET_CRYPTO_ecc_key_create_from_file (keyfile);
  if (NULL == key)
  {
@@ -455,7 +455,7 @@ setup_alice (const struct GNUNET_CONFIGURATION_Handle * cfg)
  if (NULL == nh[2])
  {
    GNUNET_log(GNUNET_ERROR_TYPE_ERROR, "Failed to connect to namestore\n");
-    GNUNET_CRYPTO_rsa_key_free (key);
+    GNUNET_CRYPTO_ecc_key_free (key);
    GNUNET_free (keyfile);
    return GNUNET_SYSERR;
  }
@@ -473,12 +473,12 @@ setup_alice (const struct GNUNET_CONFIGURATION_Handle * cfg)
  if (NULL == gh)
  {
    GNUNET_log(GNUNET_ERROR_TYPE_ERROR, "Failed to connect to gns\n");
-    GNUNET_CRYPTO_rsa_key_free (key);
+    GNUNET_CRYPTO_ecc_key_free (key);
    GNUNET_free (keyfile);
    return GNUNET_SYSERR;
  }
-  GNUNET_CRYPTO_rsa_key_free (key);
+  GNUNET_CRYPTO_ecc_key_free (key);
  GNUNET_free (keyfile);
  alice_is_setup = GNUNET_YES;
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Setting up alice  done\n");
diff --git a/src/gns/test_gns_max_queries.c b/src/gns/test_gns_max_queries.c
index 00caf8335..16084eb4b 100644
--- a/src/gns/test_gns_max_queries.c
+++ b/src/gns/test_gns_max_queries.c
@@ -252,10 +252,10 @@ do_check (void *cls,
          const struct GNUNET_CONFIGURATION_Handle *ccfg,
          struct GNUNET_TESTING_Peer *peer)
 {
-  struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded alice_pkey;
+  struct GNUNET_CRYPTO_EccPublicKeyBinaryEncoded alice_pkey;
-  struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded bob_pkey;
+  struct GNUNET_CRYPTO_EccPublicKeyBinaryEncoded bob_pkey;
-  struct GNUNET_CRYPTO_RsaPrivateKey *alice_key;
+  struct GNUNET_CRYPTO_EccPrivateKey *alice_key;
-  struct GNUNET_CRYPTO_RsaPrivateKey *bob_key;
+  struct GNUNET_CRYPTO_EccPrivateKey *bob_key;
  char* alice_keyfile;
  struct GNUNET_CRYPTO_ShortHashCode bob_hash;
@@ -292,11 +292,11 @@ do_check (void *cls,
  }
  requests = GNUNET_malloc ((max_parallel_lookups + TEST_ADDITIONAL_LOOKUPS + 1) *
                            sizeof (struct GNUNET_GNS_LookupRequest *));
-  alice_key = GNUNET_CRYPTO_rsa_key_create_from_file (alice_keyfile);
+  alice_key = GNUNET_CRYPTO_ecc_key_create_from_file (alice_keyfile);
-  bob_key = GNUNET_CRYPTO_rsa_key_create_from_file (KEYFILE_BOB);
+  bob_key = GNUNET_CRYPTO_ecc_key_create_from_file (KEYFILE_BOB);
-  GNUNET_CRYPTO_rsa_key_get_public (alice_key, &alice_pkey);
+  GNUNET_CRYPTO_ecc_key_get_public (alice_key, &alice_pkey);
-  GNUNET_CRYPTO_rsa_key_get_public (bob_key, &bob_pkey);
+  GNUNET_CRYPTO_ecc_key_get_public (bob_key, &bob_pkey);
  
  GNUNET_free(alice_keyfile);
@@ -329,8 +329,8 @@ do_check (void *cls,
                                  &commence_testing,
                                  NULL);
  
-  GNUNET_CRYPTO_rsa_key_free(alice_key);
+  GNUNET_CRYPTO_ecc_key_free(alice_key);
-  GNUNET_CRYPTO_rsa_key_free(bob_key);
+  GNUNET_CRYPTO_ecc_key_free(bob_key);
  GNUNET_free(web);
 }
diff --git a/src/gns/test_gns_ns_lookup.c b/src/gns/test_gns_ns_lookup.c
index f48ab8030..e0803b848 100644
--- a/src/gns/test_gns_ns_lookup.c
+++ b/src/gns/test_gns_ns_lookup.c
@@ -134,7 +134,7 @@ static struct GNUNET_NAMESTORE_QueueEntry *qe;
 /**
 * Our private key for signing records.
 */
-static struct GNUNET_CRYPTO_RsaPrivateKey *alice_key;
+static struct GNUNET_CRYPTO_EccPrivateKey *alice_key;
 /**
@@ -174,7 +174,7 @@ end_badly (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
  }
  if (NULL != alice_key)
  {
-    GNUNET_CRYPTO_rsa_key_free (alice_key);
+    GNUNET_CRYPTO_ecc_key_free (alice_key);
    alice_key = NULL;
  }
  GNUNET_break (0);
@@ -229,7 +229,7 @@ end_now (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
  }
  if (NULL != alice_key)
  {
-    GNUNET_CRYPTO_rsa_key_free (alice_key);
+    GNUNET_CRYPTO_ecc_key_free (alice_key);
    alice_key = NULL;
  }
  GNUNET_log (GNUNET_ERROR_TYPE_INFO, "Shutting down peer!\n");
@@ -592,7 +592,7 @@ do_check (void *cls,
          const struct GNUNET_CONFIGURATION_Handle *ccfg,
          struct GNUNET_TESTING_Peer *peer)
 {
-  struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded alice_pkey;
+  struct GNUNET_CRYPTO_EccPublicKeyBinaryEncoded alice_pkey;
  char* alice_keyfile;
  struct GNUNET_NAMESTORE_RecordData rd;
  struct in_addr ns;
@@ -621,8 +621,8 @@ do_check (void *cls,
    return;
  }
-  alice_key = GNUNET_CRYPTO_rsa_key_create_from_file (alice_keyfile);
+  alice_key = GNUNET_CRYPTO_ecc_key_create_from_file (alice_keyfile);
-  GNUNET_CRYPTO_rsa_key_get_public (alice_key, &alice_pkey);
+  GNUNET_CRYPTO_ecc_key_get_public (alice_key, &alice_pkey);
  GNUNET_free (alice_keyfile);
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
diff --git a/src/gns/test_gns_proxy.c b/src/gns/test_gns_proxy.c
index 10b2ec810..d07f197c3 100644
--- a/src/gns/test_gns_proxy.c
+++ b/src/gns/test_gns_proxy.c
@@ -364,7 +364,7 @@ run (void *cls,
     struct GNUNET_TESTING_Peer *peer)
 {
  enum MHD_FLAG flags;
-  struct GNUNET_CRYPTO_RsaPrivateKey *host_key;
+  struct GNUNET_CRYPTO_EccPrivateKey *host_key;
  struct GNUNET_NAMESTORE_RecordData rd;
  char *zone_keyfile;
  
@@ -421,7 +421,7 @@ run (void *cls,
    return;
  }
-  host_key = GNUNET_CRYPTO_rsa_key_create_from_file (zone_keyfile);
+  host_key = GNUNET_CRYPTO_ecc_key_create_from_file (zone_keyfile);
  rd.expiration_time = GNUNET_TIME_UNIT_FOREVER_ABS.abs_value;
  GNUNET_assert (GNUNET_OK == GNUNET_NAMESTORE_string_to_value (GNUNET_GNS_RECORD_A,
                                                               "127.0.0.1",
@@ -438,7 +438,7 @@ run (void *cls,
  GNUNET_free ((void**)rd.data);
  GNUNET_free (zone_keyfile);
-  GNUNET_CRYPTO_rsa_key_free (host_key);
+  GNUNET_CRYPTO_ecc_key_free (host_key);
 }
 int
@@ -460,7 +460,7 @@ main (int argc, char *const *argv)
  }
    GNUNET_free (binary);
-  GNUNET_CRYPTO_rsa_setup_hostkey ("test_gns_proxy.conf");
+  GNUNET_CRYPTO_ecc_setup_hostkey ("test_gns_proxy.conf");
  
  if (0 != curl_global_init (CURL_GLOBAL_WIN32))
  {
diff --git a/src/gns/test_gns_pseu_shorten.c b/src/gns/test_gns_pseu_shorten.c
index 5e2f1fc11..a104d38fc 100644
--- a/src/gns/test_gns_pseu_shorten.c
+++ b/src/gns/test_gns_pseu_shorten.c
@@ -71,16 +71,16 @@ static struct GNUNET_DHT_Handle *dht_handle;
 static const struct GNUNET_CONFIGURATION_Handle *cfg;
-static struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded alice_pkey;
+static struct GNUNET_CRYPTO_EccPublicKeyBinaryEncoded alice_pkey;
-static struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded bob_pkey;
+static struct GNUNET_CRYPTO_EccPublicKeyBinaryEncoded bob_pkey;
-static struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded our_pkey;
+static struct GNUNET_CRYPTO_EccPublicKeyBinaryEncoded our_pkey;
-static struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded priv_pkey;
+static struct GNUNET_CRYPTO_EccPublicKeyBinaryEncoded priv_pkey;
-static struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded short_pkey;
+static struct GNUNET_CRYPTO_EccPublicKeyBinaryEncoded short_pkey;
-static struct GNUNET_CRYPTO_RsaPrivateKey *alice_key;
+static struct GNUNET_CRYPTO_EccPrivateKey *alice_key;
-static struct GNUNET_CRYPTO_RsaPrivateKey *bob_key;
+static struct GNUNET_CRYPTO_EccPrivateKey *bob_key;
-static struct GNUNET_CRYPTO_RsaPrivateKey *our_key;
+static struct GNUNET_CRYPTO_EccPrivateKey *our_key;
-static struct GNUNET_CRYPTO_RsaPrivateKey *priv_key;
+static struct GNUNET_CRYPTO_EccPrivateKey *priv_key;
-static struct GNUNET_CRYPTO_RsaPrivateKey *short_key;
+static struct GNUNET_CRYPTO_EccPrivateKey *short_key;
 static struct GNUNET_CRYPTO_ShortHashCode alice_hash;
 static struct GNUNET_CRYPTO_ShortHashCode bob_hash;
 static struct GNUNET_CRYPTO_ShortHashCode our_zone;
@@ -236,9 +236,9 @@ on_lookup_result(void *cls, uint32_t rd_count,
 static void
 commence_testing (void *cls, int success)
 {
-  GNUNET_CRYPTO_rsa_key_free(our_key);
+  GNUNET_CRYPTO_ecc_key_free(our_key);
-  GNUNET_CRYPTO_rsa_key_free(bob_key);
+  GNUNET_CRYPTO_ecc_key_free(bob_key);
-  GNUNET_CRYPTO_rsa_key_free(alice_key);
+  GNUNET_CRYPTO_ecc_key_free(alice_key);
  GNUNET_NAMESTORE_disconnect (namestore_handle);
  namestore_handle = NULL;
  gns_handle = GNUNET_GNS_connect(cfg);
@@ -267,7 +267,7 @@ put_pseu_dht (void *cls, int success)
  struct GNUNET_HashCode zone_hash_double;
  uint32_t rd_payload_length;
  char* nrb_data = NULL;
-  struct GNUNET_CRYPTO_RsaSignature *sig;
+  struct GNUNET_CRYPTO_EccSignature *sig;
  struct GNUNET_NAMESTORE_RecordData rd;
  
  memset (&rd, 0, sizeof (struct GNUNET_NAMESTORE_RecordData));
@@ -308,9 +308,9 @@ put_pseu_dht (void *cls, int success)
  {
    GNUNET_log(GNUNET_ERROR_TYPE_ERROR, "Record serialization failed!\n");
    ok = 3;
-    GNUNET_CRYPTO_rsa_key_free(our_key);
+    GNUNET_CRYPTO_ecc_key_free(our_key);
-    GNUNET_CRYPTO_rsa_key_free(bob_key);
+    GNUNET_CRYPTO_ecc_key_free(bob_key);
-    GNUNET_CRYPTO_rsa_key_free(alice_key);
+    GNUNET_CRYPTO_ecc_key_free(alice_key);
    GNUNET_free(sig);
    GNUNET_free (nrb);
    end_badly_now ();
@@ -318,7 +318,7 @@ put_pseu_dht (void *cls, int success)
  }
  GNUNET_CRYPTO_short_hash(GNUNET_GNS_MASTERZONE_STR, strlen(GNUNET_GNS_MASTERZONE_STR), &name_hash);
  GNUNET_CRYPTO_short_hash(&alice_pkey,
-                     sizeof(struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded),
+                     sizeof(struct GNUNET_CRYPTO_EccPublicKeyBinaryEncoded),
                     &zone_hash);
  GNUNET_CRYPTO_short_hash_double(&name_hash, &name_hash_double);
@@ -355,7 +355,7 @@ put_www_dht(void *cls, int success)
  struct GNUNET_HashCode zone_hash_double;
  uint32_t rd_payload_length;
  char* nrb_data = NULL;
-  struct GNUNET_CRYPTO_RsaSignature *sig;
+  struct GNUNET_CRYPTO_EccSignature *sig;
  struct GNUNET_NAMESTORE_RecordData rd;
  char* ip = TEST_IP;
  struct in_addr *web = GNUNET_malloc(sizeof(struct in_addr));
@@ -396,9 +396,9 @@ put_www_dht(void *cls, int success)
  {
    GNUNET_log(GNUNET_ERROR_TYPE_ERROR, "Record serialization failed!\n");
    ok = 3;
-    GNUNET_CRYPTO_rsa_key_free(our_key);
+    GNUNET_CRYPTO_ecc_key_free(our_key);
-    GNUNET_CRYPTO_rsa_key_free(bob_key);
+    GNUNET_CRYPTO_ecc_key_free(bob_key);
-    GNUNET_CRYPTO_rsa_key_free(alice_key);
+    GNUNET_CRYPTO_ecc_key_free(alice_key);
    GNUNET_free (sig);
    GNUNET_free(web);
    GNUNET_free (nrb);
@@ -407,7 +407,7 @@ put_www_dht(void *cls, int success)
  }
  GNUNET_CRYPTO_short_hash(TEST_RECORD_NAME, strlen(TEST_RECORD_NAME), &name_hash);
  GNUNET_CRYPTO_short_hash(&alice_pkey,
-                     sizeof(struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded),
+                     sizeof(struct GNUNET_CRYPTO_EccPublicKeyBinaryEncoded),
                     &zone_hash);
  GNUNET_CRYPTO_short_hash_double(&zone_hash, &zone_hash_double);
  GNUNET_CRYPTO_short_hash_double(&name_hash, &name_hash_double);
@@ -443,7 +443,7 @@ put_pkey_dht(void *cls, int32_t success, const char *emsg)
  struct GNUNET_HashCode zone_hash_double;
  uint32_t rd_payload_length;
  char* nrb_data = NULL;
-  struct GNUNET_CRYPTO_RsaSignature *sig;
+  struct GNUNET_CRYPTO_EccSignature *sig;
  struct GNUNET_NAMESTORE_RecordData rd;
  
  rd.expiration_time = UINT64_MAX;
@@ -477,9 +477,9 @@ put_pkey_dht(void *cls, int32_t success, const char *emsg)
    GNUNET_log(GNUNET_ERROR_TYPE_ERROR, "Record serialization failed!\n");
    ok = 3;
    
-    GNUNET_CRYPTO_rsa_key_free (our_key);
+    GNUNET_CRYPTO_ecc_key_free (our_key);
-    GNUNET_CRYPTO_rsa_key_free (bob_key);
+    GNUNET_CRYPTO_ecc_key_free (bob_key);
-    GNUNET_CRYPTO_rsa_key_free (alice_key);
+    GNUNET_CRYPTO_ecc_key_free (alice_key);
    GNUNET_free (sig);
    GNUNET_free (nrb);
    end_badly_now ();
@@ -490,7 +490,7 @@ put_pkey_dht(void *cls, int32_t success, const char *emsg)
  GNUNET_CRYPTO_short_hash(TEST_AUTHORITY_ALICE,
                     strlen(TEST_AUTHORITY_ALICE), &name_hash);
  GNUNET_CRYPTO_short_hash(&bob_pkey,
-                     sizeof(struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded),
+                     sizeof(struct GNUNET_CRYPTO_EccPublicKeyBinaryEncoded),
                     &zone_hash);
  GNUNET_CRYPTO_short_hash_double(&zone_hash, &zone_hash_double);
  GNUNET_CRYPTO_short_hash_double(&name_hash, &name_hash_double);
@@ -610,21 +610,21 @@ do_check (void *cls,
    end_badly_now();
    return;
  }
-  our_key = GNUNET_CRYPTO_rsa_key_create_from_file (our_keyfile);
+  our_key = GNUNET_CRYPTO_ecc_key_create_from_file (our_keyfile);
-  priv_key = GNUNET_CRYPTO_rsa_key_create_from_file (private_keyfile);
+  priv_key = GNUNET_CRYPTO_ecc_key_create_from_file (private_keyfile);
-  short_key = GNUNET_CRYPTO_rsa_key_create_from_file (shorten_keyfile);
+  short_key = GNUNET_CRYPTO_ecc_key_create_from_file (shorten_keyfile);
-  bob_key = GNUNET_CRYPTO_rsa_key_create_from_file (KEYFILE_BOB);
+  bob_key = GNUNET_CRYPTO_ecc_key_create_from_file (KEYFILE_BOB);
-  alice_key = GNUNET_CRYPTO_rsa_key_create_from_file (KEYFILE_ALICE);
+  alice_key = GNUNET_CRYPTO_ecc_key_create_from_file (KEYFILE_ALICE);
  
  GNUNET_free(our_keyfile);
  GNUNET_free(shorten_keyfile);
  GNUNET_free(private_keyfile);
-  GNUNET_CRYPTO_rsa_key_get_public (our_key, &our_pkey);
+  GNUNET_CRYPTO_ecc_key_get_public (our_key, &our_pkey);
-  GNUNET_CRYPTO_rsa_key_get_public (priv_key, &priv_pkey);
+  GNUNET_CRYPTO_ecc_key_get_public (priv_key, &priv_pkey);
-  GNUNET_CRYPTO_rsa_key_get_public (short_key, &short_pkey);
+  GNUNET_CRYPTO_ecc_key_get_public (short_key, &short_pkey);
-  GNUNET_CRYPTO_rsa_key_get_public (bob_key, &bob_pkey);
+  GNUNET_CRYPTO_ecc_key_get_public (bob_key, &bob_pkey);
-  GNUNET_CRYPTO_rsa_key_get_public (alice_key, &alice_pkey);
+  GNUNET_CRYPTO_ecc_key_get_public (alice_key, &alice_pkey);
  GNUNET_CRYPTO_short_hash(&bob_pkey, sizeof(bob_pkey), &bob_hash);
  GNUNET_CRYPTO_short_hash(&alice_pkey, sizeof(alice_pkey), &alice_hash);
  GNUNET_CRYPTO_short_hash(&our_pkey, sizeof(our_pkey), &our_zone);
diff --git a/src/gns/test_gns_revocation.c b/src/gns/test_gns_revocation.c
index 8e677880a..540f58a35 100644
--- a/src/gns/test_gns_revocation.c
+++ b/src/gns/test_gns_revocation.c
@@ -180,12 +180,12 @@ do_check (void *cls,
          const struct GNUNET_CONFIGURATION_Handle *ccfg,
          struct GNUNET_TESTING_Peer *peer)
 {
-  struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded alice_pkey;
+  struct GNUNET_CRYPTO_EccPublicKeyBinaryEncoded alice_pkey;
-  struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded bob_pkey;
+  struct GNUNET_CRYPTO_EccPublicKeyBinaryEncoded bob_pkey;
-  struct GNUNET_CRYPTO_RsaPrivateKey *alice_key;
+  struct GNUNET_CRYPTO_EccPrivateKey *alice_key;
-  struct GNUNET_CRYPTO_RsaPrivateKey *bob_key;
+  struct GNUNET_CRYPTO_EccPrivateKey *bob_key;
  struct GNUNET_CRYPTO_ShortHashCode bob_hash;
-  struct GNUNET_CRYPTO_RsaSignature *sig;
+  struct GNUNET_CRYPTO_EccSignature *sig;
  char* alice_keyfile;
  cfg = ccfg;
@@ -209,11 +209,11 @@ do_check (void *cls,
      return;
  }
-  alice_key = GNUNET_CRYPTO_rsa_key_create_from_file (alice_keyfile);
+  alice_key = GNUNET_CRYPTO_ecc_key_create_from_file (alice_keyfile);
-  bob_key = GNUNET_CRYPTO_rsa_key_create_from_file (KEYFILE_BOB);
+  bob_key = GNUNET_CRYPTO_ecc_key_create_from_file (KEYFILE_BOB);
-  GNUNET_CRYPTO_rsa_key_get_public (alice_key, &alice_pkey);
+  GNUNET_CRYPTO_ecc_key_get_public (alice_key, &alice_pkey);
-  GNUNET_CRYPTO_rsa_key_get_public (bob_key, &bob_pkey);
+  GNUNET_CRYPTO_ecc_key_get_public (bob_key, &bob_pkey);
  struct GNUNET_NAMESTORE_RecordData rd;
  char* ip = TEST_IP;
@@ -264,8 +264,8 @@ do_check (void *cls,
  GNUNET_free (alice_keyfile);
  GNUNET_free (web);
  GNUNET_free (sig);
-  GNUNET_CRYPTO_rsa_key_free (bob_key);
+  GNUNET_CRYPTO_ecc_key_free (bob_key);
-  GNUNET_CRYPTO_rsa_key_free (alice_key);
+  GNUNET_CRYPTO_ecc_key_free (alice_key);
 }
diff --git a/src/gns/test_gns_simple_delegated_lookup.c b/src/gns/test_gns_simple_delegated_lookup.c
index 393ddfb0e..f2610c167 100644
--- a/src/gns/test_gns_simple_delegated_lookup.c
+++ b/src/gns/test_gns_simple_delegated_lookup.c
@@ -189,12 +189,12 @@ do_check (void *cls,
          const struct GNUNET_CONFIGURATION_Handle *ccfg,
          struct GNUNET_TESTING_Peer *peer)
 {
-  struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded alice_pkey;
+  struct GNUNET_CRYPTO_EccPublicKeyBinaryEncoded alice_pkey;
-  struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded bob_pkey;
+  struct GNUNET_CRYPTO_EccPublicKeyBinaryEncoded bob_pkey;
-  struct GNUNET_CRYPTO_RsaPrivateKey *alice_key;
+  struct GNUNET_CRYPTO_EccPrivateKey *alice_key;
-  struct GNUNET_CRYPTO_RsaPrivateKey *bob_key;
+  struct GNUNET_CRYPTO_EccPrivateKey *bob_key;
  struct GNUNET_CRYPTO_ShortHashCode bob_hash;
-  struct GNUNET_CRYPTO_RsaSignature *sig;
+  struct GNUNET_CRYPTO_EccSignature *sig;
  char* alice_keyfile;
  struct GNUNET_TIME_Absolute et;
  struct GNUNET_NAMESTORE_RecordData rd;
@@ -223,10 +223,10 @@ do_check (void *cls,
    GNUNET_SCHEDULER_shutdown ();
    return;
  }
-  alice_key = GNUNET_CRYPTO_rsa_key_create_from_file (alice_keyfile);
+  alice_key = GNUNET_CRYPTO_ecc_key_create_from_file (alice_keyfile);
-  bob_key = GNUNET_CRYPTO_rsa_key_create_from_file (KEYFILE_BOB);
+  bob_key = GNUNET_CRYPTO_ecc_key_create_from_file (KEYFILE_BOB);
-  GNUNET_CRYPTO_rsa_key_get_public (alice_key, &alice_pkey);
+  GNUNET_CRYPTO_ecc_key_get_public (alice_key, &alice_pkey);
-  GNUNET_CRYPTO_rsa_key_get_public (bob_key, &bob_pkey);
+  GNUNET_CRYPTO_ecc_key_get_public (bob_key, &bob_pkey);
  rd.expiration_time = UINT64_MAX;
  GNUNET_assert (1 == inet_pton (AF_INET, ip, &web));
  GNUNET_CRYPTO_short_hash (&bob_pkey, sizeof(bob_pkey), &bob_hash);
@@ -259,8 +259,8 @@ do_check (void *cls,
                               NULL);
  GNUNET_free (sig);
  GNUNET_free (alice_keyfile);
-  GNUNET_CRYPTO_rsa_key_free (bob_key);
+  GNUNET_CRYPTO_ecc_key_free (bob_key);
-  GNUNET_CRYPTO_rsa_key_free (alice_key);
+  GNUNET_CRYPTO_ecc_key_free (alice_key);
 }
diff --git a/src/gns/test_gns_simple_get_authority.c b/src/gns/test_gns_simple_get_authority.c
index 111f8f1f9..300e7be5b 100644
--- a/src/gns/test_gns_simple_get_authority.c
+++ b/src/gns/test_gns_simple_get_authority.c
@@ -178,15 +178,15 @@ void do_check (void *cls,
              const struct GNUNET_CONFIGURATION_Handle *ccfg,
              struct GNUNET_TESTING_Peer *peer)
 {
-  struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded our_pkey;
+  struct GNUNET_CRYPTO_EccPublicKeyBinaryEncoded our_pkey;
-  struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded alice_pkey;
+  struct GNUNET_CRYPTO_EccPublicKeyBinaryEncoded alice_pkey;
-  struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded bob_pkey;
+  struct GNUNET_CRYPTO_EccPublicKeyBinaryEncoded bob_pkey;
-  struct GNUNET_CRYPTO_RsaPrivateKey *our_key;
+  struct GNUNET_CRYPTO_EccPrivateKey *our_key;
-  struct GNUNET_CRYPTO_RsaPrivateKey *alice_key;
+  struct GNUNET_CRYPTO_EccPrivateKey *alice_key;
-  struct GNUNET_CRYPTO_RsaPrivateKey *bob_key;
+  struct GNUNET_CRYPTO_EccPrivateKey *bob_key;
  struct GNUNET_CRYPTO_ShortHashCode bob_hash;
  struct GNUNET_CRYPTO_ShortHashCode alice_hash;
-  struct GNUNET_CRYPTO_RsaSignature *sig;
+  struct GNUNET_CRYPTO_EccSignature *sig;
  char* our_keyfile;
  cfg = ccfg;
@@ -211,15 +211,15 @@ void do_check (void *cls,
    return;
  }
-  our_key = GNUNET_CRYPTO_rsa_key_create_from_file (our_keyfile);
+  our_key = GNUNET_CRYPTO_ecc_key_create_from_file (our_keyfile);
  GNUNET_free(our_keyfile);
-  bob_key = GNUNET_CRYPTO_rsa_key_create_from_file (KEYFILE_BOB);
+  bob_key = GNUNET_CRYPTO_ecc_key_create_from_file (KEYFILE_BOB);
-  alice_key = GNUNET_CRYPTO_rsa_key_create_from_file (KEYFILE_ALICE);
+  alice_key = GNUNET_CRYPTO_ecc_key_create_from_file (KEYFILE_ALICE);
-  GNUNET_CRYPTO_rsa_key_get_public (our_key, &our_pkey);
+  GNUNET_CRYPTO_ecc_key_get_public (our_key, &our_pkey);
-  GNUNET_CRYPTO_rsa_key_get_public (alice_key, &alice_pkey);
+  GNUNET_CRYPTO_ecc_key_get_public (alice_key, &alice_pkey);
-  GNUNET_CRYPTO_rsa_key_get_public (bob_key, &bob_pkey);
+  GNUNET_CRYPTO_ecc_key_get_public (bob_key, &bob_pkey);
  struct GNUNET_NAMESTORE_RecordData rd;
  char* ip = TEST_IP;
@@ -298,9 +298,9 @@ void do_check (void *cls,
  GNUNET_free (web);
  GNUNET_free (sig);
-  GNUNET_CRYPTO_rsa_key_free (alice_key);
+  GNUNET_CRYPTO_ecc_key_free (alice_key);
-  GNUNET_CRYPTO_rsa_key_free (bob_key);
+  GNUNET_CRYPTO_ecc_key_free (bob_key);
-  GNUNET_CRYPTO_rsa_key_free (our_key);
+  GNUNET_CRYPTO_ecc_key_free (our_key);
 }
diff --git a/src/gns/test_gns_simple_lookup.c b/src/gns/test_gns_simple_lookup.c
index 96283df5b..ff325a464 100644
--- a/src/gns/test_gns_simple_lookup.c
+++ b/src/gns/test_gns_simple_lookup.c
@@ -221,8 +221,8 @@ do_check (void *cls,
          const struct GNUNET_CONFIGURATION_Handle *ccfg,
          struct GNUNET_TESTING_Peer *peer)
 {
-  struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded alice_pkey;
+  struct GNUNET_CRYPTO_EccPublicKeyBinaryEncoded alice_pkey;
-  struct GNUNET_CRYPTO_RsaPrivateKey *alice_key;
+  struct GNUNET_CRYPTO_EccPrivateKey *alice_key;
  struct GNUNET_NAMESTORE_RecordData rd;
  char* alice_keyfile;
  char* ip = TEST_IP;
@@ -251,8 +251,8 @@ do_check (void *cls,
    return;
  }
-  alice_key = GNUNET_CRYPTO_rsa_key_create_from_file (alice_keyfile);
+  alice_key = GNUNET_CRYPTO_ecc_key_create_from_file (alice_keyfile);
-  GNUNET_CRYPTO_rsa_key_get_public (alice_key, &alice_pkey);
+  GNUNET_CRYPTO_ecc_key_get_public (alice_key, &alice_pkey);
  GNUNET_free (alice_keyfile);
  rd.expiration_time = UINT64_MAX;
  GNUNET_assert (1 == inet_pton (AF_INET, ip, &web));
@@ -266,7 +266,7 @@ do_check (void *cls,
                                         &rd,
                                         &commence_testing,
                                         NULL);
-  GNUNET_CRYPTO_rsa_key_free (alice_key);
+  GNUNET_CRYPTO_ecc_key_free (alice_key);
 }
diff --git a/src/gns/test_gns_simple_mx_lookup.c b/src/gns/test_gns_simple_mx_lookup.c
index cfaea67ad..f928a3913 100644
--- a/src/gns/test_gns_simple_mx_lookup.c
+++ b/src/gns/test_gns_simple_mx_lookup.c
@@ -180,12 +180,12 @@ do_check (void *cls,
          const struct GNUNET_CONFIGURATION_Handle *ccfg,
          struct GNUNET_TESTING_Peer *peer)
 {
-  struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded alice_pkey;
+  struct GNUNET_CRYPTO_EccPublicKeyBinaryEncoded alice_pkey;
-  struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded bob_pkey;
+  struct GNUNET_CRYPTO_EccPublicKeyBinaryEncoded bob_pkey;
-  struct GNUNET_CRYPTO_RsaPrivateKey *alice_key;
+  struct GNUNET_CRYPTO_EccPrivateKey *alice_key;
-  struct GNUNET_CRYPTO_RsaPrivateKey *bob_key;
+  struct GNUNET_CRYPTO_EccPrivateKey *bob_key;
  struct GNUNET_CRYPTO_ShortHashCode bob_hash;
-  struct GNUNET_CRYPTO_RsaSignature *sig;
+  struct GNUNET_CRYPTO_EccSignature *sig;
  char* alice_keyfile;
  struct GNUNET_TIME_Absolute et;
@@ -210,11 +210,11 @@ do_check (void *cls,
    return;
  }
-  alice_key = GNUNET_CRYPTO_rsa_key_create_from_file (alice_keyfile);
+  alice_key = GNUNET_CRYPTO_ecc_key_create_from_file (alice_keyfile);
-  bob_key = GNUNET_CRYPTO_rsa_key_create_from_file (KEYFILE_BOB);
+  bob_key = GNUNET_CRYPTO_ecc_key_create_from_file (KEYFILE_BOB);
-  GNUNET_CRYPTO_rsa_key_get_public (alice_key, &alice_pkey);
+  GNUNET_CRYPTO_ecc_key_get_public (alice_key, &alice_pkey);
-  GNUNET_CRYPTO_rsa_key_get_public (bob_key, &bob_pkey);
+  GNUNET_CRYPTO_ecc_key_get_public (bob_key, &bob_pkey);
  struct GNUNET_NAMESTORE_RecordData rd;
  char* ip = TEST_IP;
@@ -282,8 +282,8 @@ do_check (void *cls,
  GNUNET_free (mx_record);
  GNUNET_free (mail);
  GNUNET_free (sig);
-  GNUNET_CRYPTO_rsa_key_free (bob_key);
+  GNUNET_CRYPTO_ecc_key_free (bob_key);
-  GNUNET_CRYPTO_rsa_key_free (alice_key);
+  GNUNET_CRYPTO_ecc_key_free (alice_key);
 }
diff --git a/src/gns/test_gns_simple_shorten.c b/src/gns/test_gns_simple_shorten.c
index c6d49f82f..9b61a41c8 100644
--- a/src/gns/test_gns_simple_shorten.c
+++ b/src/gns/test_gns_simple_shorten.c
@@ -61,10 +61,10 @@ static struct GNUNET_GNS_Handle *gns_handle;
 const struct GNUNET_CONFIGURATION_Handle *cfg;
-struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded priv_pkey;
+struct GNUNET_CRYPTO_EccPublicKeyBinaryEncoded priv_pkey;
-struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded short_pkey;
+struct GNUNET_CRYPTO_EccPublicKeyBinaryEncoded short_pkey;
-struct GNUNET_CRYPTO_RsaPrivateKey *priv_key;
+struct GNUNET_CRYPTO_EccPrivateKey *priv_key;
-struct GNUNET_CRYPTO_RsaPrivateKey *short_key;
+struct GNUNET_CRYPTO_EccPrivateKey *short_key;
 struct GNUNET_CRYPTO_ShortHashCode priv_zone;
 struct GNUNET_CRYPTO_ShortHashCode short_zone;
@@ -170,15 +170,15 @@ void do_check (void *cls,
              const struct GNUNET_CONFIGURATION_Handle *ccfg,
              struct GNUNET_TESTING_Peer *peer)
 {
-  struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded our_pkey;
+  struct GNUNET_CRYPTO_EccPublicKeyBinaryEncoded our_pkey;
-  struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded alice_pkey;
+  struct GNUNET_CRYPTO_EccPublicKeyBinaryEncoded alice_pkey;
-  struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded bob_pkey;
+  struct GNUNET_CRYPTO_EccPublicKeyBinaryEncoded bob_pkey;
-  struct GNUNET_CRYPTO_RsaPrivateKey *our_key;
+  struct GNUNET_CRYPTO_EccPrivateKey *our_key;
-  struct GNUNET_CRYPTO_RsaPrivateKey *alice_key;
+  struct GNUNET_CRYPTO_EccPrivateKey *alice_key;
-  struct GNUNET_CRYPTO_RsaPrivateKey *bob_key;
+  struct GNUNET_CRYPTO_EccPrivateKey *bob_key;
  struct GNUNET_CRYPTO_ShortHashCode bob_hash;
  struct GNUNET_CRYPTO_ShortHashCode alice_hash;
-  struct GNUNET_CRYPTO_RsaSignature *sig;
+  struct GNUNET_CRYPTO_EccSignature *sig;
  char* our_keyfile;
  char* private_keyfile;
  char* shorten_keyfile;
@@ -226,22 +226,22 @@ void do_check (void *cls,
    return;
  }
-  our_key = GNUNET_CRYPTO_rsa_key_create_from_file (our_keyfile);
+  our_key = GNUNET_CRYPTO_ecc_key_create_from_file (our_keyfile);
  GNUNET_free(our_keyfile);
-  bob_key = GNUNET_CRYPTO_rsa_key_create_from_file (KEYFILE_BOB);
+  bob_key = GNUNET_CRYPTO_ecc_key_create_from_file (KEYFILE_BOB);
-  alice_key = GNUNET_CRYPTO_rsa_key_create_from_file (KEYFILE_ALICE);
+  alice_key = GNUNET_CRYPTO_ecc_key_create_from_file (KEYFILE_ALICE);
-  priv_key = GNUNET_CRYPTO_rsa_key_create_from_file (private_keyfile);
+  priv_key = GNUNET_CRYPTO_ecc_key_create_from_file (private_keyfile);
-  short_key = GNUNET_CRYPTO_rsa_key_create_from_file (shorten_keyfile);
+  short_key = GNUNET_CRYPTO_ecc_key_create_from_file (shorten_keyfile);
  GNUNET_free(shorten_keyfile);
  GNUNET_free(private_keyfile);
  
-  GNUNET_CRYPTO_rsa_key_get_public (our_key, &our_pkey);
+  GNUNET_CRYPTO_ecc_key_get_public (our_key, &our_pkey);
-  GNUNET_CRYPTO_rsa_key_get_public (alice_key, &alice_pkey);
+  GNUNET_CRYPTO_ecc_key_get_public (alice_key, &alice_pkey);
-  GNUNET_CRYPTO_rsa_key_get_public (bob_key, &bob_pkey);
+  GNUNET_CRYPTO_ecc_key_get_public (bob_key, &bob_pkey);
-  GNUNET_CRYPTO_rsa_key_get_public (priv_key, &priv_pkey);
+  GNUNET_CRYPTO_ecc_key_get_public (priv_key, &priv_pkey);
-  GNUNET_CRYPTO_rsa_key_get_public (short_key, &short_pkey);
+  GNUNET_CRYPTO_ecc_key_get_public (short_key, &short_pkey);
  GNUNET_CRYPTO_short_hash(&priv_pkey, sizeof(priv_pkey), &priv_zone);
  GNUNET_CRYPTO_short_hash(&short_pkey, sizeof(short_pkey), &short_zone);
@@ -318,11 +318,11 @@ void do_check (void *cls,
                               NULL);
  GNUNET_free(web);
-  GNUNET_CRYPTO_rsa_key_free(our_key);
+  GNUNET_CRYPTO_ecc_key_free(our_key);
-  GNUNET_CRYPTO_rsa_key_free(bob_key);
+  GNUNET_CRYPTO_ecc_key_free(bob_key);
-  GNUNET_CRYPTO_rsa_key_free(alice_key);
+  GNUNET_CRYPTO_ecc_key_free(alice_key);
-  GNUNET_CRYPTO_rsa_key_free(priv_key);
+  GNUNET_CRYPTO_ecc_key_free(priv_key);
-  GNUNET_CRYPTO_rsa_key_free(short_key);
+  GNUNET_CRYPTO_ecc_key_free(short_key);
 }
diff --git a/src/gns/test_gns_simple_srv_lookup.c b/src/gns/test_gns_simple_srv_lookup.c
index 40e5aec8d..c0208639d 100644
--- a/src/gns/test_gns_simple_srv_lookup.c
+++ b/src/gns/test_gns_simple_srv_lookup.c
@@ -182,12 +182,12 @@ do_check (void *cls,
          const struct GNUNET_CONFIGURATION_Handle *ccfg,
          struct GNUNET_TESTING_Peer *peer)
 {
-  struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded alice_pkey;
+  struct GNUNET_CRYPTO_EccPublicKeyBinaryEncoded alice_pkey;
-  struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded bob_pkey;
+  struct GNUNET_CRYPTO_EccPublicKeyBinaryEncoded bob_pkey;
-  struct GNUNET_CRYPTO_RsaPrivateKey *alice_key;
+  struct GNUNET_CRYPTO_EccPrivateKey *alice_key;
-  struct GNUNET_CRYPTO_RsaPrivateKey *bob_key;
+  struct GNUNET_CRYPTO_EccPrivateKey *bob_key;
  struct GNUNET_CRYPTO_ShortHashCode bob_hash;
-  struct GNUNET_CRYPTO_RsaSignature *sig;
+  struct GNUNET_CRYPTO_EccSignature *sig;
  char* alice_keyfile;
  struct srv_data *srv_data;
  struct GNUNET_TIME_Absolute et;
@@ -213,11 +213,11 @@ do_check (void *cls,
    return;
  }
-  alice_key = GNUNET_CRYPTO_rsa_key_create_from_file (alice_keyfile);
+  alice_key = GNUNET_CRYPTO_ecc_key_create_from_file (alice_keyfile);
-  bob_key = GNUNET_CRYPTO_rsa_key_create_from_file (KEYFILE_BOB);
+  bob_key = GNUNET_CRYPTO_ecc_key_create_from_file (KEYFILE_BOB);
-  GNUNET_CRYPTO_rsa_key_get_public (alice_key, &alice_pkey);
+  GNUNET_CRYPTO_ecc_key_get_public (alice_key, &alice_pkey);
-  GNUNET_CRYPTO_rsa_key_get_public (bob_key, &bob_pkey);
+  GNUNET_CRYPTO_ecc_key_get_public (bob_key, &bob_pkey);
  struct GNUNET_NAMESTORE_RecordData rd;
  char* ip = TEST_IP;
@@ -288,8 +288,8 @@ do_check (void *cls,
  GNUNET_free (srv_data);
  GNUNET_free (sipserver);
  GNUNET_free (sig);
-  GNUNET_CRYPTO_rsa_key_free (bob_key);
+  GNUNET_CRYPTO_ecc_key_free (bob_key);
-  GNUNET_CRYPTO_rsa_key_free (alice_key);
+  GNUNET_CRYPTO_ecc_key_free (alice_key);
 }
diff --git a/src/gns/test_gns_simple_zkey_lookup.c b/src/gns/test_gns_simple_zkey_lookup.c
index dd1a3f7bd..923664b77 100644
--- a/src/gns/test_gns_simple_zkey_lookup.c
+++ b/src/gns/test_gns_simple_zkey_lookup.c
@@ -199,11 +199,11 @@ do_check (void *cls,
          const struct GNUNET_CONFIGURATION_Handle *ccfg,
          struct GNUNET_TESTING_Peer *peer)
 {
-  struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded alice_pkey;
+  struct GNUNET_CRYPTO_EccPublicKeyBinaryEncoded alice_pkey;
-  struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded bob_pkey;
+  struct GNUNET_CRYPTO_EccPublicKeyBinaryEncoded bob_pkey;
-  struct GNUNET_CRYPTO_RsaPrivateKey *alice_key;
+  struct GNUNET_CRYPTO_EccPrivateKey *alice_key;
-  struct GNUNET_CRYPTO_RsaPrivateKey *bob_key;
+  struct GNUNET_CRYPTO_EccPrivateKey *bob_key;
-  struct GNUNET_CRYPTO_RsaSignature *sig;
+  struct GNUNET_CRYPTO_EccSignature *sig;
  char* alice_keyfile;
  cfg = ccfg;
@@ -227,11 +227,11 @@ do_check (void *cls,
    return;
  }
-  alice_key = GNUNET_CRYPTO_rsa_key_create_from_file (alice_keyfile);
+  alice_key = GNUNET_CRYPTO_ecc_key_create_from_file (alice_keyfile);
-  bob_key = GNUNET_CRYPTO_rsa_key_create_from_file (KEYFILE_BOB);
+  bob_key = GNUNET_CRYPTO_ecc_key_create_from_file (KEYFILE_BOB);
-  GNUNET_CRYPTO_rsa_key_get_public (alice_key, &alice_pkey);
+  GNUNET_CRYPTO_ecc_key_get_public (alice_key, &alice_pkey);
-  GNUNET_CRYPTO_rsa_key_get_public (bob_key, &bob_pkey);
+  GNUNET_CRYPTO_ecc_key_get_public (bob_key, &bob_pkey);
  struct GNUNET_NAMESTORE_RecordData rd;
  char* ip = TEST_IP;
@@ -273,8 +273,8 @@ do_check (void *cls,
  GNUNET_free (alice_keyfile);
  GNUNET_free (web);
  GNUNET_free (sig);
-  GNUNET_CRYPTO_rsa_key_free (bob_key);
+  GNUNET_CRYPTO_ecc_key_free (bob_key);
-  GNUNET_CRYPTO_rsa_key_free (alice_key);
+  GNUNET_CRYPTO_ecc_key_free (alice_key);
 }
diff --git a/src/gns/zonefiles/test_zonekey b/src/gns/zonefiles/test_zonekey
index cfa760624..870c56315 100644
--- a/src/gns/zonefiles/test_zonekey
+++ b/src/gns/zonefiles/test_zonekey
Binary files differ
diff --git a/src/include/block_dns.h b/src/include/block_dns.h
index 0ca5a47a5..c7e1fbb55 100644
--- a/src/include/block_dns.h
+++ b/src/include/block_dns.h
@@ -47,18 +47,18 @@ struct GNUNET_DNS_Record
  /**
   * Signature of the peer affirming that he is offering the service.
   */
-  struct GNUNET_CRYPTO_RsaSignature signature;
+  struct GNUNET_CRYPTO_EccSignature signature;
  /**
   * Beginning of signed portion of the record, signs everything until
   * the end of the struct.
   */
-  struct GNUNET_CRYPTO_RsaSignaturePurpose purpose;
+  struct GNUNET_CRYPTO_EccSignaturePurpose purpose;
  /**
   * The peer providing this service
   */
-  struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded peer;
+  struct GNUNET_CRYPTO_EccPublicKeyBinaryEncoded peer;
  /**
   * The descriptor for the service
diff --git a/src/include/block_gns.h b/src/include/block_gns.h
index 7b4ceed18..2f864f4d3 100644
--- a/src/include/block_gns.h
+++ b/src/include/block_gns.h
@@ -39,12 +39,12 @@ struct GNSNameRecordBlock
  /**
   * The public key of the authority
   */
-  struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded public_key;
+  struct GNUNET_CRYPTO_EccPublicKeyBinaryEncoded public_key;
  /**
   * GNUNET_RSA_Signature using RSA-key generated from the records.
   */
-  struct GNUNET_CRYPTO_RsaSignature signature;
+  struct GNUNET_CRYPTO_EccSignature signature;
  /* number of records that follow */
  uint32_t rd_count GNUNET_PACKED;
diff --git a/src/include/gnunet_consensus_service.h b/src/include/gnunet_consensus_service.h
index f7f784f6e..66d48e0e2 100644
--- a/src/include/gnunet_consensus_service.h
+++ b/src/include/gnunet_consensus_service.h
@@ -4,7 +4,7 @@
      GNUnet is free software; you can redistribute it and/or modify
      it under the terms of the GNU General Public License as published
-      by the Free Software Foundation; either version 2, or (at your
+      by the Free Software Foundation; either version 3, or (at your
      option) any later version.
      GNUnet is distributed in the hope that it will be useful, but
diff --git a/src/include/gnunet_crypto_lib.h b/src/include/gnunet_crypto_lib.h
index a3c4e999f..eb16e0120 100644
--- a/src/include/gnunet_crypto_lib.h
+++ b/src/include/gnunet_crypto_lib.h
@@ -299,10 +299,13 @@ struct GNUNET_CRYPTO_EccPublicKeyBinaryEncoded
 };
+/**
+ * Private ECC key encoded for transmission (with length prefix).
+ */
 struct GNUNET_CRYPTO_EccPrivateKeyBinaryEncoded
 {
  /**
-   * Overall size of the private key.
+   * Overall size of the private key in network byte order.
   */
  uint16_t size;
diff --git a/src/include/gnunet_gns_service.h b/src/include/gnunet_gns_service.h
index 8d2fde3d6..739bfa0f6 100644
--- a/src/include/gnunet_gns_service.h
+++ b/src/include/gnunet_gns_service.h
@@ -173,7 +173,7 @@ GNUNET_GNS_lookup (struct GNUNET_GNS_Handle *handle,
                   const char * name,
                   enum GNUNET_GNS_RecordType type,
                   int only_cached,
-                   struct GNUNET_CRYPTO_RsaPrivateKey *shorten_key,
+                   struct GNUNET_CRYPTO_EccPrivateKey *shorten_key,
                   GNUNET_GNS_LookupResultProcessor proc,
                   void *proc_cls);
@@ -199,7 +199,7 @@ GNUNET_GNS_lookup_zone (struct GNUNET_GNS_Handle *handle,
                        struct GNUNET_CRYPTO_ShortHashCode *zone,
                        enum GNUNET_GNS_RecordType type,
                        int only_cached,
-                        struct GNUNET_CRYPTO_RsaPrivateKey *shorten_key,
+                        struct GNUNET_CRYPTO_EccPrivateKey *shorten_key,
                        GNUNET_GNS_LookupResultProcessor proc,
                        void *proc_cls);
diff --git a/src/include/gnunet_namestore_plugin.h b/src/include/gnunet_namestore_plugin.h
index 1168e0d13..e969170e5 100644
--- a/src/include/gnunet_namestore_plugin.h
+++ b/src/include/gnunet_namestore_plugin.h
@@ -53,12 +53,12 @@ extern "C"
 *        because the user queried for a particular record type only)
 */
 typedef void (*GNUNET_NAMESTORE_RecordIterator) (void *cls,
-                                                 const struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded *zone_key,
+                                                 const struct GNUNET_CRYPTO_EccPublicKeyBinaryEncoded *zone_key,
                                                 struct GNUNET_TIME_Absolute expire,
                                                 const char *name,
                                                 unsigned int rd_len,
                                                 const struct GNUNET_NAMESTORE_RecordData *rd,
-                                                 const struct GNUNET_CRYPTO_RsaSignature *signature);
+                                                 const struct GNUNET_CRYPTO_EccSignature *signature);
 /**
@@ -88,12 +88,12 @@ struct GNUNET_NAMESTORE_PluginFunctions
   * @return GNUNET_OK on success, else GNUNET_SYSERR
   */
  int (*put_records) (void *cls, 
-                      const struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded *zone_key,
+                      const struct GNUNET_CRYPTO_EccPublicKeyBinaryEncoded *zone_key,
                      struct GNUNET_TIME_Absolute expire,
                      const char *name,
                      unsigned int rd_len,
                      const struct GNUNET_NAMESTORE_RecordData *rd,
-                      const struct GNUNET_CRYPTO_RsaSignature *signature);
+                      const struct GNUNET_CRYPTO_EccSignature *signature);
  /**
diff --git a/src/include/gnunet_namestore_service.h b/src/include/gnunet_namestore_service.h
index 4267e2044..38083ed9c 100644
--- a/src/include/gnunet_namestore_service.h
+++ b/src/include/gnunet_namestore_service.h
@@ -243,12 +243,12 @@ struct GNUNET_NAMESTORE_RecordData
 */
 struct GNUNET_NAMESTORE_QueueEntry *
 GNUNET_NAMESTORE_record_put (struct GNUNET_NAMESTORE_Handle *h,
-                             const struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded *zone_key,
+                             const struct GNUNET_CRYPTO_EccPublicKeyBinaryEncoded *zone_key,
                             const char *name,
                             struct GNUNET_TIME_Absolute freshness,
                             unsigned int rd_count,
                             const struct GNUNET_NAMESTORE_RecordData *rd,
-                             const struct GNUNET_CRYPTO_RsaSignature *signature,
+                             const struct GNUNET_CRYPTO_EccSignature *signature,
                             GNUNET_NAMESTORE_ContinuationWithStatus cont,
                             void *cont_cls);
@@ -266,12 +266,12 @@ GNUNET_NAMESTORE_record_put (struct GNUNET_NAMESTORE_Handle *h,
 * @return GNUNET_OK if the signature is valid
 */
 int
-GNUNET_NAMESTORE_verify_signature (const struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded *public_key,
+GNUNET_NAMESTORE_verify_signature (const struct GNUNET_CRYPTO_EccPublicKeyBinaryEncoded *public_key,
                                   const struct GNUNET_TIME_Absolute freshness,
                                   const char *name,
                                   unsigned int rd_count,
                                   const struct GNUNET_NAMESTORE_RecordData *rd,
-                                   const struct GNUNET_CRYPTO_RsaSignature *signature);
+                                   const struct GNUNET_CRYPTO_EccSignature *signature);
 /**
@@ -290,7 +290,7 @@ GNUNET_NAMESTORE_verify_signature (const struct GNUNET_CRYPTO_RsaPublicKeyBinary
 */
 struct GNUNET_NAMESTORE_QueueEntry *
 GNUNET_NAMESTORE_record_create (struct GNUNET_NAMESTORE_Handle *h,
-                                const struct GNUNET_CRYPTO_RsaPrivateKey *pkey,
+                                const struct GNUNET_CRYPTO_EccPrivateKey *pkey,
                                const char *name,
                                const struct GNUNET_NAMESTORE_RecordData *rd,
                                GNUNET_NAMESTORE_ContinuationWithStatus cont,
@@ -314,7 +314,7 @@ GNUNET_NAMESTORE_record_create (struct GNUNET_NAMESTORE_Handle *h,
 */
 struct GNUNET_NAMESTORE_QueueEntry *
 GNUNET_NAMESTORE_record_remove (struct GNUNET_NAMESTORE_Handle *h,
-                                const struct GNUNET_CRYPTO_RsaPrivateKey *pkey,
+                                const struct GNUNET_CRYPTO_EccPrivateKey *pkey,
                                const char *name,
                                const struct GNUNET_NAMESTORE_RecordData *rd,
                                GNUNET_NAMESTORE_ContinuationWithStatus cont,
@@ -338,12 +338,12 @@ GNUNET_NAMESTORE_record_remove (struct GNUNET_NAMESTORE_Handle *h,
 *        because the user queried for a particular record type only)
 */
 typedef void (*GNUNET_NAMESTORE_RecordProcessor) (void *cls,
-                                                  const struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded *zone_key,
+                                                  const struct GNUNET_CRYPTO_EccPublicKeyBinaryEncoded *zone_key,
                                                  struct GNUNET_TIME_Absolute freshness,                            
                                                  const char *name,
                                                  unsigned int rd_len,
                                                  const struct GNUNET_NAMESTORE_RecordData *rd,
-                                                  const struct GNUNET_CRYPTO_RsaSignature *signature);
+                                                  const struct GNUNET_CRYPTO_EccSignature *signature);
 /**
diff --git a/src/namestore/gnunet-namestore.c b/src/namestore/gnunet-namestore.c
index a79ec5e78..699df0670 100644
--- a/src/namestore/gnunet-namestore.c
+++ b/src/namestore/gnunet-namestore.c
@@ -36,7 +36,7 @@
 /**
 * Hostkey generation context
 */
-struct GNUNET_CRYPTO_RsaKeyGenerationContext * keygen;
+struct GNUNET_CRYPTO_EccKeyGenerationContext * keygen;
 /**
 * Handle to the namestore.
@@ -51,7 +51,7 @@ static struct GNUNET_CRYPTO_ShortHashCode zone;
 /**
 * Private key for the our zone.
 */
-static struct GNUNET_CRYPTO_RsaPrivateKey *zone_pkey;
+static struct GNUNET_CRYPTO_EccPrivateKey *zone_pkey;
 /**
 * Keyfile to manipulate.
@@ -146,7 +146,7 @@ do_shutdown (void *cls,
 {
  if (NULL != keygen)
  {
-    GNUNET_CRYPTO_rsa_key_create_stop (keygen);
+    GNUNET_CRYPTO_ecc_key_create_stop (keygen);
    keygen = NULL;
  }
@@ -177,7 +177,7 @@ do_shutdown (void *cls,
  }
  if (NULL != zone_pkey)
  {
-    GNUNET_CRYPTO_rsa_key_free (zone_pkey);
+    GNUNET_CRYPTO_ecc_key_free (zone_pkey);
    zone_pkey = NULL;
  }
  if (NULL != uri)
@@ -267,12 +267,12 @@ del_continuation (void *cls,
 */
 static void
 display_record (void *cls,
-                const struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded *zone_key,
+                const struct GNUNET_CRYPTO_EccPublicKeyBinaryEncoded *zone_key,
                struct GNUNET_TIME_Absolute expire,                         
                const char *name,
                unsigned int rd_len,
                const struct GNUNET_NAMESTORE_RecordData *rd,
-                const struct GNUNET_CRYPTO_RsaSignature *signature)
+                const struct GNUNET_CRYPTO_EccSignature *signature)
 {
  const char *typestring;
  char *s;
@@ -328,11 +328,11 @@ display_record (void *cls,
 static void
 key_generation_cb (void *cls,
-                   struct GNUNET_CRYPTO_RsaPrivateKey *pk,
+                   struct GNUNET_CRYPTO_EccPrivateKey *pk,
                   const char *emsg)
 {
  struct GNUNET_CONFIGURATION_Handle *cfg = cls;
-  struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded pub;
+  struct GNUNET_CRYPTO_EccPublicKeyBinaryEncoded pub;
  uint32_t type;
  void *data = NULL;
  size_t data_size = 0;
@@ -354,7 +354,7 @@ key_generation_cb (void *cls,
    /* nothing more to be done */  
    fprintf (stderr,
             _("No options given\n"));
-    GNUNET_CRYPTO_rsa_key_free (zone_pkey);
+    GNUNET_CRYPTO_ecc_key_free (zone_pkey);
    zone_pkey = NULL;
    return; 
  }
@@ -364,7 +364,7 @@ key_generation_cb (void *cls,
                _("Failed to read or create private zone key\n"));
    return;
  }
-  GNUNET_CRYPTO_rsa_key_get_public (zone_pkey,
+  GNUNET_CRYPTO_ecc_key_get_public (zone_pkey,
                                    &pub);
  GNUNET_CRYPTO_short_hash (&pub, sizeof (pub), &zone);
@@ -625,7 +625,7 @@ testservice_task (void *cls,
             _("Using default zone file `%s'\n"),
             keyfile);
  }
-  keygen = GNUNET_CRYPTO_rsa_key_create_start (keyfile, key_generation_cb, cfg);
+  keygen = GNUNET_CRYPTO_ecc_key_create_start (keyfile, key_generation_cb, cfg);
  GNUNET_free (keyfile);
  keyfile = NULL;
  if (NULL == keygen)
diff --git a/src/namestore/gnunet-service-namestore.c b/src/namestore/gnunet-service-namestore.c
index a14ad923d..02f33679b 100644
--- a/src/namestore/gnunet-service-namestore.c
+++ b/src/namestore/gnunet-service-namestore.c
@@ -143,7 +143,7 @@ struct GNUNET_NAMESTORE_CryptoContainer
  /**
   * Zone's private key
   */
-  struct GNUNET_CRYPTO_RsaPrivateKey *privkey;
+  struct GNUNET_CRYPTO_EccPrivateKey *privkey;
 };
@@ -205,7 +205,7 @@ struct KeyLoadContext
 {
  struct KeyLoadContext *next;
  struct KeyLoadContext *prev;
-  struct GNUNET_CRYPTO_RsaKeyGenerationContext *keygen;
+  struct GNUNET_CRYPTO_EccKeyGenerationContext *keygen;
  char *filename;
  unsigned int *counter;
 };
@@ -222,19 +222,19 @@ static int
 write_key_to_file (const char *filename, 
                   struct GNUNET_NAMESTORE_CryptoContainer *c)
 {
-  struct GNUNET_CRYPTO_RsaPrivateKey *ret = c->privkey;
+  struct GNUNET_CRYPTO_EccPrivateKey *ret = c->privkey;
-  struct GNUNET_CRYPTO_RsaPrivateKeyBinaryEncoded *enc;
+  struct GNUNET_CRYPTO_EccPrivateKeyBinaryEncoded *enc;
  struct GNUNET_DISK_FileHandle *fd;
  struct GNUNET_CRYPTO_ShortHashCode zone;
-  struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded pubkey;
+  struct GNUNET_CRYPTO_EccPublicKeyBinaryEncoded pubkey;
-  struct GNUNET_CRYPTO_RsaPrivateKey *privkey;
+  struct GNUNET_CRYPTO_EccPrivateKey *privkey;
  fd = GNUNET_DISK_file_open (filename, 
                              GNUNET_DISK_OPEN_WRITE | GNUNET_DISK_OPEN_CREATE | GNUNET_DISK_OPEN_FAILIFEXISTS, 
                              GNUNET_DISK_PERM_USER_READ | GNUNET_DISK_PERM_USER_WRITE);
  if ( (NULL == fd) && (EEXIST == errno) )
  {
-    privkey = GNUNET_CRYPTO_rsa_key_create_from_file (filename);
+    privkey = GNUNET_CRYPTO_ecc_key_create_from_file (filename);
    if (NULL == privkey)
    {
      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
@@ -243,9 +243,9 @@ write_key_to_file (const char *filename,
                  _("file exists but reading key failed"));
      return GNUNET_SYSERR;
    }
-    GNUNET_CRYPTO_rsa_key_get_public (privkey, &pubkey);
+    GNUNET_CRYPTO_ecc_key_get_public (privkey, &pubkey);
-    GNUNET_CRYPTO_short_hash (&pubkey, sizeof (struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded), &zone);
+    GNUNET_CRYPTO_short_hash (&pubkey, sizeof (struct GNUNET_CRYPTO_EccPublicKeyBinaryEncoded), &zone);
-    GNUNET_CRYPTO_rsa_key_free (privkey);
+    GNUNET_CRYPTO_ecc_key_free (privkey);
    if (0 == memcmp (&zone, &c->zone, sizeof(zone)))
    {
      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
@@ -264,17 +264,17 @@ write_key_to_file (const char *filename,
    LOG_STRERROR_FILE (GNUNET_ERROR_TYPE_ERROR, "open", filename);
    return GNUNET_SYSERR;
  }
-  if (GNUNET_YES != GNUNET_DISK_file_lock (fd, 0, sizeof (struct GNUNET_CRYPTO_RsaPrivateKeyBinaryEncoded), GNUNET_YES))
+  if (GNUNET_YES != GNUNET_DISK_file_lock (fd, 0, sizeof (struct GNUNET_CRYPTO_EccPrivateKeyBinaryEncoded), GNUNET_YES))
  {
    GNUNET_break (GNUNET_YES == GNUNET_DISK_file_close (fd));
    return GNUNET_SYSERR;
  }
-  enc = GNUNET_CRYPTO_rsa_encode_key (ret);
+  enc = GNUNET_CRYPTO_ecc_encode_key (ret);
  GNUNET_assert (NULL != enc);
-  GNUNET_assert (ntohs (enc->len) == GNUNET_DISK_file_write (fd, enc, ntohs (enc->len)));
+  GNUNET_assert (ntohs (enc->size) == GNUNET_DISK_file_write (fd, enc, ntohs (enc->size)));
  GNUNET_free (enc);
  GNUNET_DISK_file_sync (fd);
-  if (GNUNET_YES != GNUNET_DISK_file_unlock (fd, 0, sizeof (struct GNUNET_CRYPTO_RsaPrivateKeyBinaryEncoded)))
+  if (GNUNET_YES != GNUNET_DISK_file_unlock (fd, 0, sizeof (struct GNUNET_CRYPTO_EccPrivateKeyBinaryEncoded)))
    LOG_STRERROR_FILE (GNUNET_ERROR_TYPE_WARNING, "fcntl", filename);
  GNUNET_assert (GNUNET_YES == GNUNET_DISK_file_close (fd));
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
@@ -308,7 +308,7 @@ zone_to_disk_it (void *cls,
                    GNUNET_short_h2s (&c->zone));
  (void) write_key_to_file(c->filename, c);
  GNUNET_assert (GNUNET_OK == GNUNET_CONTAINER_multihashmap_remove (zonekeys, key, value));
-  GNUNET_CRYPTO_rsa_key_free (c->privkey);
+  GNUNET_CRYPTO_ecc_key_free (c->privkey);
  GNUNET_free (c->filename);
  GNUNET_free (c);
  return GNUNET_OK;
@@ -323,22 +323,22 @@ zone_to_disk_it (void *cls,
 *        be taken over or freed and should not be used afterwards)
 */
 static void
-learn_private_key (struct GNUNET_CRYPTO_RsaPrivateKey *pkey)
+learn_private_key (struct GNUNET_CRYPTO_EccPrivateKey *pkey)
 {
-  struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded pub;
+  struct GNUNET_CRYPTO_EccPublicKeyBinaryEncoded pub;
  struct GNUNET_HashCode long_hash;
  struct GNUNET_CRYPTO_ShortHashCode pubkey_hash;
  struct GNUNET_NAMESTORE_CryptoContainer *cc;
-  GNUNET_CRYPTO_rsa_key_get_public (pkey, &pub);
+  GNUNET_CRYPTO_ecc_key_get_public (pkey, &pub);
  GNUNET_CRYPTO_short_hash (&pub,
-                            sizeof (struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded),
+                            sizeof (struct GNUNET_CRYPTO_EccPublicKeyBinaryEncoded),
                            &pubkey_hash);
  GNUNET_CRYPTO_short_hash_double (&pubkey_hash, &long_hash);
  if (GNUNET_NO != GNUNET_CONTAINER_multihashmap_contains(zonekeys, &long_hash))
  {
-    GNUNET_CRYPTO_rsa_key_free (pkey);
+    GNUNET_CRYPTO_ecc_key_free (pkey);
    return;
  }  
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, 
@@ -414,7 +414,7 @@ cleanup_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
  {
    GNUNET_CONTAINER_DLL_remove (kl_head, kl_tail, kl);
    if (NULL != kl->keygen)
-      GNUNET_CRYPTO_rsa_key_create_stop (kl->keygen);
+      GNUNET_CRYPTO_ecc_key_create_stop (kl->keygen);
    GNUNET_free (kl->filename);
    GNUNET_free (kl);
  }
@@ -570,18 +570,18 @@ struct LookupNameContext
 */
 static void
 handle_lookup_name_it (void *cls,
-                       const struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded *zone_key,
+                       const struct GNUNET_CRYPTO_EccPublicKeyBinaryEncoded *zone_key,
                       struct GNUNET_TIME_Absolute expire,
                       const char *name,
                       unsigned int rd_count,
                       const struct GNUNET_NAMESTORE_RecordData *rd,
-                       const struct GNUNET_CRYPTO_RsaSignature *signature)
+                       const struct GNUNET_CRYPTO_EccSignature *signature)
 {
  struct LookupNameContext *lnc = cls;
  struct LookupNameResponseMessage *lnr_msg;
  struct GNUNET_NAMESTORE_RecordData *rd_selected;
  struct GNUNET_NAMESTORE_CryptoContainer *cc;
-  struct GNUNET_CRYPTO_RsaSignature *signature_new;
+  struct GNUNET_CRYPTO_EccSignature *signature_new;
  struct GNUNET_TIME_Absolute e;
  struct GNUNET_TIME_Relative re;
  struct GNUNET_CRYPTO_ShortHashCode zone_key_hash;
@@ -607,7 +607,7 @@ handle_lookup_name_it (void *cls,
  if (NULL != zone_key) 
  {
    GNUNET_CRYPTO_short_hash (zone_key, 
-                              sizeof (struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded), 
+                              sizeof (struct GNUNET_CRYPTO_EccPublicKeyBinaryEncoded), 
                              &zone_key_hash);
    GNUNET_CRYPTO_short_hash_double (&zone_key_hash, &long_hash);
    if (NULL != (cc = GNUNET_CONTAINER_multihashmap_get (zonekeys, &long_hash)))   
@@ -728,7 +728,7 @@ handle_lookup_name_it (void *cls,
  rd_ser_len = GNUNET_NAMESTORE_records_get_size (copied_elements, rd_selected);
  name_len = (NULL == name) ? 0 : strlen(name) + 1;
  r_size = sizeof (struct LookupNameResponseMessage) +
-           sizeof (struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded) +
+           sizeof (struct GNUNET_CRYPTO_EccPublicKeyBinaryEncoded) +
           name_len +
           rd_ser_len;
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, 
@@ -885,7 +885,7 @@ handle_record_put (void *cls,
  struct GNUNET_NAMESTORE_Client *nc;
  const struct RecordPutMessage *rp_msg;
  struct GNUNET_TIME_Absolute expire;
-  const struct GNUNET_CRYPTO_RsaSignature *signature;
+  const struct GNUNET_CRYPTO_EccSignature *signature;
  struct RecordPutResponseMessage rpr_msg;
  struct GNUNET_CRYPTO_ShortHashCode zone_hash;
  size_t name_len;
@@ -1008,7 +1008,7 @@ struct CreateRecordContext
  /**
   * Zone's public key
   */
-  struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded pubkey;
+  struct GNUNET_CRYPTO_EccPublicKeyBinaryEncoded pubkey;
  /**
   * Name for the record to create
@@ -1044,14 +1044,14 @@ struct CreateRecordContext
 */
 static void
 handle_create_record_it (void *cls,
-                         const struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded *pubkey,
+                         const struct GNUNET_CRYPTO_EccPublicKeyBinaryEncoded *pubkey,
                         struct GNUNET_TIME_Absolute expire,
                         const char *name,
                         unsigned int rd_count,
                         const struct GNUNET_NAMESTORE_RecordData *rd,
-                         const struct GNUNET_CRYPTO_RsaSignature *signature)
+                         const struct GNUNET_CRYPTO_EccSignature *signature)
 {
-  static struct GNUNET_CRYPTO_RsaSignature dummy_signature;
+  static struct GNUNET_CRYPTO_EccSignature dummy_signature;
  struct CreateRecordContext *crc = cls;
  struct GNUNET_NAMESTORE_RecordData *rd_new;
  struct GNUNET_TIME_Absolute block_expiration;
@@ -1159,7 +1159,7 @@ handle_record_create (void *cls,
  struct GNUNET_NAMESTORE_Client *nc;
  const struct RecordCreateMessage *rp_msg;
  struct CreateRecordContext crc;
-  struct GNUNET_CRYPTO_RsaPrivateKey *pkey;
+  struct GNUNET_CRYPTO_EccPrivateKey *pkey;
  struct RecordCreateResponseMessage rcr_msg;
  size_t name_len;
  size_t msg_size;
@@ -1219,7 +1219,8 @@ handle_record_create (void *cls,
    GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
    return;
  }
-  if (NULL == (pkey = GNUNET_CRYPTO_rsa_decode_key (pkey_tmp, key_len)))
+  if (NULL == (pkey = GNUNET_CRYPTO_ecc_decode_key (pkey_tmp, key_len,
+                                                    GNUNET_NO)))
  {
    GNUNET_break (0);
    GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
@@ -1229,15 +1230,15 @@ handle_record_create (void *cls,
      GNUNET_NAMESTORE_records_deserialize (rd_ser_len, rd_ser, rd_count, &rd))
  {
    GNUNET_break (0);
-    GNUNET_CRYPTO_rsa_key_free (pkey);
+    GNUNET_CRYPTO_ecc_key_free (pkey);
    GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
    return;
  }
  /* Extracting and converting private key */
-  GNUNET_CRYPTO_rsa_key_get_public (pkey, &crc.pubkey);
+  GNUNET_CRYPTO_ecc_key_get_public (pkey, &crc.pubkey);
  GNUNET_CRYPTO_short_hash (&crc.pubkey,
-                            sizeof (struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded),
+                            sizeof (struct GNUNET_CRYPTO_EccPublicKeyBinaryEncoded),
                            &pubkey_hash);
  learn_private_key (pkey);
@@ -1318,14 +1319,14 @@ struct RemoveRecordContext
 */
 static void
 handle_record_remove_it (void *cls,
-                         const struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded *zone_key,
+                         const struct GNUNET_CRYPTO_EccPublicKeyBinaryEncoded *zone_key,
                         struct GNUNET_TIME_Absolute expire,
                         const char *name,
                         unsigned int rd_count,
                         const struct GNUNET_NAMESTORE_RecordData *rd,
-                         const struct GNUNET_CRYPTO_RsaSignature *signature)
+                         const struct GNUNET_CRYPTO_EccSignature *signature)
 {
-  static struct GNUNET_CRYPTO_RsaSignature dummy_signature;
+  static struct GNUNET_CRYPTO_EccSignature dummy_signature;
  struct RemoveRecordContext *rrc = cls;
  unsigned int c;
  int found;
@@ -1364,7 +1365,7 @@ handle_record_remove_it (void *cls,
                "No records left for name `%s', removing name\n",
                name);
    GNUNET_CRYPTO_short_hash (zone_key, 
-                              sizeof (struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded), 
+                              sizeof (struct GNUNET_CRYPTO_EccPublicKeyBinaryEncoded), 
                              &pubkey_hash);
    if (GNUNET_OK !=
        GSN_database->remove_records (GSN_database->cls,
@@ -1421,8 +1422,8 @@ handle_record_remove (void *cls,
  struct GNUNET_NAMESTORE_Client *nc;
  const struct RecordRemoveMessage *rr_msg;
  struct RecordRemoveResponseMessage rrr_msg;
-  struct GNUNET_CRYPTO_RsaPrivateKey *pkey;
+  struct GNUNET_CRYPTO_EccPrivateKey *pkey;
-  struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded pub;
+  struct GNUNET_CRYPTO_EccPublicKeyBinaryEncoded pub;
  struct GNUNET_CRYPTO_ShortHashCode pubkey_hash;
  struct GNUNET_NAMESTORE_RecordData rd;
  const char *pkey_tmp;
@@ -1484,15 +1485,16 @@ handle_record_remove (void *cls,
    GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
    return;
  }
-  if (NULL == (pkey = GNUNET_CRYPTO_rsa_decode_key (pkey_tmp, key_len)))
+  if (NULL == (pkey = GNUNET_CRYPTO_ecc_decode_key (pkey_tmp, key_len,
+                                                    GNUNET_NO)))
  {
    GNUNET_break (0);
    GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
    return;
  }
-  GNUNET_CRYPTO_rsa_key_get_public (pkey, &pub);
+  GNUNET_CRYPTO_ecc_key_get_public (pkey, &pub);
  GNUNET_CRYPTO_short_hash (&pub, 
-                            sizeof (struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded), 
+                            sizeof (struct GNUNET_CRYPTO_EccPublicKeyBinaryEncoded), 
                            &pubkey_hash);
  learn_private_key (pkey);
  if (GNUNET_OK !=
@@ -1618,12 +1620,12 @@ struct ZoneToNameCtx
 */
 static void
 handle_zone_to_name_it (void *cls,
-                        const struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded *zone_key,
+                        const struct GNUNET_CRYPTO_EccPublicKeyBinaryEncoded *zone_key,
                        struct GNUNET_TIME_Absolute expire,
                        const char *name,
                        unsigned int rd_count,
                        const struct GNUNET_NAMESTORE_RecordData *rd,
-                        const struct GNUNET_CRYPTO_RsaSignature *signature)
+                        const struct GNUNET_CRYPTO_EccSignature *signature)
 {
  struct ZoneToNameCtx *ztn_ctx = cls;
  struct ZoneToNameResponseMessage *ztnr_msg;
@@ -1658,7 +1660,7 @@ handle_zone_to_name_it (void *cls,
  rd_ser_len = GNUNET_NAMESTORE_records_get_size (rd_count, rd);
  msg_size = sizeof (struct ZoneToNameResponseMessage) + name_len + rd_ser_len;
  if (NULL != signature)
-    msg_size += sizeof (struct GNUNET_CRYPTO_RsaSignature);
+    msg_size += sizeof (struct GNUNET_CRYPTO_EccSignature);
  if (msg_size >= GNUNET_SERVER_MAX_MESSAGE_SIZE)
  {
    GNUNET_break (0);
@@ -1683,7 +1685,7 @@ handle_zone_to_name_it (void *cls,
  GNUNET_NAMESTORE_records_serialize (rd_count, rd, rd_ser_len, rd_tmp);
  sig_tmp = &rd_tmp[rd_ser_len];
  if (NULL != signature)
-    memcpy (sig_tmp, signature, sizeof (struct GNUNET_CRYPTO_RsaSignature));
+    memcpy (sig_tmp, signature, sizeof (struct GNUNET_CRYPTO_EccSignature));
  ztn_ctx->success = GNUNET_OK;
  GNUNET_SERVER_notification_context_unicast (snc, ztn_ctx->nc->client,
                                              &ztnr_msg->gns_header.header,
@@ -1797,16 +1799,16 @@ struct ZoneIterationProcResult
 */
 static void
 zone_iteraterate_proc (void *cls,
-                       const struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded *zone_key,
+                       const struct GNUNET_CRYPTO_EccPublicKeyBinaryEncoded *zone_key,
                       struct GNUNET_TIME_Absolute expire,
                       const char *name,
                       unsigned int rd_count,
                       const struct GNUNET_NAMESTORE_RecordData *rd,
-                       const struct GNUNET_CRYPTO_RsaSignature *signature)
+                       const struct GNUNET_CRYPTO_EccSignature *signature)
 {
  struct ZoneIterationProcResult *proc = cls;
  struct GNUNET_NAMESTORE_RecordData rd_filtered[rd_count];
-  struct GNUNET_CRYPTO_RsaSignature *new_signature = NULL;
+  struct GNUNET_CRYPTO_EccSignature *new_signature = NULL;
  struct GNUNET_NAMESTORE_CryptoContainer *cc;
  struct GNUNET_HashCode long_hash;
  struct GNUNET_CRYPTO_ShortHashCode zone_hash;
@@ -1884,7 +1886,7 @@ zone_iteraterate_proc (void *cls,
    /* compute / obtain signature, but only if we (a) have records and (b) expiration times were 
       converted to absolute expiration times */
    GNUNET_CRYPTO_short_hash (zone_key, 
-                              sizeof (struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded),
+                              sizeof (struct GNUNET_CRYPTO_EccPublicKeyBinaryEncoded),
                              &zone_hash);
    GNUNET_CRYPTO_short_hash_double (&zone_hash, &long_hash);
    if (NULL != (cc = GNUNET_CONTAINER_multihashmap_get(zonekeys, &long_hash)))
@@ -2160,7 +2162,7 @@ handle_iteration_next (void *cls,
 static void
 zonekey_it_key_cb (void *cls,
-                   struct GNUNET_CRYPTO_RsaPrivateKey *pk,
+                   struct GNUNET_CRYPTO_EccPrivateKey *pk,
                   const char *emsg)
 {
  struct KeyLoadContext *kl = cls;
@@ -2201,7 +2203,7 @@ zonekey_file_it (void *cls, const char *filename)
  kl = GNUNET_malloc (sizeof (struct KeyLoadContext));
  kl->filename = strdup (filename);
  kl->counter = cls;
-  kl->keygen = GNUNET_CRYPTO_rsa_key_create_start (filename, zonekey_it_key_cb, kl);
+  kl->keygen = GNUNET_CRYPTO_ecc_key_create_start (filename, zonekey_it_key_cb, kl);
  if (NULL == kl->keygen)
  {
    GNUNET_free (kl->filename);
diff --git a/src/namestore/namestore.h b/src/namestore/namestore.h
index 0e7ecfda3..b0d3ffad0 100644
--- a/src/namestore/namestore.h
+++ b/src/namestore/namestore.h
@@ -62,8 +62,8 @@ GNUNET_short_h2s (const struct GNUNET_CRYPTO_ShortHashCode * hc);
 *
 * @return the signature
 */
-struct GNUNET_CRYPTO_RsaSignature *
+struct GNUNET_CRYPTO_EccSignature *
-GNUNET_NAMESTORE_create_signature (const struct GNUNET_CRYPTO_RsaPrivateKey *key,
+GNUNET_NAMESTORE_create_signature (const struct GNUNET_CRYPTO_EccPrivateKey *key,
    struct GNUNET_TIME_Absolute expire,
    const char *name,
    const struct GNUNET_NAMESTORE_RecordData *rd,
@@ -212,12 +212,12 @@ struct LookupNameResponseMessage
  /**
   * All zeros if 'contains_sig' is GNUNET_NO.
   */
-  struct GNUNET_CRYPTO_RsaSignature signature;
+  struct GNUNET_CRYPTO_EccSignature signature;
  /**
   * The public key for the name
   */
-  struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded public_key;
+  struct GNUNET_CRYPTO_EccPublicKeyBinaryEncoded public_key;
  /* 0-terminated name and serialized record data */
  /* rd_len bytes serialized record data */
@@ -262,12 +262,12 @@ struct RecordPutMessage
  /**
   * The signature
   */
-  struct GNUNET_CRYPTO_RsaSignature signature;
+  struct GNUNET_CRYPTO_EccSignature signature;
  /**
   * The public key
   */
-  struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded public_key;
+  struct GNUNET_CRYPTO_EccPublicKeyBinaryEncoded public_key;
  /* name (0-terminated) followed by "rd_count" serialized records */
@@ -327,7 +327,7 @@ struct RecordCreateMessage
  uint16_t pkey_len;
  /* followed by:
-   * GNUNET_CRYPTO_RsaPrivateKeyBinaryEncoded private key with length pkey_len
+   * GNUNET_CRYPTO_EccPrivateKeyBinaryEncoded private key with length pkey_len
   * name with length name_len
   * serialized record data with length rd_len
   * */
@@ -383,7 +383,7 @@ struct RecordRemoveMessage
  uint16_t pkey_len;
  /* followed by:
-   * GNUNET_CRYPTO_RsaPrivateKeyBinaryEncoded private key with length pkey_len
+   * GNUNET_CRYPTO_EccPrivateKeyBinaryEncoded private key with length pkey_len
   * name with length name_len
   * serialized record data with length rd_len
   * */
@@ -507,12 +507,12 @@ struct ZoneToNameResponseMessage
  /**
   * Signature
   */
-  struct GNUNET_CRYPTO_RsaSignature signature;
+  struct GNUNET_CRYPTO_EccSignature signature;
  /**
   * Publik key
   */
-  struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded zone_key;
+  struct GNUNET_CRYPTO_EccPublicKeyBinaryEncoded zone_key;
 };
@@ -600,12 +600,12 @@ struct ZoneIterationResponseMessage
  /**
   * All zeros if 'contains_sig' is GNUNET_NO.
   */
-  struct GNUNET_CRYPTO_RsaSignature signature;
+  struct GNUNET_CRYPTO_EccSignature signature;
  /**
   * The public key
   */
-  struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded public_key;
+  struct GNUNET_CRYPTO_EccPublicKeyBinaryEncoded public_key;
 
 
diff --git a/src/namestore/namestore_api.c b/src/namestore/namestore_api.c
index 5e82e08ba..7a7c3eabb 100644
--- a/src/namestore/namestore_api.c
+++ b/src/namestore/namestore_api.c
@@ -264,9 +264,9 @@ handle_lookup_name_response (struct GNUNET_NAMESTORE_QueueEntry *qe,
 {
  const char *name;
  const char * rd_tmp;
-  const struct GNUNET_CRYPTO_RsaSignature *signature;
+  const struct GNUNET_CRYPTO_EccSignature *signature;
  struct GNUNET_TIME_Absolute expire;
-  const struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded *public_key_tmp;
+  const struct GNUNET_CRYPTO_EccPublicKeyBinaryEncoded *public_key_tmp;
  size_t exp_msg_len;
  size_t msg_len;
  size_t name_len;
@@ -282,7 +282,7 @@ handle_lookup_name_response (struct GNUNET_NAMESTORE_QueueEntry *qe,
  contains_sig = ntohs (msg->contains_sig);
  expire = GNUNET_TIME_absolute_ntoh (msg->expire);
  exp_msg_len = sizeof (struct LookupNameResponseMessage) +
-      sizeof (struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded) +
+      sizeof (struct GNUNET_CRYPTO_EccPublicKeyBinaryEncoded) +
      name_len + rd_len;
  if (msg_len != exp_msg_len)
  {
@@ -589,7 +589,7 @@ handle_zone_iteration_response (struct GNUNET_NAMESTORE_ZoneIterator *ze,
                                const struct ZoneIterationResponseMessage *msg,
                                size_t size)
 {
-  struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded pubdummy;
+  struct GNUNET_CRYPTO_EccPublicKeyBinaryEncoded pubdummy;
  size_t msg_len;
  size_t exp_msg_len;
  size_t name_len;
@@ -1003,12 +1003,12 @@ GNUNET_NAMESTORE_disconnect (struct GNUNET_NAMESTORE_Handle *h)
 */
 struct GNUNET_NAMESTORE_QueueEntry *
 GNUNET_NAMESTORE_record_put (struct GNUNET_NAMESTORE_Handle *h,
-                             const struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded *zone_key,
+                             const struct GNUNET_CRYPTO_EccPublicKeyBinaryEncoded *zone_key,
                             const char *name,
                             struct GNUNET_TIME_Absolute freshness,
                             unsigned int rd_count,
                             const struct GNUNET_NAMESTORE_RecordData *rd,
-                             const struct GNUNET_CRYPTO_RsaSignature *signature,
+                             const struct GNUNET_CRYPTO_EccSignature *signature,
                             GNUNET_NAMESTORE_ContinuationWithStatus cont,
                             void *cont_cls)
 {
@@ -1088,18 +1088,18 @@ GNUNET_NAMESTORE_record_put (struct GNUNET_NAMESTORE_Handle *h,
 * @return GNUNET_OK if the signature is valid
 */
 int
-GNUNET_NAMESTORE_verify_signature (const struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded *public_key,
+GNUNET_NAMESTORE_verify_signature (const struct GNUNET_CRYPTO_EccPublicKeyBinaryEncoded *public_key,
                                   const struct GNUNET_TIME_Absolute freshness,
                                   const char *name,
                                   unsigned int rd_count,
                                   const struct GNUNET_NAMESTORE_RecordData *rd,
-                                   const struct GNUNET_CRYPTO_RsaSignature *signature)
+                                   const struct GNUNET_CRYPTO_EccSignature *signature)
 {
  size_t rd_ser_len;
  size_t name_len;
  char *name_tmp;
  char *rd_ser;
-  struct GNUNET_CRYPTO_RsaSignaturePurpose *sig_purpose;
+  struct GNUNET_CRYPTO_EccSignaturePurpose *sig_purpose;
  struct GNUNET_TIME_AbsoluteNBO *expire_tmp;
  struct GNUNET_TIME_AbsoluteNBO expire_nbo = GNUNET_TIME_absolute_hton (freshness);
  uint32_t sig_len;
@@ -1115,11 +1115,11 @@ GNUNET_NAMESTORE_verify_signature (const struct GNUNET_CRYPTO_RsaPublicKeyBinary
    return GNUNET_SYSERR;
  }
  rd_ser_len = GNUNET_NAMESTORE_records_get_size (rd_count, rd);
-  sig_len = sizeof (struct GNUNET_CRYPTO_RsaSignaturePurpose) + sizeof (struct GNUNET_TIME_AbsoluteNBO) + rd_ser_len + name_len;
+  sig_len = sizeof (struct GNUNET_CRYPTO_EccSignaturePurpose) + sizeof (struct GNUNET_TIME_AbsoluteNBO) + rd_ser_len + name_len;
  {
    char sig_buf[sig_len] GNUNET_ALIGN;
-    sig_purpose = (struct GNUNET_CRYPTO_RsaSignaturePurpose *) sig_buf;
+    sig_purpose = (struct GNUNET_CRYPTO_EccSignaturePurpose *) sig_buf;
    sig_purpose->size = htonl (sig_len);
    sig_purpose->purpose = htonl (GNUNET_SIGNATURE_PURPOSE_GNS_RECORD_SIGN);
    expire_tmp = (struct GNUNET_TIME_AbsoluteNBO *) &sig_purpose[1];
@@ -1129,7 +1129,7 @@ GNUNET_NAMESTORE_verify_signature (const struct GNUNET_CRYPTO_RsaPublicKeyBinary
    rd_ser = &name_tmp[name_len];
    GNUNET_assert (rd_ser_len ==
                   GNUNET_NAMESTORE_records_serialize (rd_count, rd, rd_ser_len, rd_ser));
-    return GNUNET_CRYPTO_rsa_verify (GNUNET_SIGNATURE_PURPOSE_GNS_RECORD_SIGN, sig_purpose, signature, public_key);
+    return GNUNET_CRYPTO_ecc_verify (GNUNET_SIGNATURE_PURPOSE_GNS_RECORD_SIGN, sig_purpose, signature, public_key);
  }
 }
@@ -1149,7 +1149,7 @@ GNUNET_NAMESTORE_verify_signature (const struct GNUNET_CRYPTO_RsaPublicKeyBinary
 */
 struct GNUNET_NAMESTORE_QueueEntry *
 GNUNET_NAMESTORE_record_create (struct GNUNET_NAMESTORE_Handle *h,
-                                const struct GNUNET_CRYPTO_RsaPrivateKey *pkey,
+                                const struct GNUNET_CRYPTO_EccPrivateKey *pkey,
                                const char *name,
                                const struct GNUNET_NAMESTORE_RecordData *rd,
                                GNUNET_NAMESTORE_ContinuationWithStatus cont,
@@ -1166,7 +1166,7 @@ GNUNET_NAMESTORE_record_create (struct GNUNET_NAMESTORE_Handle *h,
  size_t key_len;
  uint32_t rid;
  struct RecordCreateMessage * msg;
-  struct GNUNET_CRYPTO_RsaPrivateKeyBinaryEncoded * pkey_enc;
+  struct GNUNET_CRYPTO_EccPrivateKeyBinaryEncoded * pkey_enc;
  GNUNET_assert (NULL != h);
  GNUNET_assert (NULL != pkey);
@@ -1190,11 +1190,11 @@ GNUNET_NAMESTORE_record_create (struct GNUNET_NAMESTORE_Handle *h,
  qe->op_id = rid;
  GNUNET_CONTAINER_DLL_insert_tail (h->op_head, h->op_tail, qe);
-  pkey_enc = GNUNET_CRYPTO_rsa_encode_key (pkey);
+  pkey_enc = GNUNET_CRYPTO_ecc_encode_key (pkey);
  GNUNET_assert (NULL != pkey_enc);
  /* setup msg */
-  key_len = ntohs (pkey_enc->len);
+  key_len = ntohs (pkey_enc->size);
  rd_ser_len = GNUNET_NAMESTORE_records_get_size(1, rd);
  msg_size = sizeof (struct RecordCreateMessage) + key_len + name_len + rd_ser_len;
  pe = GNUNET_malloc(sizeof (struct PendingMessage) + msg_size);
@@ -1244,14 +1244,14 @@ GNUNET_NAMESTORE_record_create (struct GNUNET_NAMESTORE_Handle *h,
 */
 struct GNUNET_NAMESTORE_QueueEntry *
 GNUNET_NAMESTORE_record_remove (struct GNUNET_NAMESTORE_Handle *h,
-                                const struct GNUNET_CRYPTO_RsaPrivateKey *pkey,
+                                const struct GNUNET_CRYPTO_EccPrivateKey *pkey,
                                const char *name,
                                const struct GNUNET_NAMESTORE_RecordData *rd,
                                GNUNET_NAMESTORE_ContinuationWithStatus cont,
                                void *cont_cls)
 {
  struct GNUNET_NAMESTORE_QueueEntry *qe;
-  struct GNUNET_CRYPTO_RsaPrivateKeyBinaryEncoded * pkey_enc;
+  struct GNUNET_CRYPTO_EccPrivateKeyBinaryEncoded *pkey_enc;
  struct PendingMessage *pe;
  struct RecordRemoveMessage * msg;
  char *pkey_tmp;
@@ -1282,15 +1282,15 @@ GNUNET_NAMESTORE_record_remove (struct GNUNET_NAMESTORE_Handle *h,
  qe->op_id = rid;
  GNUNET_CONTAINER_DLL_insert_tail (h->op_head, h->op_tail, qe);
-  pkey_enc = GNUNET_CRYPTO_rsa_encode_key (pkey);
+  pkey_enc = GNUNET_CRYPTO_ecc_encode_key (pkey);
  GNUNET_assert (NULL != pkey_enc);
-  key_len = ntohs (pkey_enc->len);
+  key_len = ntohs (pkey_enc->size);
  rd_count = (NULL == rd) ? 0 : 1;
  rd_ser_len = GNUNET_NAMESTORE_records_get_size (rd_count, rd);
  name_len = strlen (name) + 1;
  msg_size = sizeof (struct RecordRemoveMessage) + key_len + name_len + rd_ser_len;
-  pe = GNUNET_malloc(sizeof (struct PendingMessage) + msg_size);
+  pe = GNUNET_malloc (sizeof (struct PendingMessage) + msg_size);
  pe->size = msg_size;
  pe->is_init = GNUNET_NO;
  msg = (struct RecordRemoveMessage *) &pe[1];
diff --git a/src/namestore/namestore_common.c b/src/namestore/namestore_common.c
index 573a8d0a8..826eae504 100644
--- a/src/namestore/namestore_common.c
+++ b/src/namestore/namestore_common.c
@@ -279,15 +279,15 @@ GNUNET_NAMESTORE_records_deserialize (size_t len,
 *
 * @return the signature
 */
-struct GNUNET_CRYPTO_RsaSignature *
+struct GNUNET_CRYPTO_EccSignature *
-GNUNET_NAMESTORE_create_signature (const struct GNUNET_CRYPTO_RsaPrivateKey *key,
+GNUNET_NAMESTORE_create_signature (const struct GNUNET_CRYPTO_EccPrivateKey *key,
                                   struct GNUNET_TIME_Absolute expire,
                                   const char *name,
                                   const struct GNUNET_NAMESTORE_RecordData *rd,
                                   unsigned int rd_count)
 {
-  struct GNUNET_CRYPTO_RsaSignature *sig;
+  struct GNUNET_CRYPTO_EccSignature *sig;
-  struct GNUNET_CRYPTO_RsaSignaturePurpose *sig_purpose;
+  struct GNUNET_CRYPTO_EccSignaturePurpose *sig_purpose;
  struct GNUNET_TIME_AbsoluteNBO expire_nbo;
  size_t rd_ser_len;
  size_t name_len;
@@ -302,7 +302,7 @@ GNUNET_NAMESTORE_create_signature (const struct GNUNET_CRYPTO_RsaPrivateKey *key
    GNUNET_break (0);
    return NULL;
  }
-  sig = GNUNET_malloc (sizeof (struct GNUNET_CRYPTO_RsaSignature));
+  sig = GNUNET_malloc (sizeof (struct GNUNET_CRYPTO_EccSignature));
  name_len = strlen (name) + 1;
  expire_nbo = GNUNET_TIME_absolute_hton (expire);
  rd_ser_len = GNUNET_NAMESTORE_records_get_size (rd_count, rd);
@@ -311,7 +311,7 @@ GNUNET_NAMESTORE_create_signature (const struct GNUNET_CRYPTO_RsaPrivateKey *key
    GNUNET_assert (rd_ser_len ==
                   GNUNET_NAMESTORE_records_serialize (rd_count, rd, rd_ser_len, rd_ser));
-    sig_len = sizeof (struct GNUNET_CRYPTO_RsaSignaturePurpose) + sizeof (struct GNUNET_TIME_AbsoluteNBO) + rd_ser_len + name_len;
+    sig_len = sizeof (struct GNUNET_CRYPTO_EccSignaturePurpose) + sizeof (struct GNUNET_TIME_AbsoluteNBO) + rd_ser_len + name_len;
    sig_purpose = GNUNET_malloc (sig_len);
    sig_purpose->size = htonl (sig_len);
    sig_purpose->purpose = htonl (GNUNET_SIGNATURE_PURPOSE_GNS_RECORD_SIGN);
@@ -321,7 +321,7 @@ GNUNET_NAMESTORE_create_signature (const struct GNUNET_CRYPTO_RsaPrivateKey *key
    memcpy (name_tmp, name, name_len);
    rd_tmp = &name_tmp[name_len];
    memcpy (rd_tmp, rd_ser, rd_ser_len);
-    res = GNUNET_CRYPTO_rsa_sign (key, sig_purpose, sig);
+    res = GNUNET_CRYPTO_ecc_sign (key, sig_purpose, sig);
    GNUNET_free (sig_purpose);
  }
  if (GNUNET_OK != res)
diff --git a/src/namestore/plugin_namestore_postgres.c b/src/namestore/plugin_namestore_postgres.c
index 3cddc952d..070549b33 100644
--- a/src/namestore/plugin_namestore_postgres.c
+++ b/src/namestore/plugin_namestore_postgres.c
@@ -269,12 +269,12 @@ namestore_postgres_remove_records (void *cls,
 */
 static int 
 namestore_postgres_put_records (void *cls, 
-                                const struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded *zone_key,
+                                const struct GNUNET_CRYPTO_EccPublicKeyBinaryEncoded *zone_key,
                                struct GNUNET_TIME_Absolute expire,
                                const char *name,
                                unsigned int rd_count,
                                const struct GNUNET_NAMESTORE_RecordData *rd,
-                                const struct GNUNET_CRYPTO_RsaSignature *signature)
+                                const struct GNUNET_CRYPTO_EccSignature *signature)
 {
  struct Plugin *plugin = cls;
  PGresult *ret;
@@ -287,7 +287,7 @@ namestore_postgres_put_records (void *cls,
  unsigned int i;
  GNUNET_CRYPTO_short_hash (zone_key, 
-                            sizeof (struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded),
+                            sizeof (struct GNUNET_CRYPTO_EccPublicKeyBinaryEncoded),
                            &zone);
  (void) namestore_postgres_remove_records (plugin, &zone, name);
  name_len = strlen (name);
@@ -327,12 +327,12 @@ namestore_postgres_put_records (void *cls,
      (const char *) &rvalue_be
    };
    int paramLengths[] = {
-      sizeof (struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded),
+      sizeof (struct GNUNET_CRYPTO_EccPublicKeyBinaryEncoded),
      name_len,
      sizeof (uint32_t),
      data_size,
      sizeof (uint64_t),
-      sizeof (struct GNUNET_CRYPTO_RsaSignature), 
+      sizeof (struct GNUNET_CRYPTO_EccSignature), 
      sizeof (struct GNUNET_CRYPTO_ShortHashCode),
      sizeof (struct GNUNET_CRYPTO_ShortHashCode),
      sizeof (struct GNUNET_CRYPTO_ShortHashCode),
@@ -378,8 +378,8 @@ get_record_and_call_iterator (struct Plugin *plugin,
 {
  unsigned int record_count;
  size_t data_size;
-  const struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded *zone_key;
+  const struct GNUNET_CRYPTO_EccPublicKeyBinaryEncoded *zone_key;
-  const struct GNUNET_CRYPTO_RsaSignature *sig;
+  const struct GNUNET_CRYPTO_EccSignature *sig;
  struct GNUNET_TIME_Absolute expiration;
  const char *data;
  const char *name;
@@ -406,16 +406,16 @@ get_record_and_call_iterator (struct Plugin *plugin,
  }
  GNUNET_assert (1 == cnt);
  if ((6 != PQnfields (res)) || 
-      (sizeof (struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded) != PQgetlength (res, 0, 0)) || 
+      (sizeof (struct GNUNET_CRYPTO_EccPublicKeyBinaryEncoded) != PQgetlength (res, 0, 0)) || 
      (sizeof (uint32_t) != PQfsize (res, 2)) || 
      (sizeof (uint64_t) != PQfsize (res, 4)) || 
-      (sizeof (struct GNUNET_CRYPTO_RsaSignature) != PQgetlength (res, 0, 5)))
+      (sizeof (struct GNUNET_CRYPTO_EccSignature) != PQgetlength (res, 0, 5)))
  {
    GNUNET_break (0);
    PQclear (res);
    return GNUNET_SYSERR;
  }
-  zone_key = (const struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded *) PQgetvalue (res, 0, 0);
+  zone_key = (const struct GNUNET_CRYPTO_EccPublicKeyBinaryEncoded *) PQgetvalue (res, 0, 0);
  name = PQgetvalue (res, 0, 1);
  name_len = PQgetlength (res, 0, 1);
  record_count = ntohl (*(uint32_t *) PQgetvalue (res, 0, 2));
@@ -423,7 +423,7 @@ get_record_and_call_iterator (struct Plugin *plugin,
  data = PQgetvalue (res, 0, 3);
  expiration.abs_value =
    GNUNET_ntohll (*(uint64_t *) PQgetvalue (res, 0, 4));
-  sig = (const struct GNUNET_CRYPTO_RsaSignature*) PQgetvalue (res, 0, 5);
+  sig = (const struct GNUNET_CRYPTO_EccSignature*) PQgetvalue (res, 0, 5);
  if (record_count > 64 * 1024)
  {
    /* sanity check, don't stack allocate far too much just
diff --git a/src/namestore/plugin_namestore_sqlite.c b/src/namestore/plugin_namestore_sqlite.c
index f0deb7fa9..f0b801d1e 100644
--- a/src/namestore/plugin_namestore_sqlite.c
+++ b/src/namestore/plugin_namestore_sqlite.c
@@ -450,12 +450,12 @@ namestore_sqlite_remove_records (void *cls,
 */
 static int 
 namestore_sqlite_put_records (void *cls, 
-                              const struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded *zone_key,
+                              const struct GNUNET_CRYPTO_EccPublicKeyBinaryEncoded *zone_key,
                              struct GNUNET_TIME_Absolute expire,
                              const char *name,
                              unsigned int rd_count,
                              const struct GNUNET_NAMESTORE_RecordData *rd,
-                              const struct GNUNET_CRYPTO_RsaSignature *signature)
+                              const struct GNUNET_CRYPTO_EccSignature *signature)
 {
  struct Plugin *plugin = cls;
  int n;
@@ -467,7 +467,7 @@ namestore_sqlite_put_records (void *cls,
  size_t data_size;
  unsigned int i;
-  GNUNET_CRYPTO_short_hash (zone_key, sizeof (struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded), &zone);
+  GNUNET_CRYPTO_short_hash (zone_key, sizeof (struct GNUNET_CRYPTO_EccPublicKeyBinaryEncoded), &zone);
  (void) namestore_sqlite_remove_records (plugin, &zone, name);
  name_len = strlen (name);
  GNUNET_CRYPTO_short_hash (name, name_len, &nh);
@@ -497,12 +497,12 @@ namestore_sqlite_put_records (void *cls,
      GNUNET_break (0);
      return GNUNET_SYSERR;
    }
-    if ((SQLITE_OK != sqlite3_bind_blob (plugin->put_records, 1, zone_key, sizeof (struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded), SQLITE_STATIC)) ||
+    if ((SQLITE_OK != sqlite3_bind_blob (plugin->put_records, 1, zone_key, sizeof (struct GNUNET_CRYPTO_EccPublicKeyBinaryEncoded), SQLITE_STATIC)) ||
        (SQLITE_OK != sqlite3_bind_text (plugin->put_records, 2, name, -1, SQLITE_STATIC)) ||
        (SQLITE_OK != sqlite3_bind_int (plugin->put_records, 3, rd_count)) ||
        (SQLITE_OK != sqlite3_bind_blob (plugin->put_records, 4, data, data_size, SQLITE_STATIC)) ||
        (SQLITE_OK != sqlite3_bind_int64 (plugin->put_records, 5, expire.abs_value)) ||
-        (SQLITE_OK != sqlite3_bind_blob (plugin->put_records, 6, signature, sizeof (struct GNUNET_CRYPTO_RsaSignature), SQLITE_STATIC)) ||
+        (SQLITE_OK != sqlite3_bind_blob (plugin->put_records, 6, signature, sizeof (struct GNUNET_CRYPTO_EccSignature), SQLITE_STATIC)) ||
        (SQLITE_OK != sqlite3_bind_blob (plugin->put_records, 7, &zone_delegation, sizeof (struct GNUNET_CRYPTO_ShortHashCode), SQLITE_STATIC)) ||
        (SQLITE_OK != sqlite3_bind_blob (plugin->put_records, 8, &zone, sizeof (struct GNUNET_CRYPTO_ShortHashCode), SQLITE_STATIC)) ||
        (SQLITE_OK != sqlite3_bind_blob (plugin->put_records, 9, &nh, sizeof (struct GNUNET_CRYPTO_ShortHashCode), SQLITE_STATIC)) ||
@@ -560,8 +560,8 @@ get_record_and_call_iterator (struct Plugin *plugin,
  int sret;
  unsigned int record_count;
  size_t data_size;
-  const struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded *zone_key;
+  const struct GNUNET_CRYPTO_EccPublicKeyBinaryEncoded *zone_key;
-  const struct GNUNET_CRYPTO_RsaSignature *sig;
+  const struct GNUNET_CRYPTO_EccSignature *sig;
  struct GNUNET_TIME_Absolute expiration;
  const char *data;
  const char *name;
@@ -578,8 +578,8 @@ get_record_and_call_iterator (struct Plugin *plugin,
    expiration.abs_value = (uint64_t) sqlite3_column_int64 (stmt, 4);
    sig = sqlite3_column_blob (stmt, 5);
-    if ( (sizeof (struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded) != sqlite3_column_bytes (stmt, 0)) ||
+    if ( (sizeof (struct GNUNET_CRYPTO_EccPublicKeyBinaryEncoded) != sqlite3_column_bytes (stmt, 0)) ||
-         (sizeof (struct GNUNET_CRYPTO_RsaSignature) != sqlite3_column_bytes (stmt, 5)) )
+         (sizeof (struct GNUNET_CRYPTO_EccSignature) != sqlite3_column_bytes (stmt, 5)) )
    {
      GNUNET_break (0);
      ret = GNUNET_SYSERR;
diff --git a/src/namestore/test_namestore_api.c b/src/namestore/test_namestore_api.c
index c290673fa..32dd4844c 100644
--- a/src/namestore/test_namestore_api.c
+++ b/src/namestore/test_namestore_api.c
@@ -39,9 +39,9 @@ static struct GNUNET_NAMESTORE_Handle *nsh;
 static GNUNET_SCHEDULER_TaskIdentifier endbadly_task;
-static struct GNUNET_CRYPTO_RsaPrivateKey *privkey;
+static struct GNUNET_CRYPTO_EccPrivateKey *privkey;
-static struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded pubkey;
+static struct GNUNET_CRYPTO_EccPublicKeyBinaryEncoded pubkey;
 static struct GNUNET_CRYPTO_ShortHashCode zone;
@@ -60,7 +60,7 @@ cleanup ()
  }
  if (NULL != privkey)
  {
-    GNUNET_CRYPTO_rsa_key_free (privkey);
+    GNUNET_CRYPTO_ecc_key_free (privkey);
    privkey = NULL;
  }
  GNUNET_SCHEDULER_shutdown ();
@@ -96,12 +96,12 @@ end (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 static void
 name_lookup_proc (void *cls,
-                  const struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded *zone_key,
+                  const struct GNUNET_CRYPTO_EccPublicKeyBinaryEncoded *zone_key,
                  struct GNUNET_TIME_Absolute expire,
                  const char *name,
                  unsigned int rd_count,
                  const struct GNUNET_NAMESTORE_RecordData *rd,
-                  const struct GNUNET_CRYPTO_RsaSignature *signature)
+                  const struct GNUNET_CRYPTO_EccSignature *signature)
 {
  nsqe = NULL;
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
@@ -135,7 +135,7 @@ run (void *cls,
     const struct GNUNET_CONFIGURATION_Handle *cfg,
     struct GNUNET_TESTING_Peer *peer)
 {
-  struct GNUNET_CRYPTO_RsaSignature signature;
+  struct GNUNET_CRYPTO_EccSignature signature;
  struct GNUNET_NAMESTORE_RecordData rd;
  char *hostkey_file;
  const char * name = "dummy.dummy.gnunet";
@@ -147,10 +147,10 @@ run (void *cls,
                   DIR_SEPARATOR_STR,
                   "N0UJMP015AFUNR2BTNM3FKPBLG38913BL8IDMCO2H0A1LIB81960.zkey");
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Using zonekey file `%s' \n", hostkey_file);
-  privkey = GNUNET_CRYPTO_rsa_key_create_from_file (hostkey_file);
+  privkey = GNUNET_CRYPTO_ecc_key_create_from_file (hostkey_file);
  GNUNET_free (hostkey_file);
  GNUNET_assert (privkey != NULL);
-  GNUNET_CRYPTO_rsa_key_get_public (privkey, &pubkey);
+  GNUNET_CRYPTO_ecc_key_get_public (privkey, &pubkey);
  GNUNET_CRYPTO_short_hash (&pubkey, sizeof (pubkey), &zone);
  memset (&signature, '\0', sizeof (signature));
  rd.expiration_time = GNUNET_TIME_absolute_get().abs_value;
diff --git a/src/namestore/test_namestore_api_create.c b/src/namestore/test_namestore_api_create.c
index 8bdf1338d..6db832149 100644
--- a/src/namestore/test_namestore_api_create.c
+++ b/src/namestore/test_namestore_api_create.c
@@ -50,13 +50,13 @@ static struct GNUNET_NAMESTORE_Handle * nsh;
 static GNUNET_SCHEDULER_TaskIdentifier endbadly_task;
-static struct GNUNET_CRYPTO_RsaPrivateKey * privkey;
+static struct GNUNET_CRYPTO_EccPrivateKey * privkey;
-static struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded pubkey;
+static struct GNUNET_CRYPTO_EccPublicKeyBinaryEncoded pubkey;
-static struct GNUNET_CRYPTO_RsaSignature *s_signature;
+static struct GNUNET_CRYPTO_EccSignature *s_signature;
-static struct GNUNET_CRYPTO_RsaSignature *s_signature_updated;
+static struct GNUNET_CRYPTO_EccSignature *s_signature_updated;
 static struct GNUNET_CRYPTO_ShortHashCode s_zone;
@@ -82,7 +82,7 @@ endbadly (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
    GNUNET_NAMESTORE_disconnect (nsh);
  nsh = NULL;
  if (privkey != NULL)
-    GNUNET_CRYPTO_rsa_key_free (privkey);
+    GNUNET_CRYPTO_ecc_key_free (privkey);
  privkey = NULL;
  GNUNET_free_non_null (s_name);
  res = 1;
@@ -102,7 +102,7 @@ end (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
  GNUNET_free_non_null (s_second_record);
  GNUNET_free_non_null (s_name);
  if (privkey != NULL)
-    GNUNET_CRYPTO_rsa_key_free (privkey);
+    GNUNET_CRYPTO_ecc_key_free (privkey);
  privkey = NULL;
  if (nsh != NULL)
    GNUNET_NAMESTORE_disconnect (nsh);
@@ -112,12 +112,12 @@ end (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 static void 
 name_lookup_second_proc (void *cls,
-                         const struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded *zone_key,
+                         const struct GNUNET_CRYPTO_EccPublicKeyBinaryEncoded *zone_key,
                         struct GNUNET_TIME_Absolute expire,
                         const char *n,
                         unsigned int rd_count,
                         const struct GNUNET_NAMESTORE_RecordData *rd,
-                         const struct GNUNET_CRYPTO_RsaSignature *signature)
+                         const struct GNUNET_CRYPTO_EccSignature *signature)
 {
  static int found = GNUNET_NO;
  int failed = GNUNET_NO;
@@ -126,7 +126,7 @@ name_lookup_second_proc (void *cls,
  if (n != NULL)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Checking returned results\n");
-    if (0 != memcmp (zone_key, &pubkey, sizeof (struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded)))
+    if (0 != memcmp (zone_key, &pubkey, sizeof (struct GNUNET_CRYPTO_EccPublicKeyBinaryEncoded)))
    {
      GNUNET_break (0);
      failed = GNUNET_YES;
@@ -172,7 +172,7 @@ name_lookup_second_proc (void *cls,
    rd_new[1].flags = 0; /* unset GNUNET_NAMESTORE_RF_AUTHORITY */
    s_signature_updated = GNUNET_NAMESTORE_create_signature (privkey, expire, s_name, rd_new, 2);
-    if (0 != memcmp (s_signature_updated, signature, sizeof (struct GNUNET_CRYPTO_RsaSignature)))
+    if (0 != memcmp (s_signature_updated, signature, sizeof (struct GNUNET_CRYPTO_EccSignature)))
    {
      GNUNET_break (0);
      failed = GNUNET_YES;
@@ -219,12 +219,12 @@ create_second_cont (void *cls, int32_t success, const char *emsg)
 static void 
 name_lookup_initial_proc (void *cls,
-                          const struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded *zone_key,
+                          const struct GNUNET_CRYPTO_EccPublicKeyBinaryEncoded *zone_key,
                          struct GNUNET_TIME_Absolute expire,
                          const char *n,
                          unsigned int rd_count,
                          const struct GNUNET_NAMESTORE_RecordData *rd,
-                          const struct GNUNET_CRYPTO_RsaSignature *signature)
+                          const struct GNUNET_CRYPTO_EccSignature *signature)
 {
  char * name = cls;
  static int found = GNUNET_NO;
@@ -234,7 +234,7 @@ name_lookup_initial_proc (void *cls,
  if (n != NULL)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Checking returned results\n");
-    if (0 != memcmp (zone_key, &pubkey, sizeof (struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded)))
+    if (0 != memcmp (zone_key, &pubkey, sizeof (struct GNUNET_CRYPTO_EccPublicKeyBinaryEncoded)))
    {
      GNUNET_break (0);
      failed = GNUNET_YES;
@@ -267,7 +267,7 @@ name_lookup_initial_proc (void *cls,
      failed = GNUNET_YES;
    }
-    if (0 != memcmp (s_signature, signature, sizeof (struct GNUNET_CRYPTO_RsaSignature)))
+    if (0 != memcmp (s_signature, signature, sizeof (struct GNUNET_CRYPTO_EccSignature)))
    {
      GNUNET_break (0);
      failed = GNUNET_YES;
@@ -357,10 +357,10 @@ run (void *cls,
  GNUNET_asprintf(&hostkey_file,"zonefiles%s%s",DIR_SEPARATOR_STR,
      "N0UJMP015AFUNR2BTNM3FKPBLG38913BL8IDMCO2H0A1LIB81960.zkey");
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Using zonekey file `%s' \n", hostkey_file);
-  privkey = GNUNET_CRYPTO_rsa_key_create_from_file(hostkey_file);
+  privkey = GNUNET_CRYPTO_ecc_key_create_from_file(hostkey_file);
  GNUNET_free (hostkey_file);
  /* get public key */
-  GNUNET_CRYPTO_rsa_key_get_public(privkey, &pubkey);
+  GNUNET_CRYPTO_ecc_key_get_public(privkey, &pubkey);
  /* create record */
  s_name = GNUNET_NAMESTORE_normalize_string ("DUMMY.dummy.gnunet");
@@ -373,7 +373,7 @@ run (void *cls,
  s_signature = GNUNET_NAMESTORE_create_signature(privkey, et, s_name, s_first_record, 1);
  /* create random zone hash */
-  GNUNET_CRYPTO_short_hash (&pubkey, sizeof (struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded), &s_zone);
+  GNUNET_CRYPTO_short_hash (&pubkey, sizeof (struct GNUNET_CRYPTO_EccPublicKeyBinaryEncoded), &s_zone);
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Name: `%s' Zone: `%s' \n", s_name, GNUNET_short_h2s (&s_zone));
  nsh = GNUNET_NAMESTORE_connect (cfg);
diff --git a/src/namestore/test_namestore_api_create_update.c b/src/namestore/test_namestore_api_create_update.c
index 2a5c45e75..5df7c4934 100644
--- a/src/namestore/test_namestore_api_create_update.c
+++ b/src/namestore/test_namestore_api_create_update.c
@@ -50,11 +50,11 @@ static struct GNUNET_NAMESTORE_Handle * nsh;
 static GNUNET_SCHEDULER_TaskIdentifier endbadly_task;
-static struct GNUNET_CRYPTO_RsaPrivateKey * privkey;
+static struct GNUNET_CRYPTO_EccPrivateKey * privkey;
-static struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded pubkey;
+static struct GNUNET_CRYPTO_EccPublicKeyBinaryEncoded pubkey;
-static struct GNUNET_CRYPTO_RsaSignature *s_signature;
+static struct GNUNET_CRYPTO_EccSignature *s_signature;
 static struct GNUNET_CRYPTO_ShortHashCode s_zone;
@@ -80,7 +80,7 @@ endbadly (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
    GNUNET_NAMESTORE_disconnect (nsh);
  nsh = NULL;
  if (privkey != NULL)
-    GNUNET_CRYPTO_rsa_key_free (privkey);
+    GNUNET_CRYPTO_ecc_key_free (privkey);
  privkey = NULL;
  GNUNET_free_non_null (s_name);
  res = 1;
@@ -99,7 +99,7 @@ end (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
  GNUNET_free (s_first_record);
  GNUNET_free_non_null (s_second_record);
  if (privkey != NULL)
-    GNUNET_CRYPTO_rsa_key_free (privkey);
+    GNUNET_CRYPTO_ecc_key_free (privkey);
  privkey = NULL;
  if (nsh != NULL)
    GNUNET_NAMESTORE_disconnect (nsh);
@@ -208,11 +208,11 @@ run (void *cls,
  GNUNET_asprintf(&hostkey_file,"zonefiles%s%s",DIR_SEPARATOR_STR,
      "N0UJMP015AFUNR2BTNM3FKPBLG38913BL8IDMCO2H0A1LIB81960.zkey");
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Using zonekey file `%s' \n", hostkey_file);
-  privkey = GNUNET_CRYPTO_rsa_key_create_from_file(hostkey_file);
+  privkey = GNUNET_CRYPTO_ecc_key_create_from_file(hostkey_file);
  GNUNET_free (hostkey_file);
  GNUNET_assert (privkey != NULL);
  /* get public key */
-  GNUNET_CRYPTO_rsa_key_get_public(privkey, &pubkey);
+  GNUNET_CRYPTO_ecc_key_get_public(privkey, &pubkey);
  /* create record */
  s_name = GNUNET_NAMESTORE_normalize_string ("DUMMY.dummy.gnunet");
@@ -226,7 +226,7 @@ run (void *cls,
  s_signature = GNUNET_NAMESTORE_create_signature(privkey, et, s_name, s_first_record, 1);
  /* create random zone hash */
-  GNUNET_CRYPTO_short_hash (&pubkey, sizeof (struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded), &s_zone);
+  GNUNET_CRYPTO_short_hash (&pubkey, sizeof (struct GNUNET_CRYPTO_EccPublicKeyBinaryEncoded), &s_zone);
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Name: `%s' Zone: `%s' \n", s_name, GNUNET_short_h2s (&s_zone));
  nsh = GNUNET_NAMESTORE_connect (cfg);
diff --git a/src/namestore/test_namestore_api_lookup.c b/src/namestore/test_namestore_api_lookup.c
index 7d2f86e86..fdd229b23 100644
--- a/src/namestore/test_namestore_api_lookup.c
+++ b/src/namestore/test_namestore_api_lookup.c
@@ -43,11 +43,11 @@ static struct GNUNET_NAMESTORE_Handle * nsh;
 static GNUNET_SCHEDULER_TaskIdentifier endbadly_task;
-static struct GNUNET_CRYPTO_RsaPrivateKey * privkey;
+static struct GNUNET_CRYPTO_EccPrivateKey * privkey;
-static struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded pubkey;
+static struct GNUNET_CRYPTO_EccPublicKeyBinaryEncoded pubkey;
-static struct GNUNET_CRYPTO_RsaSignature *s_signature;
+static struct GNUNET_CRYPTO_EccSignature *s_signature;
 static struct GNUNET_CRYPTO_ShortHashCode s_zone;
@@ -70,7 +70,7 @@ cleanup ()
  }
  if (NULL != privkey)
  {
-    GNUNET_CRYPTO_rsa_key_free (privkey);
+    GNUNET_CRYPTO_ecc_key_free (privkey);
    privkey = NULL;
  }
  GNUNET_SCHEDULER_shutdown ();
@@ -105,12 +105,12 @@ end (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 static void
 name_lookup_proc (void *cls,
-                  const struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded *zone_key,
+                  const struct GNUNET_CRYPTO_EccPublicKeyBinaryEncoded *zone_key,
                  struct GNUNET_TIME_Absolute expire,
                  const char *n,
                  unsigned int rd_count,
                  const struct GNUNET_NAMESTORE_RecordData *rd,
-                  const struct GNUNET_CRYPTO_RsaSignature *signature)
+                  const struct GNUNET_CRYPTO_EccSignature *signature)
 {
  static int found = GNUNET_NO;
  int c;
@@ -119,13 +119,13 @@ name_lookup_proc (void *cls,
  {
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Checking returned results\n");
    if (0 != memcmp (zone_key, &pubkey, 
-                     sizeof (struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded)))
+                     sizeof (struct GNUNET_CRYPTO_EccPublicKeyBinaryEncoded)))
    {
      GNUNET_break (0);
    }
    GNUNET_assert (NULL != signature);
    if (0 != memcmp (signature, s_signature, 
-                     sizeof (struct GNUNET_CRYPTO_RsaSignature)))
+                     sizeof (struct GNUNET_CRYPTO_EccSignature)))
    {
      GNUNET_break (0);
    }
@@ -222,10 +222,10 @@ run (void *cls,
                                                &endbadly, NULL);
  /* load privat key from file not included in zonekey dir */
-  privkey = GNUNET_CRYPTO_rsa_key_create_from_file("test_hostkey");
+  privkey = GNUNET_CRYPTO_ecc_key_create_from_file("test_hostkey");
  GNUNET_assert (NULL != privkey);
  /* get public key */
-  GNUNET_CRYPTO_rsa_key_get_public(privkey, &pubkey);
+  GNUNET_CRYPTO_ecc_key_get_public(privkey, &pubkey);
  /* create record */
  s_name = GNUNET_NAMESTORE_normalize_string ("DUMMY.dummy.gnunet");
@@ -243,7 +243,7 @@ run (void *cls,
    
    /* create random zone hash */
    GNUNET_CRYPTO_short_hash (&pubkey, 
-                              sizeof (struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded), 
+                              sizeof (struct GNUNET_CRYPTO_EccPublicKeyBinaryEncoded), 
                              &s_zone);
    nsh = GNUNET_NAMESTORE_connect (cfg);
    GNUNET_break (NULL != nsh);
diff --git a/src/namestore/test_namestore_api_lookup_specific_type.c b/src/namestore/test_namestore_api_lookup_specific_type.c
index 4d2aa1cfe..49988ed3f 100644
--- a/src/namestore/test_namestore_api_lookup_specific_type.c
+++ b/src/namestore/test_namestore_api_lookup_specific_type.c
@@ -48,11 +48,11 @@ static struct GNUNET_NAMESTORE_Handle * nsh;
 static GNUNET_SCHEDULER_TaskIdentifier endbadly_task;
-static struct GNUNET_CRYPTO_RsaPrivateKey * privkey;
+static struct GNUNET_CRYPTO_EccPrivateKey * privkey;
-static struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded pubkey;
+static struct GNUNET_CRYPTO_EccPublicKeyBinaryEncoded pubkey;
-static struct GNUNET_CRYPTO_RsaSignature *s_signature;
+static struct GNUNET_CRYPTO_EccSignature *s_signature;
 static struct GNUNET_CRYPTO_ShortHashCode s_zone;
@@ -76,7 +76,7 @@ endbadly (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
    GNUNET_NAMESTORE_disconnect (nsh);
  nsh = NULL;
  if (privkey != NULL)
-    GNUNET_CRYPTO_rsa_key_free (privkey);
+    GNUNET_CRYPTO_ecc_key_free (privkey);
  privkey = NULL;
  GNUNET_free_non_null (s_name);
  res = 1;
@@ -100,7 +100,7 @@ end (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
  GNUNET_free (s_rd);
  GNUNET_free_non_null (s_name);
  if (privkey != NULL)
-    GNUNET_CRYPTO_rsa_key_free (privkey);
+    GNUNET_CRYPTO_ecc_key_free (privkey);
  privkey = NULL;
  if (nsh != NULL)
    GNUNET_NAMESTORE_disconnect (nsh);
@@ -110,18 +110,18 @@ end (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 static void 
 name_lookup_existing_record_type (void *cls,
-                                  const struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded *zone_key,
+                                  const struct GNUNET_CRYPTO_EccPublicKeyBinaryEncoded *zone_key,
                                  struct GNUNET_TIME_Absolute expire,
                                  const char *n,
                                  unsigned int rd_count,
                                  const struct GNUNET_NAMESTORE_RecordData *rd,
-                                  const struct GNUNET_CRYPTO_RsaSignature *signature)
+                                  const struct GNUNET_CRYPTO_EccSignature *signature)
 {
  int failed = GNUNET_NO;
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Namestore returned %u records\n", rd_count);
-  if ((NULL == n) || (0 != memcmp(zone_key, &pubkey, sizeof (struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded))))
+  if ((NULL == n) || (0 != memcmp(zone_key, &pubkey, sizeof (struct GNUNET_CRYPTO_EccPublicKeyBinaryEncoded))))
  {
    GNUNET_break(0);
    failed = GNUNET_YES;
@@ -156,12 +156,12 @@ name_lookup_existing_record_type (void *cls,
 static void
 name_lookup_non_existing_record_type (void *cls,
-                                      const struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded *zone_key,
+                                      const struct GNUNET_CRYPTO_EccPublicKeyBinaryEncoded *zone_key,
                                      struct GNUNET_TIME_Absolute expire,
                                      const char *n,
                                      unsigned int rd_count,
                                      const struct GNUNET_NAMESTORE_RecordData *rd,
-                                      const struct GNUNET_CRYPTO_RsaSignature *signature)
+                                      const struct GNUNET_CRYPTO_EccSignature *signature)
 {
  int failed = GNUNET_NO;
  /* We expect zone key != NULL, name != NULL, rd_count 0, rd NULL, signature NULL */
@@ -280,11 +280,11 @@ run (void *cls,
  GNUNET_asprintf(&hostkey_file,"zonefiles%s%s",DIR_SEPARATOR_STR,
      "N0UJMP015AFUNR2BTNM3FKPBLG38913BL8IDMCO2H0A1LIB81960.zkey");
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Using zonekey file `%s' \n", hostkey_file);
-  privkey = GNUNET_CRYPTO_rsa_key_create_from_file(hostkey_file);
+  privkey = GNUNET_CRYPTO_ecc_key_create_from_file(hostkey_file);
  GNUNET_free (hostkey_file);
  GNUNET_assert (privkey != NULL);
  /* get public key */
-  GNUNET_CRYPTO_rsa_key_get_public(privkey, &pubkey);
+  GNUNET_CRYPTO_ecc_key_get_public(privkey, &pubkey);
  /* create record */
  s_name = GNUNET_NAMESTORE_normalize_string ("DUMMY.dummy.gnunet");
@@ -300,7 +300,7 @@ run (void *cls,
    s_signature = GNUNET_NAMESTORE_create_signature(privkey, et, s_name, s_rd, RECORDS);
    /* create random zone hash */
-    GNUNET_CRYPTO_short_hash (&pubkey, sizeof (struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded), &s_zone);
+    GNUNET_CRYPTO_short_hash (&pubkey, sizeof (struct GNUNET_CRYPTO_EccPublicKeyBinaryEncoded), &s_zone);
    nsh = GNUNET_NAMESTORE_connect (cfg);
    GNUNET_break (NULL != nsh);
    GNUNET_break (s_rd != NULL);
diff --git a/src/namestore/test_namestore_api_put.c b/src/namestore/test_namestore_api_put.c
index e4bc5e4bb..df5cb336e 100644
--- a/src/namestore/test_namestore_api_put.c
+++ b/src/namestore/test_namestore_api_put.c
@@ -42,9 +42,9 @@ static struct GNUNET_NAMESTORE_Handle * nsh;
 static GNUNET_SCHEDULER_TaskIdentifier endbadly_task;
-static struct GNUNET_CRYPTO_RsaPrivateKey * privkey;
+static struct GNUNET_CRYPTO_EccPrivateKey * privkey;
-static struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded pubkey;
+static struct GNUNET_CRYPTO_EccPublicKeyBinaryEncoded pubkey;
 static struct GNUNET_NAMESTORE_RecordData *s_rd;
@@ -66,7 +66,7 @@ endbadly (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
  if (privkey != NULL)
  {
-    GNUNET_CRYPTO_rsa_key_free (privkey);
+    GNUNET_CRYPTO_ecc_key_free (privkey);
    privkey = NULL;
  }
  GNUNET_SCHEDULER_shutdown ();
@@ -85,7 +85,7 @@ end (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
  if (privkey != NULL)
  {
-    GNUNET_CRYPTO_rsa_key_free (privkey);
+    GNUNET_CRYPTO_ecc_key_free (privkey);
    privkey = NULL;
  }
  if (nsh != NULL)
@@ -136,7 +136,7 @@ run (void *cls,
     const struct GNUNET_CONFIGURATION_Handle *cfg,
     struct GNUNET_TESTING_Peer *peer)
 {
-  struct GNUNET_CRYPTO_RsaSignature *signature;
+  struct GNUNET_CRYPTO_EccSignature *signature;
  char * s_name;
  int c;
  char *hostkey_file;
@@ -147,11 +147,11 @@ run (void *cls,
  GNUNET_asprintf(&hostkey_file,"zonefiles%s%s",DIR_SEPARATOR_STR,
      "N0UJMP015AFUNR2BTNM3FKPBLG38913BL8IDMCO2H0A1LIB81960.zkey");
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Using zonekey file `%s' \n", hostkey_file);
-  privkey = GNUNET_CRYPTO_rsa_key_create_from_file(hostkey_file);
+  privkey = GNUNET_CRYPTO_ecc_key_create_from_file(hostkey_file);
  GNUNET_assert (privkey != NULL);
  GNUNET_free (hostkey_file);
  /* get public key */
-  GNUNET_CRYPTO_rsa_key_get_public(privkey, &pubkey);
+  GNUNET_CRYPTO_ecc_key_get_public(privkey, &pubkey);
  nsh = GNUNET_NAMESTORE_connect (cfg);
  GNUNET_break (NULL != nsh);
  /* create record */
diff --git a/src/namestore/test_namestore_api_remove.c b/src/namestore/test_namestore_api_remove.c
index 8583e69c9..265a93b81 100644
--- a/src/namestore/test_namestore_api_remove.c
+++ b/src/namestore/test_namestore_api_remove.c
@@ -49,11 +49,11 @@ static struct GNUNET_NAMESTORE_Handle * nsh;
 static GNUNET_SCHEDULER_TaskIdentifier endbadly_task;
-static struct GNUNET_CRYPTO_RsaPrivateKey * privkey;
+static struct GNUNET_CRYPTO_EccPrivateKey * privkey;
-static struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded pubkey;
+static struct GNUNET_CRYPTO_EccPublicKeyBinaryEncoded pubkey;
-static struct GNUNET_CRYPTO_RsaSignature *s_signature;
+static struct GNUNET_CRYPTO_EccSignature *s_signature;
 static struct GNUNET_CRYPTO_ShortHashCode s_zone;
@@ -77,7 +77,7 @@ endbadly (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
    GNUNET_NAMESTORE_disconnect (nsh);
  nsh = NULL;
  if (privkey != NULL)
-    GNUNET_CRYPTO_rsa_key_free (privkey);
+    GNUNET_CRYPTO_ecc_key_free (privkey);
  privkey = NULL;
  GNUNET_free_non_null (s_name);
  res = 1;
@@ -98,7 +98,7 @@ end (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
    GNUNET_free_non_null((void *) s_rd[c].data);
  GNUNET_free (s_rd);
  if (privkey != NULL)
-    GNUNET_CRYPTO_rsa_key_free (privkey);
+    GNUNET_CRYPTO_ecc_key_free (privkey);
  privkey = NULL;
  if (nsh != NULL)
    GNUNET_NAMESTORE_disconnect (nsh);
@@ -109,12 +109,12 @@ end (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 static void
 name_lookup_proc (void *cls,
-                  const struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded *zone_key,
+                  const struct GNUNET_CRYPTO_EccPublicKeyBinaryEncoded *zone_key,
                  struct GNUNET_TIME_Absolute expire,
                  const char *n,
                  unsigned int rd_count,
                  const struct GNUNET_NAMESTORE_RecordData *rd,
-                  const struct GNUNET_CRYPTO_RsaSignature *signature)
+                  const struct GNUNET_CRYPTO_EccSignature *signature)
 {
  static int found = GNUNET_NO;
  int failed = GNUNET_NO;
@@ -123,7 +123,7 @@ name_lookup_proc (void *cls,
  if (n != NULL)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Lookup for name `%s' returned %u records\n", n, rd_count);
-    if (0 != memcmp (zone_key, &pubkey, sizeof (struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded)))
+    if (0 != memcmp (zone_key, &pubkey, sizeof (struct GNUNET_CRYPTO_EccPublicKeyBinaryEncoded)))
    {
      GNUNET_break (0);
      failed = GNUNET_YES;
@@ -254,11 +254,11 @@ run (void *cls,
  GNUNET_asprintf(&hostkey_file,"zonefiles%s%s",DIR_SEPARATOR_STR,
      "N0UJMP015AFUNR2BTNM3FKPBLG38913BL8IDMCO2H0A1LIB81960.zkey");
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Using zonekey file `%s' \n", hostkey_file);
-  privkey = GNUNET_CRYPTO_rsa_key_create_from_file(hostkey_file);
+  privkey = GNUNET_CRYPTO_ecc_key_create_from_file(hostkey_file);
  GNUNET_free (hostkey_file);
  GNUNET_assert (privkey != NULL);
  /* get public key */
-  GNUNET_CRYPTO_rsa_key_get_public(privkey, &pubkey);
+  GNUNET_CRYPTO_ecc_key_get_public(privkey, &pubkey);
  /* create record */
  s_name = GNUNET_NAMESTORE_normalize_string ("DUMMY.dummy.gnunet");
@@ -273,7 +273,7 @@ run (void *cls,
  s_signature = GNUNET_NAMESTORE_create_signature(privkey, et, s_name, s_rd, RECORDS);
  /* create random zone hash */
-  GNUNET_CRYPTO_short_hash (&pubkey, sizeof (struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded), &s_zone);
+  GNUNET_CRYPTO_short_hash (&pubkey, sizeof (struct GNUNET_CRYPTO_EccPublicKeyBinaryEncoded), &s_zone);
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Name: `%s' Zone: `%s' \n", s_name, GNUNET_short_h2s (&s_zone));
  nsh = GNUNET_NAMESTORE_connect (cfg);
diff --git a/src/namestore/test_namestore_api_remove_not_existing_record.c b/src/namestore/test_namestore_api_remove_not_existing_record.c
index 973cf94e4..16586240a 100644
--- a/src/namestore/test_namestore_api_remove_not_existing_record.c
+++ b/src/namestore/test_namestore_api_remove_not_existing_record.c
@@ -49,11 +49,11 @@ static struct GNUNET_NAMESTORE_Handle * nsh;
 static GNUNET_SCHEDULER_TaskIdentifier endbadly_task;
-static struct GNUNET_CRYPTO_RsaPrivateKey * privkey;
+static struct GNUNET_CRYPTO_EccPrivateKey * privkey;
-static struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded pubkey;
+static struct GNUNET_CRYPTO_EccPublicKeyBinaryEncoded pubkey;
-static struct GNUNET_CRYPTO_RsaSignature *s_signature;
+static struct GNUNET_CRYPTO_EccSignature *s_signature;
 static struct GNUNET_HashCode s_zone;
@@ -77,7 +77,7 @@ endbadly (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
    GNUNET_NAMESTORE_disconnect (nsh);
  nsh = NULL;
  if (privkey != NULL)
-    GNUNET_CRYPTO_rsa_key_free (privkey);
+    GNUNET_CRYPTO_ecc_key_free (privkey);
  privkey = NULL;
  GNUNET_free_non_null (s_name);
  res = 1;
@@ -99,7 +99,7 @@ end (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
  GNUNET_free (s_rd);
  if (privkey != NULL)
-    GNUNET_CRYPTO_rsa_key_free (privkey);
+    GNUNET_CRYPTO_ecc_key_free (privkey);
  privkey = NULL;
  if (nsh != NULL)
    GNUNET_NAMESTORE_disconnect (nsh);
@@ -190,11 +190,11 @@ run (void *cls,
  GNUNET_asprintf(&hostkey_file,"zonefiles%s%s",DIR_SEPARATOR_STR,
      "N0UJMP015AFUNR2BTNM3FKPBLG38913BL8IDMCO2H0A1LIB81960.zkey");
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Using zonekey file `%s' \n", hostkey_file);
-  privkey = GNUNET_CRYPTO_rsa_key_create_from_file(hostkey_file);
+  privkey = GNUNET_CRYPTO_ecc_key_create_from_file(hostkey_file);
  GNUNET_free (hostkey_file);
  GNUNET_assert (privkey != NULL);
  /* get public key */
-  GNUNET_CRYPTO_rsa_key_get_public(privkey, &pubkey);
+  GNUNET_CRYPTO_ecc_key_get_public(privkey, &pubkey);
  /* create record */
  s_name = GNUNET_NAMESTORE_normalize_string ("DUMMY.dummy.gnunet");
@@ -209,7 +209,7 @@ run (void *cls,
  s_signature = GNUNET_NAMESTORE_create_signature(privkey, et, s_name, s_rd, RECORDS);
  /* create random zone hash */
-  GNUNET_CRYPTO_hash (&pubkey, sizeof (struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded), &s_zone);
+  GNUNET_CRYPTO_hash (&pubkey, sizeof (struct GNUNET_CRYPTO_EccPublicKeyBinaryEncoded), &s_zone);
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Name: `%s' Zone: `%s' \n", s_name, GNUNET_h2s_full(&s_zone));
  nsh = GNUNET_NAMESTORE_connect (cfg);
diff --git a/src/namestore/test_namestore_api_sign_verify.c b/src/namestore/test_namestore_api_sign_verify.c
index 10be25bb4..647cc59be 100644
--- a/src/namestore/test_namestore_api_sign_verify.c
+++ b/src/namestore/test_namestore_api_sign_verify.c
@@ -42,9 +42,9 @@
 #define TEST_REMOVE_RECORD_DATA 'b'
-static struct GNUNET_CRYPTO_RsaPrivateKey * privkey;
+static struct GNUNET_CRYPTO_EccPrivateKey * privkey;
-static struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded pubkey;
+static struct GNUNET_CRYPTO_EccPublicKeyBinaryEncoded pubkey;
 static struct GNUNET_NAMESTORE_RecordData *s_rd;
@@ -76,19 +76,19 @@ static void
 run (void *cls, char *const *args, const char *cfgfile,
     const struct GNUNET_CONFIGURATION_Handle *cfg)
 {
-  struct GNUNET_CRYPTO_RsaSignature * signature;
+  struct GNUNET_CRYPTO_EccSignature * signature;
  /* load privat key */
  char *hostkey_file;
  GNUNET_asprintf(&hostkey_file,"zonefiles%s%s",DIR_SEPARATOR_STR,
      "N0UJMP015AFUNR2BTNM3FKPBLG38913BL8IDMCO2H0A1LIB81960.zkey");
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Using zonekey file `%s' \n", hostkey_file);
-  privkey = GNUNET_CRYPTO_rsa_key_create_from_file(hostkey_file);
+  privkey = GNUNET_CRYPTO_ecc_key_create_from_file(hostkey_file);
  GNUNET_free (hostkey_file);
  GNUNET_assert (privkey != NULL);
  struct GNUNET_TIME_Absolute expire = GNUNET_TIME_absolute_get();
  /* get public key */
-  GNUNET_CRYPTO_rsa_key_get_public(privkey, &pubkey);
+  GNUNET_CRYPTO_ecc_key_get_public(privkey, &pubkey);
  int res_c;
  int res_w;
diff --git a/src/namestore/test_namestore_api_zone_iteration.c b/src/namestore/test_namestore_api_zone_iteration.c
index e61fb67d4..48ac35f71 100644
--- a/src/namestore/test_namestore_api_zone_iteration.c
+++ b/src/namestore/test_namestore_api_zone_iteration.c
@@ -37,15 +37,15 @@ static GNUNET_SCHEDULER_TaskIdentifier endbadly_task;
 static GNUNET_SCHEDULER_TaskIdentifier stopiteration_task;
-static struct GNUNET_CRYPTO_RsaPrivateKey * privkey;
+static struct GNUNET_CRYPTO_EccPrivateKey * privkey;
-static struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded pubkey;
+static struct GNUNET_CRYPTO_EccPublicKeyBinaryEncoded pubkey;
 static struct GNUNET_HashCode zone;
-static struct GNUNET_CRYPTO_RsaPrivateKey * privkey2;
+static struct GNUNET_CRYPTO_EccPrivateKey * privkey2;
-static struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded pubkey2;
+static struct GNUNET_CRYPTO_EccPublicKeyBinaryEncoded pubkey2;
 static struct GNUNET_HashCode zone2;
@@ -55,19 +55,19 @@ static int res;
 static int returned_records;
-static struct GNUNET_CRYPTO_RsaSignature *sig_1;
+static struct GNUNET_CRYPTO_EccSignature *sig_1;
 static char * s_name_1;
 static struct GNUNET_NAMESTORE_RecordData *s_rd_1;
-static struct GNUNET_CRYPTO_RsaSignature *sig_2;
+static struct GNUNET_CRYPTO_EccSignature *sig_2;
 static char * s_name_2;
 static struct GNUNET_NAMESTORE_RecordData *s_rd_2;
-static struct GNUNET_CRYPTO_RsaSignature *sig_3;
+static struct GNUNET_CRYPTO_EccSignature *sig_3;
 static char * s_name_3;
@@ -117,11 +117,11 @@ endbadly (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
  }
  if (privkey != NULL)
-    GNUNET_CRYPTO_rsa_key_free (privkey);
+    GNUNET_CRYPTO_ecc_key_free (privkey);
  privkey = NULL;
  if (privkey2 != NULL)
-    GNUNET_CRYPTO_rsa_key_free (privkey2);
+    GNUNET_CRYPTO_ecc_key_free (privkey2);
  privkey2 = NULL;
  res = 1;
 }
@@ -143,11 +143,11 @@ end (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
  }
  if (privkey != NULL)
-    GNUNET_CRYPTO_rsa_key_free (privkey);
+    GNUNET_CRYPTO_ecc_key_free (privkey);
  privkey = NULL;
  if (privkey2 != NULL)
-    GNUNET_CRYPTO_rsa_key_free (privkey2);
+    GNUNET_CRYPTO_ecc_key_free (privkey2);
  privkey2 = NULL;
  GNUNET_free (sig_1);
@@ -179,12 +179,12 @@ end (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 static void
 zone_proc (void *cls,
-           const struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded *zone_key,
+           const struct GNUNET_CRYPTO_EccPublicKeyBinaryEncoded *zone_key,
           struct GNUNET_TIME_Absolute expire,
           const char *name,
           unsigned int rd_count,
           const struct GNUNET_NAMESTORE_RecordData *rd,
-           const struct GNUNET_CRYPTO_RsaSignature *signature)
+           const struct GNUNET_CRYPTO_EccSignature *signature)
 {
  int failed = GNUNET_NO;
  if ((zone_key == NULL) && (name == NULL))
@@ -204,7 +204,7 @@ zone_proc (void *cls,
    if (GNUNET_OK != GNUNET_NAMESTORE_verify_signature (zone_key, expire, name, rd_count, rd, signature))
    {
      struct GNUNET_HashCode zone_key_hash;
-      GNUNET_CRYPTO_hash (zone_key, sizeof (struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded), &zone_key_hash);
+      GNUNET_CRYPTO_hash (zone_key, sizeof (struct GNUNET_CRYPTO_EccPublicKeyBinaryEncoded), &zone_key_hash);
      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Verifying signature for `%s' in zone `%s' with %u records  and expiration %llu failed\n", name, GNUNET_h2s(&zone_key_hash), rd_count, expire.abs_value);
      failed = GNUNET_YES;
@@ -227,7 +227,7 @@ zone_proc (void *cls,
        failed = GNUNET_YES;
        GNUNET_break (0);
      }
-      if (0 != memcmp (signature, sig_1, sizeof (struct GNUNET_CRYPTO_RsaSignature)))
+      if (0 != memcmp (signature, sig_1, sizeof (struct GNUNET_CRYPTO_EccSignature)))
      {
        failed = GNUNET_YES;
        GNUNET_break (0);
@@ -248,7 +248,7 @@ zone_proc (void *cls,
        failed = GNUNET_YES;
        GNUNET_break (0);
      }
-      if (0 != memcmp (signature, sig_2, sizeof (struct GNUNET_CRYPTO_RsaSignature)))
+      if (0 != memcmp (signature, sig_2, sizeof (struct GNUNET_CRYPTO_EccSignature)))
      {
        failed = GNUNET_YES;
        GNUNET_break (0);
@@ -275,7 +275,7 @@ zone_proc (void *cls,
        GNUNET_break (0);
      }
-      if (0 != memcmp (signature, sig_3, sizeof (struct GNUNET_CRYPTO_RsaSignature)))
+      if (0 != memcmp (signature, sig_3, sizeof (struct GNUNET_CRYPTO_EccSignature)))
      {
        failed = GNUNET_YES;
        GNUNET_break (0);
@@ -370,12 +370,12 @@ create_record (unsigned int count)
 */
 static void
 empty_zone_proc (void *cls,
-                 const struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded *zone_key,
+                 const struct GNUNET_CRYPTO_EccPublicKeyBinaryEncoded *zone_key,
                 struct GNUNET_TIME_Absolute expire,
                 const char *name,
                 unsigned int rd_count,
                 const struct GNUNET_NAMESTORE_RecordData *rd,
-                 const struct GNUNET_CRYPTO_RsaSignature *signature)
+                 const struct GNUNET_CRYPTO_EccSignature *signature)
 {
  char *hostkey_file;
  struct GNUNET_TIME_Absolute et;
@@ -387,21 +387,21 @@ empty_zone_proc (void *cls,
  GNUNET_asprintf(&hostkey_file,"zonefiles%s%s",DIR_SEPARATOR_STR,
      "N0UJMP015AFUNR2BTNM3FKPBLG38913BL8IDMCO2H0A1LIB81960.zkey");
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Using zonekey file `%s' \n", hostkey_file);
-  privkey = GNUNET_CRYPTO_rsa_key_create_from_file(hostkey_file);
+  privkey = GNUNET_CRYPTO_ecc_key_create_from_file(hostkey_file);
  GNUNET_free (hostkey_file);
  GNUNET_assert (privkey != NULL);
-  GNUNET_CRYPTO_rsa_key_get_public(privkey, &pubkey);
+  GNUNET_CRYPTO_ecc_key_get_public(privkey, &pubkey);
  GNUNET_CRYPTO_hash(&pubkey, sizeof (pubkey), &zone);
  GNUNET_asprintf(&hostkey_file,"zonefiles%s%s",DIR_SEPARATOR_STR,
      "HGU0A0VCU334DN7F2I9UIUMVQMM7JMSD142LIMNUGTTV9R0CF4EG.zkey");
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Using zonekey file `%s' \n", hostkey_file);
-  privkey2 = GNUNET_CRYPTO_rsa_key_create_from_file(hostkey_file);
+  privkey2 = GNUNET_CRYPTO_ecc_key_create_from_file(hostkey_file);
  GNUNET_free (hostkey_file);
  GNUNET_assert (privkey2 != NULL);
-  GNUNET_CRYPTO_rsa_key_get_public(privkey2, &pubkey2);
+  GNUNET_CRYPTO_ecc_key_get_public(privkey2, &pubkey2);
  GNUNET_CRYPTO_hash(&pubkey2, sizeof (pubkey), &zone2);
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Created record 1\n");
diff --git a/src/namestore/test_namestore_api_zone_iteration_specific_zone.c b/src/namestore/test_namestore_api_zone_iteration_specific_zone.c
index 7adf3fe2a..53457cdaa 100644
--- a/src/namestore/test_namestore_api_zone_iteration_specific_zone.c
+++ b/src/namestore/test_namestore_api_zone_iteration_specific_zone.c
@@ -37,15 +37,15 @@ static GNUNET_SCHEDULER_TaskIdentifier endbadly_task;
 static GNUNET_SCHEDULER_TaskIdentifier stopiteration_task;
-static struct GNUNET_CRYPTO_RsaPrivateKey * privkey;
+static struct GNUNET_CRYPTO_EccPrivateKey * privkey;
-static struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded pubkey;
+static struct GNUNET_CRYPTO_EccPublicKeyBinaryEncoded pubkey;
 static struct GNUNET_CRYPTO_ShortHashCode zone;
-static struct GNUNET_CRYPTO_RsaPrivateKey * privkey2;
+static struct GNUNET_CRYPTO_EccPrivateKey * privkey2;
-static struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded pubkey2;
+static struct GNUNET_CRYPTO_EccPublicKeyBinaryEncoded pubkey2;
 static struct GNUNET_CRYPTO_ShortHashCode zone2;
@@ -55,19 +55,19 @@ static int res;
 static int returned_records;
-static struct GNUNET_CRYPTO_RsaSignature *sig_1;
+static struct GNUNET_CRYPTO_EccSignature *sig_1;
 static char * s_name_1;
 static struct GNUNET_NAMESTORE_RecordData *s_rd_1;
-static struct GNUNET_CRYPTO_RsaSignature *sig_2;
+static struct GNUNET_CRYPTO_EccSignature *sig_2;
 static char * s_name_2;
 static struct GNUNET_NAMESTORE_RecordData *s_rd_2;
-static struct GNUNET_CRYPTO_RsaSignature *sig_3;
+static struct GNUNET_CRYPTO_EccSignature *sig_3;
 static char * s_name_3;
@@ -115,11 +115,11 @@ endbadly (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
  }
  if (privkey != NULL)
-    GNUNET_CRYPTO_rsa_key_free (privkey);
+    GNUNET_CRYPTO_ecc_key_free (privkey);
  privkey = NULL;
  if (privkey2 != NULL)
-    GNUNET_CRYPTO_rsa_key_free (privkey2);
+    GNUNET_CRYPTO_ecc_key_free (privkey2);
  privkey2 = NULL;
  res = 1;
 }
@@ -139,10 +139,10 @@ end (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
    endbadly_task = GNUNET_SCHEDULER_NO_TASK;
  }
  if (privkey != NULL)
-    GNUNET_CRYPTO_rsa_key_free (privkey);
+    GNUNET_CRYPTO_ecc_key_free (privkey);
  privkey = NULL;
  if (privkey2 != NULL)
-    GNUNET_CRYPTO_rsa_key_free (privkey2);
+    GNUNET_CRYPTO_ecc_key_free (privkey2);
  privkey2 = NULL;
  GNUNET_free (sig_1);
@@ -174,12 +174,12 @@ end (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 static void
 zone_proc (void *cls,
-           const struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded *zone_key,
+           const struct GNUNET_CRYPTO_EccPublicKeyBinaryEncoded *zone_key,
           struct GNUNET_TIME_Absolute expire,
           const char *name,
           unsigned int rd_count,
           const struct GNUNET_NAMESTORE_RecordData *rd,
-           const struct GNUNET_CRYPTO_RsaSignature *signature)
+           const struct GNUNET_CRYPTO_EccSignature *signature)
 {
  int failed = GNUNET_NO;
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Callback for zone `%s'\n", GNUNET_short_h2s (&zone));
@@ -212,7 +212,7 @@ zone_proc (void *cls,
        failed = GNUNET_YES;
        GNUNET_break (0);
      }
-      if (0 != memcmp (signature, sig_1, sizeof (struct GNUNET_CRYPTO_RsaSignature)))
+      if (0 != memcmp (signature, sig_1, sizeof (struct GNUNET_CRYPTO_EccSignature)))
      {
        failed = GNUNET_YES;
        GNUNET_break (0);
@@ -233,7 +233,7 @@ zone_proc (void *cls,
        failed = GNUNET_YES;
        GNUNET_break (0);
      }
-      if (0 != memcmp (signature, sig_2, sizeof (struct GNUNET_CRYPTO_RsaSignature)))
+      if (0 != memcmp (signature, sig_2, sizeof (struct GNUNET_CRYPTO_EccSignature)))
      {
        failed = GNUNET_YES;
        GNUNET_break (0);
@@ -334,19 +334,19 @@ run (void *cls,
  GNUNET_asprintf(&hostkey_file,"zonefiles%s%s",DIR_SEPARATOR_STR,
      "N0UJMP015AFUNR2BTNM3FKPBLG38913BL8IDMCO2H0A1LIB81960.zkey");
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Using zonekey file `%s' \n", hostkey_file);
-  privkey = GNUNET_CRYPTO_rsa_key_create_from_file(hostkey_file);
+  privkey = GNUNET_CRYPTO_ecc_key_create_from_file(hostkey_file);
  GNUNET_free (hostkey_file);
  GNUNET_assert (privkey != NULL);
-  GNUNET_CRYPTO_rsa_key_get_public(privkey, &pubkey);
+  GNUNET_CRYPTO_ecc_key_get_public(privkey, &pubkey);
  GNUNET_CRYPTO_short_hash (&pubkey, sizeof (pubkey), &zone);
  GNUNET_asprintf(&hostkey_file,"zonefiles%s%s",DIR_SEPARATOR_STR,
      "HGU0A0VCU334DN7F2I9UIUMVQMM7JMSD142LIMNUGTTV9R0CF4EG.zkey");
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Using zonekey file `%s' \n", hostkey_file);
-  privkey2 = GNUNET_CRYPTO_rsa_key_create_from_file(hostkey_file);
+  privkey2 = GNUNET_CRYPTO_ecc_key_create_from_file(hostkey_file);
  GNUNET_free (hostkey_file);
  GNUNET_assert (privkey2 != NULL);
-  GNUNET_CRYPTO_rsa_key_get_public(privkey2, &pubkey2);
+  GNUNET_CRYPTO_ecc_key_get_public(privkey2, &pubkey2);
  GNUNET_CRYPTO_short_hash (&pubkey2, sizeof (pubkey), &zone2);
  nsh = GNUNET_NAMESTORE_connect (cfg);
  GNUNET_break (NULL != nsh);
diff --git a/src/namestore/test_namestore_api_zone_iteration_stop.c b/src/namestore/test_namestore_api_zone_iteration_stop.c
index dcb6f8c7d..666e09ee8 100644
--- a/src/namestore/test_namestore_api_zone_iteration_stop.c
+++ b/src/namestore/test_namestore_api_zone_iteration_stop.c
@@ -36,15 +36,15 @@ static GNUNET_SCHEDULER_TaskIdentifier endbadly_task;
 static GNUNET_SCHEDULER_TaskIdentifier stopiteration_task;
-static struct GNUNET_CRYPTO_RsaPrivateKey * privkey;
+static struct GNUNET_CRYPTO_EccPrivateKey * privkey;
-static struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded pubkey;
+static struct GNUNET_CRYPTO_EccPublicKeyBinaryEncoded pubkey;
 static struct GNUNET_HashCode zone;
-static struct GNUNET_CRYPTO_RsaPrivateKey * privkey2;
+static struct GNUNET_CRYPTO_EccPrivateKey * privkey2;
-static struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded pubkey2;
+static struct GNUNET_CRYPTO_EccPublicKeyBinaryEncoded pubkey2;
 static struct GNUNET_HashCode zone2;
@@ -54,19 +54,19 @@ static int res;
 static int returned_records;
-static struct GNUNET_CRYPTO_RsaSignature *sig_1;
+static struct GNUNET_CRYPTO_EccSignature *sig_1;
 static char * s_name_1;
 static struct GNUNET_NAMESTORE_RecordData *s_rd_1;
-static struct GNUNET_CRYPTO_RsaSignature *sig_2;
+static struct GNUNET_CRYPTO_EccSignature *sig_2;
 static char * s_name_2;
 static struct GNUNET_NAMESTORE_RecordData *s_rd_2;
-static struct GNUNET_CRYPTO_RsaSignature *sig_3;
+static struct GNUNET_CRYPTO_EccSignature *sig_3;
 static char * s_name_3;
@@ -112,11 +112,11 @@ endbadly (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
    GNUNET_free (s_rd_3);
  }
  if (privkey != NULL)
-    GNUNET_CRYPTO_rsa_key_free (privkey);
+    GNUNET_CRYPTO_ecc_key_free (privkey);
  privkey = NULL;
  if (privkey2 != NULL)
-    GNUNET_CRYPTO_rsa_key_free (privkey2);
+    GNUNET_CRYPTO_ecc_key_free (privkey2);
  privkey2 = NULL;
  res = 1;
 }
@@ -137,10 +137,10 @@ end (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
    endbadly_task = GNUNET_SCHEDULER_NO_TASK;
  }
  if (privkey != NULL)
-    GNUNET_CRYPTO_rsa_key_free (privkey);
+    GNUNET_CRYPTO_ecc_key_free (privkey);
  privkey = NULL;
  if (privkey2 != NULL)
-    GNUNET_CRYPTO_rsa_key_free (privkey2);
+    GNUNET_CRYPTO_ecc_key_free (privkey2);
  privkey2 = NULL;
  GNUNET_free (sig_1);
@@ -177,12 +177,12 @@ end (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 static void
 zone_proc (void *cls,
-           const struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded *zone_key,
+           const struct GNUNET_CRYPTO_EccPublicKeyBinaryEncoded *zone_key,
           struct GNUNET_TIME_Absolute expire,
           const char *name,
           unsigned int rd_count,
           const struct GNUNET_NAMESTORE_RecordData *rd,
-           const struct GNUNET_CRYPTO_RsaSignature *signature)
+           const struct GNUNET_CRYPTO_EccSignature *signature)
 {
  int failed = GNUNET_NO;
@@ -383,19 +383,19 @@ run (void *cls,
  GNUNET_asprintf(&hostkey_file,"zonefiles%s%s",DIR_SEPARATOR_STR,
      "N0UJMP015AFUNR2BTNM3FKPBLG38913BL8IDMCO2H0A1LIB81960.zkey");
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Using zonekey file `%s' \n", hostkey_file);
-  privkey = GNUNET_CRYPTO_rsa_key_create_from_file(hostkey_file);
+  privkey = GNUNET_CRYPTO_ecc_key_create_from_file(hostkey_file);
  GNUNET_free (hostkey_file);
  GNUNET_assert (privkey != NULL);
-  GNUNET_CRYPTO_rsa_key_get_public(privkey, &pubkey);
+  GNUNET_CRYPTO_ecc_key_get_public(privkey, &pubkey);
  GNUNET_CRYPTO_hash(&pubkey, sizeof (pubkey), &zone);
  GNUNET_asprintf(&hostkey_file,"zonefiles%s%s",DIR_SEPARATOR_STR,
      "HGU0A0VCU334DN7F2I9UIUMVQMM7JMSD142LIMNUGTTV9R0CF4EG.zkey");
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Using zonekey file `%s' \n", hostkey_file);
-  privkey2 = GNUNET_CRYPTO_rsa_key_create_from_file(hostkey_file);
+  privkey2 = GNUNET_CRYPTO_ecc_key_create_from_file(hostkey_file);
  GNUNET_free (hostkey_file);
  GNUNET_assert (privkey2 != NULL);
-  GNUNET_CRYPTO_rsa_key_get_public(privkey2, &pubkey2);
+  GNUNET_CRYPTO_ecc_key_get_public(privkey2, &pubkey2);
  GNUNET_CRYPTO_hash(&pubkey2, sizeof (pubkey), &zone2);
  nsh = GNUNET_NAMESTORE_connect (cfg);
diff --git a/src/namestore/test_namestore_api_zone_to_name.c b/src/namestore/test_namestore_api_zone_to_name.c
index 85620719d..2734ebae8 100644
--- a/src/namestore/test_namestore_api_zone_to_name.c
+++ b/src/namestore/test_namestore_api_zone_to_name.c
@@ -43,9 +43,9 @@ static struct GNUNET_NAMESTORE_Handle * nsh;
 static GNUNET_SCHEDULER_TaskIdentifier endbadly_task;
-static struct GNUNET_CRYPTO_RsaPrivateKey * privkey;
+static struct GNUNET_CRYPTO_EccPrivateKey * privkey;
-static struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded pubkey;
+static struct GNUNET_CRYPTO_EccPublicKeyBinaryEncoded pubkey;
 static struct GNUNET_TIME_Absolute expire;
@@ -55,7 +55,7 @@ static struct GNUNET_CRYPTO_ShortHashCode s_zone_value;
 static char * s_name;
-static struct GNUNET_CRYPTO_RsaSignature *s_signature;
+static struct GNUNET_CRYPTO_EccSignature *s_signature;
 static int res;
@@ -73,7 +73,7 @@ endbadly (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
    GNUNET_NAMESTORE_disconnect (nsh);
  nsh = NULL;
  if (privkey != NULL)
-    GNUNET_CRYPTO_rsa_key_free (privkey);
+    GNUNET_CRYPTO_ecc_key_free (privkey);
  privkey = NULL;
  res = 1;
 }
@@ -88,7 +88,7 @@ end (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
    endbadly_task = GNUNET_SCHEDULER_NO_TASK;
  }
  if (privkey != NULL)
-    GNUNET_CRYPTO_rsa_key_free (privkey);
+    GNUNET_CRYPTO_ecc_key_free (privkey);
  privkey = NULL;
  if (nsh != NULL)
    GNUNET_NAMESTORE_disconnect (nsh);
@@ -98,12 +98,12 @@ end (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 static void
 zone_to_name_proc (void *cls,
-                   const struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded *zone_key,
+                   const struct GNUNET_CRYPTO_EccPublicKeyBinaryEncoded *zone_key,
                   struct GNUNET_TIME_Absolute expire,
                   const char *n,
                   unsigned int rd_count,
                   const struct GNUNET_NAMESTORE_RecordData *rd,
-                   const struct GNUNET_CRYPTO_RsaSignature *signature)
+                   const struct GNUNET_CRYPTO_EccSignature *signature)
 {
  int fail = GNUNET_NO;
@@ -125,7 +125,7 @@ zone_to_name_proc (void *cls,
      fail = GNUNET_YES;
      GNUNET_break (0);
    }
-    if ((zone_key == NULL) || (0 != memcmp (zone_key, &pubkey, sizeof (struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded))))
+    if ((zone_key == NULL) || (0 != memcmp (zone_key, &pubkey, sizeof (struct GNUNET_CRYPTO_EccPublicKeyBinaryEncoded))))
    {
      fail = GNUNET_YES;
      GNUNET_break (0);
@@ -175,14 +175,14 @@ run (void *cls,
  GNUNET_asprintf(&hostkey_file,"zonefiles%s%s",DIR_SEPARATOR_STR,
      "N0UJMP015AFUNR2BTNM3FKPBLG38913BL8IDMCO2H0A1LIB81960.zkey");
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Using zonekey file `%s' \n", hostkey_file);
-  privkey = GNUNET_CRYPTO_rsa_key_create_from_file(hostkey_file);
+  privkey = GNUNET_CRYPTO_ecc_key_create_from_file(hostkey_file);
  GNUNET_free (hostkey_file);
  GNUNET_assert (privkey != NULL);
  /* get public key */
-  GNUNET_CRYPTO_rsa_key_get_public(privkey, &pubkey);
+  GNUNET_CRYPTO_ecc_key_get_public(privkey, &pubkey);
  /* zone hash */
-  GNUNET_CRYPTO_short_hash (&pubkey, sizeof (struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded), &s_zone);
+  GNUNET_CRYPTO_short_hash (&pubkey, sizeof (struct GNUNET_CRYPTO_EccPublicKeyBinaryEncoded), &s_zone);
  GNUNET_CRYPTO_short_hash (s_name, strlen (s_name) + 1, &s_zone_value);
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Using PKEY `%s' \n", GNUNET_short_h2s (&s_zone_value));
diff --git a/src/namestore/test_plugin_namestore.c b/src/namestore/test_plugin_namestore.c
index ea0bc781c..b7d2341e4 100644
--- a/src/namestore/test_plugin_namestore.c
+++ b/src/namestore/test_plugin_namestore.c
@@ -95,19 +95,19 @@ load_plugin (const struct GNUNET_CONFIGURATION_Handle *cfg)
 */
 static void 
 test_record (void *cls,
-             const struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded *zone_key,
+             const struct GNUNET_CRYPTO_EccPublicKeyBinaryEncoded *zone_key,
             struct GNUNET_TIME_Absolute expire,
             const char *name,
             unsigned int rd_count,
             const struct GNUNET_NAMESTORE_RecordData *rd,
-             const struct GNUNET_CRYPTO_RsaSignature *signature)
+             const struct GNUNET_CRYPTO_EccSignature *signature)
 {
  int *idp = cls;
  int id = *idp;
-  struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded tzone_key;
+  struct GNUNET_CRYPTO_EccPublicKeyBinaryEncoded tzone_key;
  char tname[64];
  unsigned int trd_count = 1 + (id % 1024);
-  struct GNUNET_CRYPTO_RsaSignature tsignature;
+  struct GNUNET_CRYPTO_EccSignature tsignature;
  unsigned int i;
  GNUNET_snprintf (tname, sizeof (tname),
@@ -122,8 +122,8 @@ test_record (void *cls,
  memset (&tzone_key, (id % 241), sizeof (tzone_key));
  memset (&tsignature, (id % 243), sizeof (tsignature));
  GNUNET_assert (0 == strcmp (name, tname));
-  GNUNET_assert (0 == memcmp (&tzone_key, zone_key, sizeof (struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded)));
+  GNUNET_assert (0 == memcmp (&tzone_key, zone_key, sizeof (struct GNUNET_CRYPTO_EccPublicKeyBinaryEncoded)));
-  GNUNET_assert (0 == memcmp (&tsignature, signature, sizeof (struct GNUNET_CRYPTO_RsaSignature)));
+  GNUNET_assert (0 == memcmp (&tsignature, signature, sizeof (struct GNUNET_CRYPTO_EccSignature)));
 }
@@ -139,12 +139,12 @@ get_record (struct GNUNET_NAMESTORE_PluginFunctions *nsp, int id)
 static void
 put_record (struct GNUNET_NAMESTORE_PluginFunctions *nsp, int id)
 {
-  struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded zone_key;
+  struct GNUNET_CRYPTO_EccPublicKeyBinaryEncoded zone_key;
  struct GNUNET_TIME_Absolute expire;
  char name[64];
  unsigned int rd_count = 1 + (id % 1024);
  struct GNUNET_NAMESTORE_RecordData rd[rd_count];
-  struct GNUNET_CRYPTO_RsaSignature signature;
+  struct GNUNET_CRYPTO_EccSignature signature;
  unsigned int i;
  GNUNET_snprintf (name, sizeof (name),
@@ -175,7 +175,7 @@ run (void *cls, char *const *args, const char *cfgfile,
     const struct GNUNET_CONFIGURATION_Handle *cfg)
 {
  struct GNUNET_NAMESTORE_PluginFunctions *nsp;  
-  struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded zone_key;
+  struct GNUNET_CRYPTO_EccPublicKeyBinaryEncoded zone_key;
  struct GNUNET_CRYPTO_ShortHashCode zone;
  
  ok = 0;
diff --git a/src/namestore/zonefiles/HGU0A0VCU334DN7F2I9UIUMVQMM7JMSD142LIMNUGTTV9R0CF4EG.zkey b/src/namestore/zonefiles/HGU0A0VCU334DN7F2I9UIUMVQMM7JMSD142LIMNUGTTV9R0CF4EG.zkey
index eac1d1e2f..955042ba4 100644
--- a/src/namestore/zonefiles/HGU0A0VCU334DN7F2I9UIUMVQMM7JMSD142LIMNUGTTV9R0CF4EG.zkey
+++ b/src/namestore/zonefiles/HGU0A0VCU334DN7F2I9UIUMVQMM7JMSD142LIMNUGTTV9R0CF4EG.zkey
Binary files differ
diff --git a/src/namestore/zonefiles/N0UJMP015AFUNR2BTNM3FKPBLG38913BL8IDMCO2H0A1LIB81960.zkey b/src/namestore/zonefiles/N0UJMP015AFUNR2BTNM3FKPBLG38913BL8IDMCO2H0A1LIB81960.zkey
index 871fc90ed..8c8c5d54f 100644
--- a/src/namestore/zonefiles/N0UJMP015AFUNR2BTNM3FKPBLG38913BL8IDMCO2H0A1LIB81960.zkey
+++ b/src/namestore/zonefiles/N0UJMP015AFUNR2BTNM3FKPBLG38913BL8IDMCO2H0A1LIB81960.zkey
Binary files differ
diff --git a/src/pt/test_gns_vpn.c b/src/pt/test_gns_vpn.c
index d550e3511..7eed31ceb 100644
--- a/src/pt/test_gns_vpn.c
+++ b/src/pt/test_gns_vpn.c
@@ -363,7 +363,7 @@ run (void *cls,
  enum MHD_FLAG flags;
  struct GNUNET_PeerIdentity id;
  struct GNUNET_CRYPTO_HashAsciiEncoded peername;
-  struct GNUNET_CRYPTO_RsaPrivateKey *host_key;
+  struct GNUNET_CRYPTO_EccPrivateKey *host_key;
  struct GNUNET_NAMESTORE_RecordData rd;
  char *rd_string;
  char *zone_keyfile;
@@ -392,7 +392,7 @@ run (void *cls,
    return;
  }
-  host_key = GNUNET_CRYPTO_rsa_key_create_from_file (zone_keyfile);
+  host_key = GNUNET_CRYPTO_ecc_key_create_from_file (zone_keyfile);
  rd.expiration_time = GNUNET_TIME_UNIT_FOREVER_ABS.abs_value;
  GNUNET_asprintf (&rd_string, "6 %s %s", (char*)&peername, "www.gads.");
  GNUNET_assert (GNUNET_OK == GNUNET_NAMESTORE_string_to_value (GNUNET_GNS_RECORD_VPN,
@@ -410,7 +410,7 @@ run (void *cls,
  GNUNET_free ((void**)rd.data);
  GNUNET_free (rd_string);
  GNUNET_free (zone_keyfile);
-  GNUNET_CRYPTO_rsa_key_free (host_key);
+  GNUNET_CRYPTO_ecc_key_free (host_key);
 }
@@ -561,7 +561,7 @@ main (int argc, char *const *argv)
  GNUNET_free (bin_vpn);    
  GNUNET_free (bin_exit);
  GNUNET_free (bin_dns);
-  GNUNET_CRYPTO_rsa_setup_hostkey ("test_gns_vpn.conf");
+  GNUNET_CRYPTO_ecc_setup_hostkey ("test_gns_vpn.conf");
  
  dest_ip = "169.254.86.1";
  dest_af = AF_INET;
diff --git a/src/pt/test_gnunet_vpn.c b/src/pt/test_gnunet_vpn.c
index c8c7317fc..3a675654d 100644
--- a/src/pt/test_gnunet_vpn.c
+++ b/src/pt/test_gnunet_vpn.c
@@ -426,7 +426,7 @@ main (int argc, char *const *argv)
  GNUNET_free (vpn_binary);
  GNUNET_free (exit_binary);
-  GNUNET_CRYPTO_rsa_setup_hostkey ("test_gnunet_vpn.conf");
+  GNUNET_CRYPTO_ecc_setup_hostkey ("test_gnunet_vpn.conf");
  bin = argv[0];
  if (NULL != strstr (bin, "lt-"))
    bin = strstr (bin, "lt-") + 4;
author	Christian Grothoff <christian@grothoff.org>	2013-05-29 08:18:55 +0000
committer	Christian Grothoff <christian@grothoff.org>	2013-05-29 08:18:55 +0000
commit	022002438e4047d235a688cfd9da7b63ab990103 (patch)
tree	8d0cb444a3ab376b5a8f614fb87bdeb31e7b3327
parent	b62eb443ee3af84f87030fad9fd11a948b1a2503 (diff)
download	gnunet-022002438e4047d235a688cfd9da7b63ab990103.tar.gz gnunet-022002438e4047d235a688cfd9da7b63ab990103.zip