tests: Add tests for mpi_cmp.
[libgcrypt.git] / random / random.c
1 /* random.c - Random number switch
2  * Copyright (C) 2003, 2006, 2008, 2012  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   This module switches between different implementations of random
22   number generators and provides a few help functions.
23  */
24
25 #include <config.h>
26 #include <stdio.h>
27 #include <stdlib.h>
28 #include <errno.h>
29 #include <time.h>
30 #include <sys/types.h>
31 #include <unistd.h>
32
33 #include "g10lib.h"
34 #include "random.h"
35 #include "rand-internal.h"
36 #include "cipher.h"         /* For _gcry_sha1_hash_buffer().  */
37 #include "ath.h"
38
39
40 /* If not NULL a progress function called from certain places and the
41    opaque value passed along.  Registered by
42    _gcry_register_random_progress (). */
43 static void (*progress_cb) (void *,const char*,int,int, int );
44 static void *progress_cb_data;
45
46 /* Flags indicating the requested RNG types.  */
47 static struct
48 {
49   int standard;
50   int fips;
51   int system;
52 } rng_types;
53
54
55 /* This is the lock we use to protect the buffer used by the nonce
56    generation.  */
57 static ath_mutex_t nonce_buffer_lock;
58
59
60 \f
61 /* ---  Functions  --- */
62
63
64 /* Used to register a progress callback.  This needs to be called
65    before any threads are created. */
66 void
67 _gcry_register_random_progress (void (*cb)(void *,const char*,int,int,int),
68                                 void *cb_data )
69 {
70   progress_cb = cb;
71   progress_cb_data = cb_data;
72 }
73
74
75 /* This progress function is currently used by the random modules to
76    give hints on how much more entropy is required. */
77 void
78 _gcry_random_progress (const char *what, int printchar, int current, int total)
79 {
80   if (progress_cb)
81     progress_cb (progress_cb_data, what, printchar, current, total);
82 }
83
84
85 /* Set the preferred RNG type.  This may be called at any time even
86    before gcry_check_version.  Thus we can't assume any thread system
87    initialization.  A type of 0 is used to indicate that any Libgcrypt
88    initialization has been done.*/
89 void
90 _gcry_set_preferred_rng_type (int type)
91 {
92   static int any_init;
93
94   if (!type)
95     {
96       any_init = 1;
97     }
98   else if (type == GCRY_RNG_TYPE_STANDARD)
99     {
100       rng_types.standard = 1;
101     }
102   else if (any_init)
103     {
104       /* After any initialization has been done we only allow to
105          upgrade to the standard RNG (handled above).  All other
106          requests are ignored.  The idea is that the application needs
107          to declare a preference for a weaker RNG as soon as possible
108          and before any library sets a preference.  We assume that a
109          library which uses Libgcrypt calls an init function very
110          early.  This way --- even if the library gets initialized
111          early by the application --- it is unlikely that it can
112          select a lower priority RNG.
113
114          This scheme helps to ensure that existing unmodified
115          applications (e.g. gpg2), which don't known about the new RNG
116          selection system, will continue to use the standard RNG and
117          not be tricked by some library to use a lower priority RNG.
118          There are some loopholes here but at least most GnuPG stuff
119          should be save because it calls src_c{gcry_control
120          (GCRYCTL_SUSPEND_SECMEM_WARN);} quite early and thus inhibits
121          switching to a low priority RNG.
122        */
123     }
124   else if (type == GCRY_RNG_TYPE_FIPS)
125     {
126       rng_types.fips = 1;
127     }
128   else if (type == GCRY_RNG_TYPE_SYSTEM)
129     {
130       rng_types.system = 1;
131     }
132 }
133
134
135 /* Initialize this random subsystem.  If FULL is false, this function
136    merely calls the basic initialization of the module and does not do
137    anything more.  Doing this is not really required but when running
138    in a threaded environment we might get a race condition
139    otherwise. */
140 void
141 _gcry_random_initialize (int full)
142 {
143   static int nonce_initialized;
144   int err;
145
146   if (!nonce_initialized)
147     {
148       nonce_initialized = 1;
149       err = ath_mutex_init (&nonce_buffer_lock);
150       if (err)
151         log_fatal ("failed to create the nonce buffer lock: %s\n",
152                    strerror (err) );
153     }
154
155   if (fips_mode ())
156     _gcry_rngfips_initialize (full);
157   else if (rng_types.standard)
158     _gcry_rngcsprng_initialize (full);
159   else if (rng_types.fips)
160     _gcry_rngfips_initialize (full);
161   else if (rng_types.system)
162     _gcry_rngsystem_initialize (full);
163   else
164     _gcry_rngcsprng_initialize (full);
165 }
166
167
168 /* Return the current RNG type.  IGNORE_FIPS_MODE is a flag used to
169    skip the test for FIPS.  This is useful, so that we are able to
170    return the type of the RNG even before we have setup FIPS mode
171    (note that FIPS mode is enabled by default until it is switched off
172    by the initialization).  This is mostly useful for the regression
173    test.  */
174 int
175 _gcry_get_rng_type (int ignore_fips_mode)
176 {
177   if (!ignore_fips_mode && fips_mode ())
178     return GCRY_RNG_TYPE_FIPS;
179   else if (rng_types.standard)
180     return GCRY_RNG_TYPE_STANDARD;
181   else if (rng_types.fips)
182     return GCRY_RNG_TYPE_FIPS;
183   else if (rng_types.system)
184     return GCRY_RNG_TYPE_SYSTEM;
185   else
186     return GCRY_RNG_TYPE_STANDARD;
187 }
188
189
190 void
191 _gcry_random_dump_stats (void)
192 {
193   if (fips_mode ())
194     _gcry_rngfips_dump_stats ();
195   else
196     _gcry_rngcsprng_dump_stats ();
197 }
198
199
200 /* This function should be called during initialization and before
201    initialization of this module to place the random pools into secure
202    memory.  */
203 void
204 _gcry_secure_random_alloc (void)
205 {
206   if (fips_mode ())
207     ;  /* Not used; the FIPS RNG is always in secure mode.  */
208   else
209     _gcry_rngcsprng_secure_alloc ();
210 }
211
212
213 /* This may be called before full initialization to degrade the
214    quality of the RNG for the sake of a faster running test suite.  */
215 void
216 _gcry_enable_quick_random_gen (void)
217 {
218   if (fips_mode ())
219     ;  /* Not used.  */
220   else
221     _gcry_rngcsprng_enable_quick_gen ();
222 }
223
224
225 void
226 _gcry_set_random_daemon_socket (const char *socketname)
227 {
228   if (fips_mode ())
229     ;  /* Not used.  */
230   else
231     _gcry_rngcsprng_set_daemon_socket (socketname);
232 }
233
234 /* With ONOFF set to 1, enable the use of the daemon.  With ONOFF set
235    to 0, disable the use of the daemon.  With ONOF set to -1, return
236    whether the daemon has been enabled. */
237 int
238 _gcry_use_random_daemon (int onoff)
239 {
240   if (fips_mode ())
241     return 0; /* Never enabled in fips mode.  */
242   else
243     return _gcry_rngcsprng_use_daemon (onoff);
244 }
245
246
247 /* This function returns true if no real RNG is available or the
248    quality of the RNG has been degraded for test purposes.  */
249 int
250 _gcry_random_is_faked (void)
251 {
252   if (fips_mode ())
253     return _gcry_rngfips_is_faked ();
254   else
255     return _gcry_rngcsprng_is_faked ();
256 }
257
258
259 /* Add BUFLEN bytes from BUF to the internal random pool.  QUALITY
260    should be in the range of 0..100 to indicate the goodness of the
261    entropy added, or -1 for goodness not known.  */
262 gcry_error_t
263 gcry_random_add_bytes (const void *buf, size_t buflen, int quality)
264 {
265   if (fips_mode ())
266     return 0; /* No need for this in fips mode.  */
267   else if (rng_types.standard)
268     return _gcry_rngcsprng_add_bytes (buf, buflen, quality);
269   else if (rng_types.fips)
270     return 0;
271   else if (rng_types.system)
272     return 0;
273   else /* default */
274     return _gcry_rngcsprng_add_bytes (buf, buflen, quality);
275 }
276
277
278 /* Helper function.  */
279 static void
280 do_randomize (void *buffer, size_t length, enum gcry_random_level level)
281 {
282   if (fips_mode ())
283     _gcry_rngfips_randomize (buffer, length, level);
284   else if (rng_types.standard)
285     _gcry_rngcsprng_randomize (buffer, length, level);
286   else if (rng_types.fips)
287     _gcry_rngfips_randomize (buffer, length, level);
288   else if (rng_types.system)
289     _gcry_rngsystem_randomize (buffer, length, level);
290   else /* default */
291     _gcry_rngcsprng_randomize (buffer, length, level);
292 }
293
294 /* The public function to return random data of the quality LEVEL.
295    Returns a pointer to a newly allocated and randomized buffer of
296    LEVEL and NBYTES length.  Caller must free the buffer.  */
297 void *
298 gcry_random_bytes (size_t nbytes, enum gcry_random_level level)
299 {
300   void *buffer;
301
302   buffer = gcry_xmalloc (nbytes);
303   do_randomize (buffer, nbytes, level);
304   return buffer;
305 }
306
307
308 /* The public function to return random data of the quality LEVEL;
309    this version of the function returns the random in a buffer allocated
310    in secure memory.  Caller must free the buffer. */
311 void *
312 gcry_random_bytes_secure (size_t nbytes, enum gcry_random_level level)
313 {
314   void *buffer;
315
316   /* Historical note (1.3.0--1.4.1): The buffer was only allocated
317      in secure memory if the pool in random-csprng.c was also set to
318      use secure memory.  */
319   buffer = gcry_xmalloc_secure (nbytes);
320   do_randomize (buffer, nbytes, level);
321   return buffer;
322 }
323
324
325 /* Public function to fill the buffer with LENGTH bytes of
326    cryptographically strong random bytes.  Level GCRY_WEAK_RANDOM is
327    not very strong, GCRY_STRONG_RANDOM is strong enough for most
328    usage, GCRY_VERY_STRONG_RANDOM is good for key generation stuff but
329    may be very slow.  */
330 void
331 gcry_randomize (void *buffer, size_t length, enum gcry_random_level level)
332 {
333   do_randomize (buffer, length, level);
334 }
335
336
337 /* This function may be used to specify the file to be used as a seed
338    file for the PRNG.  This function should be called prior to the
339    initialization of the random module.  NAME may not be NULL.  */
340 void
341 _gcry_set_random_seed_file (const char *name)
342 {
343   if (fips_mode ())
344     ; /* No need for this in fips mode.  */
345   else if (rng_types.standard)
346     _gcry_rngcsprng_set_seed_file (name);
347   else if (rng_types.fips)
348     ;
349   else if (rng_types.system)
350     ;
351   else /* default */
352     _gcry_rngcsprng_set_seed_file (name);
353 }
354
355
356 /* If a seed file has been setup, this function may be used to write
357    back the random numbers entropy pool.  */
358 void
359 _gcry_update_random_seed_file (void)
360 {
361   if (fips_mode ())
362     ; /* No need for this in fips mode.  */
363   else if (rng_types.standard)
364     _gcry_rngcsprng_update_seed_file ();
365   else if (rng_types.fips)
366     ;
367   else if (rng_types.system)
368     ;
369   else /* default */
370     _gcry_rngcsprng_update_seed_file ();
371 }
372
373
374
375 /* The fast random pool function as called at some places in
376    libgcrypt.  This is merely a wrapper to make sure that this module
377    is initialized and to lock the pool.  Note, that this function is a
378    NOP unless a random function has been used or _gcry_initialize (1)
379    has been used.  We use this hack so that the internal use of this
380    function in cipher_open and md_open won't start filling up the
381    random pool, even if no random will be required by the process. */
382 void
383 _gcry_fast_random_poll (void)
384 {
385   if (fips_mode ())
386     ; /* No need for this in fips mode.  */
387   else if (rng_types.standard)
388     _gcry_rngcsprng_fast_poll ();
389   else if (rng_types.fips)
390     ;
391   else if (rng_types.system)
392     ;
393   else /* default */
394     _gcry_rngcsprng_fast_poll ();
395 }
396
397
398
399 /* Create an unpredicable nonce of LENGTH bytes in BUFFER. */
400 void
401 gcry_create_nonce (void *buffer, size_t length)
402 {
403   static unsigned char nonce_buffer[20+8];
404   static int nonce_buffer_initialized = 0;
405   static volatile pid_t my_pid; /* The volatile is there to make sure the
406                                    compiler does not optimize the code away
407                                    in case the getpid function is badly
408                                    attributed. */
409   volatile pid_t apid;
410   unsigned char *p;
411   size_t n;
412   int err;
413
414   /* First check whether we shall use the FIPS nonce generator.  This
415      is only done in FIPS mode, in all other modes, we use our own
416      nonce generator which is seeded by the RNG actual in use.  */
417   if (fips_mode ())
418     {
419       _gcry_rngfips_create_nonce (buffer, length);
420       return;
421     }
422
423   /* This is the nonce generator, which formerly lived in
424      random-csprng.c.  It is now used by all RNG types except when in
425      FIPS mode (not that this means it is also used if the FIPS RNG
426      has been selected but we are not in fips mode).  */
427
428   /* Make sure we are initialized. */
429   _gcry_random_initialize (1);
430
431   /* Acquire the nonce buffer lock. */
432   err = ath_mutex_lock (&nonce_buffer_lock);
433   if (err)
434     log_fatal ("failed to acquire the nonce buffer lock: %s\n",
435                strerror (err));
436
437   apid = getpid ();
438   /* The first time initialize our buffer. */
439   if (!nonce_buffer_initialized)
440     {
441       time_t atime = time (NULL);
442       pid_t xpid = apid;
443
444       my_pid = apid;
445
446       if ((sizeof apid + sizeof atime) > sizeof nonce_buffer)
447         BUG ();
448
449       /* Initialize the first 20 bytes with a reasonable value so that
450          a failure of gcry_randomize won't affect us too much.  Don't
451          care about the uninitialized remaining bytes. */
452       p = nonce_buffer;
453       memcpy (p, &xpid, sizeof xpid);
454       p += sizeof xpid;
455       memcpy (p, &atime, sizeof atime);
456
457       /* Initialize the never changing private part of 64 bits. */
458       gcry_randomize (nonce_buffer+20, 8, GCRY_WEAK_RANDOM);
459
460       nonce_buffer_initialized = 1;
461     }
462   else if ( my_pid != apid )
463     {
464       /* We forked. Need to reseed the buffer - doing this for the
465          private part should be sufficient. */
466       do_randomize (nonce_buffer+20, 8, GCRY_WEAK_RANDOM);
467       /* Update the pid so that we won't run into here again and
468          again. */
469       my_pid = apid;
470     }
471
472   /* Create the nonce by hashing the entire buffer, returning the hash
473      and updating the first 20 bytes of the buffer with this hash. */
474   for (p = buffer; length > 0; length -= n, p += n)
475     {
476       _gcry_sha1_hash_buffer (nonce_buffer,
477                               nonce_buffer, sizeof nonce_buffer);
478       n = length > 20? 20 : length;
479       memcpy (p, nonce_buffer, n);
480     }
481
482   /* Release the nonce buffer lock. */
483   err = ath_mutex_unlock (&nonce_buffer_lock);
484   if (err)
485     log_fatal ("failed to release the nonce buffer lock: %s\n",
486                strerror (err));
487 }
488
489
490 /* Run the self-tests for the RNG.  This is currently only implemented
491    for the FIPS generator.  */
492 gpg_error_t
493 _gcry_random_selftest (selftest_report_func_t report)
494 {
495   if (fips_mode ())
496     return _gcry_rngfips_selftest (report);
497   else
498     return 0; /* No selftests yet.  */
499 }
500
501
502 /* Create a new test context for an external RNG test driver.  On
503    success the test context is stored at R_CONTEXT; on failure NULL is
504    stored at R_CONTEXT and an error code is returned.  */
505 gcry_err_code_t
506 _gcry_random_init_external_test (void **r_context,
507                                  unsigned int flags,
508                                  const void *key, size_t keylen,
509                                  const void *seed, size_t seedlen,
510                                  const void *dt, size_t dtlen)
511 {
512   (void)flags;
513   if (fips_mode ())
514     return _gcry_rngfips_init_external_test (r_context, flags, key, keylen,
515                                              seed, seedlen,
516                                              dt, dtlen);
517   else
518     return GPG_ERR_NOT_SUPPORTED;
519 }
520
521 /* Get BUFLEN bytes from the RNG using the test CONTEXT and store them
522    at BUFFER.  Return 0 on success or an error code.  */
523 gcry_err_code_t
524 _gcry_random_run_external_test (void *context, char *buffer, size_t buflen)
525 {
526   if (fips_mode ())
527     return _gcry_rngfips_run_external_test (context, buffer, buflen);
528   else
529     return GPG_ERR_NOT_SUPPORTED;
530 }
531
532 /* Release the test CONTEXT.  */
533 void
534 _gcry_random_deinit_external_test (void *context)
535 {
536   if (fips_mode ())
537     _gcry_rngfips_deinit_external_test (context);
538 }