Prepare a release candidate
[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 byte is will be replaced by the
148      value of field TEST_DT_COUNTER which will be incremented with
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   unsigned char 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, 15);
287       buffer[15] = rng_ctx->test_dt_counter++;
288       return;
289     }
290
291
292 #if HAVE_GETTIMEOFDAY
293   {
294     static u32 last_sec, last_usec;
295     static u32 counter1, counter0;
296     static u16 counter2;
297     
298     unsigned int usec;
299     struct timeval tv;
300
301     if (!last_sec)
302       {
303         /* This is the very first time we are called: Set the counters
304            to an not so easy predictable value to avoid always
305            starting at 0.  Not really needed but it doesn't harm.  */
306         counter1 = (u32)getpid ();
307 #ifndef HAVE_W32_SYSTEM
308         counter0 = (u32)getppid ();
309 #endif
310       }
311
312
313     if (gettimeofday (&tv, NULL))
314       log_fatal ("gettimeofday() failed: %s\n", strerror (errno));
315
316     /* The microseconds part is always less than 1 millon (0x0f4240).
317        Thus we don't care about the MSB and in addition shift it to
318        the left by 4 bits.  */
319     usec = tv.tv_usec;
320     usec <<= 4;
321     /* If we got the same time as by the last invocation, bump up
322        counter2 and save the time for the next invocation.  */
323     if (tv.tv_sec == last_sec && usec == last_usec)
324       {
325         counter2++;
326         counter2 &= 0x0fff;
327       }
328     else
329       {
330         counter2 = 0;
331         last_sec = tv.tv_sec;
332         last_usec = usec;
333       }
334     /* Fill the buffer with the timestamp.  */
335     buffer[0] = ((tv.tv_sec >> 24) & 0xff);
336     buffer[1] = ((tv.tv_sec >> 16) & 0xff);
337     buffer[2] = ((tv.tv_sec >> 8) & 0xff);
338     buffer[3] = (tv.tv_sec & 0xff);
339     buffer[4] = ((usec >> 16) & 0xff);
340     buffer[5] = ((usec >> 8) & 0xff);
341     buffer[6] = ((usec & 0xf0) | ((counter2 >> 8) & 0x0f));
342     buffer[7] = (counter2 & 0xff);
343     /* Add the free running counter.  */
344     buffer[8]  = ((counter1 >> 24) & 0xff);
345     buffer[9]  = ((counter1 >> 16) & 0xff);
346     buffer[10] = ((counter1 >> 8) & 0xff); 
347     buffer[11] = ((counter1) & 0xff);
348     buffer[12] = ((counter0 >> 24) & 0xff);
349     buffer[13] = ((counter0 >> 16) & 0xff);
350     buffer[14] = ((counter0 >> 8) & 0xff); 
351     buffer[15] = ((counter0) & 0xff);
352     /* Bump up that counter.  */
353     if (!++counter0)
354       ++counter1;
355   }
356 #else
357   log_fatal ("gettimeofday() not available on this system\n");
358 #endif
359
360   /* log_printhex ("x931_get_dt: ", buffer, 16); */
361 }
362
363
364 /* XOR the buffers A and B which are each of LENGTH bytes and store
365    the result at R.  R needs to be provided by the caller with a size
366    of at least LENGTH bytes.  */
367 static void
368 xor_buffer (unsigned char *r, 
369             const unsigned char *a, const unsigned char *b, size_t length)
370 {
371   for ( ; length; length--, a++, b++, r++)
372     *r = (*a ^ *b);
373 }
374
375
376 /* Encrypt LENGTH bytes of INPUT to OUTPUT using KEY.  LENGTH
377    needs to be 16. */
378 static void
379 encrypt_aes (gcry_cipher_hd_t key, 
380              unsigned char *output, const unsigned char *input, size_t length)
381 {
382   gpg_error_t err;
383
384   gcry_assert (length == 16);
385
386   err = gcry_cipher_encrypt (key, output, length, input, length);
387   if (err)
388     log_fatal ("AES encryption in RNG failed: %s\n", gcry_strerror (err));
389 }
390
391
392 /* The core ANSI X9.31, Appendix A.2.4 function using AES.  The caller
393    needs to pass a 16 byte buffer for the result, the 16 byte
394    datetime_DT value and the 16 byte seed value V.  The caller also
395    needs to pass an appropriate KEY and make sure to pass a valid
396    seed_V.  The caller also needs to provide two 16 bytes buffer for
397    intermediate results, they may be reused by the caller later.
398
399    On return the result is stored at RESULT_R and the SEED_V is
400    updated.  May only be used while holding the lock.  */
401 static void
402 x931_aes (unsigned char result_R[16], 
403           unsigned char datetime_DT[16], unsigned char seed_V[16],
404           gcry_cipher_hd_t key,
405           unsigned char intermediate_I[16], unsigned char temp_xor[16])
406 {
407   /* Let ede*X(Y) represent the AES encryption of Y under the key *X.
408
409      Let V be a 128-bit seed value which is also kept secret, and XOR
410      be the exclusive-or operator. Let DT be a date/time vector which
411      is updated on each iteration. I is a intermediate value. 
412
413      I = ede*K(DT)  */
414   encrypt_aes (key, intermediate_I, datetime_DT, 16);
415
416   /* R = ede*K(I XOR V) */
417   xor_buffer (temp_xor, intermediate_I, seed_V, 16);
418   encrypt_aes (key, result_R, temp_xor, 16);
419
420   /* V = ede*K(R XOR I).  */
421   xor_buffer (temp_xor, result_R, intermediate_I, 16);
422   encrypt_aes (key, seed_V, temp_xor, 16);
423
424   /* Zero out temporary values.  */
425   wipememory (intermediate_I, 16);
426   wipememory (temp_xor, 16);
427 }
428
429
430 /* The high level driver to x931_aes.  This one does the required
431    tests and calls the core function until the entire buffer has been
432    filled.  OUTPUT is a caller provided buffer of LENGTH bytes to
433    receive the random, RNG_CTX is the context of the RNG.  The context
434    must be properly initialized.  Returns 0 on success. */
435 static int
436 x931_aes_driver (unsigned char *output, size_t length, rng_context_t rng_ctx)
437 {
438   unsigned char datetime_DT[16];
439   unsigned char *intermediate_I, *temp_buffer, *result_buffer;
440   size_t nbytes;
441
442   gcry_assert (fips_rng_is_locked);
443   gcry_assert (rng_ctx->cipher_hd);
444   gcry_assert (rng_ctx->is_seeded);
445
446   gcry_assert (tempvalue_for_x931_aes_driver);
447   gcry_assert (TEMPVALUE_FOR_X931_AES_DRIVER_SIZE == 48);
448   intermediate_I = tempvalue_for_x931_aes_driver;
449   temp_buffer    = tempvalue_for_x931_aes_driver + 16;
450   result_buffer  = tempvalue_for_x931_aes_driver + 32;
451
452   while (length)
453     {
454       /* We require a new seed after some time.  */
455       if (rng_ctx->use_counter > SEED_TTL)
456         {
457           x931_reseed (rng_ctx);
458           rng_ctx->use_counter = 0;
459         }
460
461       /* Due to the design of the RNG, we always receive 16 bytes (128
462          bit) of random even if we require less.  The extra bytes
463          returned are not used.  Intheory we could save them for the
464          next invocation, but that would make the control flow harder
465          to read.  */
466       nbytes = length < 16? length : 16;
467
468       x931_get_dt (datetime_DT, 16, rng_ctx);
469       x931_aes (result_buffer,
470                 datetime_DT, rng_ctx->seed_V, rng_ctx->cipher_hd,
471                 intermediate_I, temp_buffer);
472       rng_ctx->use_counter++;
473
474       /* Do a basic check on the output to avoid a stuck generator.  */
475       if (!rng_ctx->compare_value_valid)
476         {
477           /* First time used, only save the result.  */
478           memcpy (rng_ctx->compare_value, result_buffer, 16);
479           rng_ctx->compare_value_valid = 1;
480           continue;
481         }
482       if (!memcmp (rng_ctx->compare_value, result_buffer, 16))
483         {
484           /* Ooops, we received the same 128 bit block - that should
485              in theory never happen.  The FIPS requirement says that
486              we need to put ourself into the error state in such
487              case.  */
488           fips_signal_error ("duplicate 128 bit block returned by RNG");
489           return -1;
490         }
491       memcpy (rng_ctx->compare_value, result_buffer, 16);
492       
493       /* Append to outbut.  */
494       memcpy (output, result_buffer, nbytes);
495       wipememory (result_buffer, 16);
496       output += nbytes;
497       length -= nbytes;
498     }
499
500   return 0;
501 }
502
503
504 /* Callback for x931_generate_key. Note that this callback uses the
505    global ENTROPY_COLLECT_BUFFER which has been setup by get_entropy.
506    ORIGIN is not used but required due to the design of entropy
507    gathering module. */
508 static void
509 entropy_collect_cb (const void *buffer, size_t length,
510                     enum random_origins origin)
511 {
512   const unsigned char *p = buffer;
513
514   (void)origin;
515
516   gcry_assert (fips_rng_is_locked);
517   gcry_assert (entropy_collect_buffer);
518
519   /* Note that we need to protect against gatherers returning more
520      than the requested bytes (e.g. rndw32).  */
521   while (length-- && entropy_collect_buffer_len < entropy_collect_buffer_size)
522     {
523       entropy_collect_buffer[entropy_collect_buffer_len++] ^= *p++;
524     }
525 }
526
527
528 /* Get NBYTES of entropy from the kernel device.  The callers needs to
529    free the returned buffer.  The function either succeeds or
530    terminates the process in case of a fatal error. */
531 static void *
532 get_entropy (size_t nbytes)
533 {
534   void *result;
535   int rc;
536
537   gcry_assert (!entropy_collect_buffer);
538   entropy_collect_buffer = gcry_xmalloc_secure (nbytes);
539   entropy_collect_buffer_size = nbytes;
540   entropy_collect_buffer_len = 0;
541
542 #if USE_RNDLINUX
543   rc = _gcry_rndlinux_gather_random (entropy_collect_cb, 0,
544                                      X931_AES_KEYLEN,
545                                      GCRY_VERY_STRONG_RANDOM);
546 #elif USE_RNDW32
547   do 
548     {
549       rc = _gcry_rndw32_gather_random (entropy_collect_cb, 0,
550                                        X931_AES_KEYLEN,
551                                        GCRY_VERY_STRONG_RANDOM);
552     }
553   while (rc >= 0 && entropy_collect_buffer_len < entropy_collect_buffer_size);
554 #else
555   rc = -1;
556 #endif
557
558   if (rc < 0 || entropy_collect_buffer_len != entropy_collect_buffer_size)
559     {
560       gcry_free (entropy_collect_buffer);
561       entropy_collect_buffer = NULL;
562       log_fatal ("error getting entropy data\n");
563     }
564   result = entropy_collect_buffer;
565   entropy_collect_buffer = NULL;
566   return result;
567 }
568
569
570 /* Generate a key for use with x931_aes.  The function returns a
571    handle to the cipher context readily prepared for ECB encryption.
572    If FOR_NONCE is true, the key is retrieved by readong random from
573    the standard generator.  On error NULL is returned.  */
574 static gcry_cipher_hd_t
575 x931_generate_key (int for_nonce)
576 {
577   gcry_cipher_hd_t hd;
578   gpg_error_t err;
579   void *buffer;
580
581   gcry_assert (fips_rng_is_locked);
582
583   /* Allocate a cipher context.  */
584   err = gcry_cipher_open (&hd, GCRY_CIPHER_AES128, GCRY_CIPHER_MODE_ECB,
585                           GCRY_CIPHER_SECURE);
586   if (err)
587     {
588       log_error ("error creating cipher context for RNG: %s\n",
589                  gcry_strerror (err));
590       return NULL;
591     }
592
593   /* Get a key from the standard RNG or from the entropy source.  */
594   if (for_nonce)
595     {
596       buffer = gcry_xmalloc (X931_AES_KEYLEN);
597       get_random (buffer, X931_AES_KEYLEN, std_rng_context);
598     }
599   else
600     {
601       buffer = get_entropy (X931_AES_KEYLEN);
602     }
603
604   /* Set the key and delete the buffer because the key is now part of
605      the cipher context.  */
606   err = gcry_cipher_setkey (hd, buffer, X931_AES_KEYLEN);
607   wipememory (buffer, X931_AES_KEYLEN);
608   gcry_free (buffer);
609   if (err)
610     {
611       log_error ("error creating key for RNG: %s\n", gcry_strerror (err));
612       gcry_cipher_close (hd);
613       return NULL;
614     }
615
616   return hd;
617 }
618
619
620 /* Generate a key for use with x931_aes.  The function copies a seed
621    of LENGTH bytes into SEED_BUFFER. LENGTH needs to by given as 16.  */
622 static void
623 x931_generate_seed (unsigned char *seed_buffer, size_t length)
624 {
625   void *buffer;
626
627   gcry_assert (fips_rng_is_locked);
628   gcry_assert (length == 16);
629
630   buffer = get_entropy (X931_AES_KEYLEN);
631
632   memcpy (seed_buffer, buffer, X931_AES_KEYLEN);
633   wipememory (buffer, X931_AES_KEYLEN);
634   gcry_free (buffer);
635 }
636
637
638
639 /* Reseed a generator.  This is also used for the initial seeding. */
640 static void
641 x931_reseed (rng_context_t rng_ctx)
642 {
643   gcry_assert (fips_rng_is_locked);
644
645   if (rng_ctx == nonce_context)
646     {
647       /* The nonce context is special.  It will be seeded using the
648          standard random generator.  */
649       get_random (rng_ctx->seed_V, 16, std_rng_context);
650       rng_ctx->is_seeded = 1;
651       rng_ctx->seed_init_pid = getpid ();
652     }
653   else
654     {
655       /* The other two generators are seeded from /dev/random.  */
656       x931_generate_seed (rng_ctx->seed_V, 16);
657       rng_ctx->is_seeded = 1;
658       rng_ctx->seed_init_pid = getpid ();
659     }
660 }
661
662
663 /* Core random function.  This is used for both nonce and random
664    generator.  The actual RNG to be used depends on the random context
665    RNG_CTX passed.  Note that this function is called with the RNG not
666    yet locked.  */
667 static void
668 get_random (void *buffer, size_t length, rng_context_t rng_ctx)
669 {
670   gcry_assert (buffer);
671   gcry_assert (rng_ctx);
672
673   check_guards (rng_ctx);
674
675   /* Initialize the cipher handle and thus setup the key if needed.  */
676   if (!rng_ctx->cipher_hd)
677     {
678       if (rng_ctx == nonce_context)
679         rng_ctx->cipher_hd = x931_generate_key (1);
680       else
681         rng_ctx->cipher_hd = x931_generate_key (0);
682       if (!rng_ctx->cipher_hd)
683         goto bailout;
684       rng_ctx->key_init_pid = getpid ();
685     }
686
687   /* Initialize the seed value if needed.  */
688   if (!rng_ctx->is_seeded)
689     x931_reseed (rng_ctx);
690
691   if (rng_ctx->key_init_pid != getpid ()
692       || rng_ctx->seed_init_pid != getpid ())
693     {
694       /* We are in a child of us.  Because we have no way yet to do
695          proper re-initialization (including self-checks etc), the
696          only chance we have is to bail out.  Obviusly a fork/exec
697          won't harm because the exec overwrites the old image. */
698       fips_signal_error ("fork without proper re-initialization "
699                          "detected in RNG");
700       goto bailout;
701     }
702
703   if (x931_aes_driver (buffer, length, rng_ctx))
704     goto bailout;
705
706   check_guards (rng_ctx);
707   return;
708
709  bailout:
710   log_fatal ("severe error getting random\n");
711   /*NOTREACHED*/
712 }
713
714
715 \f
716 /* --- Public Functions --- */
717
718 /* Initialize this random subsystem.  If FULL is false, this function
719    merely calls the basic initialization of the module and does not do
720    anything more.  Doing this is not really required but when running
721    in a threaded environment we might get a race condition
722    otherwise. */
723 void
724 _gcry_rngfips_initialize (int full)
725 {
726   basic_initialization ();
727   if (!full)
728     return;
729
730   /* Allocate temporary buffers.  If that buffer already exists we
731      know that we are already initialized.  */
732   lock_rng ();
733   if (!tempvalue_for_x931_aes_driver)
734     {
735       tempvalue_for_x931_aes_driver
736         = gcry_xmalloc_secure (TEMPVALUE_FOR_X931_AES_DRIVER_SIZE);
737
738       /* Allocate the random contexts.  Note that we do not need to use
739          secure memory for the nonce context.  */
740       nonce_context = gcry_xcalloc (1, sizeof *nonce_context);
741       setup_guards (nonce_context);
742
743       std_rng_context = gcry_xcalloc_secure (1, sizeof *std_rng_context);
744       setup_guards (std_rng_context);
745       
746       strong_rng_context = gcry_xcalloc_secure (1, sizeof *strong_rng_context);
747       setup_guards (strong_rng_context);
748     }
749   else
750     {
751       /* Already initialized. Do some sanity checks.  */
752       gcry_assert (!nonce_context->test_dt_ptr);
753       gcry_assert (!std_rng_context->test_dt_ptr);
754       gcry_assert (!strong_rng_context->test_dt_ptr);
755       check_guards (nonce_context);
756       check_guards (std_rng_context);
757       check_guards (strong_rng_context);
758     }
759   unlock_rng ();
760 }
761
762
763 /* Print some statistics about the RNG.  */
764 void
765 _gcry_rngfips_dump_stats (void)
766 {
767   /* Not yet implemented.  */
768 }
769
770
771 /* This function returns true if no real RNG is available or the
772    quality of the RNG has been degraded for test purposes.  */
773 int
774 _gcry_rngfips_is_faked (void)
775 {
776   return 0;  /* Faked random is not allowed.  */
777 }
778
779
780 /* Add BUFLEN bytes from BUF to the internal random pool.  QUALITY
781    should be in the range of 0..100 to indicate the goodness of the
782    entropy added, or -1 for goodness not known. */
783 gcry_error_t
784 _gcry_rngfips_add_bytes (const void *buf, size_t buflen, int quality)
785 {
786   return 0;  /* Not implemented. */
787 }   
788
789     
790 /* Public function to fill the buffer with LENGTH bytes of
791    cryptographically strong random bytes.  Level GCRY_WEAK_RANDOM is
792    here mapped to GCRY_STRING_RANDOM, GCRY_STRONG_RANDOM is strong
793    enough for most usage, GCRY_VERY_STRONG_RANDOM is good for key
794    generation stuff but may be very slow.  */
795 void
796 _gcry_rngfips_randomize (void *buffer, size_t length,
797                          enum gcry_random_level level)
798 {
799   _gcry_rngfips_initialize (1);  /* Auto-initialize if needed.  */
800   
801   lock_rng ();
802   if (level == GCRY_VERY_STRONG_RANDOM)
803     get_random (buffer, length, strong_rng_context);
804   else
805     get_random (buffer, length, std_rng_context);
806   unlock_rng ();
807 }
808
809
810 /* Create an unpredicable nonce of LENGTH bytes in BUFFER. */
811 void
812 _gcry_rngfips_create_nonce (void *buffer, size_t length)
813 {
814   _gcry_rngfips_initialize (1);  /* Auto-initialize if needed.  */
815
816   lock_rng ();
817   get_random (buffer, length, nonce_context);
818   unlock_rng ();
819 }
820
821
822 /* Run a Know-Answer-Test using a dedicated test context.  Note that
823    we can't use the samples from the NISR RNGVS document because they
824    don't take the requirement to throw away the first block and use
825    that for duplicate check in account.  Thus we made up our own test
826    vectors. */
827 static gcry_err_code_t
828 selftest_kat (selftest_report_func_t report)
829 {
830   static struct 
831   {
832     const unsigned char key[16];
833     const unsigned char dt[16];
834     const unsigned char v[16];
835     const unsigned char r[3][16];
836   } tv[] =
837     {
838       { { 0xb9, 0xca, 0x7f, 0xd6, 0xa0, 0xf5, 0xd3, 0x42,
839           0x19, 0x6d, 0x84, 0x91, 0x76, 0x1c, 0x3b, 0xbe },
840         { 0x48, 0xb2, 0x82, 0x98, 0x68, 0xc2, 0x80, 0x00,
841           0x00, 0x00, 0x28, 0x18, 0x00, 0x00, 0x25, 0x00 },
842         { 0x52, 0x17, 0x8d, 0x29, 0xa2, 0xd5, 0x84, 0x12,
843           0x9d, 0x89, 0x9a, 0x45, 0x82, 0x02, 0xf7, 0x77 },
844         { { 0x42, 0x9c, 0x08, 0x3d, 0x82, 0xf4, 0x8a, 0x40,
845             0x66, 0xb5, 0x49, 0x27, 0xab, 0x42, 0xc7, 0xc3 },
846           { 0x0e, 0xb7, 0x61, 0x3c, 0xfe, 0xb0, 0xbe, 0x73,
847             0xf7, 0x6e, 0x6d, 0x6f, 0x1d, 0xa3, 0x14, 0xfa },
848           { 0xbb, 0x4b, 0xc1, 0x0e, 0xc5, 0xfb, 0xcd, 0x46,
849             0xbe, 0x28, 0x61, 0xe7, 0x03, 0x2b, 0x37, 0x7d } } },
850       { { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
851           0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
852         { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
853           0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
854         { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
855           0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
856         { { 0xf7, 0x95, 0xbd, 0x4a, 0x52, 0xe2, 0x9e, 0xd7,
857             0x13, 0xd3, 0x13, 0xfa, 0x20, 0xe9, 0x8d, 0xbc },
858           { 0xc8, 0xd1, 0xe5, 0x11, 0x59, 0x52, 0xf7, 0xfa,
859             0x37, 0x38, 0xb4, 0xc5, 0xce, 0xb2, 0xb0, 0x9a },
860           { 0x0d, 0x9c, 0xc5, 0x0d, 0x16, 0xe1, 0xbc, 0xed, 
861             0xcf, 0x60, 0x62, 0x09, 0x9d, 0x20, 0x83, 0x7e } } },
862       { { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
863           0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f },
864         { 0x80, 0x00, 0x81, 0x01, 0x82, 0x02, 0x83, 0x03,
865           0xa0, 0x20, 0xa1, 0x21, 0xa2, 0x22, 0xa3, 0x23 },
866         { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
867           0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff },
868         { { 0x96, 0xed, 0xcc, 0xc3, 0xdd, 0x04, 0x7f, 0x75,
869             0x63, 0x19, 0x37, 0x6f, 0x15, 0x22, 0x57, 0x56 },
870           { 0x7a, 0x14, 0x76, 0x77, 0x95, 0x17, 0x7e, 0xc8,
871             0x92, 0xe8, 0xdd, 0x15, 0xcb, 0x1f, 0xbc, 0xb1 },
872           { 0x25, 0x3e, 0x2e, 0xa2, 0x41, 0x1b, 0xdd, 0xf5, 
873             0x21, 0x48, 0x41, 0x71, 0xb3, 0x8d, 0x2f, 0x4c } } }
874     };
875   int tvidx, ridx;
876   rng_context_t test_ctx;
877   gpg_error_t err;
878   const char *errtxt = NULL;
879   unsigned char result[16];
880
881   gcry_assert (tempvalue_for_x931_aes_driver);
882
883   test_ctx = gcry_xcalloc (1, sizeof *test_ctx);
884   setup_guards (test_ctx);
885   
886   lock_rng ();
887
888   for (tvidx=0; tvidx < DIM (tv); tvidx++)
889     {
890       /* Setup the key.  */
891       err = gcry_cipher_open (&test_ctx->cipher_hd,
892                               GCRY_CIPHER_AES128, GCRY_CIPHER_MODE_ECB,
893                               GCRY_CIPHER_SECURE);
894       if (err)
895         {
896           errtxt = "error creating cipher context for RNG";
897           goto leave;
898         }
899
900       err = gcry_cipher_setkey (test_ctx->cipher_hd, tv[tvidx].key, 16);
901       if (err)
902         {
903           errtxt = "error setting key for RNG";
904           goto leave;
905         }
906       test_ctx->key_init_pid = getpid ();
907       
908       /* Setup the seed.  */
909       memcpy (test_ctx->seed_V, tv[tvidx].v, 16);
910       test_ctx->is_seeded = 1;
911       test_ctx->seed_init_pid = getpid ();
912       
913       /* Setup a DT value.  */
914       test_ctx->test_dt_ptr = tv[tvidx].dt;
915       test_ctx->test_dt_counter = tv[tvidx].dt[15];
916
917       /* Get ant compare the first three results.  */
918       for (ridx=0; ridx < 3; ridx++)
919         {
920           /* Compute the next value.  */
921           if (x931_aes_driver (result, 16, test_ctx))
922             {
923               errtxt = "X9.31 RNG core function failed";
924               goto leave;
925             }
926           
927           /* Compare it to the known value.  */
928           if (memcmp (result, tv[tvidx].r[ridx], 16))
929             {
930               /* log_printhex ("x931_aes got: ", result, 16); */
931               /* log_printhex ("x931_aes exp: ", tv[tvidx].r[ridx], 16); */
932               errtxt = "RNG output does not match known value";
933               goto leave;
934             }
935         }
936
937       /* This test is actual pretty pointless because we use a local test
938          context.  */
939       if (test_ctx->key_init_pid != getpid ()
940           || test_ctx->seed_init_pid != getpid ())
941         {
942           errtxt = "fork detection failed";
943           goto leave;
944         }
945
946       gcry_cipher_close (test_ctx->cipher_hd);
947       test_ctx->cipher_hd = NULL;
948       test_ctx->is_seeded = 0;
949       check_guards (test_ctx);
950     }
951
952  leave:
953   unlock_rng ();
954   gcry_cipher_close (test_ctx->cipher_hd);
955   check_guards (test_ctx);
956   gcry_free (test_ctx);
957   if (report && errtxt)
958     report ("random", 0, "KAT", errtxt);
959   return errtxt? GPG_ERR_SELFTEST_FAILED : 0;
960 }
961
962
963 /* Run the self-tests.  */
964 gcry_error_t
965 _gcry_rngfips_selftest (selftest_report_func_t report)
966 {
967   gcry_err_code_t ec;
968
969 #if defined(USE_RNDLINUX) || defined(USE_RNDW32)
970   {
971     char buffer[8];
972
973     /* Do a simple test using the public interface.  This will also
974        enforce full intialization of the RNG.  We need to be fully
975        initialized due to the global requirement of the
976        tempvalue_for_x931_aes_driver stuff. */
977     gcry_randomize (buffer, sizeof buffer, GCRY_STRONG_RANDOM);
978   }
979
980   ec = selftest_kat (report);
981
982 #else /*!(USE_RNDLINUX||USE_RNDW32)*/
983   report ("random", 0, "setup", "no entropy gathering module");
984   ec = GPG_ERR_SELFTEST_FAILED;
985 #endif
986   return gpg_error (ec);
987 }
988