Completed the RNG implementaion switching.
[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) and uses the AES
25    variant.
26
27
28  */
29
30 #include <config.h>
31 #include <stdio.h>
32 #include <stdlib.h>
33 #include <errno.h>
34 #include <sys/types.h>
35 #include <unistd.h>
36 #ifdef HAVE_GETTIMEOFDAY
37 #include <sys/time.h>
38 #endif
39
40 #include "g10lib.h"
41 #include "random.h"
42 #include "rand-internal.h"
43 #include "ath.h"
44
45 /* This is the lock we use to serialize access to this RNG.  The extra
46    integer variable is only used to check the locking state; that is,
47    it is not meant to be thread-safe but merely as a failsafe feature
48    to assert proper locking.  */
49 static ath_mutex_t fips_rng_lock = ATH_MUTEX_INITIALIZER;
50 static int fips_rng_is_locked;
51
52
53 /* The required size for the temporary buffer of the x931_aes_driver
54    function and the buffer itself which will be allocated in secure
55    memory.  This needs to be global variable for proper initialization
56    and to allow shutting down the RNG without leaking memory.  May
57    only be used while holding the FIPS_RNG_LOCK.
58
59    This variable is also used to avoid duplicate initialization.  */
60 #define TEMPVALUE_FOR_X931_AES_DRIVER_SIZE 48
61 static unsigned char *tempvalue_for_x931_aes_driver;
62
63
64 /* The length of the key we use:  16 bytes (128 bit) for AES128.  */
65 #define X931_AES_KEYLEN  16
66 /* A global buffer used to communicate between the x931_generate_key
67    and x931_generate_seed functions and the entropy_collect_cb
68    function.  It may only be used by these functions. */
69 static unsigned char *entropy_collect_buffer;  /* Buffer.  */
70 static size_t entropy_collect_buffer_len;      /* Used length.  */
71 static size_t entropy_collect_buffer_size;     /* Allocated length.  */
72
73
74 /* This random context type is used to track properties of one random
75    generator. Thee context are usually allocated in secure memory so
76    that the seed value is well protected.  There are a couble of guard
77    fields to help detecting applications accidently overwriting parts
78    of the memory. */
79 struct rng_context
80 {
81   unsigned char guard_0[1];
82
83   /* The handle of the cipher used by the RNG.  If this one is not
84      NULL a cipher handle along with a random key has been
85      established.  */
86   gcry_cipher_hd_t cipher_hd;
87
88   /* If this flag is true, this context requires strong entropy;
89      i.e. from /dev/random.  */
90   int need_strong_entropy:1;
91
92   /* If this flag is true, the SEED_V buffer below carries a valid
93      seed.  */
94   int is_seeded:1;
95
96   /* The very first block generated is used to compare the result
97      against the last result.  This flag indicates that such a block
98      is available.  */
99   int compare_value_valid:1;
100
101   unsigned char guard_1[1];
102
103   /* The buffer containing the seed value V.  */
104   unsigned char seed_V[16];
105
106   unsigned char guard_2[1];
107
108   /* The last result from the x931_aes fucntion.  Only valid if
109      compare_value_valid is set.  */
110   unsigned char compare_value[16];
111
112   unsigned char guard_3[1];
113
114   /* We need to keep track of the process which did the initialization
115      so that we can detect a fork.  The volatile modifier is required
116      so that the compiler does not optimize it away in case the getpid
117      function is badly attributed.  */ 
118    pid_t key_init_pid;
119    pid_t seed_init_pid;
120 };
121 typedef struct rng_context *rng_context_t;
122
123
124 /* The random context used for the nonce generator.  May only be used
125    while holding the FIPS_RNG_LOCK.  */
126 static rng_context_t nonce_context;
127 /* The random context used for the standard random generator.  May
128    only be used while holding the FIPS_RNG_LOCK.  */
129 static rng_context_t std_rng_context;
130 /* The random context used for the very strong random generator.  May
131    only be used while holding the FIPS_RNG_LOCK.  */
132 static rng_context_t strong_rng_context;
133
134
135
136 \f
137 /* --- Functions  --- */
138
139 /* Basic initialization is required to initialize mutexes and
140    do a few checks on the implementation.  */
141 static void
142 basic_initialization (void)
143 {
144   static int initialized;
145   int my_errno;
146
147   if (!initialized)
148     return;
149   initialized = 1;
150
151   my_errno = ath_mutex_init (&fips_rng_lock);
152   if (my_errno)
153     log_fatal ("failed to create the RNG lock: %s\n", strerror (my_errno));
154   fips_rng_is_locked = 0;
155       
156   /* Make sure that we are still using the values we have
157      traditionally used for the random levels.  */
158   gcry_assert (GCRY_WEAK_RANDOM == 0 
159                && GCRY_STRONG_RANDOM == 1
160                && GCRY_VERY_STRONG_RANDOM == 2);
161
162 }
163
164
165 /* Acquire the fips_rng_lock.  */
166 static void
167 lock_rng (void)
168 {
169   int my_errno;
170
171   my_errno = ath_mutex_lock (&fips_rng_lock);
172   if (my_errno)
173     log_fatal ("failed to acquire the RNG lock: %s\n", strerror (my_errno));
174   fips_rng_is_locked = 1;
175 }
176
177
178 /* Release the fips_rng_lock.  */
179 static void
180 unlock_rng (void)
181 {
182   int my_errno;
183
184   fips_rng_is_locked = 0;
185   my_errno = ath_mutex_unlock (&fips_rng_lock);
186   if (my_errno)
187     log_fatal ("failed to release the RNG lock: %s\n", strerror (my_errno));
188 }
189
190 static void
191 setup_guards (rng_context_t rng_ctx)
192 {
193   /* Set the guards to some arbitrary values.  */
194   rng_ctx->guard_0[0] = 17;
195   rng_ctx->guard_1[0] = 42;
196   rng_ctx->guard_2[0] = 137;
197   rng_ctx->guard_3[0] = 252;
198 }
199
200 static void
201 check_guards (rng_context_t rng_ctx)
202 {
203   if ( rng_ctx->guard_0[0] != 17
204        || rng_ctx->guard_1[0] != 42
205        || rng_ctx->guard_2[0] != 137
206        || rng_ctx->guard_3[0] != 252 )
207     log_fatal ("memory corruption detected in RNG context %p\n", rng_ctx);
208 }
209
210
211 /* Get the DT vector for use with the core PRNG function.  Buffer
212    needs to be provided by the caller with a size of at least LENGTH
213    bytes.  The 16 byte timestamp we construct is made up the real time
214    and three counters:
215
216    Buffer:       00112233445566778899AABBCCDDEEFF
217                  !--+---!!-+-!!+!!--+---!!--+---!     
218    seconds ---------/      |   |    |       |
219    microseconds -----------/   |    |       |
220    counter2 -------------------/    |       |
221    counter1 ------------------------/       |
222    counter0 --------------------------------/
223
224    Counter 2 is just 12 bits wide and used to track fractions of
225    milliseconds whereas counters 1 and 0 are combined to a free
226    running 64 bit counter.  */
227 static void 
228 x931_get_dt (unsigned char *buffer, size_t length)
229 {
230   gcry_assert (length == 16); /* This length is required for use with AES.  */
231   gcry_assert (fips_rng_is_locked);
232
233 #if HAVE_GETTIMEOFDAY
234   {
235     static u32 last_sec, last_usec;
236     static u32 counter1, counter0;
237     static u16 counter2;
238     
239     unsigned int usec;
240     struct timeval tv;
241
242     if (!last_sec)
243       {
244         /* This is the very first time we are called: Set the counters
245            to an not so easy predictable value to avoid always
246            starting at 0.  Not really needed but it doesn't harm.  */
247         counter1 = (u32)getpid ();
248         counter0 = (u32)getppid ();
249       }
250
251
252     if (gettimeofday (&tv, NULL))
253       log_fatal ("gettimeofday() failed: %s\n", strerror (errno));
254
255     /* The microseconds part is always less than 1 millon (0x0f4240).
256        Thus we don't care about the MSB and in addition shift it to
257        the left by 4 bits.  */
258     usec = tv.tv_usec;
259     usec <<= 4;
260     /* If we got the same time as by the last invocation, bump up
261        counter2 and save the time for the next invocation.  */
262     if (tv.tv_sec == last_sec && usec == last_usec)
263       {
264         counter2++;
265         counter2 &= 0x0fff;
266       }
267     else
268       {
269         counter2 = 0;
270         last_sec = tv.tv_sec;
271         last_usec = usec;
272       }
273     /* Fill the buffer with the timestamp.  */
274     buffer[0] = ((tv.tv_sec >> 24) & 0xff);
275     buffer[1] = ((tv.tv_sec >> 16) & 0xff);
276     buffer[2] = ((tv.tv_sec >> 8) & 0xff);
277     buffer[3] = (tv.tv_sec & 0xff);
278     buffer[4] = ((usec >> 16) & 0xff);
279     buffer[5] = ((usec >> 8) & 0xff);
280     buffer[6] = ((usec & 0xf0) | ((counter2 >> 8) & 0x0f));
281     buffer[7] = (counter2 & 0xff);
282     /* Add the free running counter.  */
283     buffer[8]  = ((counter1 >> 24) & 0xff);
284     buffer[9]  = ((counter1 >> 16) & 0xff);
285     buffer[10] = ((counter1 >> 8) & 0xff); 
286     buffer[11] = ((counter1) & 0xff);
287     buffer[12] = ((counter0 >> 24) & 0xff);
288     buffer[13] = ((counter0 >> 16) & 0xff);
289     buffer[14] = ((counter0 >> 8) & 0xff); 
290     buffer[15] = ((counter0) & 0xff);
291     /* Bump up that counter.  */
292     if (!++counter0)
293       ++counter1;
294   }
295 #else
296   log_fatal ("gettimeofday() not available on this system\n");
297 #endif
298
299   /* log_printhex ("x931_get_dt: ", buffer, 16); */
300 }
301
302
303 /* XOR the buffers A and B which are each of LENGTH bytes and store
304    the result at R.  R needs to be provided by the caller with a size
305    of at least LENGTH bytes.  */
306 static void
307 xor_buffer (unsigned char *r, 
308             const unsigned char *a, const unsigned char *b, size_t length)
309 {
310   for ( ; length; length--, a++, b++, r++)
311     *r = (*a ^ *b);
312 }
313
314
315 /* Encrypt LENGTH bytes of INPUT to OUTPUT using KEY.  LENGTH
316    needs to be 16. */
317 static void
318 encrypt_aes (gcry_cipher_hd_t key, 
319              unsigned char *output, const unsigned char *input, size_t length)
320 {
321   gpg_error_t err;
322
323   gcry_assert (length == 16);
324
325   err = gcry_cipher_encrypt (key, output, length, input, length);
326   if (err)
327     log_fatal ("AES encryption in RNG failed: %s\n", gcry_strerror (err));
328 }
329
330
331 /* The core ANSI X9.31, Appendix A.2.4 function using AES.  The caller
332    needs to pass a 16 byte buffer for the result and the 16 byte seed
333    value V.  The caller also needs to pass an appropriate KEY and make
334    sure to pass a valid seed_V.  The caller also needs to provide two
335    16 bytes buffer for intermediate results, they may be reused by the
336    caller later.
337
338    On return the result is stored at RESULT_R and the SEED_V is
339    updated.  May only be used while holding the lock.  */
340 static void
341 x931_aes (unsigned char result_R[16], unsigned char seed_V[16],
342           gcry_cipher_hd_t key,
343           unsigned char intermediate_I[16], unsigned char temp_xor[16])
344 {
345   unsigned char datetime_DT[16];
346
347   /* Let ede*X(Y) represent the AES encryption of Y under the key *X.
348
349      Let V be a 128-bit seed value which is also kept secret, and XOR
350      be the exclusive-or operator. Let DT be a date/time vector which
351      is updated on each iteration. I is a intermediate value. 
352
353      I = ede*K(DT)  */
354   x931_get_dt (datetime_DT, 16);
355   encrypt_aes (key, intermediate_I, datetime_DT, 16);
356
357   /* R = ede*K(I XOR V) */
358   xor_buffer (temp_xor, intermediate_I, seed_V, 16);
359   encrypt_aes (key, result_R, temp_xor, 16);
360
361   /* V = ede*K(R XOR I).  */
362   xor_buffer (temp_xor, result_R, intermediate_I, 16);
363   encrypt_aes (key, seed_V, temp_xor, 16);
364
365   /* Zero out temporary values.  */
366   wipememory (intermediate_I, 16);
367   wipememory (temp_xor, 16);
368 }
369
370
371 /* The high level driver to x931_aes.  This one does the required
372    tests and calls the core function until the entire buffer has been
373    filled.  OUTPUT is a caller provided buffer of LENGTH bytes to
374    receive the random, RNG_CTX is the context of the RNG.  The context
375    must be properly initialized.  Returns 0 on success. */
376 static int
377 x931_aes_driver (unsigned char *output, size_t length, rng_context_t rng_ctx)
378 {
379   unsigned char *intermediate_I, *temp_buffer, *result_buffer;
380   size_t nbytes;
381
382   gcry_assert (fips_rng_is_locked);
383   gcry_assert (rng_ctx->cipher_hd);
384   gcry_assert (rng_ctx->is_seeded);
385
386   gcry_assert (tempvalue_for_x931_aes_driver);
387   gcry_assert (TEMPVALUE_FOR_X931_AES_DRIVER_SIZE == 48);
388   intermediate_I = tempvalue_for_x931_aes_driver;
389   temp_buffer    = tempvalue_for_x931_aes_driver + 16;
390   result_buffer  = tempvalue_for_x931_aes_driver + 32;
391
392   while (length)
393     {
394       /* Due to the design of the RNG, we always receive 16 bytes (128
395          bit) of random even if we require less.  The extra bytes
396          returned are not used.  Intheory we could save them for the
397          next invocation, but that would make the control flow harder
398          to read.  */
399       nbytes = length < 16? length : 16;
400       x931_aes (result_buffer, rng_ctx->seed_V, rng_ctx->cipher_hd,
401                 intermediate_I, temp_buffer);
402
403       /* Do a basic check on the output to avoid a stuck generator.  */
404       if (!rng_ctx->compare_value_valid)
405         {
406           /* First time used, only save the result.  */
407           memcpy (rng_ctx->compare_value, result_buffer, 16);
408           rng_ctx->compare_value_valid = 1;
409           continue;
410         }
411       if (!memcmp (rng_ctx->compare_value, result_buffer, 16))
412         {
413           /* Ooops, we received the same 128 bit block - that should
414              in theory never happen.  The FIPS requirement says that
415              we need to put ourself into the error state in such
416              case.  */
417           fips_signal_error ("duplicate 128 bit block returned by RNG");
418           return -1;
419         }
420       memcpy (rng_ctx->compare_value, result_buffer, 16);
421       
422       /* Append to outbut.  */
423       memcpy (output, result_buffer, nbytes);
424       wipememory (result_buffer, 16);
425       output += nbytes;
426       length -= nbytes;
427     }
428
429   return 0;
430 }
431
432
433 /* Callback for x931_generate_key. Note that this callback uses the
434    global ENTROPY_COLLECT_BUFFER which has been setup by
435    x931_generate_key.  ORIGIN is not used but required due to the
436    emtropy gathering module. */
437 static void
438 entropy_collect_cb (const void *buffer, size_t length,
439                     enum random_origins origin)
440 {
441   const unsigned char *p = buffer;
442
443   (void)origin;
444
445   gcry_assert (fips_rng_is_locked);
446   gcry_assert (entropy_collect_buffer);
447   
448   while (length--)
449     {
450       gcry_assert (entropy_collect_buffer_len < entropy_collect_buffer_size);
451       entropy_collect_buffer[entropy_collect_buffer_len++] ^= *p++;
452     }
453 }
454
455 /* Generate a key for use with x931_aes.  The function returns a
456    handle to the cipher context readily prepared for ECB encryption.
457    If VERY_STRONG is true the key is read from /dev/random, otherwise
458    from /dev/urandom.  On error NULL is returned.  */
459 static gcry_cipher_hd_t
460 x931_generate_key (int very_strong)
461 {
462   gcry_cipher_hd_t hd;
463   gpg_error_t err;
464
465   gcry_assert (fips_rng_is_locked);
466
467   /* Allocate a cipher context.  */
468   err = gcry_cipher_open (&hd, GCRY_CIPHER_AES128, GCRY_CIPHER_MODE_ECB,
469                           GCRY_CIPHER_SECURE);
470   if (err)
471     {
472       log_error ("error creating cipher context for RNG: %s\n",
473                  gcry_strerror (err));
474       return NULL;
475     }
476
477   /* Get a key from the entropy source.  */
478 #if USE_RNDLINUX
479   gcry_assert (!entropy_collect_buffer);
480   entropy_collect_buffer = gcry_xmalloc_secure (X931_AES_KEYLEN);
481   entropy_collect_buffer_size = X931_AES_KEYLEN;
482   entropy_collect_buffer_len = 0;
483   if (_gcry_rndlinux_gather_random (entropy_collect_cb, 0, X931_AES_KEYLEN,
484                                     (very_strong
485                                      ? GCRY_VERY_STRONG_RANDOM
486                                      : GCRY_STRONG_RANDOM)
487                                     ) < 0
488       || entropy_collect_buffer_len != entropy_collect_buffer_size)
489     {
490       gcry_free (entropy_collect_buffer);
491       entropy_collect_buffer = NULL;
492       gcry_cipher_close (hd);
493       log_fatal ("error getting entropy data for the RNG key\n");
494     }
495 #else
496   log_fatal ("/dev/random support is not compiled in\n");
497 #endif
498
499   /* Set the key and delete the buffer because the key is now part of
500      the cipher context.  */
501   err = gcry_cipher_setkey (hd, entropy_collect_buffer, X931_AES_KEYLEN);
502   wipememory (entropy_collect_buffer, X931_AES_KEYLEN);
503   gcry_free (entropy_collect_buffer);
504   entropy_collect_buffer = NULL;
505   if (err)
506     {
507       log_error ("error creating key for RNG: %s\n", gcry_strerror (err));
508       gcry_cipher_close (hd);
509       return NULL;
510     }
511
512   return hd;
513 }
514
515
516 /* Generate a key for use with x931_aes.  The function copies a seed
517    of LENGTH bytes into SEED_BUFFER. LENGTH needs to by given as 16.  */
518 static void
519 x931_generate_seed (unsigned char *seed_buffer, size_t length, int very_strong)
520 {
521   gcry_assert (fips_rng_is_locked);
522   gcry_assert (length == 16);
523
524   /* Get a seed from the entropy source.  */
525 #if USE_RNDLINUX
526   gcry_assert (!entropy_collect_buffer);
527   entropy_collect_buffer = gcry_xmalloc_secure (X931_AES_KEYLEN);
528   entropy_collect_buffer_size = X931_AES_KEYLEN;
529   entropy_collect_buffer_len = 0;
530   if (_gcry_rndlinux_gather_random (entropy_collect_cb, 0, X931_AES_KEYLEN,
531                                     (very_strong
532                                      ? GCRY_VERY_STRONG_RANDOM
533                                      : GCRY_STRONG_RANDOM)
534                                     ) < 0
535       || entropy_collect_buffer_len != entropy_collect_buffer_size)
536     {
537       gcry_free (entropy_collect_buffer);
538       entropy_collect_buffer = NULL;
539       log_fatal ("error getting entropy data for the RNG seed\n");
540     }
541 #else
542   log_fatal ("/dev/random support is not compiled in\n");
543 #endif
544   gcry_free (entropy_collect_buffer);
545   entropy_collect_buffer = NULL;
546 }
547
548
549 /* Core random function.  This is used for both nonce and random
550    generator.  The actual RNG to be used depends on the random context
551    RNG_CTX passed.  Note that this function is called with the RNG not
552    yet locked.  */
553 static void
554 get_random (void *buffer, size_t length, rng_context_t rng_ctx)
555 {
556   gcry_assert (buffer);
557   gcry_assert (rng_ctx);
558
559   lock_rng ();
560   check_guards (rng_ctx);
561
562   /* Initialize the cipher handle and thus setup the key if needed.  */
563   if (!rng_ctx->cipher_hd)
564     {
565       rng_ctx->cipher_hd = x931_generate_key (rng_ctx->need_strong_entropy);
566       if (!rng_ctx->cipher_hd)
567         goto bailout;
568       rng_ctx->key_init_pid = getpid ();
569     }
570
571   /* Initialize the seed value if needed.  */
572   if (!rng_ctx->is_seeded)
573     {
574       x931_generate_seed (rng_ctx->seed_V, 16, rng_ctx->need_strong_entropy);
575       rng_ctx->is_seeded = 1;
576       rng_ctx->seed_init_pid = getpid ();
577     }
578
579   if (rng_ctx->key_init_pid != getpid ()
580       || rng_ctx->seed_init_pid != getpid ())
581     {
582       /* We are in a child of us.  Because we have no way yet to do
583          proper re-initialization (including self-checks etc), the
584          only chance we have is to bail out.  Obviusly a fork/exec
585          won't harm because the exec overwrites the old image. */
586       fips_signal_error ("fork without proper re-initialization "
587                          "detected in RNG");
588       goto bailout;
589     }
590
591   if (x931_aes_driver (buffer, length, rng_ctx))
592     goto bailout;
593
594   check_guards (rng_ctx);
595   unlock_rng ();
596   return;
597
598  bailout:
599   unlock_rng ();
600   log_fatal ("severe error getting random\n");
601   /*NOTREACHED*/
602 }
603
604
605 \f
606 /* Initialize this random subsystem.  If FULL is false, this function
607    merely calls the basic initialization of the module and does not do
608    anything more.  Doing this is not really required but when running
609    in a threaded environment we might get a race condition
610    otherwise. */
611 void
612 _gcry_rngfips_initialize (int full)
613 {
614   basic_initialization ();
615   if (!full)
616     return;
617
618   /* Allocate temporary buffers.  If that buffer already exists we
619      know that we are already initialized.  */
620   lock_rng ();
621   if (!tempvalue_for_x931_aes_driver)
622     {
623       tempvalue_for_x931_aes_driver
624         = gcry_xmalloc_secure (TEMPVALUE_FOR_X931_AES_DRIVER_SIZE);
625
626       /* Allocate the random contexts.  Note that we do not need to use
627          secure memory for the nonce context.  */
628       nonce_context = gcry_xcalloc (1, sizeof *nonce_context);
629       setup_guards (nonce_context);
630
631       std_rng_context = gcry_xcalloc_secure (1, sizeof *std_rng_context);
632       setup_guards (std_rng_context);
633       
634       strong_rng_context = gcry_xcalloc_secure (1, sizeof *strong_rng_context);
635       strong_rng_context->need_strong_entropy = 1;
636       setup_guards (strong_rng_context);
637     }
638
639   unlock_rng ();
640 }
641
642
643 /* Print some statistics about the RNG.  */
644 void
645 _gcry_rngfips_dump_stats (void)
646 {
647   /* Not yet implemented.  */
648 }
649
650
651 /* This function returns true if no real RNG is available or the
652    quality of the RNG has been degraded for test purposes.  */
653 int
654 _gcry_rngfips_is_faked (void)
655 {
656   return 0;  /* Faked random is not allowed.  */
657 }
658
659
660 /* Add BUFLEN bytes from BUF to the internal random pool.  QUALITY
661    should be in the range of 0..100 to indicate the goodness of the
662    entropy added, or -1 for goodness not known. */
663 gcry_error_t
664 _gcry_rngfips_add_bytes (const void *buf, size_t buflen, int quality)
665 {
666   return 0;  /* Not implemented. */
667 }   
668
669     
670 /* Public function to fill the buffer with LENGTH bytes of
671    cryptographically strong random bytes.  Level GCRY_WEAK_RANDOM is
672    here mapped to GCRY_STRING_RANDOM, GCRY_STRONG_RANDOM is strong
673    enough for most usage, GCRY_VERY_STRONG_RANDOM is good for key
674    generation stuff but may be very slow.  */
675 void
676 _gcry_rngfips_randomize (void *buffer, size_t length,
677                          enum gcry_random_level level)
678 {
679   _gcry_rngfips_initialize (1);  /* Auto-initialize if needed.  */
680   
681   if (level == GCRY_VERY_STRONG_RANDOM)
682     get_random (buffer, length, strong_rng_context);
683   else
684     get_random (buffer, length, std_rng_context);
685 }
686
687
688 /* Create an unpredicable nonce of LENGTH bytes in BUFFER. */
689 void
690 _gcry_rngfips_create_nonce (void *buffer, size_t length)
691 {
692   _gcry_rngfips_initialize (1);  /* Auto-initialize if needed.  */
693
694   get_random (buffer, length, nonce_context);
695 }
696
697
698 /* Run the self-tests.  */
699 gcry_error_t
700 _gcry_rngfips_selftest (selftest_report_func_t report)
701 {
702   gcry_err_code_t ec = 0;
703   char buffer[8];
704
705   /* Do a simple test using the public interface.  */
706   gcry_randomize (buffer, sizeof buffer, GCRY_STRONG_RANDOM);
707
708
709   return gpg_error (ec);
710 }
711