Use syslog to log important messages.
[libgcrypt.git] / random / random-fips.c
1 /* random-fips.c - FIPS style random number generator
2  * Copyright (C) 2008  Free Software Foundation, Inc.
3  *
4  * This file is part of Libgcrypt.
5  *
6  * Libgcrypt is free software; you can redistribute it and/or modify
7  * it under the terms of the GNU Lesser General Public License as
8  * published by the Free Software Foundation; either version 2.1 of
9  * the License, or (at your option) any later version.
10  *
11  * Libgcrypt is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14  * GNU Lesser General Public License for more details.
15  *
16  * You should have received a copy of the GNU Lesser General Public
17  * License along with this program; if not, see <http://www.gnu.org/licenses/>.
18  */
19
20 /*
21    The core of this deterministic random number generator is
22    implemented according to the document "NIST-Recommended Random
23    Number Generator Based on ANSI X9.31 Appendix A.2.4 Using the 3-Key
24    Triple DES and AES Algorithms" (2005-01-31).  This implementation
25    uses the AES variant.
26
27    There are 3 random context which map to the different levels of
28    random quality:
29
30    Generator                Seed and Key        Kernel entropy (init/reseed)
31    ------------------------------------------------------------
32    GCRY_VERY_STRONG_RANDOM  /dev/random         256/128 bits
33    GCRY_STRONG_RANDOM       /dev/random         256/128 bits
34    gcry_create_nonce        GCRY_STRONG_RANDOM  n/a
35
36    All random generators return their data in 128 bit blocks.  If the
37    caller requested less bits, the extra bits are not used.  The key
38    for each generator is only set once at the first time a generator
39    is used.  The seed value is set with the key and again after 1000
40    (SEED_TTL) output blocks.
41
42    The GCRY_VERY_STRONG_RANDOM and GCRY_STRONG_RANDOM generators are
43    keyed and seeded from the /dev/random device.  Thus these
44    generators may block until the kernel has collected enough entropy.
45
46    The gcry_create_nonce generator is keyed and seeded from the
47    GCRY_STRONG_RANDOM generator.  It may also block if the
48    GCRY_STRONG_RANDOM generator has not yet been used before and thus
49    gets initialized on the first use by gcry_create_nonce.  This
50    special treatment is justified by the weaker requirements for a
51    nonce generator and to save precious kernel entropy for use by the
52    real random generators.
53
54  */
55
56 #include <config.h>
57 #include <stdio.h>
58 #include <stdlib.h>
59 #include <errno.h>
60 #include <sys/types.h>
61 #include <unistd.h>
62 #ifdef HAVE_GETTIMEOFDAY
63 #include <sys/time.h>
64 #endif
65
66 #include "g10lib.h"
67 #include "random.h"
68 #include "rand-internal.h"
69 #include "ath.h"
70
71 /* This is the lock we use to serialize access to this RNG.  The extra
72    integer variable is only used to check the locking state; that is,
73    it is not meant to be thread-safe but merely as a failsafe feature
74    to assert proper locking.  */
75 static ath_mutex_t fips_rng_lock = ATH_MUTEX_INITIALIZER;
76 static int fips_rng_is_locked;
77
78
79 /* The required size for the temporary buffer of the x931_aes_driver
80    function and the buffer itself which will be allocated in secure
81    memory.  This needs to be global variable for proper initialization
82    and to allow shutting down the RNG without leaking memory.  May
83    only be used while holding the FIPS_RNG_LOCK.
84
85    This variable is also used to avoid duplicate initialization.  */
86 #define TEMPVALUE_FOR_X931_AES_DRIVER_SIZE 48
87 static unsigned char *tempvalue_for_x931_aes_driver;
88
89
90 /* After having retrieved this number of blocks from the RNG, we want
91    to do a reseeding.  */
92 #define SEED_TTL 1000
93
94
95 /* The length of the key we use:  16 bytes (128 bit) for AES128.  */
96 #define X931_AES_KEYLEN  16
97 /* A global buffer used to communicate between the x931_generate_key
98    and x931_generate_seed functions and the entropy_collect_cb
99    function.  It may only be used by these functions. */
100 static unsigned char *entropy_collect_buffer;  /* Buffer.  */
101 static size_t entropy_collect_buffer_len;      /* Used length.  */
102 static size_t entropy_collect_buffer_size;     /* Allocated length.  */
103
104
105 /* This random context type is used to track properties of one random
106    generator. Thee context are usually allocated in secure memory so
107    that the seed value is well protected.  There are a couble of guard
108    fields to help detecting applications accidently overwriting parts
109    of the memory. */
110 struct rng_context
111 {
112   unsigned char guard_0[1];
113
114   /* The handle of the cipher used by the RNG.  If this one is not
115      NULL a cipher handle along with a random key has been
116      established.  */
117   gcry_cipher_hd_t cipher_hd;
118
119   /* If this flag is true, the SEED_V buffer below carries a valid
120      seed.  */
121   int is_seeded:1;
122
123   /* The very first block generated is used to compare the result
124      against the last result.  This flag indicates that such a block
125      is available.  */
126   int compare_value_valid:1;
127
128   /* A counter used to trigger re-seeding.  */
129   unsigned int use_counter;
130
131   unsigned char guard_1[1];
132
133   /* The buffer containing the seed value V.  */
134   unsigned char seed_V[16];
135
136   unsigned char guard_2[1];
137
138   /* The last result from the x931_aes fucntion.  Only valid if
139      compare_value_valid is set.  */
140   unsigned char compare_value[16];
141
142   unsigned char guard_3[1];
143
144   /* To implement a KAT we need to provide a know DT value.  To
145      accomplish this the x931_get_dt function checks whether this
146      field is not NULL and then uses the 16 bytes at this address for
147      the DT value.  However the last 4 bytes are replaced by the
148      value of field TEST_DT_COUNTER which will be incremented after
149      each invocation of x931_get_dt. We use a pointer and not a buffer
150      because there is no need to put this value into secure  memory.  */
151   const unsigned char *test_dt_ptr;
152   u32 test_dt_counter;
153
154   /* We need to keep track of the process which did the initialization
155      so that we can detect a fork.  The volatile modifier is required
156      so that the compiler does not optimize it away in case the getpid
157      function is badly attributed.  */ 
158   pid_t key_init_pid;
159   pid_t seed_init_pid;
160 };
161 typedef struct rng_context *rng_context_t;
162
163
164 /* The random context used for the nonce generator.  May only be used
165    while holding the FIPS_RNG_LOCK.  */
166 static rng_context_t nonce_context;
167 /* The random context used for the standard random generator.  May
168    only be used while holding the FIPS_RNG_LOCK.  */
169 static rng_context_t std_rng_context;
170 /* The random context used for the very strong random generator.  May
171    only be used while holding the FIPS_RNG_LOCK.  */
172 static rng_context_t strong_rng_context;
173
174
175 /* --- Local prototypes ---  */
176 static void x931_reseed (rng_context_t rng_ctx);
177 static void get_random (void *buffer, size_t length, rng_context_t rng_ctx);
178
179
180
181 \f
182 /* --- Functions  --- */
183
184 /* Basic initialization is required to initialize mutexes and
185    do a few checks on the implementation.  */
186 static void
187 basic_initialization (void)
188 {
189   static int initialized;
190   int my_errno;
191
192   if (!initialized)
193     return;
194   initialized = 1;
195
196   my_errno = ath_mutex_init (&fips_rng_lock);
197   if (my_errno)
198     log_fatal ("failed to create the RNG lock: %s\n", strerror (my_errno));
199   fips_rng_is_locked = 0;
200       
201   /* Make sure that we are still using the values we have
202      traditionally used for the random levels.  */
203   gcry_assert (GCRY_WEAK_RANDOM == 0 
204                && GCRY_STRONG_RANDOM == 1
205                && GCRY_VERY_STRONG_RANDOM == 2);
206
207 }
208
209
210 /* Acquire the fips_rng_lock.  */
211 static void
212 lock_rng (void)
213 {
214   int my_errno;
215
216   my_errno = ath_mutex_lock (&fips_rng_lock);
217   if (my_errno)
218     log_fatal ("failed to acquire the RNG lock: %s\n", strerror (my_errno));
219   fips_rng_is_locked = 1;
220 }
221
222
223 /* Release the fips_rng_lock.  */
224 static void
225 unlock_rng (void)
226 {
227   int my_errno;
228
229   fips_rng_is_locked = 0;
230   my_errno = ath_mutex_unlock (&fips_rng_lock);
231   if (my_errno)
232     log_fatal ("failed to release the RNG lock: %s\n", strerror (my_errno));
233 }
234
235 static void
236 setup_guards (rng_context_t rng_ctx)
237 {
238   /* Set the guards to some arbitrary values.  */
239   rng_ctx->guard_0[0] = 17;
240   rng_ctx->guard_1[0] = 42;
241   rng_ctx->guard_2[0] = 137;
242   rng_ctx->guard_3[0] = 252;
243 }
244
245 static void
246 check_guards (rng_context_t rng_ctx)
247 {
248   if ( rng_ctx->guard_0[0] != 17
249        || rng_ctx->guard_1[0] != 42
250        || rng_ctx->guard_2[0] != 137
251        || rng_ctx->guard_3[0] != 252 )
252     log_fatal ("memory corruption detected in RNG context %p\n", rng_ctx);
253 }
254
255
256 /* Get the DT vector for use with the core PRNG function.  Buffer
257    needs to be provided by the caller with a size of at least LENGTH
258    bytes. RNG_CTX needs to be passed to allow for a KAT.  The 16 byte
259    timestamp we construct is made up the real time and three counters:
260
261    Buffer:       00112233445566778899AABBCCDDEEFF
262                  !--+---!!-+-!!+!!--+---!!--+---!     
263    seconds ---------/      |   |    |       |
264    microseconds -----------/   |    |       |
265    counter2 -------------------/    |       |
266    counter1 ------------------------/       |
267    counter0 --------------------------------/
268
269    Counter 2 is just 12 bits wide and used to track fractions of
270    milliseconds whereas counters 1 and 0 are combined to a free
271    running 64 bit counter.  */
272 static void 
273 x931_get_dt (unsigned char *buffer, size_t length, rng_context_t rng_ctx)
274 {
275   gcry_assert (length == 16); /* This length is required for use with AES.  */
276   gcry_assert (fips_rng_is_locked);
277
278   /* If the random context indicates that a test DT should be used,
279      take the DT value from the context.  For safety reasons we do
280      this only if the context is not one of the regular contexts.  */
281   if (rng_ctx->test_dt_ptr 
282       && rng_ctx != nonce_context
283       && rng_ctx != std_rng_context
284       && rng_ctx != strong_rng_context)
285     {
286       memcpy (buffer, rng_ctx->test_dt_ptr, 16);
287       buffer[12] = (rng_ctx->test_dt_counter >> 24);
288       buffer[13] = (rng_ctx->test_dt_counter >> 16);
289       buffer[14] = (rng_ctx->test_dt_counter >> 8);
290       buffer[15] = rng_ctx->test_dt_counter;
291       rng_ctx->test_dt_counter++;
292       return;
293     }
294
295
296 #if HAVE_GETTIMEOFDAY
297   {
298     static u32 last_sec, last_usec;
299     static u32 counter1, counter0;
300     static u16 counter2;
301     
302     unsigned int usec;
303     struct timeval tv;
304
305     if (!last_sec)
306       {
307         /* This is the very first time we are called: Set the counters
308            to an not so easy predictable value to avoid always
309            starting at 0.  Not really needed but it doesn't harm.  */
310         counter1 = (u32)getpid ();
311 #ifndef HAVE_W32_SYSTEM
312         counter0 = (u32)getppid ();
313 #endif
314       }
315
316
317     if (gettimeofday (&tv, NULL))
318       log_fatal ("gettimeofday() failed: %s\n", strerror (errno));
319
320     /* The microseconds part is always less than 1 millon (0x0f4240).
321        Thus we don't care about the MSB and in addition shift it to
322        the left by 4 bits.  */
323     usec = tv.tv_usec;
324     usec <<= 4;
325     /* If we got the same time as by the last invocation, bump up
326        counter2 and save the time for the next invocation.  */
327     if (tv.tv_sec == last_sec && usec == last_usec)
328       {
329         counter2++;
330         counter2 &= 0x0fff;
331       }
332     else
333       {
334         counter2 = 0;
335         last_sec = tv.tv_sec;
336         last_usec = usec;
337       }
338     /* Fill the buffer with the timestamp.  */
339     buffer[0] = ((tv.tv_sec >> 24) & 0xff);
340     buffer[1] = ((tv.tv_sec >> 16) & 0xff);
341     buffer[2] = ((tv.tv_sec >> 8) & 0xff);
342     buffer[3] = (tv.tv_sec & 0xff);
343     buffer[4] = ((usec >> 16) & 0xff);
344     buffer[5] = ((usec >> 8) & 0xff);
345     buffer[6] = ((usec & 0xf0) | ((counter2 >> 8) & 0x0f));
346     buffer[7] = (counter2 & 0xff);
347     /* Add the free running counter.  */
348     buffer[8]  = ((counter1 >> 24) & 0xff);
349     buffer[9]  = ((counter1 >> 16) & 0xff);
350     buffer[10] = ((counter1 >> 8) & 0xff); 
351     buffer[11] = ((counter1) & 0xff);
352     buffer[12] = ((counter0 >> 24) & 0xff);
353     buffer[13] = ((counter0 >> 16) & 0xff);
354     buffer[14] = ((counter0 >> 8) & 0xff); 
355     buffer[15] = ((counter0) & 0xff);
356     /* Bump up that counter.  */
357     if (!++counter0)
358       ++counter1;
359   }
360 #else
361   log_fatal ("gettimeofday() not available on this system\n");
362 #endif
363
364   /* log_printhex ("x931_get_dt: ", buffer, 16); */
365 }
366
367
368 /* XOR the buffers A and B which are each of LENGTH bytes and store
369    the result at R.  R needs to be provided by the caller with a size
370    of at least LENGTH bytes.  */
371 static void
372 xor_buffer (unsigned char *r, 
373             const unsigned char *a, const unsigned char *b, size_t length)
374 {
375   for ( ; length; length--, a++, b++, r++)
376     *r = (*a ^ *b);
377 }
378
379
380 /* Encrypt LENGTH bytes of INPUT to OUTPUT using KEY.  LENGTH
381    needs to be 16. */
382 static void
383 encrypt_aes (gcry_cipher_hd_t key, 
384              unsigned char *output, const unsigned char *input, size_t length)
385 {
386   gpg_error_t err;
387
388   gcry_assert (length == 16);
389
390   err = gcry_cipher_encrypt (key, output, length, input, length);
391   if (err)
392     log_fatal ("AES encryption in RNG failed: %s\n", gcry_strerror (err));
393 }
394
395
396 /* The core ANSI X9.31, Appendix A.2.4 function using AES.  The caller
397    needs to pass a 16 byte buffer for the result, the 16 byte
398    datetime_DT value and the 16 byte seed value V.  The caller also
399    needs to pass an appropriate KEY and make sure to pass a valid
400    seed_V.  The caller also needs to provide two 16 bytes buffer for
401    intermediate results, they may be reused by the caller later.
402
403    On return the result is stored at RESULT_R and the SEED_V is
404    updated.  May only be used while holding the lock.  */
405 static void
406 x931_aes (unsigned char result_R[16], 
407           unsigned char datetime_DT[16], unsigned char seed_V[16],
408           gcry_cipher_hd_t key,
409           unsigned char intermediate_I[16], unsigned char temp_xor[16])
410 {
411   /* Let ede*X(Y) represent the AES encryption of Y under the key *X.
412
413      Let V be a 128-bit seed value which is also kept secret, and XOR
414      be the exclusive-or operator. Let DT be a date/time vector which
415      is updated on each iteration. I is a intermediate value. 
416
417      I = ede*K(DT)  */
418   encrypt_aes (key, intermediate_I, datetime_DT, 16);
419
420   /* R = ede*K(I XOR V) */
421   xor_buffer (temp_xor, intermediate_I, seed_V, 16);
422   encrypt_aes (key, result_R, temp_xor, 16);
423
424   /* V = ede*K(R XOR I).  */
425   xor_buffer (temp_xor, result_R, intermediate_I, 16);
426   encrypt_aes (key, seed_V, temp_xor, 16);
427
428   /* Zero out temporary values.  */
429   wipememory (intermediate_I, 16);
430   wipememory (temp_xor, 16);
431 }
432
433
434 /* The high level driver to x931_aes.  This one does the required
435    tests and calls the core function until the entire buffer has been
436    filled.  OUTPUT is a caller provided buffer of LENGTH bytes to
437    receive the random, RNG_CTX is the context of the RNG.  The context
438    must be properly initialized.  Returns 0 on success. */
439 static int
440 x931_aes_driver (unsigned char *output, size_t length, rng_context_t rng_ctx)
441 {
442   unsigned char datetime_DT[16];
443   unsigned char *intermediate_I, *temp_buffer, *result_buffer;
444   size_t nbytes;
445
446   gcry_assert (fips_rng_is_locked);
447   gcry_assert (rng_ctx->cipher_hd);
448   gcry_assert (rng_ctx->is_seeded);
449
450   gcry_assert (tempvalue_for_x931_aes_driver);
451   gcry_assert (TEMPVALUE_FOR_X931_AES_DRIVER_SIZE == 48);
452   intermediate_I = tempvalue_for_x931_aes_driver;
453   temp_buffer    = tempvalue_for_x931_aes_driver + 16;
454   result_buffer  = tempvalue_for_x931_aes_driver + 32;
455
456   while (length)
457     {
458       /* We require a new seed after some time.  */
459       if (rng_ctx->use_counter > SEED_TTL)
460         {
461           x931_reseed (rng_ctx);
462           rng_ctx->use_counter = 0;
463         }
464
465       /* Due to the design of the RNG, we always receive 16 bytes (128
466          bit) of random even if we require less.  The extra bytes
467          returned are not used.  Intheory we could save them for the
468          next invocation, but that would make the control flow harder
469          to read.  */
470       nbytes = length < 16? length : 16;
471
472       x931_get_dt (datetime_DT, 16, rng_ctx);
473       x931_aes (result_buffer,
474                 datetime_DT, rng_ctx->seed_V, rng_ctx->cipher_hd,
475                 intermediate_I, temp_buffer);
476       rng_ctx->use_counter++;
477
478       /* Do a basic check on the output to avoid a stuck generator.  */
479       if (!rng_ctx->compare_value_valid)
480         {
481           /* First time used, only save the result.  */
482           memcpy (rng_ctx->compare_value, result_buffer, 16);
483           rng_ctx->compare_value_valid = 1;
484           continue;
485         }
486       if (!memcmp (rng_ctx->compare_value, result_buffer, 16))
487         {
488           /* Ooops, we received the same 128 bit block - that should
489              in theory never happen.  The FIPS requirement says that
490              we need to put ourself into the error state in such
491              case.  */
492           fips_signal_error ("duplicate 128 bit block returned by RNG");
493           return -1;
494         }
495       memcpy (rng_ctx->compare_value, result_buffer, 16);
496       
497       /* Append to outbut.  */
498       memcpy (output, result_buffer, nbytes);
499       wipememory (result_buffer, 16);
500       output += nbytes;
501       length -= nbytes;
502     }
503
504   return 0;
505 }
506
507
508 /* Callback for x931_generate_key. Note that this callback uses the
509    global ENTROPY_COLLECT_BUFFER which has been setup by get_entropy.
510    ORIGIN is not used but required due to the design of entropy
511    gathering module. */
512 static void
513 entropy_collect_cb (const void *buffer, size_t length,
514                     enum random_origins origin)
515 {
516   const unsigned char *p = buffer;
517
518   (void)origin;
519
520   gcry_assert (fips_rng_is_locked);
521   gcry_assert (entropy_collect_buffer);
522
523   /* Note that we need to protect against gatherers returning more
524      than the requested bytes (e.g. rndw32).  */
525   while (length-- && entropy_collect_buffer_len < entropy_collect_buffer_size)
526     {
527       entropy_collect_buffer[entropy_collect_buffer_len++] ^= *p++;
528     }
529 }
530
531
532 /* Get NBYTES of entropy from the kernel device.  The callers needs to
533    free the returned buffer.  The function either succeeds or
534    terminates the process in case of a fatal error. */
535 static void *
536 get_entropy (size_t nbytes)
537 {
538   void *result;
539   int rc;
540
541   gcry_assert (!entropy_collect_buffer);
542   entropy_collect_buffer = gcry_xmalloc_secure (nbytes);
543   entropy_collect_buffer_size = nbytes;
544   entropy_collect_buffer_len = 0;
545
546 #if USE_RNDLINUX
547   rc = _gcry_rndlinux_gather_random (entropy_collect_cb, 0,
548                                      X931_AES_KEYLEN,
549                                      GCRY_VERY_STRONG_RANDOM);
550 #elif USE_RNDW32
551   do 
552     {
553       rc = _gcry_rndw32_gather_random (entropy_collect_cb, 0,
554                                        X931_AES_KEYLEN,
555                                        GCRY_VERY_STRONG_RANDOM);
556     }
557   while (rc >= 0 && entropy_collect_buffer_len < entropy_collect_buffer_size);
558 #else
559   rc = -1;
560 #endif
561
562   if (rc < 0 || entropy_collect_buffer_len != entropy_collect_buffer_size)
563     {
564       gcry_free (entropy_collect_buffer);
565       entropy_collect_buffer = NULL;
566       log_fatal ("error getting entropy data\n");
567     }
568   result = entropy_collect_buffer;
569   entropy_collect_buffer = NULL;
570   return result;
571 }
572
573
574 /* Generate a key for use with x931_aes.  The function returns a
575    handle to the cipher context readily prepared for ECB encryption.
576    If FOR_NONCE is true, the key is retrieved by readong random from
577    the standard generator.  On error NULL is returned.  */
578 static gcry_cipher_hd_t
579 x931_generate_key (int for_nonce)
580 {
581   gcry_cipher_hd_t hd;
582   gpg_error_t err;
583   void *buffer;
584
585   gcry_assert (fips_rng_is_locked);
586
587   /* Allocate a cipher context.  */
588   err = gcry_cipher_open (&hd, GCRY_CIPHER_AES128, GCRY_CIPHER_MODE_ECB,
589                           GCRY_CIPHER_SECURE);
590   if (err)
591     {
592       log_error ("error creating cipher context for RNG: %s\n",
593                  gcry_strerror (err));
594       return NULL;
595     }
596
597   /* Get a key from the standard RNG or from the entropy source.  */
598   if (for_nonce)
599     {
600       buffer = gcry_xmalloc (X931_AES_KEYLEN);
601       get_random (buffer, X931_AES_KEYLEN, std_rng_context);
602     }
603   else
604     {
605       buffer = get_entropy (X931_AES_KEYLEN);
606     }
607
608   /* Set the key and delete the buffer because the key is now part of
609      the cipher context.  */
610   err = gcry_cipher_setkey (hd, buffer, X931_AES_KEYLEN);
611   wipememory (buffer, X931_AES_KEYLEN);
612   gcry_free (buffer);
613   if (err)
614     {
615       log_error ("error creating key for RNG: %s\n", gcry_strerror (err));
616       gcry_cipher_close (hd);
617       return NULL;
618     }
619
620   return hd;
621 }
622
623
624 /* Generate a key for use with x931_aes.  The function copies a seed
625    of LENGTH bytes into SEED_BUFFER. LENGTH needs to by given as 16.  */
626 static void
627 x931_generate_seed (unsigned char *seed_buffer, size_t length)
628 {
629   void *buffer;
630
631   gcry_assert (fips_rng_is_locked);
632   gcry_assert (length == 16);
633
634   buffer = get_entropy (X931_AES_KEYLEN);
635
636   memcpy (seed_buffer, buffer, X931_AES_KEYLEN);
637   wipememory (buffer, X931_AES_KEYLEN);
638   gcry_free (buffer);
639 }
640
641
642
643 /* Reseed a generator.  This is also used for the initial seeding. */
644 static void
645 x931_reseed (rng_context_t rng_ctx)
646 {
647   gcry_assert (fips_rng_is_locked);
648
649   if (rng_ctx == nonce_context)
650     {
651       /* The nonce context is special.  It will be seeded using the
652          standard random generator.  */
653       get_random (rng_ctx->seed_V, 16, std_rng_context);
654       rng_ctx->is_seeded = 1;
655       rng_ctx->seed_init_pid = getpid ();
656     }
657   else
658     {
659       /* The other two generators are seeded from /dev/random.  */
660       x931_generate_seed (rng_ctx->seed_V, 16);
661       rng_ctx->is_seeded = 1;
662       rng_ctx->seed_init_pid = getpid ();
663     }
664 }
665
666
667 /* Core random function.  This is used for both nonce and random
668    generator.  The actual RNG to be used depends on the random context
669    RNG_CTX passed.  Note that this function is called with the RNG not
670    yet locked.  */
671 static void
672 get_random (void *buffer, size_t length, rng_context_t rng_ctx)
673 {
674   gcry_assert (buffer);
675   gcry_assert (rng_ctx);
676
677   check_guards (rng_ctx);
678
679   /* Initialize the cipher handle and thus setup the key if needed.  */
680   if (!rng_ctx->cipher_hd)
681     {
682       if (rng_ctx == nonce_context)
683         rng_ctx->cipher_hd = x931_generate_key (1);
684       else
685         rng_ctx->cipher_hd = x931_generate_key (0);
686       if (!rng_ctx->cipher_hd)
687         goto bailout;
688       rng_ctx->key_init_pid = getpid ();
689     }
690
691   /* Initialize the seed value if needed.  */
692   if (!rng_ctx->is_seeded)
693     x931_reseed (rng_ctx);
694
695   if (rng_ctx->key_init_pid != getpid ()
696       || rng_ctx->seed_init_pid != getpid ())
697     {
698       /* We are in a child of us.  Because we have no way yet to do
699          proper re-initialization (including self-checks etc), the
700          only chance we have is to bail out.  Obviusly a fork/exec
701          won't harm because the exec overwrites the old image. */
702       fips_signal_error ("fork without proper re-initialization "
703                          "detected in RNG");
704       goto bailout;
705     }
706
707   if (x931_aes_driver (buffer, length, rng_ctx))
708     goto bailout;
709
710   check_guards (rng_ctx);
711   return;
712
713  bailout:
714   log_fatal ("severe error getting random\n");
715   /*NOTREACHED*/
716 }
717
718
719 \f
720 /* --- Public Functions --- */
721
722 /* Initialize this random subsystem.  If FULL is false, this function
723    merely calls the basic initialization of the module and does not do
724    anything more.  Doing this is not really required but when running
725    in a threaded environment we might get a race condition
726    otherwise. */
727 void
728 _gcry_rngfips_initialize (int full)
729 {
730   basic_initialization ();
731   if (!full)
732     return;
733
734   /* Allocate temporary buffers.  If that buffer already exists we
735      know that we are already initialized.  */
736   lock_rng ();
737   if (!tempvalue_for_x931_aes_driver)
738     {
739       tempvalue_for_x931_aes_driver
740         = gcry_xmalloc_secure (TEMPVALUE_FOR_X931_AES_DRIVER_SIZE);
741
742       /* Allocate the random contexts.  Note that we do not need to use
743          secure memory for the nonce context.  */
744       nonce_context = gcry_xcalloc (1, sizeof *nonce_context);
745       setup_guards (nonce_context);
746
747       std_rng_context = gcry_xcalloc_secure (1, sizeof *std_rng_context);
748       setup_guards (std_rng_context);
749       
750       strong_rng_context = gcry_xcalloc_secure (1, sizeof *strong_rng_context);
751       setup_guards (strong_rng_context);
752     }
753   else
754     {
755       /* Already initialized. Do some sanity checks.  */
756       gcry_assert (!nonce_context->test_dt_ptr);
757       gcry_assert (!std_rng_context->test_dt_ptr);
758       gcry_assert (!strong_rng_context->test_dt_ptr);
759       check_guards (nonce_context);
760       check_guards (std_rng_context);
761       check_guards (strong_rng_context);
762     }
763   unlock_rng ();
764 }
765
766
767 /* Print some statistics about the RNG.  */
768 void
769 _gcry_rngfips_dump_stats (void)
770 {
771   /* Not yet implemented.  */
772 }
773
774
775 /* This function returns true if no real RNG is available or the
776    quality of the RNG has been degraded for test purposes.  */
777 int
778 _gcry_rngfips_is_faked (void)
779 {
780   return 0;  /* Faked random is not allowed.  */
781 }
782
783
784 /* Add BUFLEN bytes from BUF to the internal random pool.  QUALITY
785    should be in the range of 0..100 to indicate the goodness of the
786    entropy added, or -1 for goodness not known. */
787 gcry_error_t
788 _gcry_rngfips_add_bytes (const void *buf, size_t buflen, int quality)
789 {
790   (void)buf;
791   (void)buflen;
792   (void)quality;
793   return 0;  /* Not implemented. */
794 }   
795
796     
797 /* Public function to fill the buffer with LENGTH bytes of
798    cryptographically strong random bytes.  Level GCRY_WEAK_RANDOM is
799    here mapped to GCRY_STRONG_RANDOM, GCRY_STRONG_RANDOM is strong
800    enough for most usage, GCRY_VERY_STRONG_RANDOM is good for key
801    generation stuff but may be very slow.  */
802 void
803 _gcry_rngfips_randomize (void *buffer, size_t length,
804                          enum gcry_random_level level)
805 {
806   _gcry_rngfips_initialize (1);  /* Auto-initialize if needed.  */
807   
808   lock_rng ();
809   if (level == GCRY_VERY_STRONG_RANDOM)
810     get_random (buffer, length, strong_rng_context);
811   else
812     get_random (buffer, length, std_rng_context);
813   unlock_rng ();
814 }
815
816
817 /* Create an unpredicable nonce of LENGTH bytes in BUFFER. */
818 void
819 _gcry_rngfips_create_nonce (void *buffer, size_t length)
820 {
821   _gcry_rngfips_initialize (1);  /* Auto-initialize if needed.  */
822
823   lock_rng ();
824   get_random (buffer, length, nonce_context);
825   unlock_rng ();
826 }
827
828
829 /* Run a Know-Answer-Test using a dedicated test context.  Note that
830    we can't use the samples from the NISR RNGVS document because they
831    don't take the requirement to throw away the first block and use
832    that for duplicate check in account.  Thus we made up our own test
833    vectors. */
834 static gcry_err_code_t
835 selftest_kat (selftest_report_func_t report)
836 {
837   static struct 
838   {
839     const unsigned char key[16];
840     const unsigned char dt[16];
841     const unsigned char v[16];
842     const unsigned char r[3][16];
843   } tv[] =
844     {
845       { { 0xb9, 0xca, 0x7f, 0xd6, 0xa0, 0xf5, 0xd3, 0x42,
846           0x19, 0x6d, 0x84, 0x91, 0x76, 0x1c, 0x3b, 0xbe },
847         { 0x48, 0xb2, 0x82, 0x98, 0x68, 0xc2, 0x80, 0x00,
848           0x00, 0x00, 0x28, 0x18, 0x00, 0x00, 0x25, 0x00 },
849         { 0x52, 0x17, 0x8d, 0x29, 0xa2, 0xd5, 0x84, 0x12,
850           0x9d, 0x89, 0x9a, 0x45, 0x82, 0x02, 0xf7, 0x77 },
851         { { 0x42, 0x9c, 0x08, 0x3d, 0x82, 0xf4, 0x8a, 0x40,
852             0x66, 0xb5, 0x49, 0x27, 0xab, 0x42, 0xc7, 0xc3 },
853           { 0x0e, 0xb7, 0x61, 0x3c, 0xfe, 0xb0, 0xbe, 0x73,
854             0xf7, 0x6e, 0x6d, 0x6f, 0x1d, 0xa3, 0x14, 0xfa },
855           { 0xbb, 0x4b, 0xc1, 0x0e, 0xc5, 0xfb, 0xcd, 0x46,
856             0xbe, 0x28, 0x61, 0xe7, 0x03, 0x2b, 0x37, 0x7d } } },
857       { { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
858           0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
859         { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
860           0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
861         { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
862           0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
863         { { 0xf7, 0x95, 0xbd, 0x4a, 0x52, 0xe2, 0x9e, 0xd7,
864             0x13, 0xd3, 0x13, 0xfa, 0x20, 0xe9, 0x8d, 0xbc },
865           { 0xc8, 0xd1, 0xe5, 0x11, 0x59, 0x52, 0xf7, 0xfa,
866             0x37, 0x38, 0xb4, 0xc5, 0xce, 0xb2, 0xb0, 0x9a },
867           { 0x0d, 0x9c, 0xc5, 0x0d, 0x16, 0xe1, 0xbc, 0xed, 
868             0xcf, 0x60, 0x62, 0x09, 0x9d, 0x20, 0x83, 0x7e } } },
869       { { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
870           0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f },
871         { 0x80, 0x00, 0x81, 0x01, 0x82, 0x02, 0x83, 0x03,
872           0xa0, 0x20, 0xa1, 0x21, 0xa2, 0x22, 0xa3, 0x23 },
873         { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
874           0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff },
875         { { 0x96, 0xed, 0xcc, 0xc3, 0xdd, 0x04, 0x7f, 0x75,
876             0x63, 0x19, 0x37, 0x6f, 0x15, 0x22, 0x57, 0x56 },
877           { 0x7a, 0x14, 0x76, 0x77, 0x95, 0x17, 0x7e, 0xc8,
878             0x92, 0xe8, 0xdd, 0x15, 0xcb, 0x1f, 0xbc, 0xb1 },
879           { 0x25, 0x3e, 0x2e, 0xa2, 0x41, 0x1b, 0xdd, 0xf5, 
880             0x21, 0x48, 0x41, 0x71, 0xb3, 0x8d, 0x2f, 0x4c } } }
881     };
882   int tvidx, ridx;
883   rng_context_t test_ctx;
884   gpg_error_t err;
885   const char *errtxt = NULL;
886   unsigned char result[16];
887
888   gcry_assert (tempvalue_for_x931_aes_driver);
889
890   test_ctx = gcry_xcalloc (1, sizeof *test_ctx);
891   setup_guards (test_ctx);
892   
893   lock_rng ();
894
895   for (tvidx=0; tvidx < DIM (tv); tvidx++)
896     {
897       /* Setup the key.  */
898       err = gcry_cipher_open (&test_ctx->cipher_hd,
899                               GCRY_CIPHER_AES128, GCRY_CIPHER_MODE_ECB,
900                               GCRY_CIPHER_SECURE);
901       if (err)
902         {
903           errtxt = "error creating cipher context for RNG";
904           goto leave;
905         }
906
907       err = gcry_cipher_setkey (test_ctx->cipher_hd, tv[tvidx].key, 16);
908       if (err)
909         {
910           errtxt = "error setting key for RNG";
911           goto leave;
912         }
913       test_ctx->key_init_pid = getpid ();
914       
915       /* Setup the seed.  */
916       memcpy (test_ctx->seed_V, tv[tvidx].v, 16);
917       test_ctx->is_seeded = 1;
918       test_ctx->seed_init_pid = getpid ();
919       
920       /* Setup a DT value.  */
921       test_ctx->test_dt_ptr = tv[tvidx].dt;
922       test_ctx->test_dt_counter = ( (tv[tvidx].dt[12] << 24) 
923                                    |(tv[tvidx].dt[13] << 16)
924                                    |(tv[tvidx].dt[14] << 8)
925                                    |(tv[tvidx].dt[15]) );
926
927       /* Get and compare the first three results.  */
928       for (ridx=0; ridx < 3; ridx++)
929         {
930           /* Compute the next value.  */
931           if (x931_aes_driver (result, 16, test_ctx))
932             {
933               errtxt = "X9.31 RNG core function failed";
934               goto leave;
935             }
936           
937           /* Compare it to the known value.  */
938           if (memcmp (result, tv[tvidx].r[ridx], 16))
939             {
940               /* log_printhex ("x931_aes got: ", result, 16); */
941               /* log_printhex ("x931_aes exp: ", tv[tvidx].r[ridx], 16); */
942               errtxt = "RNG output does not match known value";
943               goto leave;
944             }
945         }
946
947       /* This test is actual pretty pointless because we use a local test
948          context.  */
949       if (test_ctx->key_init_pid != getpid ()
950           || test_ctx->seed_init_pid != getpid ())
951         {
952           errtxt = "fork detection failed";
953           goto leave;
954         }
955
956       gcry_cipher_close (test_ctx->cipher_hd);
957       test_ctx->cipher_hd = NULL;
958       test_ctx->is_seeded = 0;
959       check_guards (test_ctx);
960     }
961
962  leave:
963   unlock_rng ();
964   gcry_cipher_close (test_ctx->cipher_hd);
965   check_guards (test_ctx);
966   gcry_free (test_ctx);
967   if (report && errtxt)
968     report ("random", 0, "KAT", errtxt);
969   return errtxt? GPG_ERR_SELFTEST_FAILED : 0;
970 }
971
972
973 /* Run the self-tests.  */
974 gcry_error_t
975 _gcry_rngfips_selftest (selftest_report_func_t report)
976 {
977   gcry_err_code_t ec;
978
979 #if defined(USE_RNDLINUX) || defined(USE_RNDW32)
980   {
981     char buffer[8];
982
983     /* Do a simple test using the public interface.  This will also
984        enforce full intialization of the RNG.  We need to be fully
985        initialized due to the global requirement of the
986        tempvalue_for_x931_aes_driver stuff. */
987     gcry_randomize (buffer, sizeof buffer, GCRY_STRONG_RANDOM);
988   }
989
990   ec = selftest_kat (report);
991
992 #else /*!(USE_RNDLINUX||USE_RNDW32)*/
993   report ("random", 0, "setup", "no entropy gathering module");
994   ec = GPG_ERR_SELFTEST_FAILED;
995 #endif
996   return gpg_error (ec);
997 }
998
999
1000 /* Create a new test context for an external RNG test driver.  On
1001    success the test context is stored at R_CONTEXT; on failure NULL is
1002    stored at R_CONTEXT and an error code is returned.  */
1003 gcry_err_code_t
1004 _gcry_rngfips_init_external_test (void **r_context,
1005                                   const void *key, size_t keylen,
1006                                   const void *seed, size_t seedlen,
1007                                   const void *dt, size_t dtlen)
1008 {
1009   gpg_error_t err;
1010   rng_context_t test_ctx;
1011
1012   _gcry_rngfips_initialize (1);  /* Auto-initialize if needed.  */
1013   
1014   if (!r_context
1015       || !key  || keylen  != 16 
1016       || !seed || seedlen != 16
1017       || !dt   || dtlen   != 16 )
1018     return GPG_ERR_INV_ARG;
1019
1020   test_ctx = gcry_calloc (1, sizeof *test_ctx + dtlen);
1021   if (!test_ctx)
1022     return gpg_err_code_from_syserror ();
1023   setup_guards (test_ctx);
1024   
1025   /* Setup the key.  */
1026   err = gcry_cipher_open (&test_ctx->cipher_hd,
1027                           GCRY_CIPHER_AES128, GCRY_CIPHER_MODE_ECB,
1028                           GCRY_CIPHER_SECURE);
1029   if (err)
1030     goto leave;
1031
1032   err = gcry_cipher_setkey (test_ctx->cipher_hd, key, keylen);
1033   if (err)
1034     goto leave;
1035
1036   test_ctx->key_init_pid = getpid ();
1037       
1038   /* Setup the seed.  */
1039   memcpy (test_ctx->seed_V, seed, seedlen);
1040   test_ctx->is_seeded = 1;
1041   test_ctx->seed_init_pid = getpid ();
1042   
1043   /* Setup a DT value.  Because our context structure only stores a
1044      pointer we copy the DT value to the extra space we allocated in
1045      the test_ctx and set the pointer to tehre.  */
1046   memcpy ((char*)test_ctx + sizeof *test_ctx, dt, dtlen);
1047   test_ctx->test_dt_ptr = (unsigned char*)test_ctx + sizeof test_ctx; 
1048   test_ctx->test_dt_counter = ( (test_ctx->test_dt_ptr[12] << 24) 
1049                                |(test_ctx->test_dt_ptr[13] << 16)
1050                                |(test_ctx->test_dt_ptr[14] << 8)
1051                                |(test_ctx->test_dt_ptr[15]) );
1052
1053   check_guards (test_ctx);
1054   /* All fine.  */
1055   err = 0;
1056
1057  leave:
1058   if (err)
1059     {
1060       gcry_cipher_close (test_ctx->cipher_hd);
1061       gcry_free (test_ctx);
1062       *r_context = NULL;
1063     }
1064   else
1065     *r_context = test_ctx;
1066   return gcry_err_code (err);
1067 }
1068
1069
1070 /* Get BUFLEN bytes from the RNG using the test CONTEXT and store them
1071    at BUFFER.  Return 0 on success or an error code.  */
1072 gcry_err_code_t
1073 _gcry_rngfips_run_external_test (void *context, char *buffer, size_t buflen)
1074 {
1075   rng_context_t test_ctx = context;
1076
1077   if (!test_ctx || !buffer || buflen != 16)
1078     return GPG_ERR_INV_ARG;
1079
1080   lock_rng ();
1081   get_random (buffer, buflen, test_ctx);
1082   unlock_rng ();
1083   return 0;
1084 }
1085
1086 /* Release the test CONTEXT.  */
1087 void
1088 _gcry_rngfips_deinit_external_test (void *context)
1089 {
1090   rng_context_t test_ctx = context;
1091
1092   if (test_ctx)
1093     {
1094       gcry_cipher_close (test_ctx->cipher_hd);
1095       gcry_free (test_ctx);
1096     }
1097 }
1098
1099