random: Add a feature to close device file descriptors.
[libgcrypt.git] / random / random-csprng.c
1 /* random-csprng.c - CSPRNG style random number generator (libgcrypt classic)
2  * Copyright (C) 1998, 2000, 2001, 2002, 2003, 2004, 2005, 2006,
3  *               2007, 2008, 2010, 2012  Free Software Foundation, Inc.
4  *
5  * This file is part of Libgcrypt.
6  *
7  * Libgcrypt is free software; you can redistribute it and/or modify
8  * it under the terms of the GNU Lesser General Public License as
9  * published by the Free Software Foundation; either version 2.1 of
10  * the License, or (at your option) any later version.
11  *
12  * Libgcrypt is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15  * GNU Lesser General Public License for more details.
16  *
17  * You should have received a copy of the GNU Lesser General Public
18  * License along with this program; if not, see <http://www.gnu.org/licenses/>.
19  */
20
21 /*
22    This random number generator is modelled after the one described in
23    Peter Gutmann's 1998 Usenix Security Symposium paper: "Software
24    Generation of Practically Strong Random Numbers".  See also chapter
25    6 in his book "Cryptographic Security Architecture", New York,
26    2004, ISBN 0-387-95387-6.
27
28    Note that the acronym CSPRNG stands for "Continuously Seeded
29    PseudoRandom Number Generator" as used in Peter's implementation of
30    the paper and not only for "Cryptographically Secure PseudoRandom
31    Number Generator".
32  */
33
34
35 #include <config.h>
36 #include <stdio.h>
37 #include <stdlib.h>
38 #include <errno.h>
39 #include <string.h>
40 #include <sys/time.h>
41 #include <sys/types.h>
42 #include <sys/stat.h>
43 #include <unistd.h>
44 #include <fcntl.h>
45 #include <time.h>
46 #ifdef  HAVE_GETHRTIME
47 #include <sys/times.h>
48 #endif
49 #ifdef HAVE_GETTIMEOFDAY
50 #include <sys/time.h>
51 #endif
52 #ifdef HAVE_GETRUSAGE
53 #include <sys/resource.h>
54 #endif
55 #ifdef __MINGW32__
56 #include <process.h>
57 #endif
58 #include "g10lib.h"
59 #include "../cipher/rmd.h"
60 #include "random.h"
61 #include "rand-internal.h"
62 #include "cipher.h" /* Required for the rmd160_hash_buffer() prototype.  */
63 #include "ath.h"
64
65 #ifndef RAND_MAX   /* For SunOS. */
66 #define RAND_MAX 32767
67 #endif
68
69 /* Check whether we can lock the seed file read write. */
70 #if defined(HAVE_FCNTL) && defined(HAVE_FTRUNCATE) && !defined(HAVE_W32_SYSTEM)
71 #define LOCK_SEED_FILE 1
72 #else
73 #define LOCK_SEED_FILE 0
74 #endif
75
76 /* Define the constant we use for transforming the pool at read-out. */
77 #if SIZEOF_UNSIGNED_LONG == 8
78 #define ADD_VALUE 0xa5a5a5a5a5a5a5a5
79 #elif SIZEOF_UNSIGNED_LONG == 4
80 #define ADD_VALUE 0xa5a5a5a5
81 #else
82 #error weird size for an unsigned long
83 #endif
84
85 /* Contstants pertaining to the hash pool. */
86 #define BLOCKLEN  64   /* Hash this amount of bytes... */
87 #define DIGESTLEN 20   /* ... into a digest of this length (rmd160). */
88 /* POOLBLOCKS is the number of digests which make up the pool.  */
89 #define POOLBLOCKS 30
90 /* POOLSIZE must be a multiple of the digest length to make the AND
91    operations faster, the size should also be a multiple of unsigned
92    long.  */
93 #define POOLSIZE (POOLBLOCKS*DIGESTLEN)
94 #if (POOLSIZE % SIZEOF_UNSIGNED_LONG)
95 #error Please make sure that poolsize is a multiple of unsigned long
96 #endif
97 #define POOLWORDS (POOLSIZE / SIZEOF_UNSIGNED_LONG)
98
99
100 /* RNDPOOL is the pool we use to collect the entropy and to stir it
101    up.  Its allocated size is POOLSIZE+BLOCKLEN.  Note that this is
102    also an indication on whether the module has been fully
103    initialized. */
104 static unsigned char *rndpool;
105
106 /* KEYPOOL is used as a scratch copy to read out random from RNDPOOL.
107    Its allocated size is also POOLSIZE+BLOCKLEN.  */
108 static unsigned char *keypool;
109
110 /* This is the offset into RNDPOOL where the next random bytes are to
111    be mixed in.  */
112 static size_t pool_writepos;
113
114 /* When reading data out of KEYPOOL, we start the read at different
115    positions.  This variable keeps track on where to read next.  */
116 static size_t pool_readpos;
117
118 /* This flag is set to true as soon as the pool has been completely
119    filled the first time.  This may happen either by rereading a seed
120    file or by adding enough entropy.  */
121 static int pool_filled;
122
123 /* This counter is used to track whether the initial seeding has been
124    done with enough bytes from a reliable entropy source.  */
125 static size_t pool_filled_counter;
126
127 /* If random of level GCRY_VERY_STRONG_RANDOM has been requested we
128    have stricter requirements on what kind of entropy is in the pool.
129    In particular POOL_FILLED is not sufficient.  Thus we add some
130    extra seeding and set this flag to true if the extra seeding has
131    been done.  */
132 static int did_initial_extra_seeding;
133
134 /* This variable is used to estimated the amount of fresh entropy
135    available in RNDPOOL.  */
136 static int pool_balance;
137
138 /* After a mixing operation this variable will be set to true and
139    cleared if new entropy has been added or a remix is required for
140    other reasons.  */
141 static int just_mixed;
142
143 /* The name of the seed file or NULL if no seed file has been defined.
144    The seed file needs to be regsitered at initialiation time.  We
145    keep a malloced copy here.  */
146 static char *seed_file_name;
147
148 /* If a seed file has been registered and maybe updated on exit this
149    flag set. */
150 static int allow_seed_file_update;
151
152 /* Option flag set at initialiation time to force allocation of the
153    pool in secure memory.  */
154 static int secure_alloc;
155
156 /* This function pointer is set to the actual entropy gathering
157    function during initialization.  After initialization it is
158    guaranteed to point to function.  (On systems without a random
159    gatherer module a dummy function is used).*/
160 static int (*slow_gather_fnc)(void (*)(const void*, size_t,
161                                        enum random_origins),
162                               enum random_origins, size_t, int);
163
164 /* This function is set to the actual fast entropy gathering function
165    during initialization.  If it is NULL, no such function is
166    available. */
167 static void (*fast_gather_fnc)(void (*)(const void*, size_t,
168                                         enum random_origins),
169                                enum random_origins);
170
171
172 /* Option flag useful for debugging and the test suite.  If set
173    requests for very strong random are degraded to strong random.  Not
174    used by regular applications.  */
175 static int quick_test;
176
177 /* On systems without entropy gathering modules, this flag is set to
178    indicate that the random generator is not working properly.  A
179    warning message is issued as well.  This is useful only for
180    debugging and during development.  */
181 static int faked_rng;
182
183 /* This is the lock we use to protect all pool operations.  */
184 static ath_mutex_t pool_lock;
185
186 /* This is a helper for assert calls.  These calls are used to assert
187    that functions are called in a locked state.  It is not meant to be
188    thread-safe but as a method to get aware of missing locks in the
189    test suite.  */
190 static int pool_is_locked;
191
192
193 /* We keep some counters in this structure for the sake of the
194    _gcry_random_dump_stats () function.  */
195 static struct
196 {
197   unsigned long mixrnd;
198   unsigned long mixkey;
199   unsigned long slowpolls;
200   unsigned long fastpolls;
201   unsigned long getbytes1;
202   unsigned long ngetbytes1;
203   unsigned long getbytes2;
204   unsigned long ngetbytes2;
205   unsigned long addbytes;
206   unsigned long naddbytes;
207 } rndstats;
208
209
210
211 /* --- Stuff pertaining to the random daemon support. --- */
212 #ifdef USE_RANDOM_DAEMON
213
214 /* If ALLOW_DAEMON is true, the module will try to use the random
215    daemon first.  If the daemon has failed, this variable is set to
216    back to false and the code continues as normal.  Note, we don't
217    test this flag in a locked state because a wrong value does not
218    harm and the trhead will find out itself that the daemon does not
219    work and set it (again) to false.  */
220 static int allow_daemon;
221
222 /* During initialization, the user may set a non-default socket name
223    for accessing the random daemon.  If this value is NULL, the
224    default name will be used. */
225 static char *daemon_socket_name;
226
227 #endif /*USE_RANDOM_DAEMON*/
228
229
230
231 /* ---  Prototypes  --- */
232 static void read_pool (byte *buffer, size_t length, int level );
233 static void add_randomness (const void *buffer, size_t length,
234                             enum random_origins origin);
235 static void random_poll (void);
236 static void do_fast_random_poll (void);
237 static int (*getfnc_gather_random (void))(void (*)(const void*, size_t,
238                                                    enum random_origins),
239                                           enum random_origins, size_t, int);
240 static void (*getfnc_fast_random_poll (void))(void (*)(const void*, size_t,
241                                                        enum random_origins),
242                                               enum random_origins);
243 static void read_random_source (enum random_origins origin,
244                                 size_t length, int level);
245 static int gather_faked (void (*add)(const void*, size_t, enum random_origins),
246                          enum random_origins, size_t length, int level );
247
248
249 \f
250 /* ---  Functions  --- */
251
252
253 /* Basic initialization which is required to initialize mutexes and
254    such.  It does not run a full initialization so that the filling of
255    the random pool can be delayed until it is actually needed.  We
256    assume that this function is used before any concurrent access
257    happens. */
258 static void
259 initialize_basics(void)
260 {
261   static int initialized;
262   int err;
263
264   if (!initialized)
265     {
266       initialized = 1;
267       err = ath_mutex_init (&pool_lock);
268       if (err)
269         log_fatal ("failed to create the pool lock: %s\n", strerror (err) );
270
271 #ifdef USE_RANDOM_DAEMON
272       _gcry_daemon_initialize_basics ();
273 #endif /*USE_RANDOM_DAEMON*/
274
275       /* Make sure that we are still using the values we have
276          traditionally used for the random levels.  */
277       gcry_assert (GCRY_WEAK_RANDOM == 0
278                    && GCRY_STRONG_RANDOM == 1
279                    && GCRY_VERY_STRONG_RANDOM == 2);
280     }
281 }
282
283 /* Take the pool lock. */
284 static void
285 lock_pool (void)
286 {
287   int err;
288
289   err = ath_mutex_lock (&pool_lock);
290   if (err)
291     log_fatal ("failed to acquire the pool lock: %s\n", strerror (err));
292   pool_is_locked = 1;
293 }
294
295 /* Release the pool lock. */
296 static void
297 unlock_pool (void)
298 {
299   int err;
300
301   pool_is_locked = 0;
302   err = ath_mutex_unlock (&pool_lock);
303   if (err)
304     log_fatal ("failed to release the pool lock: %s\n", strerror (err));
305 }
306
307
308 /* Full initialization of this module. */
309 static void
310 initialize(void)
311 {
312   /* Although the basic initialization should have happened already,
313      we call it here to make sure that all prerequisites are met.  */
314   initialize_basics ();
315
316   /* Now we can look the pool and complete the initialization if
317      necessary.  */
318   lock_pool ();
319   if (!rndpool)
320     {
321       /* The data buffer is allocated somewhat larger, so that we can
322          use this extra space (which is allocated in secure memory) as
323          a temporary hash buffer */
324       rndpool = (secure_alloc
325                  ? gcry_xcalloc_secure (1, POOLSIZE + BLOCKLEN)
326                  : gcry_xcalloc (1, POOLSIZE + BLOCKLEN));
327       keypool = (secure_alloc
328                  ? gcry_xcalloc_secure (1, POOLSIZE + BLOCKLEN)
329                  : gcry_xcalloc (1, POOLSIZE + BLOCKLEN));
330
331       /* Setup the slow entropy gathering function.  The code requires
332          that this function exists. */
333       slow_gather_fnc = getfnc_gather_random ();
334       if (!slow_gather_fnc)
335         {
336           faked_rng = 1;
337           slow_gather_fnc = gather_faked;
338         }
339
340       /* Setup the fast entropy gathering function.  */
341       fast_gather_fnc = getfnc_fast_random_poll ();
342
343     }
344   unlock_pool ();
345 }
346
347
348
349
350 /* Initialize this random subsystem.  If FULL is false, this function
351    merely calls the initialize and does not do anything more.  Doing
352    this is not really required but when running in a threaded
353    environment we might get a race condition otherwise. */
354 void
355 _gcry_rngcsprng_initialize (int full)
356 {
357   if (!full)
358     initialize_basics ();
359   else
360     initialize ();
361 }
362
363
364 /* Try to close the FDs of the random gather module.  This is
365    currently only implemented for rndlinux. */
366 void
367 _gcry_rngcsprng_close_fds (void)
368 {
369   lock_pool ();
370 #if USE_RNDLINUX
371   _gcry_rndlinux_gather_random (NULL, 0, 0, 0);
372   pool_filled = 0; /* Force re-open on next use.  */
373 #endif
374   unlock_pool ();
375 }
376
377
378 void
379 _gcry_rngcsprng_dump_stats (void)
380 {
381   /* In theory we would need to lock the stats here.  However this
382      function is usually called during cleanup and then we _might_ run
383      into problems.  */
384
385   log_info ("random usage: poolsize=%d mixed=%lu polls=%lu/%lu added=%lu/%lu\n"
386             "              outmix=%lu getlvl1=%lu/%lu getlvl2=%lu/%lu%s\n",
387             POOLSIZE, rndstats.mixrnd, rndstats.slowpolls, rndstats.fastpolls,
388             rndstats.naddbytes, rndstats.addbytes,
389             rndstats.mixkey, rndstats.ngetbytes1, rndstats.getbytes1,
390             rndstats.ngetbytes2, rndstats.getbytes2,
391             _gcry_rndhw_failed_p()? " (hwrng failed)":"");
392 }
393
394
395 /* This function should be called during initialization and before
396    initialization of this module to place the random pools into secure
397    memory.  */
398 void
399 _gcry_rngcsprng_secure_alloc (void)
400 {
401   secure_alloc = 1;
402 }
403
404
405 /* This may be called before full initialization to degrade the
406    quality of the RNG for the sake of a faster running test suite.  */
407 void
408 _gcry_rngcsprng_enable_quick_gen (void)
409 {
410   quick_test = 1;
411 }
412
413
414 void
415 _gcry_rngcsprng_set_daemon_socket (const char *socketname)
416 {
417 #ifdef USE_RANDOM_DAEMON
418   if (daemon_socket_name)
419     BUG ();
420
421   daemon_socket_name = gcry_xstrdup (socketname);
422 #else /*!USE_RANDOM_DAEMON*/
423   (void)socketname;
424 #endif /*!USE_RANDOM_DAEMON*/
425 }
426
427 /* With ONOFF set to 1, enable the use of the daemon.  With ONOFF set
428    to 0, disable the use of the daemon.  With ONOF set to -1, return
429    whether the daemon has been enabled. */
430 int
431 _gcry_rngcsprng_use_daemon (int onoff)
432 {
433 #ifdef USE_RANDOM_DAEMON
434   int last;
435
436   /* This is not really thread safe.  However it is expected that this
437      function is being called during initialization and at that point
438      we are for other reasons not really thread safe.  We do not want
439      to lock it because we might eventually decide that this function
440      may even be called prior to gcry_check_version.  */
441   last = allow_daemon;
442   if (onoff != -1)
443     allow_daemon = onoff;
444
445   return last;
446 #else /*!USE_RANDOM_DAEMON*/
447   (void)onoff;
448   return 0;
449 #endif /*!USE_RANDOM_DAEMON*/
450 }
451
452
453 /* This function returns true if no real RNG is available or the
454    quality of the RNG has been degraded for test purposes.  */
455 int
456 _gcry_rngcsprng_is_faked (void)
457 {
458   /* We need to initialize due to the runtime determination of
459      available entropy gather modules.  */
460   initialize();
461   return (faked_rng || quick_test);
462 }
463
464
465 /* Add BUFLEN bytes from BUF to the internal random pool.  QUALITY
466    should be in the range of 0..100 to indicate the goodness of the
467    entropy added, or -1 for goodness not known.  */
468 gcry_error_t
469 _gcry_rngcsprng_add_bytes (const void *buf, size_t buflen, int quality)
470 {
471   size_t nbytes;
472   const char *bufptr;
473
474   if (quality == -1)
475     quality = 35;
476   else if (quality > 100)
477     quality = 100;
478   else if (quality < 0)
479     quality = 0;
480
481   if (!buf)
482     return gpg_error (GPG_ERR_INV_ARG);
483
484   if (!buflen || quality < 10)
485     return 0; /* Take a shortcut. */
486
487   /* Because we don't increment the entropy estimation with FASTPOLL,
488      we don't need to take lock that estimation while adding from an
489      external source.  This limited entropy estimation also means that
490      we can't take QUALITY into account.  */
491   initialize_basics ();
492   bufptr = buf;
493   while (buflen)
494     {
495       nbytes = buflen > POOLSIZE? POOLSIZE : buflen;
496       lock_pool ();
497       if (rndpool)
498         add_randomness (bufptr, nbytes, RANDOM_ORIGIN_EXTERNAL);
499       unlock_pool ();
500       bufptr += nbytes;
501       buflen -= nbytes;
502     }
503   return 0;
504 }
505
506
507 /* Public function to fill the buffer with LENGTH bytes of
508    cryptographically strong random bytes.  Level GCRY_WEAK_RANDOM is
509    not very strong, GCRY_STRONG_RANDOM is strong enough for most
510    usage, GCRY_VERY_STRONG_RANDOM is good for key generation stuff but
511    may be very slow.  */
512 void
513 _gcry_rngcsprng_randomize (void *buffer, size_t length,
514                            enum gcry_random_level level)
515 {
516   unsigned char *p;
517
518   /* Make sure we are initialized. */
519   initialize ();
520
521   /* Handle our hack used for regression tests of Libgcrypt. */
522   if ( quick_test && level > GCRY_STRONG_RANDOM )
523     level = GCRY_STRONG_RANDOM;
524
525   /* Make sure the level is okay. */
526   level &= 3;
527
528 #ifdef USE_RANDOM_DAEMON
529   if (allow_daemon
530       && !_gcry_daemon_randomize (daemon_socket_name, buffer, length, level))
531     return; /* The daemon succeeded. */
532   allow_daemon = 0; /* Daemon failed - switch off. */
533 #endif /*USE_RANDOM_DAEMON*/
534
535   /* Acquire the pool lock. */
536   lock_pool ();
537
538   /* Update the statistics. */
539   if (level >= GCRY_VERY_STRONG_RANDOM)
540     {
541       rndstats.getbytes2 += length;
542       rndstats.ngetbytes2++;
543     }
544   else
545     {
546       rndstats.getbytes1 += length;
547       rndstats.ngetbytes1++;
548     }
549
550   /* Read the random into the provided buffer. */
551   for (p = buffer; length > 0;)
552     {
553       size_t n;
554
555       n = length > POOLSIZE? POOLSIZE : length;
556       read_pool (p, n, level);
557       length -= n;
558       p += n;
559     }
560
561   /* Release the pool lock. */
562   unlock_pool ();
563 }
564
565
566
567
568 /*
569    Mix the pool:
570
571    |........blocks*20byte........|20byte|..44byte..|
572    <..44byte..>           <20byte>
573         |                    |
574         |                    +------+
575         +---------------------------|----------+
576                                     v          v
577    |........blocks*20byte........|20byte|..44byte..|
578                                  <.....64bytes.....>
579                                          |
580       +----------------------------------+
581      Hash
582       v
583    |.............................|20byte|..44byte..|
584    <20byte><20byte><..44byte..>
585       |                |
586       |                +---------------------+
587       +-----------------------------+        |
588                                     v        v
589    |.............................|20byte|..44byte..|
590                                  <.....64byte......>
591                                         |
592               +-------------------------+
593              Hash
594               v
595    |.............................|20byte|..44byte..|
596    <20byte><20byte><..44byte..>
597
598    and so on until we did this for all blocks.
599
600    To better protect against implementation errors in this code, we
601    xor a digest of the entire pool into the pool before mixing.
602
603    Note: this function must only be called with a locked pool.
604  */
605 static void
606 mix_pool(unsigned char *pool)
607 {
608   static unsigned char failsafe_digest[DIGESTLEN];
609   static int failsafe_digest_valid;
610
611   unsigned char *hashbuf = pool + POOLSIZE;
612   unsigned char *p, *pend;
613   int i, n;
614   RMD160_CONTEXT md;
615
616 #if DIGESTLEN != 20
617 #error must have a digest length of 20 for ripe-md-160
618 #endif
619
620   gcry_assert (pool_is_locked);
621   _gcry_rmd160_init( &md );
622
623   /* Loop over the pool.  */
624   pend = pool + POOLSIZE;
625   memcpy(hashbuf, pend - DIGESTLEN, DIGESTLEN );
626   memcpy(hashbuf+DIGESTLEN, pool, BLOCKLEN-DIGESTLEN);
627   _gcry_rmd160_mixblock( &md, hashbuf);
628   memcpy(pool, hashbuf, 20 );
629
630   if (failsafe_digest_valid && pool == rndpool)
631     {
632       for (i=0; i < 20; i++)
633         pool[i] ^= failsafe_digest[i];
634     }
635
636   p = pool;
637   for (n=1; n < POOLBLOCKS; n++)
638     {
639       memcpy (hashbuf, p, DIGESTLEN);
640
641       p += DIGESTLEN;
642       if (p+DIGESTLEN+BLOCKLEN < pend)
643         memcpy (hashbuf+DIGESTLEN, p+DIGESTLEN, BLOCKLEN-DIGESTLEN);
644       else
645         {
646           unsigned char *pp = p + DIGESTLEN;
647
648           for (i=DIGESTLEN; i < BLOCKLEN; i++ )
649             {
650               if ( pp >= pend )
651                 pp = pool;
652               hashbuf[i] = *pp++;
653             }
654         }
655
656       _gcry_rmd160_mixblock ( &md, hashbuf);
657       memcpy(p, hashbuf, 20 );
658     }
659
660     /* Our hash implementation does only leave small parts (64 bytes)
661        of the pool on the stack, so it is okay not to require secure
662        memory here.  Before we use this pool, it will be copied to the
663        help buffer anyway. */
664     if ( pool == rndpool)
665       {
666         _gcry_rmd160_hash_buffer (failsafe_digest, pool, POOLSIZE);
667         failsafe_digest_valid = 1;
668       }
669
670     _gcry_burn_stack (384); /* for the rmd160_mixblock(), rmd160_hash_buffer */
671 }
672
673
674 void
675 _gcry_rngcsprng_set_seed_file (const char *name)
676 {
677   if (seed_file_name)
678     BUG ();
679   seed_file_name = gcry_xstrdup (name);
680 }
681
682
683 /* Lock an open file identified by file descriptor FD and wait a
684    reasonable time to succeed.  With FOR_WRITE set to true a write
685    lock will be taken.  FNAME is used only for diagnostics. Returns 0
686    on success or -1 on error. */
687 static int
688 lock_seed_file (int fd, const char *fname, int for_write)
689 {
690 #ifdef __GCC__
691 #warning Check whether we can lock on Windows.
692 #endif
693 #if LOCK_SEED_FILE
694   struct flock lck;
695   struct timeval tv;
696   int backoff=0;
697
698   /* We take a lock on the entire file. */
699   memset (&lck, 0, sizeof lck);
700   lck.l_type = for_write? F_WRLCK : F_RDLCK;
701   lck.l_whence = SEEK_SET;
702
703   while (fcntl (fd, F_SETLK, &lck) == -1)
704     {
705       if (errno != EAGAIN && errno != EACCES)
706         {
707           log_info (_("can't lock `%s': %s\n"), fname, strerror (errno));
708           return -1;
709         }
710
711       if (backoff > 2) /* Show the first message after ~2.25 seconds. */
712         log_info( _("waiting for lock on `%s'...\n"), fname);
713
714       tv.tv_sec = backoff;
715       tv.tv_usec = 250000;
716       select (0, NULL, NULL, NULL, &tv);
717       if (backoff < 10)
718         backoff++ ;
719     }
720 #endif /*!LOCK_SEED_FILE*/
721   return 0;
722 }
723
724
725 /* Read in a seed from the random_seed file and return true if this
726    was successful.
727
728    Note: Multiple instances of applications sharing the same random
729    seed file can be started in parallel, in which case they will read
730    out the same pool and then race for updating it (the last update
731    overwrites earlier updates).  They will differentiate only by the
732    weak entropy that is added in read_seed_file based on the PID and
733    clock, and up to 16 bytes of weak random non-blockingly.  The
734    consequence is that the output of these different instances is
735    correlated to some extent.  In the perfect scenario, the attacker
736    can control (or at least guess) the PID and clock of the
737    application, and drain the system's entropy pool to reduce the "up
738    to 16 bytes" above to 0.  Then the dependencies of the initial
739    states of the pools are completely known.  */
740 static int
741 read_seed_file (void)
742 {
743   int fd;
744   struct stat sb;
745   unsigned char buffer[POOLSIZE];
746   int n;
747
748   gcry_assert (pool_is_locked);
749
750   if (!seed_file_name)
751     return 0;
752
753 #ifdef HAVE_DOSISH_SYSTEM
754   fd = open( seed_file_name, O_RDONLY | O_BINARY );
755 #else
756   fd = open( seed_file_name, O_RDONLY );
757 #endif
758   if( fd == -1 && errno == ENOENT)
759     {
760       allow_seed_file_update = 1;
761       return 0;
762     }
763
764   if (fd == -1 )
765     {
766       log_info(_("can't open `%s': %s\n"), seed_file_name, strerror(errno) );
767       return 0;
768     }
769   if (lock_seed_file (fd, seed_file_name, 0))
770     {
771       close (fd);
772       return 0;
773     }
774   if (fstat( fd, &sb ) )
775     {
776       log_info(_("can't stat `%s': %s\n"), seed_file_name, strerror(errno) );
777       close(fd);
778       return 0;
779     }
780   if (!S_ISREG(sb.st_mode) )
781     {
782       log_info(_("`%s' is not a regular file - ignored\n"), seed_file_name );
783       close(fd);
784       return 0;
785     }
786   if (!sb.st_size )
787     {
788       log_info(_("note: random_seed file is empty\n") );
789       close(fd);
790       allow_seed_file_update = 1;
791       return 0;
792     }
793   if (sb.st_size != POOLSIZE )
794     {
795       log_info(_("warning: invalid size of random_seed file - not used\n") );
796       close(fd);
797       return 0;
798     }
799
800   do
801     {
802       n = read( fd, buffer, POOLSIZE );
803     }
804   while (n == -1 && errno == EINTR );
805
806   if (n != POOLSIZE)
807     {
808       log_fatal(_("can't read `%s': %s\n"), seed_file_name,strerror(errno) );
809       close(fd);/*NOTREACHED*/
810       return 0;
811     }
812
813   close(fd);
814
815   add_randomness( buffer, POOLSIZE, RANDOM_ORIGIN_INIT );
816   /* add some minor entropy to the pool now (this will also force a mixing) */
817   {
818     pid_t x = getpid();
819     add_randomness( &x, sizeof(x), RANDOM_ORIGIN_INIT );
820   }
821   {
822     time_t x = time(NULL);
823     add_randomness( &x, sizeof(x), RANDOM_ORIGIN_INIT );
824   }
825   {
826     clock_t x = clock();
827     add_randomness( &x, sizeof(x), RANDOM_ORIGIN_INIT );
828   }
829
830   /* And read a few bytes from our entropy source.  By using a level
831    * of 0 this will not block and might not return anything with some
832    * entropy drivers, however the rndlinux driver will use
833    * /dev/urandom and return some stuff - Do not read too much as we
834    * want to be friendly to the scare system entropy resource. */
835   read_random_source ( RANDOM_ORIGIN_INIT, 16, GCRY_WEAK_RANDOM );
836
837   allow_seed_file_update = 1;
838   return 1;
839 }
840
841
842 void
843 _gcry_rngcsprng_update_seed_file (void)
844 {
845   unsigned long *sp, *dp;
846   int fd, i;
847
848   /* We do only a basic initialization so that we can lock the pool.
849      This is required to cope with the case that this function is
850      called by some cleanup code at a point where the RNG has never
851      been initialized.  */
852   initialize_basics ();
853   lock_pool ();
854
855   if ( !seed_file_name || !rndpool || !pool_filled )
856     {
857       unlock_pool ();
858       return;
859     }
860   if ( !allow_seed_file_update )
861     {
862       unlock_pool ();
863       log_info(_("note: random_seed file not updated\n"));
864       return;
865     }
866
867   /* At this point we know that there is something in the pool and
868      thus we can conclude that the pool has been fully initialized.  */
869
870
871   /* Copy the entropy pool to a scratch pool and mix both of them. */
872   for (i=0,dp=(unsigned long*)keypool, sp=(unsigned long*)rndpool;
873        i < POOLWORDS; i++, dp++, sp++ )
874     {
875       *dp = *sp + ADD_VALUE;
876     }
877   mix_pool(rndpool); rndstats.mixrnd++;
878   mix_pool(keypool); rndstats.mixkey++;
879
880 #if defined(HAVE_DOSISH_SYSTEM) || defined(__CYGWIN__)
881   fd = open (seed_file_name, O_WRONLY|O_CREAT|O_TRUNC|O_BINARY,
882              S_IRUSR|S_IWUSR );
883 #else
884 # if LOCK_SEED_FILE
885     fd = open (seed_file_name, O_WRONLY|O_CREAT, S_IRUSR|S_IWUSR );
886 # else
887     fd = open (seed_file_name, O_WRONLY|O_CREAT|O_TRUNC, S_IRUSR|S_IWUSR );
888 # endif
889 #endif
890
891   if (fd == -1 )
892     log_info (_("can't create `%s': %s\n"), seed_file_name, strerror(errno) );
893   else if (lock_seed_file (fd, seed_file_name, 1))
894     {
895       close (fd);
896     }
897 #if LOCK_SEED_FILE
898   else if (ftruncate (fd, 0))
899     {
900       log_info(_("can't write `%s': %s\n"), seed_file_name, strerror(errno));
901       close (fd);
902     }
903 #endif /*LOCK_SEED_FILE*/
904   else
905     {
906       do
907         {
908           i = write (fd, keypool, POOLSIZE );
909         }
910       while (i == -1 && errno == EINTR);
911       if (i != POOLSIZE)
912         log_info (_("can't write `%s': %s\n"),seed_file_name, strerror(errno));
913       if (close(fd))
914         log_info (_("can't close `%s': %s\n"),seed_file_name, strerror(errno));
915     }
916
917   unlock_pool ();
918 }
919
920
921 /* Read random out of the pool.  This function is the core of the
922    public random functions.  Note that Level GCRY_WEAK_RANDOM is not
923    anymore handled special and in fact is an alias in the API for
924    level GCRY_STRONG_RANDOM.  Must be called with the pool already
925    locked.  */
926 static void
927 read_pool (byte *buffer, size_t length, int level)
928 {
929   int i;
930   unsigned long *sp, *dp;
931   /* The volatile is there to make sure the compiler does not optimize
932      the code away in case the getpid function is badly attributed.
933      Note that we keep a pid in a static variable as well as in a
934      stack based one; the latter is to detect ill behaving thread
935      libraries, ignoring the pool mutexes. */
936   static volatile pid_t my_pid = (pid_t)(-1);
937   volatile pid_t my_pid2;
938
939   gcry_assert (pool_is_locked);
940
941  retry:
942   /* Get our own pid, so that we can detect a fork. */
943   my_pid2 = getpid ();
944   if (my_pid == (pid_t)(-1))
945     my_pid = my_pid2;
946   if ( my_pid != my_pid2 )
947     {
948       /* We detected a plain fork; i.e. we are now the child.  Update
949          the static pid and add some randomness. */
950       pid_t x;
951
952       my_pid = my_pid2;
953       x = my_pid;
954       add_randomness (&x, sizeof(x), RANDOM_ORIGIN_INIT);
955       just_mixed = 0; /* Make sure it will get mixed. */
956     }
957
958   gcry_assert (pool_is_locked);
959
960   /* Our code does not allow to extract more than POOLSIZE.  Better
961      check it here. */
962   if (length > POOLSIZE)
963     {
964       log_bug("too many random bits requested\n");
965     }
966
967   if (!pool_filled)
968     {
969       if (read_seed_file() )
970         pool_filled = 1;
971     }
972
973   /* For level 2 quality (key generation) we always make sure that the
974      pool has been seeded enough initially. */
975   if (level == GCRY_VERY_STRONG_RANDOM && !did_initial_extra_seeding)
976     {
977       size_t needed;
978
979       pool_balance = 0;
980       needed = length - pool_balance;
981       if (needed < POOLSIZE/2)
982         needed = POOLSIZE/2;
983       else if( needed > POOLSIZE )
984         BUG ();
985       read_random_source (RANDOM_ORIGIN_EXTRAPOLL, needed,
986                           GCRY_VERY_STRONG_RANDOM);
987       pool_balance += needed;
988       did_initial_extra_seeding = 1;
989     }
990
991   /* For level 2 make sure that there is enough random in the pool. */
992   if (level == GCRY_VERY_STRONG_RANDOM && pool_balance < length)
993     {
994       size_t needed;
995
996       if (pool_balance < 0)
997         pool_balance = 0;
998       needed = length - pool_balance;
999       if (needed > POOLSIZE)
1000         BUG ();
1001       read_random_source (RANDOM_ORIGIN_EXTRAPOLL, needed,
1002                           GCRY_VERY_STRONG_RANDOM);
1003       pool_balance += needed;
1004     }
1005
1006   /* Make sure the pool is filled. */
1007   while (!pool_filled)
1008     random_poll();
1009
1010   /* Always do a fast random poll (we have to use the unlocked version). */
1011   do_fast_random_poll();
1012
1013   /* Mix the pid in so that we for sure won't deliver the same random
1014      after a fork. */
1015   {
1016     pid_t apid = my_pid;
1017     add_randomness (&apid, sizeof (apid), RANDOM_ORIGIN_INIT);
1018   }
1019
1020   /* Mix the pool (if add_randomness() didn't it). */
1021   if (!just_mixed)
1022     {
1023       mix_pool(rndpool);
1024       rndstats.mixrnd++;
1025     }
1026
1027   /* Create a new pool. */
1028   for(i=0,dp=(unsigned long*)keypool, sp=(unsigned long*)rndpool;
1029       i < POOLWORDS; i++, dp++, sp++ )
1030     *dp = *sp + ADD_VALUE;
1031
1032   /* Mix both pools. */
1033   mix_pool(rndpool); rndstats.mixrnd++;
1034   mix_pool(keypool); rndstats.mixkey++;
1035
1036   /* Read the requested data.  We use a read pointer to read from a
1037      different position each time.  */
1038   while (length--)
1039     {
1040       *buffer++ = keypool[pool_readpos++];
1041       if (pool_readpos >= POOLSIZE)
1042         pool_readpos = 0;
1043       pool_balance--;
1044     }
1045
1046   if (pool_balance < 0)
1047     pool_balance = 0;
1048
1049   /* Clear the keypool. */
1050   memset (keypool, 0, POOLSIZE);
1051
1052   /* We need to detect whether a fork has happened.  A fork might have
1053      an identical pool and thus the child and the parent could emit
1054      the very same random number.  This test here is to detect forks
1055      in a multi-threaded process.  It does not work with all thread
1056      implementations in particular not with pthreads.  However it is
1057      good enough for GNU Pth. */
1058   if ( getpid () != my_pid2 )
1059     {
1060       pid_t x = getpid();
1061       add_randomness (&x, sizeof(x), RANDOM_ORIGIN_INIT);
1062       just_mixed = 0; /* Make sure it will get mixed. */
1063       my_pid = x;     /* Also update the static pid. */
1064       goto retry;
1065     }
1066 }
1067
1068
1069
1070 /* Add LENGTH bytes of randomness from buffer to the pool.  ORIGIN is
1071    used to specify the randomness origin.  This is one of the
1072    RANDOM_ORIGIN_* values. */
1073 static void
1074 add_randomness (const void *buffer, size_t length, enum random_origins origin)
1075 {
1076   const unsigned char *p = buffer;
1077   size_t count = 0;
1078
1079   gcry_assert (pool_is_locked);
1080
1081   rndstats.addbytes += length;
1082   rndstats.naddbytes++;
1083   while (length-- )
1084     {
1085       rndpool[pool_writepos++] ^= *p++;
1086       count++;
1087       if (pool_writepos >= POOLSIZE )
1088         {
1089           /* It is possible that we are invoked before the pool is
1090              filled using an unreliable origin of entropy, for example
1091              the fast random poll.  To avoid flagging the pool as
1092              filled in this case, we track the initial filling state
1093              separately.  See also the remarks about the seed file. */
1094           if (origin >= RANDOM_ORIGIN_SLOWPOLL && !pool_filled)
1095             {
1096               pool_filled_counter += count;
1097               count = 0;
1098               if (pool_filled_counter >= POOLSIZE)
1099                 pool_filled = 1;
1100             }
1101           pool_writepos = 0;
1102           mix_pool(rndpool); rndstats.mixrnd++;
1103           just_mixed = !length;
1104         }
1105     }
1106 }
1107
1108
1109
1110 static void
1111 random_poll()
1112 {
1113   rndstats.slowpolls++;
1114   read_random_source (RANDOM_ORIGIN_SLOWPOLL, POOLSIZE/5, GCRY_STRONG_RANDOM);
1115 }
1116
1117
1118 /* Runtime determination of the slow entropy gathering module.  */
1119 static int (*
1120 getfnc_gather_random (void))(void (*)(const void*, size_t,
1121                                       enum random_origins),
1122                              enum random_origins, size_t, int)
1123 {
1124   int (*fnc)(void (*)(const void*, size_t, enum random_origins),
1125              enum random_origins, size_t, int);
1126
1127 #if USE_RNDLINUX
1128   if ( !access (NAME_OF_DEV_RANDOM, R_OK)
1129        && !access (NAME_OF_DEV_URANDOM, R_OK))
1130     {
1131       fnc = _gcry_rndlinux_gather_random;
1132       return fnc;
1133     }
1134 #endif
1135
1136 #if USE_RNDEGD
1137   if ( _gcry_rndegd_connect_socket (1) != -1 )
1138     {
1139       fnc = _gcry_rndegd_gather_random;
1140       return fnc;
1141     }
1142 #endif
1143
1144 #if USE_RNDUNIX
1145   fnc = _gcry_rndunix_gather_random;
1146   return fnc;
1147 #endif
1148
1149 #if USE_RNDW32
1150   fnc = _gcry_rndw32_gather_random;
1151   return fnc;
1152 #endif
1153
1154 #if USE_RNDW32CE
1155   fnc = _gcry_rndw32ce_gather_random;
1156   return fnc;
1157 #endif
1158
1159   log_fatal (_("no entropy gathering module detected\n"));
1160
1161   return NULL; /*NOTREACHED*/
1162 }
1163
1164 /* Runtime determination of the fast entropy gathering function.
1165    (Currently a compile time method is used.)  */
1166 static void (*
1167 getfnc_fast_random_poll (void))( void (*)(const void*, size_t,
1168                                           enum random_origins),
1169                                  enum random_origins)
1170 {
1171 #if USE_RNDW32
1172   return _gcry_rndw32_gather_random_fast;
1173 #endif
1174 #if USE_RNDW32CE
1175   return _gcry_rndw32ce_gather_random_fast;
1176 #endif
1177   return NULL;
1178 }
1179
1180
1181
1182 static void
1183 do_fast_random_poll (void)
1184 {
1185   gcry_assert (pool_is_locked);
1186
1187   rndstats.fastpolls++;
1188
1189   if (fast_gather_fnc)
1190     fast_gather_fnc (add_randomness, RANDOM_ORIGIN_FASTPOLL);
1191
1192   /* Continue with the generic functions. */
1193 #if HAVE_GETHRTIME
1194   {
1195     hrtime_t tv;
1196     tv = gethrtime();
1197     add_randomness( &tv, sizeof(tv), RANDOM_ORIGIN_FASTPOLL );
1198   }
1199 #elif HAVE_GETTIMEOFDAY
1200   {
1201     struct timeval tv;
1202     if( gettimeofday( &tv, NULL ) )
1203       BUG();
1204     add_randomness( &tv.tv_sec, sizeof(tv.tv_sec), RANDOM_ORIGIN_FASTPOLL );
1205     add_randomness( &tv.tv_usec, sizeof(tv.tv_usec), RANDOM_ORIGIN_FASTPOLL );
1206   }
1207 #elif HAVE_CLOCK_GETTIME
1208   {     struct timespec tv;
1209   if( clock_gettime( CLOCK_REALTIME, &tv ) == -1 )
1210     BUG();
1211   add_randomness( &tv.tv_sec, sizeof(tv.tv_sec), RANDOM_ORIGIN_FASTPOLL );
1212   add_randomness( &tv.tv_nsec, sizeof(tv.tv_nsec), RANDOM_ORIGIN_FASTPOLL );
1213   }
1214 #else /* use times */
1215 # ifndef HAVE_DOSISH_SYSTEM
1216   {     struct tms buf;
1217   times( &buf );
1218   add_randomness( &buf, sizeof buf, RANDOM_ORIGIN_FASTPOLL );
1219   }
1220 # endif
1221 #endif
1222
1223 #ifdef HAVE_GETRUSAGE
1224 # ifdef RUSAGE_SELF
1225   {
1226     struct rusage buf;
1227     /* QNX/Neutrino does return ENOSYS - so we just ignore it and add
1228        whatever is in buf.  In a chroot environment it might not work
1229        at all (i.e. because /proc/ is not accessible), so we better
1230        ignore all error codes and hope for the best. */
1231     getrusage (RUSAGE_SELF, &buf );
1232     add_randomness( &buf, sizeof buf, RANDOM_ORIGIN_FASTPOLL );
1233     memset( &buf, 0, sizeof buf );
1234   }
1235 # else /*!RUSAGE_SELF*/
1236 #  ifdef __GCC__
1237 #   warning There is no RUSAGE_SELF on this system
1238 #  endif
1239 # endif /*!RUSAGE_SELF*/
1240 #endif /*HAVE_GETRUSAGE*/
1241
1242   /* Time and clock are availabe on all systems - so we better do it
1243      just in case one of the above functions didn't work.  */
1244   {
1245     time_t x = time(NULL);
1246     add_randomness( &x, sizeof(x), RANDOM_ORIGIN_FASTPOLL );
1247   }
1248   {
1249     clock_t x = clock();
1250     add_randomness( &x, sizeof(x), RANDOM_ORIGIN_FASTPOLL );
1251   }
1252
1253   /* If the system features a fast hardware RNG, read some bytes from
1254      there.  */
1255   _gcry_rndhw_poll_fast (add_randomness, RANDOM_ORIGIN_FASTPOLL);
1256 }
1257
1258
1259 /* The fast random pool function as called at some places in
1260    libgcrypt.  This is merely a wrapper to make sure that this module
1261    is initialized and to lock the pool.  Note, that this function is a
1262    NOP unless a random function has been used or _gcry_initialize (1)
1263    has been used.  We use this hack so that the internal use of this
1264    function in cipher_open and md_open won't start filling up the
1265    random pool, even if no random will be required by the process. */
1266 void
1267 _gcry_rngcsprng_fast_poll (void)
1268 {
1269   initialize_basics ();
1270
1271   lock_pool ();
1272   if (rndpool)
1273     {
1274       /* Yes, we are fully initialized. */
1275       do_fast_random_poll ();
1276     }
1277   unlock_pool ();
1278 }
1279
1280
1281
1282 static void
1283 read_random_source (enum random_origins orgin, size_t length, int level )
1284 {
1285   if ( !slow_gather_fnc )
1286     log_fatal ("Slow entropy gathering module not yet initialized\n");
1287
1288   if ( slow_gather_fnc (add_randomness, orgin, length, level) < 0)
1289     log_fatal ("No way to gather entropy for the RNG\n");
1290 }
1291
1292
1293 static int
1294 gather_faked (void (*add)(const void*, size_t, enum random_origins),
1295               enum random_origins origin, size_t length, int level )
1296 {
1297   static int initialized=0;
1298   size_t n;
1299   char *buffer, *p;
1300
1301   (void)add;
1302   (void)level;
1303
1304   if ( !initialized )
1305     {
1306       log_info(_("WARNING: using insecure random number generator!!\n"));
1307       initialized=1;
1308 #ifdef HAVE_RAND
1309       srand( time(NULL)*getpid());
1310 #else
1311       srandom( time(NULL)*getpid());
1312 #endif
1313     }
1314
1315   p = buffer = gcry_xmalloc( length );
1316   n = length;
1317 #ifdef HAVE_RAND
1318   while ( n-- )
1319     *p++ = ((unsigned)(1 + (int) (256.0*rand()/(RAND_MAX+1.0)))-1);
1320 #else
1321   while ( n-- )
1322     *p++ = ((unsigned)(1 + (int) (256.0*random()/(RAND_MAX+1.0)))-1);
1323 #endif
1324   add_randomness ( buffer, length, origin );
1325   gcry_free (buffer);
1326   return 0; /* okay */
1327 }