-fix non-deterministic peerstore sync failure

8 files changed, 518 insertions, 52 deletions

diff --git a/src/include/gnunet_crypto_lib.h b/src/include/gnunet_crypto_lib.h
index 3ee8ea5a7..38a3ab3b6 100644
--- a/src/include/gnunet_crypto_lib.h
+++ b/src/include/gnunet_crypto_lib.h
@@ -1297,20 +1297,100 @@ GNUNET_CRYPTO_ecc_dlog_prepare (unsigned int max,
                                 unsigned int mem);
 
 
-
 /**
  * Calculate ECC discrete logarithm for small factors.
+ * Opposite of #GNUNET_CRYPTO_ecc_dexp().
  * 
  * @param dlc precalculated values, determine range of factors
  * @param input point on the curve to factor
  * @return `dlc->max` if dlog failed, otherwise the factor
  */
-unsigned int
+int
 GNUNET_CRYPTO_ecc_dlog (struct GNUNET_CRYPTO_EccDlogContext *edc,
                         gcry_mpi_point_t input);
 
 
 /**
+ * Multiply the generator g of the elliptic curve by @a val
+ * to obtain the point on the curve representing @a val.
+ * Afterwards, point addition will correspond to integer
+ * addition.  #GNUNET_CRYPTO_ecc_dlog() can be used to 
+ * convert a point back to an integer (as long as the
+ * integer is smaller than the MAX of the @a edc context).
+ * 
+ * @param edc calculation context for ECC operations
+ * @param val value to encode into a point
+ * @return representation of the value as an ECC point,
+ *         must be freed using #GNUNET_CRYPTO_ecc_free()
+ */
+gcry_mpi_point_t
+GNUNET_CRYPTO_ecc_dexp (struct GNUNET_CRYPTO_EccDlogContext *edc,
+                        int val);
+
+
+/**
+ * Multiply the generator g of the elliptic curve by @a val
+ * to obtain the point on the curve representing @a val.
+ * 
+ * @param edc calculation context for ECC operations
+ * @param val (positive) value to encode into a point
+ * @return representation of the value as an ECC point,
+ *         must be freed using #GNUNET_CRYPTO_ecc_free()
+ */
+gcry_mpi_point_t
+GNUNET_CRYPTO_ecc_dexp_mpi (struct GNUNET_CRYPTO_EccDlogContext *edc,
+                            gcry_mpi_t val);
+
+
+/**
+ * Add two points on the elliptic curve.
+ * 
+ * @param edc calculation context for ECC operations
+ * @param a some value
+ * @param b some value
+ * @return @a a + @a b, must be freed using #GNUNET_CRYPTO_ecc_free()
+ */
+gcry_mpi_point_t
+GNUNET_CRYPTO_ecc_add (struct GNUNET_CRYPTO_EccDlogContext *edc,
+                       gcry_mpi_point_t a,
+                       gcry_mpi_point_t b);
+
+
+/**
+ * Obtain a random point on the curve and its
+ * additive inverse. Both returned values
+ * must be freed using #GNUNET_CRYPTO_ecc_free().
+ * 
+ * @param edc calculation context for ECC operations
+ * @param[out] r set to a random point on the curve
+ * @param[out] r_inv set to the additive inverse of @a r
+ */
+void
+GNUNET_CRYPTO_ecc_rnd (struct GNUNET_CRYPTO_EccDlogContext *edc,
+                       gcry_mpi_point_t *r,
+                       gcry_mpi_point_t *r_inv);
+
+
+/**
+ * Generate a random value mod n.
+ *
+ * @param edc ECC context
+ * @return random value mod n.
+ */
+gcry_mpi_t
+GNUNET_CRYPTO_ecc_random_mod_n (struct GNUNET_CRYPTO_EccDlogContext *edc);
+
+
+/**
+ * Free a point value returned by the API.
+ * 
+ * @param p point to free
+ */
+void
+GNUNET_CRYPTO_ecc_free (gcry_mpi_point_t p);
+
+
+/**
  * Release precalculated values.
  *
  * @param dlc dlog context
diff --git a/src/peerstore/gnunet-service-peerstore.c b/src/peerstore/gnunet-service-peerstore.c
index 99facb0cc..f680c5d14 100644
--- a/src/peerstore/gnunet-service-peerstore.c
+++ b/src/peerstore/gnunet-service-peerstore.c
@@ -1,6 +1,6 @@
 /*
      This file is part of GNUnet.
-     Copyright (C)
+     Copyright (C) 2014, 2015 GNUnet e.V.
 
      GNUnet is free software; you can redistribute it and/or modify
      it under the terms of the GNU General Public License as published
diff --git a/src/peerstore/test_peerstore_api_sync.c b/src/peerstore/test_peerstore_api_sync.c
index 2b2d34374..f53aad544 100644
--- a/src/peerstore/test_peerstore_api_sync.c
+++ b/src/peerstore/test_peerstore_api_sync.c
@@ -1,6 +1,6 @@
 /*
      This file is part of GNUnet.
-     Copyright (C)
+     Copyright (C) 2015 GNUnet e.V.
 
      GNUnet is free software; you can redistribute it and/or modify
      it under the terms of the GNU General Public License as published
@@ -19,26 +19,69 @@
 */
 /**
  * @file peerstore/test_peerstore_api_sync.c
- * @brief testcase for peerstore sync before disconnect feature
+ * @brief testcase for peerstore sync-on-disconnect feature. Stores
+ *        a value just before disconnecting, and then checks that
+ *        this value is actually stored.
+ * @author Omar Tarabai
+ * @author Christian Grothoff (minor fix, comments)
  */
 #include "platform.h"
 #include "gnunet_util_lib.h"
 #include "gnunet_testing_lib.h"
 #include "gnunet_peerstore_service.h"
 
-static int ok = 1;
+/**
+ * Overall result, 0 for success.
+ */
+static int ok = 404;
 
+/**
+ * Configuration we use.
+ */
 static const struct GNUNET_CONFIGURATION_Handle *cfg;
 
+/**
+ * handle to talk to the peerstore.
+ */
 static struct GNUNET_PEERSTORE_Handle *h;
 
-static char *subsystem = "test_peerstore_api_sync";
+/**
+ * Subsystem we store the value for.
+ */
+static const char *subsystem = "test_peerstore_api_sync";
+
+/**
+ * Fake PID under which we store the value.
+ */
 static struct GNUNET_PeerIdentity pid;
-static char *key = "test_peerstore_api_store_key";
-static char *val = "test_peerstore_api_store_val";
 
+/**
+ * Test key we're storing the test value under.
+ */
+static const char *key = "test_peerstore_api_store_key";
+
+/**
+ * Test value we are storing.
+ */
+static const char *val = "test_peerstore_api_store_val";
+
+
+/**
+ * Function that should be called with the result of the
+ * lookup, and finally once with NULL to signal the end
+ * of the iteration.
+ *
+ * Upon the first call, we set "ok" to success. On the
+ * second call (end of iteration) we terminate the test.
+ *
+ * @param cls NULL
+ * @param record the information stored in the peerstore
+ * @param emsg any error message
+ * @return #GNUNET_YES (all good, continue)
+ */
 static int
-iterate_cb (void *cls, const struct GNUNET_PEERSTORE_Record *record,
+iterate_cb (void *cls, 
+            const struct GNUNET_PEERSTORE_Record *record,
             const char *emsg)
 {
   const char *rec_val;
@@ -46,7 +89,8 @@ iterate_cb (void *cls, const struct GNUNET_PEERSTORE_Record *record,
   GNUNET_break (NULL == emsg);
   if (NULL == record)
   {
-    GNUNET_PEERSTORE_disconnect (h, GNUNET_NO);
+    GNUNET_PEERSTORE_disconnect (h, 
+                                 GNUNET_NO);
     GNUNET_SCHEDULER_shutdown ();
     return GNUNET_YES;
   }
@@ -57,25 +101,68 @@ iterate_cb (void *cls, const struct GNUNET_PEERSTORE_Record *record,
 }
 
 
+/**
+ * Run the 2nd stage of the test where we fetch the
+ * data that should have been stored.
+ *
+ * @param cls NULL
+ * @param tc unused
+ */
+static void
+test_cont (void *cls,
+           const struct GNUNET_SCHEDULER_TaskContext *tc)
+{
+  h = GNUNET_PEERSTORE_connect (cfg);
+  GNUNET_PEERSTORE_iterate (h, 
+                            subsystem, 
+                            &pid, key,
+                            GNUNET_TIME_UNIT_FOREVER_REL, 
+                            &iterate_cb, NULL);
+}
+
+
+/**
+ * Actually run the test.
+ */
 static void
 test1 ()
 {
-  GNUNET_PEERSTORE_store (h, subsystem, &pid, key, val, strlen (val) + 1,
-                          GNUNET_TIME_UNIT_FOREVER_ABS,
-                          GNUNET_PEERSTORE_STOREOPTION_REPLACE, NULL, NULL);
-  GNUNET_PEERSTORE_disconnect (h, GNUNET_YES);
   h = GNUNET_PEERSTORE_connect (cfg);
-  GNUNET_PEERSTORE_iterate (h, subsystem, &pid, key,
-                            GNUNET_TIME_UNIT_FOREVER_REL, &iterate_cb, NULL);
+  GNUNET_PEERSTORE_store (h, 
+                          subsystem,
+                          &pid, 
+                          key, 
+                          val, strlen (val) + 1,
+                          GNUNET_TIME_UNIT_FOREVER_ABS,
+                          GNUNET_PEERSTORE_STOREOPTION_REPLACE, 
+                          NULL, NULL);
+  GNUNET_PEERSTORE_disconnect (h, 
+                               GNUNET_YES);
+  h = NULL;
+  /* We need to wait a little bit to give the disconnect
+     a chance to actually finish the operation; otherwise,
+     the test may fail non-deterministically if the new
+     connection is faster than the cleanup routine of the
+     old one. */
+  GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_SECONDS,
+                                &test_cont,
+                                NULL);
 }
 
 
+/**
+ * Initialize globals and launch the test.
+ *
+ * @param cls NULL
+ * @param c configuration to use
+ * @param peer handle to our peer (unused)
+ */
 static void
-run (void *cls, const struct GNUNET_CONFIGURATION_Handle *c,
+run (void *cls, 
+     const struct GNUNET_CONFIGURATION_Handle *c,
      struct GNUNET_TESTING_Peer *peer)
 {
   cfg = c;
-  h = GNUNET_PEERSTORE_connect (cfg);
   GNUNET_assert (NULL != h);
   memset (&pid, 1, sizeof (pid));
   test1 ();
@@ -86,10 +173,16 @@ int
 main (int argc, char *argv[])
 {
   if (0 !=
-      GNUNET_TESTING_service_run ("test-gnunet-peerstore", "peerstore",
-                                  "test_peerstore_api_data.conf", &run, NULL))
+      GNUNET_TESTING_service_run ("test-gnunet-peerstore-sync", 
+                                  "peerstore",
+                                  "test_peerstore_api_data.conf",
+                                  &run, NULL))
     return 1;
+  if (0 != ok)
+    fprintf (stderr,
+             "Test failed: %d\n",
+             ok).
   return ok;
 }
 
-/* end of test_peerstore_api_store.c */
+/* end of test_peerstore_api_sync.c */
diff --git a/src/util/crypto_ecc_dlog.c b/src/util/crypto_ecc_dlog.c
index 34f3c203d..3a2a91532 100644
--- a/src/util/crypto_ecc_dlog.c
+++ b/src/util/crypto_ecc_dlog.c
@@ -20,11 +20,10 @@
 
 /**
  * @file util/crypto_ecc_dlog.c
- * @brief ECC discreate logarithm for small values
+ * @brief ECC addition and discreate logarithm for small values.
+ *        Allows us to use ECC for computations as long as the
+ *        result is relativey small.
  * @author Christian Grothoff
- *
- * TODO:
- * - support negative factors
  */
 #include "platform.h"
 #include <gcrypt.h>
@@ -66,9 +65,27 @@ extract_pk (gcry_mpi_point_t pt,
  */
 struct GNUNET_CRYPTO_EccDlogContext 
 {
+  /**
+   * Maximum absolute value the calculation supports.
+   */
   unsigned int max;
+
+  /**
+   * How much memory should we use (relates to the number of entries in the map).
+   */
   unsigned int mem;
+
+  /**
+   * Map mapping points (here "interpreted" as EdDSA public keys) to
+   * a "void * = long" which corresponds to the numeric value of the
+   * point.  As NULL is used to represent "unknown", the actual value
+   * represented by the entry in the map is the "long" minus @e max.
+   */
   struct GNUNET_CONTAINER_MultiPeerMap *map;
+
+  /**
+   * Context to use for operations on the elliptic curve.
+   */
   gcry_ctx_t ctx;
 
 };
@@ -91,8 +108,10 @@ GNUNET_CRYPTO_ecc_dlog_prepare (unsigned int max,
   struct GNUNET_PeerIdentity key;
   gcry_mpi_point_t gKi;
   gcry_mpi_t fact;
+  gcry_mpi_t n;
   unsigned int i;
 
+  GNUNET_assert (max < INT32_MAX);
   edc = GNUNET_new (struct GNUNET_CRYPTO_EccDlogContext);
   edc->max = max;
   edc->mem = mem;
@@ -115,10 +134,25 @@ GNUNET_CRYPTO_ecc_dlog_prepare (unsigned int max,
     GNUNET_assert (GNUNET_OK ==
                    GNUNET_CONTAINER_multipeermap_put (edc->map,
                                                       &key,
-                                                      (void*) (long) i + 1,
+                                                      (void*) (long) i + max,
+                                                      GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
+  }
+  /* negative values */
+  n = gcry_mpi_ec_get_mpi ("n", edc->ctx, 1);
+  for (i=1;i<mem;i++)
+  {
+    gcry_mpi_set_ui (fact, i * K);
+    gcry_mpi_sub (fact, n, fact);
+    gcry_mpi_ec_mul (gKi, fact, g, edc->ctx);
+    extract_pk (gKi, edc->ctx, &key);
+    GNUNET_assert (GNUNET_OK ==
+                   GNUNET_CONTAINER_multipeermap_put (edc->map,
+                                                      &key,
+                                                      (void*) (long) max - i,
                                                       GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
   }
   gcry_mpi_release (fact);
+  gcry_mpi_release (n);
   gcry_mpi_point_release (gKi);
   gcry_mpi_point_release (g);
   return edc;
@@ -132,7 +166,7 @@ GNUNET_CRYPTO_ecc_dlog_prepare (unsigned int max,
  * @param input point on the curve to factor
  * @return `edc->max` if dlog failed, otherwise the factor
  */
-unsigned int
+int
 GNUNET_CRYPTO_ecc_dlog (struct GNUNET_CRYPTO_EccDlogContext *edc,
                         gcry_mpi_point_t input)
 {
@@ -141,7 +175,7 @@ GNUNET_CRYPTO_ecc_dlog (struct GNUNET_CRYPTO_EccDlogContext *edc,
   struct GNUNET_PeerIdentity key;
   gcry_mpi_point_t q;
   unsigned int i;
-  unsigned int res;
+  int res;
   void *retp;
 
   g = gcry_mpi_ec_get_point ("g", edc->ctx, 0);
@@ -159,10 +193,10 @@ GNUNET_CRYPTO_ecc_dlog (struct GNUNET_CRYPTO_EccDlogContext *edc,
                                               &key);
     if (NULL != retp)
     {
-      res = (((long) retp) - 1) * K - i;
-      fprintf (stderr,
-               "Got DLOG %u\n",
-               res);
+      res = (((long) retp) - edc->max) * K - i;
+      /* we continue the loop here to make the implementation
+         "constant-time". If we do not care about this, we could just
+         'break' here and do fewer operations... */
     }
     if (i == edc->max/edc->mem)
       break;
@@ -180,6 +214,40 @@ GNUNET_CRYPTO_ecc_dlog (struct GNUNET_CRYPTO_EccDlogContext *edc,
 
 
 /**
+ * Generate a random value mod n.
+ *
+ * @param edc ECC context
+ * @return random value mod n.
+ */
+gcry_mpi_t
+GNUNET_CRYPTO_ecc_random_mod_n (struct GNUNET_CRYPTO_EccDlogContext *edc)
+{
+  gcry_mpi_t n;
+  unsigned int highbit;
+  gcry_mpi_t r;
+
+  n = gcry_mpi_ec_get_mpi ("n", edc->ctx, 1);
+
+  /* check public key for number of bits, bail out if key is all zeros */
+  highbit = 256; /* Curve25519 */
+  while ( (! gcry_mpi_test_bit (n, highbit)) &&
+          (0 != highbit) )
+    highbit--;
+  GNUNET_assert (0 != highbit);
+  /* generate fact < n (without bias) */
+  GNUNET_assert (NULL != (r = gcry_mpi_new (0)));
+  do {
+    gcry_mpi_randomize (r, 
+                        highbit + 1,
+                        GCRY_STRONG_RANDOM);
+  }
+  while (gcry_mpi_cmp (r, n) >= 0);  
+  gcry_mpi_release (n);
+  return r;
+}
+
+
+/**
  * Release precalculated values.
  *
  * @param edc dlog context
@@ -191,6 +259,147 @@ GNUNET_CRYPTO_ecc_dlog_release (struct GNUNET_CRYPTO_EccDlogContext *edc)
   GNUNET_CONTAINER_multipeermap_destroy (edc->map);
   GNUNET_free (edc);
 }
+
+
+/**
+ * Multiply the generator g of the elliptic curve by @a val
+ * to obtain the point on the curve representing @a val.
+ * Afterwards, point addition will correspond to integer
+ * addition.  #GNUNET_CRYPTO_ecc_dlog() can be used to 
+ * convert a point back to an integer (as long as the
+ * integer is smaller than the MAX of the @a edc context).
+ * 
+ * @param edc calculation context for ECC operations
+ * @param val value to encode into a point
+ * @return representation of the value as an ECC point,
+ *         must be freed using #GNUNET_CRYPTO_ecc_free()
+ */
+gcry_mpi_point_t
+GNUNET_CRYPTO_ecc_dexp (struct GNUNET_CRYPTO_EccDlogContext *edc,
+                        int val)
+{
+  gcry_mpi_t fact;
+  gcry_mpi_t n;
+  gcry_mpi_point_t g;
+  gcry_mpi_point_t r;
+
+  g = gcry_mpi_ec_get_point ("g", edc->ctx, 0);
+  GNUNET_assert (NULL != g);
+  fact = gcry_mpi_new (0);
+  if (val < 0)
+  {
+    n = gcry_mpi_ec_get_mpi ("n", edc->ctx, 1);
+    gcry_mpi_set_ui (fact, - val);
+    gcry_mpi_sub (fact, n, fact);
+    gcry_mpi_release (n);
+  }
+  else
+  {
+    gcry_mpi_set_ui (fact, val);
+  }
+  r = gcry_mpi_point_new (0);
+  gcry_mpi_ec_mul (r, fact, g, edc->ctx);
+  gcry_mpi_release (fact);
+  gcry_mpi_point_release (g);
+  return r;
+}
+
+
+/**
+ * Multiply the generator g of the elliptic curve by @a val
+ * to obtain the point on the curve representing @a val.
+ * 
+ * @param edc calculation context for ECC operations
+ * @param val (positive) value to encode into a point
+ * @return representation of the value as an ECC point,
+ *         must be freed using #GNUNET_CRYPTO_ecc_free()
+ */
+gcry_mpi_point_t
+GNUNET_CRYPTO_ecc_dexp_mpi (struct GNUNET_CRYPTO_EccDlogContext *edc,
+                            gcry_mpi_t val)
+{
+  gcry_mpi_point_t g;
+  gcry_mpi_point_t r;
+
+  g = gcry_mpi_ec_get_point ("g", edc->ctx, 0);
+  GNUNET_assert (NULL != g);
+  r = gcry_mpi_point_new (0);
+  gcry_mpi_ec_mul (r, val, g, edc->ctx);
+  gcry_mpi_point_release (g);
+  return r;
+}
+
+
+/**
+ * Add two points on the elliptic curve.
+ * 
+ * @param edc calculation context for ECC operations
+ * @param a some value
+ * @param b some value
+ * @return @a a + @a b, must be freed using #GNUNET_CRYPTO_ecc_free()
+ */
+gcry_mpi_point_t
+GNUNET_CRYPTO_ecc_add (struct GNUNET_CRYPTO_EccDlogContext *edc,
+                       gcry_mpi_point_t a,
+                       gcry_mpi_point_t b)
+{
+  gcry_mpi_point_t r;
   
+  r = gcry_mpi_point_new (0);
+  gcry_mpi_ec_add (r, a, b, edc->ctx);
+  return r;
+}
+
+
+/**
+ * Obtain a random point on the curve and its
+ * additive inverse. Both returned values
+ * must be freed using #GNUNET_CRYPTO_ecc_free().
+ * 
+ * @param edc calculation context for ECC operations
+ * @param[out] r set to a random point on the curve
+ * @param[out] r_inv set to the additive inverse of @a r
+ */
+void
+GNUNET_CRYPTO_ecc_rnd (struct GNUNET_CRYPTO_EccDlogContext *edc,
+                       gcry_mpi_point_t *r,
+                       gcry_mpi_point_t *r_inv)
+{
+  gcry_mpi_t fact;
+  gcry_mpi_t n;
+  gcry_mpi_point_t g;
+
+  fact = GNUNET_CRYPTO_ecc_random_mod_n (edc);
+
+  /* calculate 'r' */
+  g = gcry_mpi_ec_get_point ("g", edc->ctx, 0);
+  GNUNET_assert (NULL != g);
+  *r = gcry_mpi_point_new (0);
+  gcry_mpi_ec_mul (*r, fact, g, edc->ctx);
+
+  /* calculate 'r_inv' */
+  n = gcry_mpi_ec_get_mpi ("n", edc->ctx, 1);
+  gcry_mpi_sub (fact, n, fact); /* fact = n - fact = - fact */
+  *r_inv = gcry_mpi_point_new (0); 
+  gcry_mpi_ec_mul (*r_inv, fact, g, edc->ctx);
+
+  gcry_mpi_release (n);
+  gcry_mpi_release (fact);
+  gcry_mpi_point_release (g);
+}
+ 
+
+/**
+ * Free a point value returned by the API.
+ * 
+ * @param p point to free
+ */
+void
+GNUNET_CRYPTO_ecc_free (gcry_mpi_point_t p)
+{
+  gcry_mpi_point_release (p);
+}
+
+ 
 /* end of crypto_ecc_dlog.c */
 
diff --git a/src/util/crypto_paillier.c b/src/util/crypto_paillier.c
index 8d5245d3e..e348be80a 100644
--- a/src/util/crypto_paillier.c
+++ b/src/util/crypto_paillier.c
@@ -269,7 +269,7 @@ GNUNET_CRYPTO_paillier_encrypt (const struct GNUNET_CRYPTO_PaillierPublicKey *pu
   }
 
   /* generate r < n (without bias) */
-  GNUNET_assert (0 != (r = gcry_mpi_new (0)));
+  GNUNET_assert (NULL != (r = gcry_mpi_new (0)));
   do {
     gcry_mpi_randomize (r, highbit + 1, GCRY_STRONG_RANDOM);
   }
diff --git a/src/util/gnunet-ecc.c b/src/util/gnunet-ecc.c
index 5585ae85c..081cd0525 100644
--- a/src/util/gnunet-ecc.c
+++ b/src/util/gnunet-ecc.c
@@ -28,6 +28,9 @@
 #include "gnunet_testing_lib.h"
 #include <gcrypt.h>
 
+/**
+ * Number of characters a Base32-encoded public key requires.
+ */
 #define KEY_STR_LEN sizeof(struct GNUNET_CRYPTO_EddsaPublicKey)*8/5+1
 
 /**
@@ -69,9 +72,9 @@ create_keys (const char *fn, const char *prefix)
   struct GNUNET_CRYPTO_EddsaPrivateKey *pk;
   struct GNUNET_CRYPTO_EddsaPublicKey target_pub;
   static char vanity[KEY_STR_LEN + 1];
-  int len;
-  int n;
-  int rest;
+  size_t len;
+  size_t n;
+  size_t rest;
   unsigned char mask;
   unsigned target_byte;
   char *s;
@@ -119,9 +122,9 @@ create_keys (const char *fn, const char *prefix)
              s);
     GNUNET_free (s);
     fprintf (stderr,
-             "\nattempt %s [%d, %X]\n",
+             "\nattempt %s [%u, %X]\n",
              vanity,
-             n,
+             (unsigned int) n,
              mask);
   }
   else
diff --git a/src/util/resolver_api.c b/src/util/resolver_api.c
index 7d7c74ad6..8d2986c7b 100644
--- a/src/util/resolver_api.c
+++ b/src/util/resolver_api.c
@@ -1028,7 +1028,10 @@ GNUNET_RESOLVER_local_fqdn_get ()
            gai_strerror (ret));
       return NULL;
     }
-    rval = GNUNET_strdup (ai->ai_canonname);
+    if (NULL != ai->ai_canonname)
+      rval = GNUNET_strdup (ai->ai_canonname);
+    else
+      rval = GNUNET_strdup (hostname);
     freeaddrinfo (ai);
     return rval;
   }
diff --git a/src/util/test_crypto_ecc_dlog.c b/src/util/test_crypto_ecc_dlog.c
index a594e5795..2101b28f1 100644
--- a/src/util/test_crypto_ecc_dlog.c
+++ b/src/util/test_crypto_ecc_dlog.c
@@ -22,9 +22,6 @@
  * @file util/test_crypto_ecc_dlog.c
  * @brief testcase for ECC DLOG calculation
  * @author Christian Grothoff
- *
- * TODO:
- * - test negative numbers
  */
 #include "platform.h"
 #include "gnunet_util_lib.h"
@@ -42,52 +39,132 @@
 /**
  * Maximum value we test dlog for.
  */
-#define MAX_FACT 1000000
+#define MAX_FACT 100
 
 /**
  * Maximum memory to use, sqrt(MAX_FACT) is a good choice.
  */
-#define MAX_MEM 1000
+#define MAX_MEM 10
+
+/**
+ * How many values do we test?
+ */  
+#define TEST_ITER 10
 
+/**
+ * Range of values to use for MATH tests.
+ */  
+#define MATH_MAX 5
 
+
+/**
+ * Do some DLOG operations for testing.
+ *
+ * @param edc context for ECC operations
+ */
 static void
 test_dlog (struct GNUNET_CRYPTO_EccDlogContext *edc)
 {
   gcry_mpi_t fact;
+  gcry_mpi_t n;
   gcry_ctx_t ctx;
   gcry_mpi_point_t q;
   gcry_mpi_point_t g;
   unsigned int i;
-  unsigned int x;
+  int x;
+  int iret;
 
   GNUNET_assert (0 == gcry_mpi_ec_new (&ctx, NULL, CURVE));
   g = gcry_mpi_ec_get_point ("g", ctx, 0);
   GNUNET_assert (NULL != g);
+  n = gcry_mpi_ec_get_mpi ("n", ctx, 0);
   q = gcry_mpi_point_new (0);
   fact = gcry_mpi_new (0);
-  for (i=0;i<10;i++)
+  for (i=0;i<TEST_ITER;i++)
   {
+    fprintf (stderr, ".");
     x = GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK,
                                   MAX_FACT);
-    gcry_mpi_set_ui (fact, x);
+    if (0 == GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK,
+                                       2))
+    {
+      gcry_mpi_set_ui (fact, x);
+      gcry_mpi_sub (fact, n, fact);
+      x = - x;
+    }
+    else 
+    {
+      gcry_mpi_set_ui (fact, x);
+    }
     gcry_mpi_ec_mul (q, fact, g, ctx);
     if  (x !=
-         GNUNET_CRYPTO_ecc_dlog (edc,
-                                 q))
+         (iret = GNUNET_CRYPTO_ecc_dlog (edc,
+                                         q)))
     {
       fprintf (stderr, 
-               "DLOG failed for value %u\n", 
-               x);
+               "DLOG failed for value %d (%d)\n", 
+               x,
+               iret);
       GNUNET_assert (0);
     }
   }
   gcry_mpi_release (fact);
+  gcry_mpi_release (n);
   gcry_mpi_point_release (g);
   gcry_mpi_point_release (q);
   gcry_ctx_release (ctx);
+  fprintf (stderr, "\n");
+}
+
+
+/**
+ * Do some arithmetic operations for testing.
+ *
+ * @param edc context for ECC operations
+ */
+static void
+test_math (struct GNUNET_CRYPTO_EccDlogContext *edc)
+{
+  int i;
+  int j;
+  gcry_mpi_point_t ip;
+  gcry_mpi_point_t jp;
+  gcry_mpi_point_t r;
+  gcry_mpi_point_t ir;
+  gcry_mpi_point_t irj;
+  gcry_mpi_point_t r_inv;
+  gcry_mpi_point_t sum;
+
+  for (i=-MATH_MAX;i<MATH_MAX;i++)
+  {
+    ip = GNUNET_CRYPTO_ecc_dexp (edc, i);
+    for (j=-MATH_MAX;j<MATH_MAX;j++)
+    {
+      fprintf (stderr, ".");
+      jp = GNUNET_CRYPTO_ecc_dexp (edc, j);
+      GNUNET_CRYPTO_ecc_rnd (edc,
+                             &r,
+                             &r_inv);
+      ir = GNUNET_CRYPTO_ecc_add (edc, ip, r);
+      irj = GNUNET_CRYPTO_ecc_add (edc, ir, jp);
+      sum = GNUNET_CRYPTO_ecc_add (edc, irj, r_inv);
+      GNUNET_assert (i + j ==
+                     GNUNET_CRYPTO_ecc_dlog (edc,
+                                             sum));
+      GNUNET_CRYPTO_ecc_free (jp);
+      GNUNET_CRYPTO_ecc_free (ir);
+      GNUNET_CRYPTO_ecc_free (irj);
+      GNUNET_CRYPTO_ecc_free (r);
+      GNUNET_CRYPTO_ecc_free (r_inv);
+      GNUNET_CRYPTO_ecc_free (sum);
+    }
+    GNUNET_CRYPTO_ecc_free (ip);
+  }
+  fprintf (stderr, "\n");
 }
 
 
+
 int
 main (int argc, char *argv[])
 {
@@ -109,6 +186,7 @@ main (int argc, char *argv[])
   edc = GNUNET_CRYPTO_ecc_dlog_prepare (MAX_FACT,
                                         MAX_MEM);
   test_dlog (edc);
+  test_math (edc);
   GNUNET_CRYPTO_ecc_dlog_release (edc);
   return 0;
 }