1 files changed, 260 insertions, 260 deletions

diff --git a/src/util/crypto_ksk.c b/src/util/crypto_ksk.c
index 7a0b4410a..7c23fc1e0 100644
--- a/src/util/crypto_ksk.c
+++ b/src/util/crypto_ksk.c
@@ -49,12 +49,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;
 
 /**
@@ -82,23 +82,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);
+#if HAVE_GCRY_MPI_LSHIFT
+      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)
@@ -110,12 +110,12 @@ mpz_trailing_zeroes (gcry_mpi_t n)
 {
   unsigned int idx, cnt;
 
-  cnt = gcry_mpi_get_nbits(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;
 }
@@ -154,7 +154,7 @@ is_prime (gcry_mpi_t n, int steps, GNUNET_HashCode * hc)
   a2 = gcry_mpi_set_ui (NULL, 2);
 
   nbits = gcry_mpi_get_nbits (n);
-  gcry_mpi_sub_ui(nminus1, n, 1);
+  gcry_mpi_sub_ui (nminus1, n, 1);
 
   /* Find q and k, so that n = 1 + 2^k * q . */
   q = gcry_mpi_set (NULL, nminus1);
@@ -162,30 +162,30 @@ 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);
+    }
+    gcry_mpi_powm (y, x, q, n);
+    if (gcry_mpi_cmp_ui (y, 1) && gcry_mpi_cmp (y, nminus1))
     {
-      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. */
-        }
+      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:
@@ -208,18 +208,18 @@ 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);
+  }
 }
 
 
 static void
-gen_prime (gcry_mpi_t *ptest, unsigned int nbits, GNUNET_HashCode * hc)
+gen_prime (gcry_mpi_t * ptest, unsigned int nbits, GNUNET_HashCode * hc)
 {
   /* Note: 2 is not included because it can be tested more easily by
-     looking at bit 0. The last entry in this list is marked by a zero */
+   * looking at bit 0. The last entry in this list is marked by a zero */
   static const uint16_t small_prime_numbers[] = {
     3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43,
     47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97, 101,
@@ -317,76 +317,77 @@ gen_prime (gcry_mpi_t *ptest, unsigned int nbits, GNUNET_HashCode * hc)
   /* Make nbits fit into mpz_t implementation. */
   val_2 = gcry_mpi_set_ui (NULL, 2);
   val_3 = gcry_mpi_set_ui (NULL, 3);
-  prime = gcry_mpi_snew(0);
-  result = gcry_mpi_new(0);
-  pminus1 = gcry_mpi_new(0);
-  *ptest = gcry_mpi_new(0);
+  prime = gcry_mpi_snew (0);
+  result = gcry_mpi_new (0);
+  pminus1 = gcry_mpi_new (0);
+  *ptest = gcry_mpi_new (0);
   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)
     {
-      /* 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. */
+      /* 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;
+      }
     }
+  }
 }
 
 /**
@@ -396,11 +397,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,
+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;
 
@@ -409,47 +410,47 @@ generate_kblock_key (KBlock_secret_key * sk,
     nbits++;
 
   sk->e = gcry_mpi_set_ui (NULL, 257);
-  sk->n = gcry_mpi_new(0);
-  sk->p = gcry_mpi_new(0);
-  sk->q = gcry_mpi_new(0);
-  sk->d = gcry_mpi_new(0);
-  sk->u = gcry_mpi_new(0);
-
-  t1 = gcry_mpi_new(0);
-  t2 = gcry_mpi_new(0);
-  phi = gcry_mpi_new(0);
-  g = gcry_mpi_new(0);
-  f = gcry_mpi_new(0);
+  sk->n = gcry_mpi_new (0);
+  sk->p = gcry_mpi_new (0);
+  sk->q = gcry_mpi_new (0);
+  sk->d = gcry_mpi_new (0);
+  sk->u = gcry_mpi_new (0);
+
+  t1 = gcry_mpi_new (0);
+  t2 = gcry_mpi_new (0);
+  phi = gcry_mpi_new (0);
+  g = gcry_mpi_new (0);
+  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)));
 
@@ -499,14 +500,14 @@ makeKblockKeyInternal (const GNUNET_HashCode * hc)
 
   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 ] */
+                                         * -- 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;
@@ -516,10 +517,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);
@@ -544,10 +545,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;
 }
 
@@ -574,10 +575,10 @@ ksk_decode_key (const struct KskRsaPrivateKeyBinaryEncoded *encoding)
                       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,
@@ -585,11 +586,11 @@ ksk_decode_key (const struct KskRsaPrivateKeyBinaryEncoded *encoding)
                       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,
@@ -597,101 +598,100 @@ ksk_decode_key (const struct KskRsaPrivateKeyBinaryEncoded *encoding)
                       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);
+                            "(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);
@@ -706,10 +706,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;
@@ -739,13 +739,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;
@@ -761,10 +761,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);
 }