1 files changed, 383 insertions, 43 deletions

diff --git a/src/gnsrecord/gnsrecord_crypto.c b/src/gnsrecord/gnsrecord_crypto.c
index 9c551a936..289f0e885 100644
--- a/src/gnsrecord/gnsrecord_crypto.c
+++ b/src/gnsrecord/gnsrecord_crypto.c
@@ -64,7 +64,6 @@ ecdsa_symmetric_decrypt (
 }
 
 
-
 ssize_t
 ecdsa_symmetric_encrypt (
   const void *block,
@@ -92,6 +91,34 @@ ecdsa_symmetric_encrypt (
 }
 
 
+enum GNUNET_GenericReturnValue
+eddsa_symmetric_decrypt (
+  const void *block,
+  size_t size,
+  const unsigned char *key,
+  const unsigned char *nonce,
+  void *result)
+{
+  if (0 != crypto_secretbox_open_easy (result, block, size, nonce, key))
+  {
+    return GNUNET_SYSERR;
+  }
+  return GNUNET_OK;
+}
+
+
+enum GNUNET_GenericReturnValue
+eddsa_symmetric_encrypt (
+  const void *block,
+  size_t size,
+  const unsigned char *key,
+  const unsigned char *nonce,
+  void *result)
+{
+  crypto_secretbox_easy (result, block, size, nonce, key);
+  return GNUNET_OK;
+}
+
 
 /**
  * Derive session key and iv from label and public key.
@@ -131,6 +158,42 @@ derive_block_aes_key (unsigned char *ctr,
 
 
 /**
+ * Derive session key and iv from label and public key.
+ *
+ * @param nonce initialization vector to initialize
+ * @param skey session key to initialize
+ * @param label label to use for KDF
+ * @param pub public key to use for KDF
+ */
+static void
+derive_block_xsalsa_key (unsigned char *nonce,
+                         unsigned char *key,
+                         const char *label,
+                         uint64_t exp,
+                         const struct GNUNET_CRYPTO_EddsaPublicKey *pub)
+{
+  static const char ctx_key[] = "gns-aes-ctx-key";
+  static const char ctx_iv[] = "gns-aes-ctx-iv";
+
+  GNUNET_CRYPTO_kdf (key, crypto_secretbox_KEYBYTES,
+                     ctx_key, strlen (ctx_key),
+                     pub, sizeof(struct GNUNET_CRYPTO_EddsaPublicKey),
+                     label, strlen (label),
+                     NULL, 0);
+  memset (nonce, 0, crypto_secretbox_NONCEBYTES);
+  /** 16 byte nonce **/
+  GNUNET_CRYPTO_kdf (nonce, (crypto_secretbox_NONCEBYTES - sizeof (exp)),
+                     ctx_iv, strlen (ctx_iv),
+                     pub, sizeof(struct GNUNET_CRYPTO_EddsaPublicKey),
+                     label, strlen (label),
+                     NULL, 0);
+  /** Expiration time 64 bit. **/
+  memcpy (nonce + (crypto_secretbox_NONCEBYTES - sizeof (exp)),
+          &exp, sizeof (exp));
+}
+
+
+/**
  * Sign name and records
  *
  * @param key the private key
@@ -246,6 +309,119 @@ block_create_ecdsa (const struct GNUNET_CRYPTO_EcdsaPrivateKey *key,
 
 
 /**
+ * Sign name and records (EDDSA version)
+ *
+ * @param key the private key
+ * @param pkey associated public key
+ * @param expire block expiration
+ * @param label the name for the records
+ * @param rd record data
+ * @param rd_count number of records
+ * @return NULL on error (block too large)
+ */
+static struct GNUNET_GNSRECORD_Block *
+block_create_eddsa (const struct GNUNET_CRYPTO_EddsaPrivateKey *key,
+                    const struct GNUNET_CRYPTO_EddsaPublicKey *pkey,
+                    struct GNUNET_TIME_Absolute expire,
+                    const char *label,
+                    const struct GNUNET_GNSRECORD_Data *rd,
+                    unsigned int rd_count)
+{
+  ssize_t payload_len = GNUNET_GNSRECORD_records_get_size (rd_count,
+                                                           rd);
+  struct GNUNET_GNSRECORD_Block *block;
+  struct GNUNET_GNSRECORD_EddsaBlock *edblock;
+  struct GNUNET_CRYPTO_EddsaPrivateScalar dkey;
+  unsigned char nonce[crypto_secretbox_NONCEBYTES];
+  unsigned char skey[crypto_secretbox_KEYBYTES];
+  struct GNUNET_GNSRECORD_Data rdc[GNUNET_NZL (rd_count)];
+  uint32_t rd_count_nbo;
+  struct GNUNET_TIME_Absolute now;
+
+  if (payload_len < 0)
+  {
+    GNUNET_break (0);
+    return NULL;
+  }
+  if (payload_len > GNUNET_GNSRECORD_MAX_BLOCK_SIZE)
+  {
+    GNUNET_break (0);
+    return NULL;
+  }
+  /* convert relative to absolute times */
+  now = GNUNET_TIME_absolute_get ();
+  for (unsigned int i = 0; i < rd_count; i++)
+  {
+    rdc[i] = rd[i];
+    if (0 != (rd[i].flags & GNUNET_GNSRECORD_RF_RELATIVE_EXPIRATION))
+    {
+      struct GNUNET_TIME_Relative t;
+
+      /* encrypted blocks must never have relative expiration times, convert! */
+      rdc[i].flags &= ~GNUNET_GNSRECORD_RF_RELATIVE_EXPIRATION;
+      t.rel_value_us = rdc[i].expiration_time;
+      rdc[i].expiration_time = GNUNET_TIME_absolute_add (now, t).abs_value_us;
+    }
+  }
+  /* serialize */
+  rd_count_nbo = htonl (rd_count);
+  {
+    char payload[sizeof(uint32_t) + payload_len];
+
+    GNUNET_memcpy (payload,
+                   &rd_count_nbo,
+                   sizeof(uint32_t));
+    GNUNET_assert (payload_len ==
+                   GNUNET_GNSRECORD_records_serialize (rd_count,
+                                                       rdc,
+                                                       payload_len,
+                                                       &payload[sizeof(uint32_t)
+                                                       ]));
+    block = GNUNET_malloc (sizeof(struct GNUNET_GNSRECORD_Block)
+                           + sizeof(uint32_t)
+                           + payload_len
+                           + crypto_secretbox_MACBYTES);
+    edblock = &block->eddsa_block;
+    block->type = htonl (GNUNET_GNSRECORD_TYPE_EDKEY);
+    edblock->purpose.size = htonl (sizeof(uint32_t)
+                                   + payload_len
+                                   + sizeof(struct
+                                            GNUNET_CRYPTO_EccSignaturePurpose)
+                                   + sizeof(struct GNUNET_TIME_AbsoluteNBO)
+                                   + crypto_secretbox_MACBYTES);
+    edblock->purpose.purpose = htonl (GNUNET_SIGNATURE_PURPOSE_GNS_RECORD_SIGN);
+    edblock->expiration_time = GNUNET_TIME_absolute_hton (expire);
+    /* encrypt and sign */
+    GNUNET_CRYPTO_eddsa_private_key_derive (key,
+                                            label,
+                                            "gns",
+                                            &dkey);
+    // FIXME: We may want a key_get_public_from_private_scalar function
+    struct GNUNET_CRYPTO_EddsaPublicKey test;
+    crypto_scalarmult_ed25519_base_noclamp (test.q_y,
+                                            dkey.s);
+    edblock->derived_key = test;
+    derive_block_xsalsa_key (nonce,
+                             skey,
+                             label,
+                             edblock->expiration_time.abs_value_us__,
+                             pkey);
+    GNUNET_break (GNUNET_OK ==
+                  eddsa_symmetric_encrypt (payload,
+                                           payload_len
+                                           + sizeof(uint32_t),
+                                           skey,
+                                           nonce,
+                                           &edblock[1]));
+  }
+  GNUNET_CRYPTO_eddsa_sign_with_scalar (&dkey,
+                                        &edblock->purpose,
+                                        &edblock->signature);
+  return block;
+}
+
+
+/**
  * Sign name and records
  *
  * @param key the private key
@@ -263,6 +439,7 @@ GNUNET_GNSRECORD_block_create (const struct GNUNET_IDENTITY_PrivateKey *key,
                                unsigned int rd_count)
 {
   struct GNUNET_CRYPTO_EcdsaPublicKey pkey;
+  struct GNUNET_CRYPTO_EddsaPublicKey edkey;
 
   switch (ntohl (key->type))
   {
@@ -275,6 +452,15 @@ GNUNET_GNSRECORD_block_create (const struct GNUNET_IDENTITY_PrivateKey *key,
                                label,
                                rd,
                                rd_count);
+  case GNUNET_GNSRECORD_TYPE_EDKEY:
+    GNUNET_CRYPTO_eddsa_key_get_public (&key->eddsa_key,
+                                        &edkey);
+    return block_create_eddsa (&key->eddsa_key,
+                               &edkey,
+                               expire,
+                               label,
+                               rd,
+                               rd_count);
   default:
     GNUNET_assert (0);
   }
@@ -319,33 +505,45 @@ GNUNET_GNSRECORD_block_create2 (const struct GNUNET_IDENTITY_PrivateKey *pkey,
                                 unsigned int rd_count)
 {
   const struct GNUNET_CRYPTO_EcdsaPrivateKey *key;
+  struct GNUNET_CRYPTO_EddsaPublicKey edpubkey;
 
-  if (GNUNET_IDENTITY_TYPE_ECDSA != ntohl (pkey->type))
+  if (GNUNET_IDENTITY_TYPE_ECDSA == ntohl (pkey->type))
   {
-    return NULL; // FIXME
-  }
-  key = &pkey->ecdsa_key;
+    key = &pkey->ecdsa_key;
 #define CSIZE 64
-  static struct KeyCacheLine cache[CSIZE];
-  struct KeyCacheLine *line;
+    static struct KeyCacheLine cache[CSIZE];
+    struct KeyCacheLine *line;
 
-  line = &cache[(*(unsigned int *) key) % CSIZE];
-  if (0 != memcmp (&line->key,
-                   key,
-                   sizeof(*key)))
+    line = &cache[(*(unsigned int *) key) % CSIZE];
+    if (0 != memcmp (&line->key,
+                     key,
+                     sizeof(*key)))
+    {
+      /* cache miss, recompute */
+      line->key = *key;
+      GNUNET_CRYPTO_ecdsa_key_get_public (key,
+                                          &line->pkey);
+    }
+#undef CSIZE
+    return block_create_ecdsa (key,
+                               &line->pkey,
+                               expire,
+                               label,
+                               rd,
+                               rd_count);
+  }
+  else if (GNUNET_IDENTITY_TYPE_EDDSA == ntohl (pkey->type))
   {
-    /* cache miss, recompute */
-    line->key = *key;
-    GNUNET_CRYPTO_ecdsa_key_get_public (key,
-                                        &line->pkey);
+    GNUNET_CRYPTO_eddsa_key_get_public (&pkey->eddsa_key,
+                                        &edpubkey);
+    return block_create_eddsa (&pkey->eddsa_key,
+                               &edpubkey,
+                               expire,
+                               label,
+                               rd,
+                               rd_count);
   }
-#undef CSIZE
-  return block_create_ecdsa (key,
-                             &line->pkey,
-                             expire,
-                             label,
-                             rd,
-                             rd_count);
+  return NULL;
 }
 
 
@@ -359,21 +557,23 @@ GNUNET_GNSRECORD_block_create2 (const struct GNUNET_IDENTITY_PrivateKey *pkey,
 enum GNUNET_GenericReturnValue
 GNUNET_GNSRECORD_block_verify (const struct GNUNET_GNSRECORD_Block *block)
 {
-  const struct GNUNET_CRYPTO_EcdsaPublicKey *key;
-  const struct GNUNET_GNSRECORD_EcdsaBlock *ecblock;
-
-  if (GNUNET_GNSRECORD_TYPE_PKEY != ntohl (block->type))
+  switch (ntohl (block->type))
   {
-    GNUNET_break (0);
+  case GNUNET_GNSRECORD_TYPE_PKEY:
+    return GNUNET_CRYPTO_ecdsa_verify_ (
+      GNUNET_SIGNATURE_PURPOSE_GNS_RECORD_SIGN,
+      &block->ecdsa_block.purpose,
+      &block->ecdsa_block.signature,
+      &block->ecdsa_block.derived_key);
+  case GNUNET_GNSRECORD_TYPE_EDKEY:
+    return GNUNET_CRYPTO_eddsa_verify_ (
+      GNUNET_SIGNATURE_PURPOSE_GNS_RECORD_SIGN,
+      &block->eddsa_block.purpose,
+      &block->eddsa_block.signature,
+      &block->eddsa_block.derived_key);
+  default:
     return GNUNET_NO;
   }
-  ecblock = &block->ecdsa_block;
-  key = &ecblock->derived_key;
-
-  return GNUNET_CRYPTO_ecdsa_verify_ (GNUNET_SIGNATURE_PURPOSE_GNS_RECORD_SIGN,
-                                      &ecblock->purpose,
-                                      &ecblock->signature,
-                                      key);
 }
 
 
@@ -505,6 +705,134 @@ block_decrypt_ecdsa (const struct GNUNET_GNSRECORD_EcdsaBlock *block,
 }
 
 
+enum GNUNET_GenericReturnValue
+block_decrypt_eddsa (const struct GNUNET_GNSRECORD_EddsaBlock *block,
+                     const struct
+                     GNUNET_CRYPTO_EddsaPublicKey *zone_key,
+                     const char *label,
+                     GNUNET_GNSRECORD_RecordCallback proc,
+                     void *proc_cls)
+{
+  size_t payload_len = ntohl (block->purpose.size)
+                       - sizeof(struct GNUNET_CRYPTO_EccSignaturePurpose)
+                       - sizeof(struct GNUNET_TIME_AbsoluteNBO);
+  unsigned char nonce[crypto_secretbox_NONCEBYTES];
+  unsigned char key[crypto_secretbox_KEYBYTES];
+
+  if (ntohl (block->purpose.size) <
+      sizeof(struct GNUNET_CRYPTO_EccSignaturePurpose)
+      + sizeof(struct GNUNET_TIME_AbsoluteNBO))
+  {
+    GNUNET_break_op (0);
+    return GNUNET_SYSERR;
+  }
+  derive_block_xsalsa_key (nonce,
+                           key,
+                           label,
+                           block->expiration_time.abs_value_us__,
+                           zone_key);
+  {
+    char payload[payload_len];
+    uint32_t rd_count;
+
+    GNUNET_break (GNUNET_OK ==
+                  eddsa_symmetric_decrypt (&block[1], payload_len,
+                                           key, nonce,
+                                           payload));
+    GNUNET_memcpy (&rd_count,
+                   payload,
+                   sizeof(uint32_t));
+    rd_count = ntohl (rd_count);
+    if (rd_count > 2048)
+    {
+      /* limit to sane value */
+      GNUNET_break_op (0);
+      return GNUNET_SYSERR;
+    }
+    {
+      struct GNUNET_GNSRECORD_Data rd[GNUNET_NZL (rd_count)];
+      unsigned int j;
+      struct GNUNET_TIME_Absolute now;
+
+      if (GNUNET_OK !=
+          GNUNET_GNSRECORD_records_deserialize (payload_len - sizeof(uint32_t),
+                                                &payload[sizeof(uint32_t)],
+                                                rd_count,
+                                                rd))
+      {
+        GNUNET_break_op (0);
+        return GNUNET_SYSERR;
+      }
+      /* hide expired records */
+      now = GNUNET_TIME_absolute_get ();
+      j = 0;
+      for (unsigned int i = 0; i < rd_count; i++)
+      {
+        if (0 != (rd[i].flags & GNUNET_GNSRECORD_RF_RELATIVE_EXPIRATION))
+        {
+          /* encrypted blocks must never have relative expiration times, skip! */
+          GNUNET_break_op (0);
+          continue;
+        }
+
+        if (0 != (rd[i].flags & GNUNET_GNSRECORD_RF_SHADOW_RECORD))
+        {
+          int include_record = GNUNET_YES;
+          /* Shadow record, figure out if we have a not expired active record */
+          for (unsigned int k = 0; k < rd_count; k++)
+          {
+            if (k == i)
+              continue;
+            if (rd[i].expiration_time < now.abs_value_us)
+              include_record = GNUNET_NO;       /* Shadow record is expired */
+            if ((rd[k].record_type == rd[i].record_type) &&
+                (rd[k].expiration_time >= now.abs_value_us) &&
+                (0 == (rd[k].flags & GNUNET_GNSRECORD_RF_SHADOW_RECORD)))
+            {
+              include_record = GNUNET_NO;         /* We have a non-expired, non-shadow record of the same type */
+              GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+                          "Ignoring shadow record\n");
+              break;
+            }
+          }
+          if (GNUNET_YES == include_record)
+          {
+            rd[i].flags ^= GNUNET_GNSRECORD_RF_SHADOW_RECORD;       /* Remove Flag */
+            if (j != i)
+              rd[j] = rd[i];
+            j++;
+          }
+        }
+        else if (rd[i].expiration_time >= now.abs_value_us)
+        {
+          /* Include this record */
+          if (j != i)
+            rd[j] = rd[i];
+          j++;
+        }
+        else
+        {
+          struct GNUNET_TIME_Absolute at;
+
+          at.abs_value_us = rd[i].expiration_time;
+          GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+                      "Excluding record that expired %s (%llu ago)\n",
+                      GNUNET_STRINGS_absolute_time_to_string (at),
+                      (unsigned long long) rd[i].expiration_time
+                      - now.abs_value_us);
+        }
+      }
+      rd_count = j;
+      if (NULL != proc)
+        proc (proc_cls,
+              rd_count,
+              (0 != rd_count) ? rd : NULL);
+    }
+  }
+  return GNUNET_OK;
+}
+
+
 /**
  * Decrypt block.
  *
@@ -524,17 +852,17 @@ GNUNET_GNSRECORD_block_decrypt (const struct GNUNET_GNSRECORD_Block *block,
                                 GNUNET_GNSRECORD_RecordCallback proc,
                                 void *proc_cls)
 {
-  const struct GNUNET_CRYPTO_EcdsaPublicKey *key;
-
-  if (GNUNET_IDENTITY_TYPE_ECDSA != ntohl (zone_key->type))
+  switch (ntohl (zone_key->type))
   {
-    return GNUNET_NO;
+  case GNUNET_IDENTITY_TYPE_ECDSA:
+    return block_decrypt_ecdsa (&block->ecdsa_block,
+                                &zone_key->ecdsa_key, label, proc, proc_cls);
+  case GNUNET_IDENTITY_TYPE_EDDSA:
+    return block_decrypt_eddsa (&block->eddsa_block,
+                                &zone_key->eddsa_key, label, proc, proc_cls);
+  default:
+    return GNUNET_SYSERR;
   }
-  key = &zone_key->ecdsa_key;
-
-  return block_decrypt_ecdsa (&block->ecdsa_block,
-                              key, label, proc, proc_cls);
-
 }
 
 
@@ -555,6 +883,7 @@ GNUNET_GNSRECORD_query_from_private_key (const struct
   switch (ntohl (zone->type))
   {
   case GNUNET_GNSRECORD_TYPE_PKEY:
+  case GNUNET_GNSRECORD_TYPE_EDKEY:
 
     GNUNET_IDENTITY_key_get_public (zone,
                                     &pub);
@@ -570,6 +899,7 @@ GNUNET_GNSRECORD_query_from_private_key (const struct
 
 /**
  * Calculate the DHT query for a given @a label in a given @a zone.
+ * FIXME: We may want to plugin-ize this at some point.
  *
  * @param pub public key of the zone
  * @param label label of the record
@@ -595,6 +925,16 @@ GNUNET_GNSRECORD_query_from_public_key (const struct
                         sizeof (pd.ecdsa_key),
                         query);
     break;
+  case GNUNET_GNSRECORD_TYPE_EDKEY:
+    pd.type = pub->type;
+    GNUNET_CRYPTO_eddsa_public_key_derive (&pub->eddsa_key,
+                                           label,
+                                           "gns",
+                                           &pd.eddsa_key);
+    GNUNET_CRYPTO_hash (&pd.eddsa_key,
+                        sizeof (pd.eddsa_key),
+                        query);
+    break;
   default:
     GNUNET_assert (0);
   }