1 files changed, 260 insertions, 257 deletions

diff --git a/src/util/crypto_ksk.c b/src/util/crypto_ksk.c
index bec87c803..3d40ce27b 100644
--- a/src/util/crypto_ksk.c
+++ b/src/util/crypto_ksk.c
@@ -39,22 +39,24 @@
 #include <gcrypt.h>
 #include <limits.h>
 
+#define LOG(kind,...) GNUNET_log_from (kind, "util", __VA_ARGS__)
+
 /**
  * Log an error message at log-level 'level' that indicates
  * a failure of the command 'cmd' with the message given
  * by gcry_strerror(rc).
  */
-#define LOG_GCRY(level, cmd, rc) do { GNUNET_log(level, _("`%s' failed at %s:%d with error: %s\n"), cmd, __FILE__, __LINE__, gcry_strerror(rc)); } while(0);
+#define LOG_GCRY(level, cmd, rc) do { LOG(level, _("`%s' failed at %s:%d with error: %s\n"), cmd, __FILE__, __LINE__, gcry_strerror(rc)); } while(0);
 
 
 typedef struct
 {
-  gcry_mpi_t n;                 /* public modulus */
-  gcry_mpi_t e;                 /* public exponent */
-  gcry_mpi_t d;                 /* exponent */
-  gcry_mpi_t p;                 /* prime  p. */
-  gcry_mpi_t q;                 /* prime  q. */
-  gcry_mpi_t u;                 /* inverse of p mod q. */
+  gcry_mpi_t n;                 /* public modulus */
+  gcry_mpi_t e;                 /* public exponent */
+  gcry_mpi_t d;                 /* exponent */
+  gcry_mpi_t p;                 /* prime  p. */
+  gcry_mpi_t q;                 /* prime  q. */
+  gcry_mpi_t u;                 /* inverse of p mod q. */
 } KBlock_secret_key;
 
 /**
@@ -82,23 +84,23 @@ mpz_randomize (gcry_mpi_t n, unsigned int nbits, GNUNET_HashCode * rnd)
 
   tmp = *rnd;
   for (i = 0; i < cnt; i++)
-  {
-    int j;
-
-    if (i > 0)
-      GNUNET_CRYPTO_hash (&hc, sizeof (GNUNET_HashCode), &tmp);
-    for (j = 0; j < sizeof (GNUNET_HashCode) / sizeof (uint32_t); j++)
     {
+      int j;
+
+      if (i > 0)
+        GNUNET_CRYPTO_hash (&hc, sizeof (GNUNET_HashCode), &tmp);
+      for (j = 0; j < sizeof (GNUNET_HashCode) / sizeof (uint32_t); j++)
+        {
 #if HAVE_GCRY_MPI_LSHIFT
-      gcry_mpi_lshift (n, n, sizeof (uint32_t) * 8);
+          gcry_mpi_lshift (n, n, sizeof (uint32_t) * 8);
 #else
-      gcry_mpi_mul_ui (n, n, 1 << (sizeof (uint32_t) * 4));
-      gcry_mpi_mul_ui (n, n, 1 << (sizeof (uint32_t) * 4));
+          gcry_mpi_mul_ui (n, n, 1 << (sizeof (uint32_t) * 4));
+          gcry_mpi_mul_ui (n, n, 1 << (sizeof (uint32_t) * 4));
 #endif
-      gcry_mpi_add_ui (n, n, ntohl (((uint32_t *) & tmp)[j]));
+          gcry_mpi_add_ui (n, n, ntohl (((uint32_t *) & tmp)[j]));
+        }
+      hc = tmp;
     }
-    hc = tmp;
-  }
   GNUNET_CRYPTO_hash (&hc, sizeof (GNUNET_HashCode), rnd);
   i = gcry_mpi_get_nbits (n);
   while (i > nbits)
@@ -112,10 +114,10 @@ mpz_trailing_zeroes (gcry_mpi_t n)
 
   cnt = gcry_mpi_get_nbits (n);
   for (idx = 0; idx < cnt; idx++)
-  {
-    if (gcry_mpi_test_bit (n, idx) == 0)
-      return idx;
-  }
+    {
+      if (gcry_mpi_test_bit (n, idx) == 0)
+        return idx;
+    }
 
   return ULONG_MAX;
 }
@@ -162,31 +164,31 @@ is_prime (gcry_mpi_t n, int steps, GNUNET_HashCode * hc)
   mpz_tdiv_q_2exp (q, q, k);
 
   for (i = 0; i < steps; i++)
-  {
-    if (!i)
-    {
-      gcry_mpi_set_ui (x, 2);
-    }
-    else
     {
-      mpz_randomize (x, nbits - 1, hc);
-      GNUNET_assert (gcry_mpi_cmp (x, nminus1) < 0);
-      GNUNET_assert (gcry_mpi_cmp_ui (x, 1) > 0);
+      if (!i)
+        {
+          gcry_mpi_set_ui (x, 2);
+        }
+      else
+        {
+          mpz_randomize (x, nbits - 1, hc);
+          GNUNET_assert (gcry_mpi_cmp (x, nminus1) < 0);
+          GNUNET_assert (gcry_mpi_cmp_ui (x, 1) > 0);
+        }
+      gcry_mpi_powm (y, x, q, n);
+      if (gcry_mpi_cmp_ui (y, 1) && gcry_mpi_cmp (y, nminus1))
+        {
+          for (j = 1; j < k && gcry_mpi_cmp (y, nminus1); j++)
+            {
+              gcry_mpi_powm (y, y, a2, n);
+              if (!gcry_mpi_cmp_ui (y, 1))
+                goto leave;     /* Not a prime. */
+            }
+          if (gcry_mpi_cmp (y, nminus1))
+            goto leave;         /* Not a prime. */
+        }
     }
-    gcry_mpi_powm (y, x, q, n);
-    if (gcry_mpi_cmp_ui (y, 1) && gcry_mpi_cmp (y, nminus1))
-    {
-      for (j = 1; j < k && gcry_mpi_cmp (y, nminus1); j++)
-      {
-        gcry_mpi_powm (y, y, a2, n);
-        if (!gcry_mpi_cmp_ui (y, 1))
-          goto leave;           /* Not a prime. */
-      }
-      if (gcry_mpi_cmp (y, nminus1))
-        goto leave;             /* Not a prime. */
-    }
-  }
-  rc = 1;                       /* May be a prime. */
+  rc = 1;                       /* May be a prime. */
 
 leave:
   gcry_mpi_release (x);
@@ -208,10 +210,10 @@ static void
 adjust (unsigned char *buf, size_t size, size_t target)
 {
   if (size < target)
-  {
-    memmove (&buf[target - size], buf, size);
-    memset (buf, 0, target - size);
-  }
+    {
+      memmove (&buf[target - size], buf, size);
+      memset (buf, 0, target - size);
+    }
 }
 
 
@@ -324,70 +326,70 @@ gen_prime (gcry_mpi_t * ptest, unsigned int nbits, GNUNET_HashCode * hc)
   tmp = gcry_mpi_new (0);
   sp = gcry_mpi_new (0);
   while (1)
-  {
-    /* generate a random number */
-    mpz_randomize (prime, nbits, hc);
-    /* Set high order bit to 1, set low order bit to 1.  If we are
-     * generating a secret prime we are most probably doing that
-     * for RSA, to make sure that the modulus does have the
-     * requested key size we set the 2 high order bits. */
-    gcry_mpi_set_bit (prime, nbits - 1);
-    gcry_mpi_set_bit (prime, nbits - 2);
-    gcry_mpi_set_bit (prime, 0);
-
-    /* Calculate all remainders. */
-    for (i = 0; i < no_of_small_prime_numbers; i++)
-    {
-      size_t written;
-
-      gcry_mpi_set_ui (sp, small_prime_numbers[i]);
-      gcry_mpi_div (NULL, tmp, prime, sp, -1);
-      mods[i] = 0;
-      written = sizeof (unsigned int);
-      GNUNET_assert (0 ==
-                     gcry_mpi_print (GCRYMPI_FMT_USG,
-                                     (unsigned char *) &mods[i], written,
-                                     &written, tmp));
-      adjust ((unsigned char *) &mods[i], written, sizeof (unsigned int));
-      mods[i] = ntohl (mods[i]);
-    }
-    /* Now try some primes starting with prime. */
-    for (step = 0; step < 20000; step += 2)
     {
-      /* Check against all the small primes we have in mods. */
+      /* generate a random number */
+      mpz_randomize (prime, nbits, hc);
+      /* Set high order bit to 1, set low order bit to 1.  If we are
+       * generating a secret prime we are most probably doing that
+       * for RSA, to make sure that the modulus does have the
+       * requested key size we set the 2 high order bits. */
+      gcry_mpi_set_bit (prime, nbits - 1);
+      gcry_mpi_set_bit (prime, nbits - 2);
+      gcry_mpi_set_bit (prime, 0);
+
+      /* Calculate all remainders. */
       for (i = 0; i < no_of_small_prime_numbers; i++)
-      {
-        uint16_t x = small_prime_numbers[i];
-
-        while (mods[i] + step >= x)
-          mods[i] -= x;
-        if (!(mods[i] + step))
-          break;
-      }
-      if (i < no_of_small_prime_numbers)
-        continue;               /* Found a multiple of an already known prime. */
-
-      gcry_mpi_add_ui (*ptest, prime, step);
-      if (!gcry_mpi_test_bit (*ptest, nbits - 2))
-        break;
-
-      /* Do a fast Fermat test now. */
-      gcry_mpi_sub_ui (pminus1, *ptest, 1);
-      gcry_mpi_powm (result, val_2, pminus1, *ptest);
-      if ((!gcry_mpi_cmp_ui (result, 1)) && (is_prime (*ptest, 5, hc)))
-      {
-        /* Got it. */
-        gcry_mpi_release (sp);
-        gcry_mpi_release (tmp);
-        gcry_mpi_release (val_2);
-        gcry_mpi_release (val_3);
-        gcry_mpi_release (result);
-        gcry_mpi_release (pminus1);
-        gcry_mpi_release (prime);
-        return;
-      }
+        {
+          size_t written;
+
+          gcry_mpi_set_ui (sp, small_prime_numbers[i]);
+          gcry_mpi_div (NULL, tmp, prime, sp, -1);
+          mods[i] = 0;
+          written = sizeof (unsigned int);
+          GNUNET_assert (0 ==
+                         gcry_mpi_print (GCRYMPI_FMT_USG,
+                                         (unsigned char *) &mods[i], written,
+                                         &written, tmp));
+          adjust ((unsigned char *) &mods[i], written, sizeof (unsigned int));
+          mods[i] = ntohl (mods[i]);
+        }
+      /* Now try some primes starting with prime. */
+      for (step = 0; step < 20000; step += 2)
+        {
+          /* Check against all the small primes we have in mods. */
+          for (i = 0; i < no_of_small_prime_numbers; i++)
+            {
+              uint16_t x = small_prime_numbers[i];
+
+              while (mods[i] + step >= x)
+                mods[i] -= x;
+              if (!(mods[i] + step))
+                break;
+            }
+          if (i < no_of_small_prime_numbers)
+            continue;           /* Found a multiple of an already known prime. */
+
+          gcry_mpi_add_ui (*ptest, prime, step);
+          if (!gcry_mpi_test_bit (*ptest, nbits - 2))
+            break;
+
+          /* Do a fast Fermat test now. */
+          gcry_mpi_sub_ui (pminus1, *ptest, 1);
+          gcry_mpi_powm (result, val_2, pminus1, *ptest);
+          if ((!gcry_mpi_cmp_ui (result, 1)) && (is_prime (*ptest, 5, hc)))
+            {
+              /* Got it. */
+              gcry_mpi_release (sp);
+              gcry_mpi_release (tmp);
+              gcry_mpi_release (val_2);
+              gcry_mpi_release (val_3);
+              gcry_mpi_release (result);
+              gcry_mpi_release (pminus1);
+              gcry_mpi_release (prime);
+              return;
+            }
+        }
     }
-  }
 }
 
 /**
@@ -397,11 +399,11 @@ gen_prime (gcry_mpi_t * ptest, unsigned int nbits, GNUNET_HashCode * hc)
  * @param hc the HC to use for PRNG (modified!)
  */
 static void
-generate_kblock_key (KBlock_secret_key *sk, unsigned int nbits,
-                     GNUNET_HashCode * hc)
+generate_kblock_key (KBlock_secret_key * sk, unsigned int nbits,
+                     GNUNET_HashCode * hc)
 {
   gcry_mpi_t t1, t2;
-  gcry_mpi_t phi;               /* helper: (p-1)(q-1) */
+  gcry_mpi_t phi;               /* helper: (p-1)(q-1) */
   gcry_mpi_t g;
   gcry_mpi_t f;
 
@@ -423,36 +425,36 @@ generate_kblock_key (KBlock_secret_key *sk, unsigned int nbits,
   f = gcry_mpi_new (0);
 
   do
-  {
-    do
     {
-      gcry_mpi_release (sk->p);
-      gcry_mpi_release (sk->q);
-      gen_prime (&sk->p, nbits / 2, hc);
-      gen_prime (&sk->q, nbits / 2, hc);
-
-      if (gcry_mpi_cmp (sk->p, sk->q) > 0)      /* p shall be smaller than q (for calc of u) */
-        gcry_mpi_swap (sk->p, sk->q);
-      /* calculate the modulus */
-      gcry_mpi_mul (sk->n, sk->p, sk->q);
+      do
+        {
+          gcry_mpi_release (sk->p);
+          gcry_mpi_release (sk->q);
+          gen_prime (&sk->p, nbits / 2, hc);
+          gen_prime (&sk->q, nbits / 2, hc);
+
+          if (gcry_mpi_cmp (sk->p, sk->q) > 0)  /* p shall be smaller than q (for calc of u) */
+            gcry_mpi_swap (sk->p, sk->q);
+          /* calculate the modulus */
+          gcry_mpi_mul (sk->n, sk->p, sk->q);
+        }
+      while (gcry_mpi_get_nbits (sk->n) != nbits);
+
+      /* calculate Euler totient: phi = (p-1)(q-1) */
+      gcry_mpi_sub_ui (t1, sk->p, 1);
+      gcry_mpi_sub_ui (t2, sk->q, 1);
+      gcry_mpi_mul (phi, t1, t2);
+      gcry_mpi_gcd (g, t1, t2);
+      gcry_mpi_div (f, NULL, phi, g, 0);
+      while (0 == gcry_mpi_gcd (t1, sk->e, phi))
+        {                       /* (while gcd is not 1) */
+          gcry_mpi_add_ui (sk->e, sk->e, 2);
+        }
+
+      /* calculate the secret key d = e^1 mod phi */
     }
-    while (gcry_mpi_get_nbits (sk->n) != nbits);
-
-    /* calculate Euler totient: phi = (p-1)(q-1) */
-    gcry_mpi_sub_ui (t1, sk->p, 1);
-    gcry_mpi_sub_ui (t2, sk->q, 1);
-    gcry_mpi_mul (phi, t1, t2);
-    gcry_mpi_gcd (g, t1, t2);
-    gcry_mpi_div (f, NULL, phi, g, 0);
-    while (0 == gcry_mpi_gcd (t1, sk->e, phi))
-    {                           /* (while gcd is not 1) */
-      gcry_mpi_add_ui (sk->e, sk->e, 2);
-    }
-
-    /* calculate the secret key d = e^1 mod phi */
-  }
   while ((0 == gcry_mpi_invm (sk->d, sk->e, f)) ||
-         (0 == gcry_mpi_invm (sk->u, sk->p, sk->q)));
+         (0 == gcry_mpi_invm (sk->u, sk->p, sk->q)));
 
   gcry_mpi_release (t1);
   gcry_mpi_release (t2);
@@ -471,13 +473,13 @@ struct KskRsaPrivateKeyBinaryEncoded
    * Total size of the structure, in bytes, in big-endian!
    */
   uint16_t len GNUNET_PACKED;
-  uint16_t sizen GNUNET_PACKED; /*  in big-endian! */
-  uint16_t sizee GNUNET_PACKED; /*  in big-endian! */
-  uint16_t sized GNUNET_PACKED; /*  in big-endian! */
-  uint16_t sizep GNUNET_PACKED; /*  in big-endian! */
-  uint16_t sizeq GNUNET_PACKED; /*  in big-endian! */
-  uint16_t sizedmp1 GNUNET_PACKED;      /*  in big-endian! */
-  uint16_t sizedmq1 GNUNET_PACKED;      /*  in big-endian! */
+  uint16_t sizen GNUNET_PACKED; /*  in big-endian! */
+  uint16_t sizee GNUNET_PACKED; /*  in big-endian! */
+  uint16_t sized GNUNET_PACKED; /*  in big-endian! */
+  uint16_t sizep GNUNET_PACKED; /*  in big-endian! */
+  uint16_t sizeq GNUNET_PACKED; /*  in big-endian! */
+  uint16_t sizedmp1 GNUNET_PACKED;      /*  in big-endian! */
+  uint16_t sizedmq1 GNUNET_PACKED;      /*  in big-endian! */
   /* followed by the actual values */
 };
 
@@ -499,16 +501,16 @@ makeKblockKeyInternal (const GNUNET_HashCode * hc)
   size_t size;
 
   hx = *hc;
-  generate_kblock_key (&sk, 1024,       /* at least 10x as fast than 2048 bits
-                                         * -- we simply cannot afford 2048 bits
-                                         * even on modern hardware, and especially
-                                         * not since clearly a dictionary attack
-                                         * will still be much cheaper
-                                         * than breaking a 1024 bit RSA key.
-                                         * If an adversary can spend the time to
-                                         * break a 1024 bit RSA key just to forge
-                                         * a signature -- SO BE IT. [ CG, 6/2005 ] */
-                       &hx);
+  generate_kblock_key (&sk, 1024,       /* at least 10x as fast than 2048 bits
+                                         * -- we simply cannot afford 2048 bits
+                                         * even on modern hardware, and especially
+                                         * not since clearly a dictionary attack
+                                         * will still be much cheaper
+                                         * than breaking a 1024 bit RSA key.
+                                         * If an adversary can spend the time to
+                                         * break a 1024 bit RSA key just to forge
+                                         * a signature -- SO BE IT. [ CG, 6/2005 ] */
+                       &hx);
   pkv[0] = &sk.n;
   pkv[1] = &sk.e;
   pkv[2] = &sk.d;
@@ -517,10 +519,10 @@ makeKblockKeyInternal (const GNUNET_HashCode * hc)
   pkv[5] = &sk.u;
   size = sizeof (struct KskRsaPrivateKeyBinaryEncoded);
   for (i = 0; i < 6; i++)
-  {
-    gcry_mpi_aprint (GCRYMPI_FMT_STD, &pbu[i], &sizes[i], *pkv[i]);
-    size += sizes[i];
-  }
+    {
+      gcry_mpi_aprint (GCRYMPI_FMT_STD, &pbu[i], &sizes[i], *pkv[i]);
+      size += sizes[i];
+    }
   GNUNET_assert (size < 65536);
   retval = GNUNET_malloc (size);
   retval->len = htons (size);
@@ -545,10 +547,10 @@ makeKblockKeyInternal (const GNUNET_HashCode * hc)
   retval->sizedmq1 = htons (0);
   memcpy (&((char *) &retval[1])[i], pbu[5], sizes[5]);
   for (i = 0; i < 6; i++)
-  {
-    gcry_mpi_release (*pkv[i]);
-    free (pbu[i]);
-  }
+    {
+      gcry_mpi_release (*pkv[i]);
+      free (pbu[i]);
+    }
   return retval;
 }
 
@@ -570,122 +572,123 @@ ksk_decode_key (const struct KskRsaPrivateKeyBinaryEncoded *encoding)
   pos = 0;
   size = ntohs (encoding->sizen);
   rc = gcry_mpi_scan (&n, GCRYMPI_FMT_USG,
-                      &((const unsigned char *) (&encoding[1]))[pos], size,
-                      &size);
+                      &((const unsigned char *) (&encoding[1]))[pos], size,
+                      &size);
   pos += ntohs (encoding->sizen);
   if (rc)
-  {
-    LOG_GCRY (GNUNET_ERROR_TYPE_ERROR, "gcry_mpi_scan", rc);
-    return NULL;
-  }
+    {
+      LOG_GCRY (GNUNET_ERROR_TYPE_ERROR, "gcry_mpi_scan", rc);
+      return NULL;
+    }
   size = ntohs (encoding->sizee);
   rc = gcry_mpi_scan (&e, GCRYMPI_FMT_USG,
-                      &((const unsigned char *) (&encoding[1]))[pos], size,
-                      &size);
+                      &((const unsigned char *) (&encoding[1]))[pos], size,
+                      &size);
   pos += ntohs (encoding->sizee);
   if (rc)
-  {
-    LOG_GCRY (GNUNET_ERROR_TYPE_ERROR, "gcry_mpi_scan", rc);
-    gcry_mpi_release (n);
-    return NULL;
-  }
+    {
+      LOG_GCRY (GNUNET_ERROR_TYPE_ERROR, "gcry_mpi_scan", rc);
+      gcry_mpi_release (n);
+      return NULL;
+    }
   size = ntohs (encoding->sized);
   rc = gcry_mpi_scan (&d, GCRYMPI_FMT_USG,
-                      &((const unsigned char *) (&encoding[1]))[pos], size,
-                      &size);
+                      &((const unsigned char *) (&encoding[1]))[pos], size,
+                      &size);
   pos += ntohs (encoding->sized);
   if (rc)
-  {
-    LOG_GCRY (GNUNET_ERROR_TYPE_ERROR, "gcry_mpi_scan", rc);
-    gcry_mpi_release (n);
-    gcry_mpi_release (e);
-    return NULL;
-  }
-  /* swap p and q! */
-  size = ntohs (encoding->sizep);
-  if (size > 0)
-  {
-    rc = gcry_mpi_scan (&q, GCRYMPI_FMT_USG,
-                        &((const unsigned char *) (&encoding[1]))[pos], size,
-                        &size);
-    pos += ntohs (encoding->sizep);
-    if (rc)
     {
       LOG_GCRY (GNUNET_ERROR_TYPE_ERROR, "gcry_mpi_scan", rc);
       gcry_mpi_release (n);
       gcry_mpi_release (e);
-      gcry_mpi_release (d);
       return NULL;
     }
-  }
+  /* swap p and q! */
+  size = ntohs (encoding->sizep);
+  if (size > 0)
+    {
+      rc = gcry_mpi_scan (&q, GCRYMPI_FMT_USG,
+                          &((const unsigned char *) (&encoding[1]))[pos],
+                          size, &size);
+      pos += ntohs (encoding->sizep);
+      if (rc)
+        {
+          LOG_GCRY (GNUNET_ERROR_TYPE_ERROR, "gcry_mpi_scan", rc);
+          gcry_mpi_release (n);
+          gcry_mpi_release (e);
+          gcry_mpi_release (d);
+          return NULL;
+        }
+    }
   else
     q = NULL;
   size = ntohs (encoding->sizeq);
   if (size > 0)
-  {
-    rc = gcry_mpi_scan (&p, GCRYMPI_FMT_USG,
-                        &((const unsigned char *) (&encoding[1]))[pos], size,
-                        &size);
-    pos += ntohs (encoding->sizeq);
-    if (rc)
     {
-      LOG_GCRY (GNUNET_ERROR_TYPE_ERROR, "gcry_mpi_scan", rc);
-      gcry_mpi_release (n);
-      gcry_mpi_release (e);
-      gcry_mpi_release (d);
-      if (q != NULL)
-        gcry_mpi_release (q);
-      return NULL;
+      rc = gcry_mpi_scan (&p, GCRYMPI_FMT_USG,
+                          &((const unsigned char *) (&encoding[1]))[pos],
+                          size, &size);
+      pos += ntohs (encoding->sizeq);
+      if (rc)
+        {
+          LOG_GCRY (GNUNET_ERROR_TYPE_ERROR, "gcry_mpi_scan", rc);
+          gcry_mpi_release (n);
+          gcry_mpi_release (e);
+          gcry_mpi_release (d);
+          if (q != NULL)
+            gcry_mpi_release (q);
+          return NULL;
+        }
     }
-  }
   else
     p = NULL;
   pos += ntohs (encoding->sizedmp1);
   pos += ntohs (encoding->sizedmq1);
   size =
-      ntohs (encoding->len) - sizeof (struct KskRsaPrivateKeyBinaryEncoded) -
-      pos;
+    ntohs (encoding->len) - sizeof (struct KskRsaPrivateKeyBinaryEncoded) -
+    pos;
   if (size > 0)
-  {
-    rc = gcry_mpi_scan (&u, GCRYMPI_FMT_USG,
-                        &((const unsigned char *) (&encoding[1]))[pos], size,
-                        &size);
-    if (rc)
     {
-      LOG_GCRY (GNUNET_ERROR_TYPE_ERROR, "gcry_mpi_scan", rc);
-      gcry_mpi_release (n);
-      gcry_mpi_release (e);
-      gcry_mpi_release (d);
-      if (p != NULL)
-        gcry_mpi_release (p);
-      if (q != NULL)
-        gcry_mpi_release (q);
-      return NULL;
+      rc = gcry_mpi_scan (&u, GCRYMPI_FMT_USG,
+                          &((const unsigned char *) (&encoding[1]))[pos],
+                          size, &size);
+      if (rc)
+        {
+          LOG_GCRY (GNUNET_ERROR_TYPE_ERROR, "gcry_mpi_scan", rc);
+          gcry_mpi_release (n);
+          gcry_mpi_release (e);
+          gcry_mpi_release (d);
+          if (p != NULL)
+            gcry_mpi_release (p);
+          if (q != NULL)
+            gcry_mpi_release (q);
+          return NULL;
+        }
     }
-  }
   else
     u = NULL;
 
   if ((p != NULL) && (q != NULL) && (u != NULL))
-  {
-    rc = gcry_sexp_build (&res, &size,  /* erroff */
-                          "(private-key(rsa(n %m)(e %m)(d %m)(p %m)(q %m)(u %m)))",
-                          n, e, d, p, q, u);
-  }
-  else
-  {
-    if ((p != NULL) && (q != NULL))
     {
-      rc = gcry_sexp_build (&res, &size,        /* erroff */
-                            "(private-key(rsa(n %m)(e %m)(d %m)(p %m)(q %m)))",
-                            n, e, d, p, q);
+      rc = gcry_sexp_build (&res, &size,        /* erroff */
+                            "(private-key(rsa(n %m)(e %m)(d %m)(p %m)(q %m)(u %m)))",
+                            n, e, d, p, q, u);
     }
-    else
+  else
     {
-      rc = gcry_sexp_build (&res, &size,        /* erroff */
-                            "(private-key(rsa(n %m)(e %m)(d %m)))", n, e, d);
+      if ((p != NULL) && (q != NULL))
+        {
+          rc = gcry_sexp_build (&res, &size,    /* erroff */
+                                "(private-key(rsa(n %m)(e %m)(d %m)(p %m)(q %m)))",
+                                n, e, d, p, q);
+        }
+      else
+        {
+          rc = gcry_sexp_build (&res, &size,    /* erroff */
+                                "(private-key(rsa(n %m)(e %m)(d %m)))", n, e,
+                                d);
+        }
     }
-  }
   gcry_mpi_release (n);
   gcry_mpi_release (e);
   gcry_mpi_release (d);
@@ -700,10 +703,10 @@ ksk_decode_key (const struct KskRsaPrivateKeyBinaryEncoded *encoding)
     LOG_GCRY (GNUNET_ERROR_TYPE_ERROR, "gcry_sexp_build", rc);
 #if EXTRA_CHECKS
   if (gcry_pk_testkey (res))
-  {
-    LOG_GCRY (GNUNET_ERROR_TYPE_ERROR, "gcry_pk_testkey", rc);
-    return NULL;
-  }
+    {
+      LOG_GCRY (GNUNET_ERROR_TYPE_ERROR, "gcry_pk_testkey", rc);
+      return NULL;
+    }
 #endif
   ret = GNUNET_malloc (sizeof (struct GNUNET_CRYPTO_RsaPrivateKey));
   ret->sexp = res;
@@ -733,13 +736,13 @@ GNUNET_CRYPTO_rsa_key_create_from_hash (const GNUNET_HashCode * hc)
   unsigned int i;
 
   for (i = 0; i < cacheSize; i++)
-  {
-    if (0 == memcmp (hc, &cache[i]->hc, sizeof (GNUNET_HashCode)))
     {
-      ret = ksk_decode_key (cache[i]->pke);
-      return ret;
+      if (0 == memcmp (hc, &cache[i]->hc, sizeof (GNUNET_HashCode)))
+        {
+          ret = ksk_decode_key (cache[i]->pke);
+          return ret;
+        }
     }
-  }
 
   line = GNUNET_malloc (sizeof (struct KBlockKeyCacheLine));
   line->hc = *hc;
@@ -755,10 +758,10 @@ void __attribute__ ((destructor)) GNUNET_CRYPTO_ksk_fini ()
   unsigned int i;
 
   for (i = 0; i < cacheSize; i++)
-  {
-    GNUNET_free (cache[i]->pke);
-    GNUNET_free (cache[i]);
-  }
+    {
+      GNUNET_free (cache[i]->pke);
+      GNUNET_free (cache[i]);
+    }
   GNUNET_array_grow (cache, cacheSize, 0);
 }