random: Add a feature to close device file descriptors.
[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 /* If possible close file descriptors used by the RNG. */
169 void
170 _gcry_random_close_fds (void)
171 {
172   /* Note that we can't do that directly because each random system
173      has its own lock functions which need to be used for accessing
174      the entropy gatherer.  */
175
176   if (fips_mode ())
177     _gcry_rngfips_close_fds ();
178   else if (rng_types.standard)
179     _gcry_rngcsprng_close_fds ();
180   else if (rng_types.fips)
181     _gcry_rngfips_close_fds ();
182   else if (rng_types.system)
183     _gcry_rngsystem_close_fds ();
184   else
185     _gcry_rngcsprng_close_fds ();
186 }
187
188
189 /* Return the current RNG type.  IGNORE_FIPS_MODE is a flag used to
190    skip the test for FIPS.  This is useful, so that we are able to
191    return the type of the RNG even before we have setup FIPS mode
192    (note that FIPS mode is enabled by default until it is switched off
193    by the initialization).  This is mostly useful for the regression
194    test.  */
195 int
196 _gcry_get_rng_type (int ignore_fips_mode)
197 {
198   if (!ignore_fips_mode && fips_mode ())
199     return GCRY_RNG_TYPE_FIPS;
200   else if (rng_types.standard)
201     return GCRY_RNG_TYPE_STANDARD;
202   else if (rng_types.fips)
203     return GCRY_RNG_TYPE_FIPS;
204   else if (rng_types.system)
205     return GCRY_RNG_TYPE_SYSTEM;
206   else
207     return GCRY_RNG_TYPE_STANDARD;
208 }
209
210
211 void
212 _gcry_random_dump_stats (void)
213 {
214   if (fips_mode ())
215     _gcry_rngfips_dump_stats ();
216   else
217     _gcry_rngcsprng_dump_stats ();
218 }
219
220
221 /* This function should be called during initialization and before
222    initialization of this module to place the random pools into secure
223    memory.  */
224 void
225 _gcry_secure_random_alloc (void)
226 {
227   if (fips_mode ())
228     ;  /* Not used; the FIPS RNG is always in secure mode.  */
229   else
230     _gcry_rngcsprng_secure_alloc ();
231 }
232
233
234 /* This may be called before full initialization to degrade the
235    quality of the RNG for the sake of a faster running test suite.  */
236 void
237 _gcry_enable_quick_random_gen (void)
238 {
239   if (fips_mode ())
240     ;  /* Not used.  */
241   else
242     _gcry_rngcsprng_enable_quick_gen ();
243 }
244
245
246 void
247 _gcry_set_random_daemon_socket (const char *socketname)
248 {
249   if (fips_mode ())
250     ;  /* Not used.  */
251   else
252     _gcry_rngcsprng_set_daemon_socket (socketname);
253 }
254
255 /* With ONOFF set to 1, enable the use of the daemon.  With ONOFF set
256    to 0, disable the use of the daemon.  With ONOF set to -1, return
257    whether the daemon has been enabled. */
258 int
259 _gcry_use_random_daemon (int onoff)
260 {
261   if (fips_mode ())
262     return 0; /* Never enabled in fips mode.  */
263   else
264     return _gcry_rngcsprng_use_daemon (onoff);
265 }
266
267
268 /* This function returns true if no real RNG is available or the
269    quality of the RNG has been degraded for test purposes.  */
270 int
271 _gcry_random_is_faked (void)
272 {
273   if (fips_mode ())
274     return _gcry_rngfips_is_faked ();
275   else
276     return _gcry_rngcsprng_is_faked ();
277 }
278
279
280 /* Add BUFLEN bytes from BUF to the internal random pool.  QUALITY
281    should be in the range of 0..100 to indicate the goodness of the
282    entropy added, or -1 for goodness not known.  */
283 gcry_err_code_t
284 _gcry_random_add_bytes (const void *buf, size_t buflen, int quality)
285 {
286   if (fips_mode ())
287     return 0; /* No need for this in fips mode.  */
288   else if (rng_types.standard)
289     return gpg_err_code (_gcry_rngcsprng_add_bytes (buf, buflen, quality));
290   else if (rng_types.fips)
291     return 0;
292   else if (rng_types.system)
293     return 0;
294   else /* default */
295     return gpg_err_code (_gcry_rngcsprng_add_bytes (buf, buflen, quality));
296 }
297
298
299 /* Helper function.  */
300 static void
301 do_randomize (void *buffer, size_t length, enum gcry_random_level level)
302 {
303   if (fips_mode ())
304     _gcry_rngfips_randomize (buffer, length, level);
305   else if (rng_types.standard)
306     _gcry_rngcsprng_randomize (buffer, length, level);
307   else if (rng_types.fips)
308     _gcry_rngfips_randomize (buffer, length, level);
309   else if (rng_types.system)
310     _gcry_rngsystem_randomize (buffer, length, level);
311   else /* default */
312     _gcry_rngcsprng_randomize (buffer, length, level);
313 }
314
315 /* The public function to return random data of the quality LEVEL.
316    Returns a pointer to a newly allocated and randomized buffer of
317    LEVEL and NBYTES length.  Caller must free the buffer.  */
318 void *
319 _gcry_random_bytes (size_t nbytes, enum gcry_random_level level)
320 {
321   void *buffer;
322
323   buffer = gcry_xmalloc (nbytes);
324   do_randomize (buffer, nbytes, level);
325   return buffer;
326 }
327
328
329 /* The public function to return random data of the quality LEVEL;
330    this version of the function returns the random in a buffer allocated
331    in secure memory.  Caller must free the buffer. */
332 void *
333 _gcry_random_bytes_secure (size_t nbytes, enum gcry_random_level level)
334 {
335   void *buffer;
336
337   /* Historical note (1.3.0--1.4.1): The buffer was only allocated
338      in secure memory if the pool in random-csprng.c was also set to
339      use secure memory.  */
340   buffer = gcry_xmalloc_secure (nbytes);
341   do_randomize (buffer, nbytes, level);
342   return buffer;
343 }
344
345
346 /* Public function to fill the buffer with LENGTH bytes of
347    cryptographically strong random bytes.  Level GCRY_WEAK_RANDOM is
348    not very strong, GCRY_STRONG_RANDOM is strong enough for most
349    usage, GCRY_VERY_STRONG_RANDOM is good for key generation stuff but
350    may be very slow.  */
351 void
352 _gcry_randomize (void *buffer, size_t length, enum gcry_random_level level)
353 {
354   do_randomize (buffer, length, level);
355 }
356
357
358 /* This function may be used to specify the file to be used as a seed
359    file for the PRNG.  This function should be called prior to the
360    initialization of the random module.  NAME may not be NULL.  */
361 void
362 _gcry_set_random_seed_file (const char *name)
363 {
364   if (fips_mode ())
365     ; /* No need for this in fips mode.  */
366   else if (rng_types.standard)
367     _gcry_rngcsprng_set_seed_file (name);
368   else if (rng_types.fips)
369     ;
370   else if (rng_types.system)
371     ;
372   else /* default */
373     _gcry_rngcsprng_set_seed_file (name);
374 }
375
376
377 /* If a seed file has been setup, this function may be used to write
378    back the random numbers entropy pool.  */
379 void
380 _gcry_update_random_seed_file (void)
381 {
382   if (fips_mode ())
383     ; /* No need for this in fips mode.  */
384   else if (rng_types.standard)
385     _gcry_rngcsprng_update_seed_file ();
386   else if (rng_types.fips)
387     ;
388   else if (rng_types.system)
389     ;
390   else /* default */
391     _gcry_rngcsprng_update_seed_file ();
392 }
393
394
395
396 /* The fast random pool function as called at some places in
397    libgcrypt.  This is merely a wrapper to make sure that this module
398    is initialized and to lock the pool.  Note, that this function is a
399    NOP unless a random function has been used or _gcry_initialize (1)
400    has been used.  We use this hack so that the internal use of this
401    function in cipher_open and md_open won't start filling up the
402    random pool, even if no random will be required by the process. */
403 void
404 _gcry_fast_random_poll (void)
405 {
406   if (fips_mode ())
407     ; /* No need for this in fips mode.  */
408   else if (rng_types.standard)
409     _gcry_rngcsprng_fast_poll ();
410   else if (rng_types.fips)
411     ;
412   else if (rng_types.system)
413     ;
414   else /* default */
415     _gcry_rngcsprng_fast_poll ();
416 }
417
418
419
420 /* Create an unpredicable nonce of LENGTH bytes in BUFFER. */
421 void
422 _gcry_create_nonce (void *buffer, size_t length)
423 {
424   static unsigned char nonce_buffer[20+8];
425   static int nonce_buffer_initialized = 0;
426   static volatile pid_t my_pid; /* The volatile is there to make sure the
427                                    compiler does not optimize the code away
428                                    in case the getpid function is badly
429                                    attributed. */
430   volatile pid_t apid;
431   unsigned char *p;
432   size_t n;
433   int err;
434
435   /* First check whether we shall use the FIPS nonce generator.  This
436      is only done in FIPS mode, in all other modes, we use our own
437      nonce generator which is seeded by the RNG actual in use.  */
438   if (fips_mode ())
439     {
440       _gcry_rngfips_create_nonce (buffer, length);
441       return;
442     }
443
444   /* This is the nonce generator, which formerly lived in
445      random-csprng.c.  It is now used by all RNG types except when in
446      FIPS mode (not that this means it is also used if the FIPS RNG
447      has been selected but we are not in fips mode).  */
448
449   /* Make sure we are initialized. */
450   _gcry_random_initialize (1);
451
452   /* Acquire the nonce buffer lock. */
453   err = ath_mutex_lock (&nonce_buffer_lock);
454   if (err)
455     log_fatal ("failed to acquire the nonce buffer lock: %s\n",
456                strerror (err));
457
458   apid = getpid ();
459   /* The first time initialize our buffer. */
460   if (!nonce_buffer_initialized)
461     {
462       time_t atime = time (NULL);
463       pid_t xpid = apid;
464
465       my_pid = apid;
466
467       if ((sizeof apid + sizeof atime) > sizeof nonce_buffer)
468         BUG ();
469
470       /* Initialize the first 20 bytes with a reasonable value so that
471          a failure of gcry_randomize won't affect us too much.  Don't
472          care about the uninitialized remaining bytes. */
473       p = nonce_buffer;
474       memcpy (p, &xpid, sizeof xpid);
475       p += sizeof xpid;
476       memcpy (p, &atime, sizeof atime);
477
478       /* Initialize the never changing private part of 64 bits. */
479       _gcry_randomize (nonce_buffer+20, 8, GCRY_WEAK_RANDOM);
480
481       nonce_buffer_initialized = 1;
482     }
483   else if ( my_pid != apid )
484     {
485       /* We forked. Need to reseed the buffer - doing this for the
486          private part should be sufficient. */
487       do_randomize (nonce_buffer+20, 8, GCRY_WEAK_RANDOM);
488       /* Update the pid so that we won't run into here again and
489          again. */
490       my_pid = apid;
491     }
492
493   /* Create the nonce by hashing the entire buffer, returning the hash
494      and updating the first 20 bytes of the buffer with this hash. */
495   for (p = buffer; length > 0; length -= n, p += n)
496     {
497       _gcry_sha1_hash_buffer (nonce_buffer,
498                               nonce_buffer, sizeof nonce_buffer);
499       n = length > 20? 20 : length;
500       memcpy (p, nonce_buffer, n);
501     }
502
503   /* Release the nonce buffer lock. */
504   err = ath_mutex_unlock (&nonce_buffer_lock);
505   if (err)
506     log_fatal ("failed to release the nonce buffer lock: %s\n",
507                strerror (err));
508 }
509
510
511 /* Run the self-tests for the RNG.  This is currently only implemented
512    for the FIPS generator.  */
513 gpg_error_t
514 _gcry_random_selftest (selftest_report_func_t report)
515 {
516   if (fips_mode ())
517     return _gcry_rngfips_selftest (report);
518   else
519     return 0; /* No selftests yet.  */
520 }
521
522
523 /* Create a new test context for an external RNG test driver.  On
524    success the test context is stored at R_CONTEXT; on failure NULL is
525    stored at R_CONTEXT and an error code is returned.  */
526 gcry_err_code_t
527 _gcry_random_init_external_test (void **r_context,
528                                  unsigned int flags,
529                                  const void *key, size_t keylen,
530                                  const void *seed, size_t seedlen,
531                                  const void *dt, size_t dtlen)
532 {
533   (void)flags;
534   if (fips_mode ())
535     return _gcry_rngfips_init_external_test (r_context, flags, key, keylen,
536                                              seed, seedlen,
537                                              dt, dtlen);
538   else
539     return GPG_ERR_NOT_SUPPORTED;
540 }
541
542 /* Get BUFLEN bytes from the RNG using the test CONTEXT and store them
543    at BUFFER.  Return 0 on success or an error code.  */
544 gcry_err_code_t
545 _gcry_random_run_external_test (void *context, char *buffer, size_t buflen)
546 {
547   if (fips_mode ())
548     return _gcry_rngfips_run_external_test (context, buffer, buflen);
549   else
550     return GPG_ERR_NOT_SUPPORTED;
551 }
552
553 /* Release the test CONTEXT.  */
554 void
555 _gcry_random_deinit_external_test (void *context)
556 {
557   if (fips_mode ())
558     _gcry_rngfips_deinit_external_test (context);
559 }