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