1 files changed, 256 insertions, 257 deletions

diff --git a/src/util/crypto_ksk.c b/src/util/crypto_ksk.c
index 3d40ce27b..60639a709 100644
--- a/src/util/crypto_ksk.c
+++ b/src/util/crypto_ksk.c
@@ -51,12 +51,12 @@
 
 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;
 
 /**
@@ -84,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;
+  {
+    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 (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]));
-        }
-      hc = tmp;
+      gcry_mpi_add_ui (n, n, ntohl (((uint32_t *) & tmp)[j]));
     }
+    hc = tmp;
+  }
   GNUNET_CRYPTO_hash (&hc, sizeof (GNUNET_HashCode), rnd);
   i = gcry_mpi_get_nbits (n);
   while (i > nbits)
@@ -114,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;
 }
@@ -164,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)
     {
-      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_set_ui (x, 2);
     }
-  rc = 1;                       /* May be a prime. */
+    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. */
+    }
+  }
+  rc = 1;                       /* May be a prime. */
 
 leave:
   gcry_mpi_release (x);
@@ -210,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);
+  }
 }
 
 
@@ -326,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++)
     {
-      /* 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. */
+      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++)
-        {
-          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;
-            }
-        }
+      {
+        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;
+      }
     }
+  }
 }
 
 /**
@@ -399,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;
 
@@ -425,36 +425,36 @@ generate_kblock_key (KBlock_secret_key * sk, unsigned int nbits,
   f = gcry_mpi_new (0);
 
   do
+  {
+    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);
-        }
-      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 */
+      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 ((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);
@@ -473,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 */
 };
 
@@ -501,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;
@@ -519,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);
@@ -547,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;
 }
 
@@ -572,123 +572,122 @@ 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)
     {
-      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;
-        }
+      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)
     {
-      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;
-        }
+      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)(u %m)))",
-                            n, e, d, p, q, u);
+      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
+    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);
-        }
-      else
-        {
-          rc = gcry_sexp_build (&res, &size,    /* erroff */
-                                "(private-key(rsa(n %m)(e %m)(d %m)))", n, e,
-                                d);
-        }
+      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);
@@ -703,10 +702,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;
@@ -736,13 +735,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)))
     {
-      if (0 == memcmp (hc, &cache[i]->hc, sizeof (GNUNET_HashCode)))
-        {
-          ret = ksk_decode_key (cache[i]->pke);
-          return ret;
-        }
+      ret = ksk_decode_key (cache[i]->pke);
+      return ret;
     }
+  }
 
   line = GNUNET_malloc (sizeof (struct KBlockKeyCacheLine));
   line->hc = *hc;
@@ -758,10 +757,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);
 }