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