src/util/crypto_ksk.c

   1 /*
   2      This file is part of GNUnet.
   3      Copyright (C) 1994, 1996, 1998, 2001, 2002, 2003 Free Software Foundation, Inc.
   4      Copyright (C) 2004, 2005, 2006 Christian Grothoff (and other contributing authors)
   5
   6      GNUnet is free software; you can redistribute it and/or modify
   7      it under the terms of the GNU General Public License as published
   8      by the Free Software Foundation; either version 2, or (at your
   9      option) any later version.
  10
  11      GNUnet is distributed in the hope that it will be useful, but
  12      WITHOUT ANY WARRANTY; without even the implied warranty of
  13      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14      General Public License for more details.
  15
  16      You should have received a copy of the GNU General Public License
  17      along with GNUnet; see the file COPYING.  If not, write to the
  18      Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  19      Boston, MA 02111-1307, USA.
  20
  21      Note: This code is based on code from libgcrypt
  22      The code was adapted for GNUnet to support RSA-key generation
  23      based on weak, pseudo-random keys.  Do NOT use to generate
  24      ordinary RSA keys!
  25 */
  26
  27
  28 /**
  29  * @file util/crypto_ksk.c
  30  * @brief implementation of RSA-Key generation for KBlocks
  31  *        (do NOT use for pseudonyms or hostkeys!)
  32  * @author Christian Grothoff
  33  */
  34
  35 #include "platform.h"
  36 #include "gnunet_common.h"
  37 #include "gnunet_crypto_lib.h"
  38 #include "gnunet_os_lib.h"
  39 #include <gmp.h>
  40 #include <gcrypt.h>
  41
  42 /**
  43  * Log an error message at log-level 'level' that indicates
  44  * a failure of the command 'cmd' with the message given
  45  * by gcry_strerror(rc).
  46  */
  47 #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);
  48
  49
  50 typedef struct
  51 {
  52   mpz_t n;                      /* public modulus */
  53   mpz_t e;                      /* public exponent */
  54   mpz_t d;                      /* exponent */
  55   mpz_t p;                      /* prime  p. */
  56   mpz_t q;                      /* prime  q. */
  57   mpz_t u;                      /* inverse of p mod q. */
  58 } KBlock_secret_key;
  59
  60 /**
  61  * The private information of an RSA key pair.
  62  * NOTE: this must match the definition in crypto_rsa.c
  63  */
  64 struct GNUNET_CRYPTO_RsaPrivateKey
  65 {
  66   gcry_sexp_t sexp;
  67 };
  68
  69
  70 /* Note: 2 is not included because it can be tested more easily by
  71    looking at bit 0. The last entry in this list is marked by a zero */
  72 static uint16_t small_prime_numbers[] = {
  73   3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43,
  74   47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97, 101,
  75   103, 107, 109, 113, 127, 131, 137, 139, 149, 151,
  76   157, 163, 167, 173, 179, 181, 191, 193, 197, 199,
  77   211, 223, 227, 229, 233, 239, 241, 251, 257, 263,
  78   269, 271, 277, 281, 283, 293, 307, 311, 313, 317,
  79   331, 337, 347, 349, 353, 359, 367, 373, 379, 383,
  80   389, 397, 401, 409, 419, 421, 431, 433, 439, 443,
  81   449, 457, 461, 463, 467, 479, 487, 491, 499, 503,
  82   509, 521, 523, 541, 547, 557, 563, 569, 571, 577,
  83   587, 593, 599, 601, 607, 613, 617, 619, 631, 641,
  84   643, 647, 653, 659, 661, 673, 677, 683, 691, 701,
  85   709, 719, 727, 733, 739, 743, 751, 757, 761, 769,
  86   773, 787, 797, 809, 811, 821, 823, 827, 829, 839,
  87   853, 857, 859, 863, 877, 881, 883, 887, 907, 911,
  88   919, 929, 937, 941, 947, 953, 967, 971, 977, 983,
  89   991, 997, 1009, 1013, 1019, 1021, 1031, 1033,
  90   1039, 1049, 1051, 1061, 1063, 1069, 1087, 1091,
  91   1093, 1097, 1103, 1109, 1117, 1123, 1129, 1151,
  92   1153, 1163, 1171, 1181, 1187, 1193, 1201, 1213,
  93   1217, 1223, 1229, 1231, 1237, 1249, 1259, 1277,
  94   1279, 1283, 1289, 1291, 1297, 1301, 1303, 1307,
  95   1319, 1321, 1327, 1361, 1367, 1373, 1381, 1399,
  96   1409, 1423, 1427, 1429, 1433, 1439, 1447, 1451,
  97   1453, 1459, 1471, 1481, 1483, 1487, 1489, 1493,
  98   1499, 1511, 1523, 1531, 1543, 1549, 1553, 1559,
  99   1567, 1571, 1579, 1583, 1597, 1601, 1607, 1609,
 100   1613, 1619, 1621, 1627, 1637, 1657, 1663, 1667,
 101   1669, 1693, 1697, 1699, 1709, 1721, 1723, 1733,
 102   1741, 1747, 1753, 1759, 1777, 1783, 1787, 1789,
 103   1801, 1811, 1823, 1831, 1847, 1861, 1867, 1871,
 104   1873, 1877, 1879, 1889, 1901, 1907, 1913, 1931,
 105   1933, 1949, 1951, 1973, 1979, 1987, 1993, 1997,
 106   1999, 2003, 2011, 2017, 2027, 2029, 2039, 2053,
 107   2063, 2069, 2081, 2083, 2087, 2089, 2099, 2111,
 108   2113, 2129, 2131, 2137, 2141, 2143, 2153, 2161,
 109   2179, 2203, 2207, 2213, 2221, 2237, 2239, 2243,
 110   2251, 2267, 2269, 2273, 2281, 2287, 2293, 2297,
 111   2309, 2311, 2333, 2339, 2341, 2347, 2351, 2357,
 112   2371, 2377, 2381, 2383, 2389, 2393, 2399, 2411,
 113   2417, 2423, 2437, 2441, 2447, 2459, 2467, 2473,
 114   2477, 2503, 2521, 2531, 2539, 2543, 2549, 2551,
 115   2557, 2579, 2591, 2593, 2609, 2617, 2621, 2633,
 116   2647, 2657, 2659, 2663, 2671, 2677, 2683, 2687,
 117   2689, 2693, 2699, 2707, 2711, 2713, 2719, 2729,
 118   2731, 2741, 2749, 2753, 2767, 2777, 2789, 2791,
 119   2797, 2801, 2803, 2819, 2833, 2837, 2843, 2851,
 120   2857, 2861, 2879, 2887, 2897, 2903, 2909, 2917,
 121   2927, 2939, 2953, 2957, 2963, 2969, 2971, 2999,
 122   3001, 3011, 3019, 3023, 3037, 3041, 3049, 3061,
 123   3067, 3079, 3083, 3089, 3109, 3119, 3121, 3137,
 124   3163, 3167, 3169, 3181, 3187, 3191, 3203, 3209,
 125   3217, 3221, 3229, 3251, 3253, 3257, 3259, 3271,
 126   3299, 3301, 3307, 3313, 3319, 3323, 3329, 3331,
 127   3343, 3347, 3359, 3361, 3371, 3373, 3389, 3391,
 128   3407, 3413, 3433, 3449, 3457, 3461, 3463, 3467,
 129   3469, 3491, 3499, 3511, 3517, 3527, 3529, 3533,
 130   3539, 3541, 3547, 3557, 3559, 3571, 3581, 3583,
 131   3593, 3607, 3613, 3617, 3623, 3631, 3637, 3643,
 132   3659, 3671, 3673, 3677, 3691, 3697, 3701, 3709,
 133   3719, 3727, 3733, 3739, 3761, 3767, 3769, 3779,
 134   3793, 3797, 3803, 3821, 3823, 3833, 3847, 3851,
 135   3853, 3863, 3877, 3881, 3889, 3907, 3911, 3917,
 136   3919, 3923, 3929, 3931, 3943, 3947, 3967, 3989,
 137   4001, 4003, 4007, 4013, 4019, 4021, 4027, 4049,
 138   4051, 4057, 4073, 4079, 4091, 4093, 4099, 4111,
 139   4127, 4129, 4133, 4139, 4153, 4157, 4159, 4177,
 140   4201, 4211, 4217, 4219, 4229, 4231, 4241, 4243,
 141   4253, 4259, 4261, 4271, 4273, 4283, 4289, 4297,
 142   4327, 4337, 4339, 4349, 4357, 4363, 4373, 4391,
 143   4397, 4409, 4421, 4423, 4441, 4447, 4451, 4457,
 144   4463, 4481, 4483, 4493, 4507, 4513, 4517, 4519,
 145   4523, 4547, 4549, 4561, 4567, 4583, 4591, 4597,
 146   4603, 4621, 4637, 4639, 4643, 4649, 4651, 4657,
 147   4663, 4673, 4679, 4691, 4703, 4721, 4723, 4729,
 148   4733, 4751, 4759, 4783, 4787, 4789, 4793, 4799,
 149   4801, 4813, 4817, 4831, 4861, 4871, 4877, 4889,
 150   4903, 4909, 4919, 4931, 4933, 4937, 4943, 4951,
 151   4957, 4967, 4969, 4973, 4987, 4993, 4999,
 152   0
 153 };
 154
 155 #define DIM(v) (sizeof(v)/sizeof((v)[0]))
 156 static int no_of_small_prime_numbers = DIM (small_prime_numbers) - 1;
 157
 158
 159      static unsigned int
 160      get_nbits (mpz_t a)
 161 {
 162   return mpz_sizeinbase (a, 2);
 163 }
 164
 165 /**
 166  * Count the number of zerobits at the low end of A
 167  */
 168 static unsigned int
 169 get_trailing_zeros (mpz_t a)
 170 {
 171   unsigned int count = 0;
 172   unsigned int nbits = get_nbits (a);
 173
 174   while ((mpz_tstbit (a, count)) && (count < nbits))
 175     count++;
 176   return count;
 177 }
 178
 179 /**
 180  * Set bit N of A. and clear all bits above
 181  */
 182 static void
 183 set_highbit (mpz_t a, unsigned int n)
 184 {
 185   unsigned int nbits;
 186
 187   nbits = get_nbits (a);
 188   while (nbits > n)
 189     mpz_clrbit (a, nbits--);
 190   mpz_setbit (a, n);
 191 }
 192
 193 static void
 194 mpz_randomize (mpz_t n, unsigned int nbits, GNUNET_HashCode * rnd)
 195 {
 196   GNUNET_HashCode *tmp;
 197   int cnt;
 198   int i;
 199
 200   cnt = (nbits / sizeof (GNUNET_HashCode) / 8) + 1;
 201   tmp = GNUNET_malloc (sizeof (GNUNET_HashCode) * cnt);
 202
 203   tmp[0] = *rnd;
 204   for (i = 0; i < cnt - 1; i++)
 205     {
 206       GNUNET_CRYPTO_hash (&tmp[i], sizeof (GNUNET_HashCode), &tmp[i + 1]);
 207     }
 208   *rnd = tmp[cnt - 1];
 209   mpz_import (n, cnt * sizeof (GNUNET_HashCode) / sizeof (unsigned int),
 210               1, sizeof (unsigned int), 1, 0, tmp);
 211   GNUNET_free (tmp);
 212   i = get_nbits (n);
 213   while (i > nbits)
 214     mpz_clrbit (n, i--);
 215 }
 216
 217 /**
 218  * Return true if n is probably a prime
 219  */
 220 static int
 221 is_prime (mpz_t n, int steps, GNUNET_HashCode * hc)
 222 {
 223   mpz_t x;
 224   mpz_t y;
 225   mpz_t z;
 226   mpz_t nminus1;
 227   mpz_t a2;
 228   mpz_t q;
 229   unsigned int i, j, k;
 230   int rc = 0;
 231   unsigned int nbits;
 232
 233   mpz_init (x);
 234   mpz_init (y);
 235   mpz_init (z);
 236   mpz_init (nminus1);
 237   mpz_init_set_ui (a2, 2);
 238   nbits = get_nbits (n);
 239   mpz_sub_ui (nminus1, n, 1);
 240
 241   /* Find q and k, so that n = 1 + 2^k * q . */
 242   mpz_init_set (q, nminus1);
 243   k = get_trailing_zeros (q);
 244   mpz_tdiv_q_2exp (q, q, k);
 245
 246   for (i = 0; i < steps; i++)
 247     {
 248       if (!i)
 249         {
 250           mpz_set_ui (x, 2);
 251         }
 252       else
 253         {
 254           mpz_randomize (x, nbits, hc);
 255
 256           /* Make sure that the number is smaller than the prime and
 257              keep the randomness of the high bit. */
 258           if (mpz_tstbit (x, nbits - 2))
 259             {
 260               set_highbit (x, nbits - 2);       /* Clear all higher bits. */
 261             }
 262           else
 263             {
 264               set_highbit (x, nbits - 2);
 265               mpz_clrbit (x, nbits - 2);
 266             }
 267           GNUNET_assert (mpz_cmp (x, nminus1) < 0 && mpz_cmp_ui (x, 1) > 0);
 268         }
 269       mpz_powm (y, x, q, n);
 270       if (mpz_cmp_ui (y, 1) && mpz_cmp (y, nminus1))
 271         {
 272           for (j = 1; j < k && mpz_cmp (y, nminus1); j++)
 273             {
 274               mpz_powm (y, y, a2, n);
 275               if (!mpz_cmp_ui (y, 1))
 276                 goto leave;     /* Not a prime. */
 277             }
 278           if (mpz_cmp (y, nminus1))
 279             goto leave;         /* Not a prime. */
 280         }
 281     }
 282   rc = 1;                       /* May be a prime. */
 283
 284 leave:
 285   mpz_clear (x);
 286   mpz_clear (y);
 287   mpz_clear (z);
 288   mpz_clear (nminus1);
 289   mpz_clear (q);
 290   mpz_clear (a2);
 291
 292   return rc;
 293 }
 294
 295 static void
 296 gen_prime (mpz_t ptest, unsigned int nbits, GNUNET_HashCode * hc)
 297 {
 298   mpz_t prime, pminus1, val_2, val_3, result;
 299   int i;
 300   unsigned x, step;
 301   int *mods;
 302   mpz_t tmp;
 303
 304   GNUNET_assert (nbits >= 16);
 305
 306   mods = GNUNET_malloc (no_of_small_prime_numbers * sizeof (*mods));
 307   /* Make nbits fit into mpz_t implementation. */
 308   mpz_init_set_ui (val_2, 2);
 309   mpz_init_set_ui (val_3, 3);
 310   mpz_init (prime);
 311   mpz_init (result);
 312   mpz_init (pminus1);
 313   mpz_init (ptest);
 314   while (1)
 315     {
 316       /* generate a random number */
 317       mpz_randomize (prime, nbits, hc);
 318       /* Set high order bit to 1, set low order bit to 1.  If we are
 319          generating a secret prime we are most probably doing that
 320          for RSA, to make sure that the modulus does have the
 321          requested key size we set the 2 high order bits. */
 322       set_highbit (prime, nbits - 1);
 323       mpz_setbit (prime, nbits - 2);
 324       mpz_setbit (prime, 0);
 325
 326       /* Calculate all remainders. */
 327       mpz_init (tmp);
 328       for (i = 0; (x = small_prime_numbers[i]); i++)
 329         mods[i] = mpz_fdiv_r_ui (tmp, prime, x);
 330       mpz_clear (tmp);
 331       /* Now try some primes starting with prime. */
 332       for (step = 0; step < 20000; step += 2)
 333         {
 334           /* Check against all the small primes we have in mods. */
 335           for (i = 0; (x = small_prime_numbers[i]); i++)
 336             {
 337               while (mods[i] + step >= x)
 338                 mods[i] -= x;
 339               if (!(mods[i] + step))
 340                 break;
 341             }
 342           if (x)
 343             continue;           /* Found a multiple of an already known prime. */
 344
 345           mpz_add_ui (ptest, prime, step);
 346           if (!mpz_tstbit (ptest, nbits - 2))
 347             break;
 348
 349           /* Do a fast Fermat test now. */
 350           mpz_sub_ui (pminus1, ptest, 1);
 351           mpz_powm (result, val_2, pminus1, ptest);
 352           if ((!mpz_cmp_ui (result, 1)) && (is_prime (ptest, 5, hc)))
 353             {
 354               /* Got it. */
 355               mpz_clear (val_2);
 356               mpz_clear (val_3);
 357               mpz_clear (result);
 358               mpz_clear (pminus1);
 359               mpz_clear (prime);
 360               GNUNET_free (mods);
 361               return;
 362             }
 363         }
 364     }
 365 }
 366
 367 /**
 368  * Find the greatest common divisor G of A and B.
 369  * Return: 1 if this 1, 0 in all other cases
 370  */
 371 static int
 372 test_gcd (mpz_t g, mpz_t xa, mpz_t xb)
 373 {
 374   mpz_t a, b;
 375
 376   mpz_init_set (a, xa);
 377   mpz_init_set (b, xb);
 378
 379   /* TAOCP Vol II, 4.5.2, Algorithm A */
 380   while (mpz_cmp_ui (b, 0))
 381     {
 382       mpz_fdiv_r (g, a, b);     /* g used as temorary variable */
 383       mpz_set (a, b);
 384       mpz_set (b, g);
 385     }
 386   mpz_set (g, a);
 387
 388   mpz_clear (a);
 389   mpz_clear (b);
 390   return (0 == mpz_cmp_ui (g, 1));
 391 }
 392
 393 /**
 394  * Generate a key pair with a key of size NBITS.
 395  * @param sk where to store the key
 396  * @param nbits the number of bits to use
 397  * @param hc the HC to use for PRNG (modified!)
 398  */
 399 static void
 400 generate_kblock_key (KBlock_secret_key * sk,
 401                      unsigned int nbits, GNUNET_HashCode * hc)
 402 {
 403   mpz_t t1, t2;
 404   mpz_t phi;                    /* helper: (p-1)(q-1) */
 405   mpz_t g;
 406   mpz_t f;
 407
 408   /* make sure that nbits is even so that we generate p, q of equal size */
 409   if ((nbits & 1))
 410     nbits++;
 411
 412   mpz_init_set_ui (sk->e, 257);
 413   mpz_init (sk->n);
 414   mpz_init (sk->p);
 415   mpz_init (sk->q);
 416   mpz_init (sk->d);
 417   mpz_init (sk->u);
 418
 419   mpz_init (t1);
 420   mpz_init (t2);
 421   mpz_init (phi);
 422   mpz_init (g);
 423   mpz_init (f);
 424
 425   do
 426     {
 427       do
 428         {
 429           mpz_clear (sk->p);
 430           mpz_clear (sk->q);
 431           gen_prime (sk->p, nbits / 2, hc);
 432           gen_prime (sk->q, nbits / 2, hc);
 433
 434           if (mpz_cmp (sk->p, sk->q) > 0)       /* p shall be smaller than q (for calc of u) */
 435             mpz_swap (sk->p, sk->q);
 436           /* calculate the modulus */
 437           mpz_mul (sk->n, sk->p, sk->q);
 438         }
 439       while (get_nbits (sk->n) != nbits);
 440
 441       /* calculate Euler totient: phi = (p-1)(q-1) */
 442       mpz_sub_ui (t1, sk->p, 1);
 443       mpz_sub_ui (t2, sk->q, 1);
 444       mpz_mul (phi, t1, t2);
 445       mpz_gcd (g, t1, t2);
 446       mpz_fdiv_q (f, phi, g);
 447
 448       while (0 == test_gcd (t1, sk->e, phi))
 449         {                       /* (while gcd is not 1) */
 450           mpz_add_ui (sk->e, sk->e, 2);
 451         }
 452
 453       /* calculate the secret key d = e^1 mod phi */
 454     }
 455   while ((0 == mpz_invert (sk->d, sk->e, f)) ||
 456          (0 == mpz_invert (sk->u, sk->p, sk->q)));
 457
 458   mpz_clear (t1);
 459   mpz_clear (t2);
 460   mpz_clear (phi);
 461   mpz_clear (f);
 462   mpz_clear (g);
 463 }
 464
 465
 466 /**
 467  * Internal representation of the private key.
 468  */
 469 struct KskRsaPrivateKeyBinaryEncoded
 470 {
 471   /**
 472    * Total size of the structure, in bytes, in big-endian!
 473    */
 474   uint16_t len GNUNET_PACKED;
 475   uint16_t sizen GNUNET_PACKED; /*  in big-endian! */
 476   uint16_t sizee GNUNET_PACKED; /*  in big-endian! */
 477   uint16_t sized GNUNET_PACKED; /*  in big-endian! */
 478   uint16_t sizep GNUNET_PACKED; /*  in big-endian! */
 479   uint16_t sizeq GNUNET_PACKED; /*  in big-endian! */
 480   uint16_t sizedmp1 GNUNET_PACKED;      /*  in big-endian! */
 481   uint16_t sizedmq1 GNUNET_PACKED;      /*  in big-endian! */
 482   /* followed by the actual values */
 483 };
 484
 485
 486 /**
 487  * Deterministically (!) create a hostkey using only the
 488  * given HashCode as input to the PRNG.
 489  */
 490 static struct KskRsaPrivateKeyBinaryEncoded *
 491 makeKblockKeyInternal (const GNUNET_HashCode * hc)
 492 {
 493   KBlock_secret_key sk;
 494   GNUNET_HashCode hx;
 495   void *pbu[6];
 496   mpz_t *pkv[6];
 497   size_t sizes[6];
 498   struct KskRsaPrivateKeyBinaryEncoded *retval;
 499   int i;
 500   size_t size;
 501
 502   hx = *hc;
 503   generate_kblock_key (&sk, 1024,       /* at least 10x as fast than 2048 bits
 504                                            -- we simply cannot afford 2048 bits
 505                                            even on modern hardware, and especially
 506                                            not since clearly a dictionary attack
 507                                            will still be much cheaper
 508                                            than breaking a 1024 bit RSA key.
 509                                            If an adversary can spend the time to
 510                                            break a 1024 bit RSA key just to forge
 511                                            a signature -- SO BE IT. [ CG, 6/2005 ] */
 512                        &hx);
 513   pkv[0] = &sk.n;
 514   pkv[1] = &sk.e;
 515   pkv[2] = &sk.d;
 516   pkv[3] = &sk.p;
 517   pkv[4] = &sk.q;
 518   pkv[5] = &sk.u;
 519   size = sizeof (struct KskRsaPrivateKeyBinaryEncoded);
 520   for (i = 0; i < 6; i++)
 521     {
 522       pbu[i] = mpz_export (NULL, &sizes[i], 1,  /* most significant word first */
 523                            1,   /* unit is bytes */
 524                            1,   /* big endian */
 525                            0,   /* nails */
 526                            *pkv[i]);
 527       size += sizes[i];
 528     }
 529   GNUNET_assert (size < 65536);
 530   retval = GNUNET_malloc (size);
 531   retval->len = htons (size);
 532   i = 0;
 533   retval->sizen = htons (sizes[0]);
 534   memcpy (&((char *) &retval[1])[i], pbu[0], sizes[0]);
 535   i += sizes[0];
 536   retval->sizee = htons (sizes[1]);
 537   memcpy (&((char *) &retval[1])[i], pbu[1], sizes[1]);
 538   i += sizes[1];
 539   retval->sized = htons (sizes[2]);
 540   memcpy (&((char *) &retval[1])[i], pbu[2], sizes[2]);
 541   i += sizes[2];
 542   /* swap p and q! */
 543   retval->sizep = htons (sizes[4]);
 544   memcpy (&((char *) &retval[1])[i], pbu[4], sizes[4]);
 545   i += sizes[4];
 546   retval->sizeq = htons (sizes[3]);
 547   memcpy (&((char *) &retval[1])[i], pbu[3], sizes[3]);
 548   i += sizes[3];
 549   retval->sizedmp1 = htons (0);
 550   retval->sizedmq1 = htons (0);
 551   memcpy (&((char *) &retval[1])[i], pbu[5], sizes[5]);
 552   for (i = 0; i < 6; i++)
 553     {
 554       mpz_clear (*pkv[i]);
 555       free (pbu[i]);
 556     }
 557   return retval;
 558 }
 559
 560
 561 /**
 562  * Decode the internal format into the format used
 563  * by libgcrypt.
 564  */
 565 static struct GNUNET_CRYPTO_RsaPrivateKey *
 566 ksk_decode_key (const struct KskRsaPrivateKeyBinaryEncoded *encoding)
 567 {
 568   struct GNUNET_CRYPTO_RsaPrivateKey *ret;
 569   gcry_sexp_t res;
 570   gcry_mpi_t n, e, d, p, q, u;
 571   int rc;
 572   size_t size;
 573   int pos;
 574
 575   pos = 0;
 576   size = ntohs (encoding->sizen);
 577   rc = gcry_mpi_scan (&n,
 578                       GCRYMPI_FMT_USG,
 579                       &((const unsigned char *) (&encoding[1]))[pos],
 580                       size, &size);
 581   pos += ntohs (encoding->sizen);
 582   if (rc)
 583     {
 584       LOG_GCRY (GNUNET_ERROR_TYPE_ERROR, "gcry_mpi_scan", rc);
 585       return NULL;
 586     }
 587   size = ntohs (encoding->sizee);
 588   rc = gcry_mpi_scan (&e,
 589                       GCRYMPI_FMT_USG,
 590                       &((const unsigned char *) (&encoding[1]))[pos],
 591                       size, &size);
 592   pos += ntohs (encoding->sizee);
 593   if (rc)
 594     {
 595       LOG_GCRY (GNUNET_ERROR_TYPE_ERROR, "gcry_mpi_scan", rc);
 596       gcry_mpi_release (n);
 597       return NULL;
 598     }
 599   size = ntohs (encoding->sized);
 600   rc = gcry_mpi_scan (&d,
 601                       GCRYMPI_FMT_USG,
 602                       &((const unsigned char *) (&encoding[1]))[pos],
 603                       size, &size);
 604   pos += ntohs (encoding->sized);
 605   if (rc)
 606     {
 607       LOG_GCRY (GNUNET_ERROR_TYPE_ERROR, "gcry_mpi_scan", rc);
 608       gcry_mpi_release (n);
 609       gcry_mpi_release (e);
 610       return NULL;
 611     }
 612   /* swap p and q! */
 613   size = ntohs (encoding->sizep);
 614   if (size > 0)
 615     {
 616       rc = gcry_mpi_scan (&q,
 617                           GCRYMPI_FMT_USG,
 618                           &((const unsigned char *) (&encoding[1]))[pos],
 619                           size, &size);
 620       pos += ntohs (encoding->sizep);
 621       if (rc)
 622         {
 623           LOG_GCRY (GNUNET_ERROR_TYPE_ERROR, "gcry_mpi_scan", rc);
 624           gcry_mpi_release (n);
 625           gcry_mpi_release (e);
 626           gcry_mpi_release (d);
 627           return NULL;
 628         }
 629     }
 630   else
 631     q = NULL;
 632   size = ntohs (encoding->sizeq);
 633   if (size > 0)
 634     {
 635       rc = gcry_mpi_scan (&p,
 636                           GCRYMPI_FMT_USG,
 637                           &((const unsigned char *) (&encoding[1]))[pos],
 638                           size, &size);
 639       pos += ntohs (encoding->sizeq);
 640       if (rc)
 641         {
 642           LOG_GCRY (GNUNET_ERROR_TYPE_ERROR, "gcry_mpi_scan", rc);
 643           gcry_mpi_release (n);
 644           gcry_mpi_release (e);
 645           gcry_mpi_release (d);
 646           if (q != NULL)
 647             gcry_mpi_release (q);
 648           return NULL;
 649         }
 650     }
 651   else
 652     p = NULL;
 653   pos += ntohs (encoding->sizedmp1);
 654   pos += ntohs (encoding->sizedmq1);
 655   size =
 656     ntohs (encoding->len) - sizeof (struct KskRsaPrivateKeyBinaryEncoded) -
 657     pos;
 658   if (size > 0)
 659     {
 660       rc = gcry_mpi_scan (&u,
 661                           GCRYMPI_FMT_USG,
 662                           &((const unsigned char *) (&encoding[1]))[pos],
 663                           size, &size);
 664       if (rc)
 665         {
 666           LOG_GCRY (GNUNET_ERROR_TYPE_ERROR, "gcry_mpi_scan", rc);
 667           gcry_mpi_release (n);
 668           gcry_mpi_release (e);
 669           gcry_mpi_release (d);
 670           if (p != NULL)
 671             gcry_mpi_release (p);
 672           if (q != NULL)
 673             gcry_mpi_release (q);
 674           return NULL;
 675         }
 676     }
 677   else
 678     u = NULL;
 679
 680   if ((p != NULL) && (q != NULL) && (u != NULL))
 681     {
 682       rc = gcry_sexp_build (&res, &size,        /* erroff */
 683                             "(private-key(rsa(n %m)(e %m)(d %m)(p %m)(q %m)(u %m)))",
 684                             n, e, d, p, q, u);
 685     }
 686   else
 687     {
 688       if ((p != NULL) && (q != NULL))
 689         {
 690           rc = gcry_sexp_build (&res, &size,    /* erroff */
 691                                 "(private-key(rsa(n %m)(e %m)(d %m)(p %m)(q %m)))",
 692                                 n, e, d, p, q);
 693         }
 694       else
 695         {
 696           rc = gcry_sexp_build (&res, &size,    /* erroff */
 697                                 "(private-key(rsa(n %m)(e %m)(d %m)))",
 698                                 n, e, d);
 699         }
 700     }
 701   gcry_mpi_release (n);
 702   gcry_mpi_release (e);
 703   gcry_mpi_release (d);
 704   if (p != NULL)
 705     gcry_mpi_release (p);
 706   if (q != NULL)
 707     gcry_mpi_release (q);
 708   if (u != NULL)
 709     gcry_mpi_release (u);
 710
 711   if (rc)
 712     LOG_GCRY (GNUNET_ERROR_TYPE_ERROR, "gcry_sexp_build", rc);
 713 #if EXTRA_CHECKS
 714   if (gcry_pk_testkey (res))
 715     {
 716       LOG_GCRY (GNUNET_ERROR_TYPE_ERROR, "gcry_pk_testkey", rc);
 717       return NULL;
 718     }
 719 #endif
 720   ret = GNUNET_malloc (sizeof (struct GNUNET_CRYPTO_RsaPrivateKey));
 721   ret->sexp = res;
 722   return ret;
 723 }
 724
 725
 726
 727
 728 typedef struct
 729 {
 730   GNUNET_HashCode hc;
 731   struct KskRsaPrivateKeyBinaryEncoded *pke;
 732 } KBlockKeyCacheLine;
 733
 734 static KBlockKeyCacheLine **cache;
 735 static unsigned int cacheSize;
 736
 737 /**
 738  * Deterministically (!) create a hostkey using only the
 739  * given HashCode as input to the PRNG.
 740  */
 741 struct GNUNET_CRYPTO_RsaPrivateKey *
 742 GNUNET_CRYPTO_rsa_key_create_from_hash (const GNUNET_HashCode * hc)
 743 {
 744   struct GNUNET_CRYPTO_RsaPrivateKey *ret;
 745   KBlockKeyCacheLine *line;
 746   int i;
 747
 748   for (i = 0; i < cacheSize; i++)
 749     {
 750       if (0 == memcmp (hc, &cache[i]->hc, sizeof (GNUNET_HashCode)))
 751         {
 752           ret = ksk_decode_key (cache[i]->pke);
 753           return ret;
 754         }
 755     }
 756
 757   line = GNUNET_malloc (sizeof (KBlockKeyCacheLine));
 758   line->hc = *hc;
 759   line->pke = makeKblockKeyInternal (hc);
 760   GNUNET_array_grow (cache, cacheSize, cacheSize + 1);
 761   cache[cacheSize - 1] = line;
 762   return ksk_decode_key (line->pke);
 763 }
 764
 765
 766 /**
 767  * Process ID of the "find" process that we use for
 768  * entropy gathering.
 769  */
 770 static pid_t genproc;
 771
 772 /**
 773  * Function called by libgcrypt whenever we are
 774  * blocked gathering entropy.
 775  */
 776 static void
 777 entropy_generator (void *cls,
 778                    const char *what,
 779                    int printchar,
 780                    int current,
 781                    int total)
 782 {
 783   unsigned long code;
 784   enum GNUNET_OS_ProcessStatusType type;
 785   int ret;
 786
 787   if (0 != strcmp (what, "need_entropy"))
 788     return;
 789   if (current == total)
 790     {
 791       if (genproc != 0)
 792         {
 793           if (0 != PLIBC_KILL(genproc, SIGTERM))
 794             GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR,
 795                                  "kill");
 796           GNUNET_break (GNUNET_OK == GNUNET_OS_process_wait (genproc));
 797           genproc = 0;
 798         }
 799       return;
 800     }
 801   if (genproc != 0)
 802     {
 803       ret = GNUNET_OS_process_status (genproc,
 804                                       &type,
 805                                       &code);
 806       if (ret == GNUNET_NO)
 807         return; /* still running */
 808       if (ret == GNUNET_SYSERR)
 809         {
 810           GNUNET_break (0);
 811           return;
 812         }
 813       if (0 != PLIBC_KILL(genproc, SIGTERM))
 814         GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR,
 815                              "kill");
 816       GNUNET_break (GNUNET_OK == GNUNET_OS_process_wait (genproc));
 817       genproc = 0;
 818     }
 819   GNUNET_log(GNUNET_ERROR_TYPE_INFO,
 820              _("Starting `%s' process to generate entropy\n"),
 821              "find");
 822   genproc = GNUNET_OS_start_process ("sh",
 823                                      "sh",
 824                                      "-c",
 825                                      "exec find / -mount -type f -exec cp {} /dev/null \\; 2>/dev/null",
 826                                      NULL);
 827 }
 828
 829
 830 static void
 831 killfind ()
 832 {
 833   if (genproc != 0)
 834     {
 835       PLIBC_KILL(genproc, SIGKILL);
 836       genproc = 0;
 837     }
 838 }
 839
 840
 841 void __attribute__ ((constructor)) GNUNET_CRYPTO_ksk_init ()
 842 {
 843   gcry_control (GCRYCTL_DISABLE_SECMEM, 0);
 844   if (!gcry_check_version (GCRYPT_VERSION))
 845     {
 846       fprintf (stderr,
 847                _
 848                ("libgcrypt has not the expected version (version %s is required).\n"),
 849                GCRYPT_VERSION);
 850       abort ();
 851     }
 852 #ifdef gcry_fast_random_poll
 853   gcry_fast_random_poll ();
 854 #endif
 855   gcry_set_progress_handler (&entropy_generator, NULL);
 856   atexit (&killfind);
 857 }
 858
 859
 860 void __attribute__ ((destructor)) GNUNET_CRYPTO_ksk_fini ()
 861 {
 862   int i;
 863
 864   for (i = 0; i < cacheSize; i++)
 865     {
 866       GNUNET_free (cache[i]->pke);
 867       GNUNET_free (cache[i]);
 868     }
 869   GNUNET_array_grow (cache, cacheSize, 0);
 870   gcry_set_progress_handler (NULL, NULL);
 871 }
 872
 873 /* end of kblockkey.c */