9921c4fd4ffb7b57924f6749bd36e88d7841a27e
[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 initailization.  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 void
365 _gcry_rngcsprng_dump_stats (void)
366 {
367   /* In theory we would need to lock the stats here.  However this
368      function is usually called during cleanup and then we _might_ run
369      into problems.  */
370
371   log_info ("random usage: poolsize=%d mixed=%lu polls=%lu/%lu added=%lu/%lu\n"
372             "              outmix=%lu getlvl1=%lu/%lu getlvl2=%lu/%lu%s\n",
373             POOLSIZE, rndstats.mixrnd, rndstats.slowpolls, rndstats.fastpolls,
374             rndstats.naddbytes, rndstats.addbytes,
375             rndstats.mixkey, rndstats.ngetbytes1, rndstats.getbytes1,
376             rndstats.ngetbytes2, rndstats.getbytes2,
377             _gcry_rndhw_failed_p()? " (hwrng failed)":"");
378 }
379
380
381 /* This function should be called during initialization and before
382    initialization of this module to place the random pools into secure
383    memory.  */
384 void
385 _gcry_rngcsprng_secure_alloc (void)
386 {
387   secure_alloc = 1;
388 }
389
390
391 /* This may be called before full initialization to degrade the
392    quality of the RNG for the sake of a faster running test suite.  */
393 void
394 _gcry_rngcsprng_enable_quick_gen (void)
395 {
396   quick_test = 1;
397 }
398
399
400 void
401 _gcry_rngcsprng_set_daemon_socket (const char *socketname)
402 {
403 #ifdef USE_RANDOM_DAEMON
404   if (daemon_socket_name)
405     BUG ();
406
407   daemon_socket_name = gcry_xstrdup (socketname);
408 #else /*!USE_RANDOM_DAEMON*/
409   (void)socketname;
410 #endif /*!USE_RANDOM_DAEMON*/
411 }
412
413 /* With ONOFF set to 1, enable the use of the daemon.  With ONOFF set
414    to 0, disable the use of the daemon.  With ONOF set to -1, return
415    whether the daemon has been enabled. */
416 int
417 _gcry_rngcsprng_use_daemon (int onoff)
418 {
419 #ifdef USE_RANDOM_DAEMON
420   int last;
421
422   /* This is not really thread safe.  However it is expected that this
423      function is being called during initialization and at that point
424      we are for other reasons not really thread safe.  We do not want
425      to lock it because we might eventually decide that this function
426      may even be called prior to gcry_check_version.  */
427   last = allow_daemon;
428   if (onoff != -1)
429     allow_daemon = onoff;
430
431   return last;
432 #else /*!USE_RANDOM_DAEMON*/
433   (void)onoff;
434   return 0;
435 #endif /*!USE_RANDOM_DAEMON*/
436 }
437
438
439 /* This function returns true if no real RNG is available or the
440    quality of the RNG has been degraded for test purposes.  */
441 int
442 _gcry_rngcsprng_is_faked (void)
443 {
444   /* We need to initialize due to the runtime determination of
445      available entropy gather modules.  */
446   initialize();
447   return (faked_rng || quick_test);
448 }
449
450
451 /* Add BUFLEN bytes from BUF to the internal random pool.  QUALITY
452    should be in the range of 0..100 to indicate the goodness of the
453    entropy added, or -1 for goodness not known.  */
454 gcry_error_t
455 _gcry_rngcsprng_add_bytes (const void *buf, size_t buflen, int quality)
456 {
457   size_t nbytes;
458   const char *bufptr;
459
460   if (quality == -1)
461     quality = 35;
462   else if (quality > 100)
463     quality = 100;
464   else if (quality < 0)
465     quality = 0;
466
467   if (!buf)
468     return gpg_error (GPG_ERR_INV_ARG);
469
470   if (!buflen || quality < 10)
471     return 0; /* Take a shortcut. */
472
473   /* Because we don't increment the entropy estimation with FASTPOLL,
474      we don't need to take lock that estimation while adding from an
475      external source.  This limited entropy estimation also means that
476      we can't take QUALITY into account.  */
477   initialize_basics ();
478   bufptr = buf;
479   while (buflen)
480     {
481       nbytes = buflen > POOLSIZE? POOLSIZE : buflen;
482       lock_pool ();
483       if (rndpool)
484         add_randomness (bufptr, nbytes, RANDOM_ORIGIN_EXTERNAL);
485       unlock_pool ();
486       bufptr += nbytes;
487       buflen -= nbytes;
488     }
489   return 0;
490 }
491
492
493 /* Public function to fill the buffer with LENGTH bytes of
494    cryptographically strong random bytes.  Level GCRY_WEAK_RANDOM is
495    not very strong, GCRY_STRONG_RANDOM is strong enough for most
496    usage, GCRY_VERY_STRONG_RANDOM is good for key generation stuff but
497    may be very slow.  */
498 void
499 _gcry_rngcsprng_randomize (void *buffer, size_t length,
500                            enum gcry_random_level level)
501 {
502   unsigned char *p;
503
504   /* Make sure we are initialized. */
505   initialize ();
506
507   /* Handle our hack used for regression tests of Libgcrypt. */
508   if ( quick_test && level > GCRY_STRONG_RANDOM )
509     level = GCRY_STRONG_RANDOM;
510
511   /* Make sure the level is okay. */
512   level &= 3;
513
514 #ifdef USE_RANDOM_DAEMON
515   if (allow_daemon
516       && !_gcry_daemon_randomize (daemon_socket_name, buffer, length, level))
517     return; /* The daemon succeeded. */
518   allow_daemon = 0; /* Daemon failed - switch off. */
519 #endif /*USE_RANDOM_DAEMON*/
520
521   /* Acquire the pool lock. */
522   lock_pool ();
523
524   /* Update the statistics. */
525   if (level >= GCRY_VERY_STRONG_RANDOM)
526     {
527       rndstats.getbytes2 += length;
528       rndstats.ngetbytes2++;
529     }
530   else
531     {
532       rndstats.getbytes1 += length;
533       rndstats.ngetbytes1++;
534     }
535
536   /* Read the random into the provided buffer. */
537   for (p = buffer; length > 0;)
538     {
539       size_t n;
540
541       n = length > POOLSIZE? POOLSIZE : length;
542       read_pool (p, n, level);
543       length -= n;
544       p += n;
545     }
546
547   /* Release the pool lock. */
548   unlock_pool ();
549 }
550
551
552
553
554 /*
555    Mix the pool:
556
557    |........blocks*20byte........|20byte|..44byte..|
558    <..44byte..>           <20byte>
559         |                    |
560         |                    +------+
561         +---------------------------|----------+
562                                     v          v
563    |........blocks*20byte........|20byte|..44byte..|
564                                  <.....64bytes.....>
565                                          |
566       +----------------------------------+
567      Hash
568       v
569    |.............................|20byte|..44byte..|
570    <20byte><20byte><..44byte..>
571       |                |
572       |                +---------------------+
573       +-----------------------------+        |
574                                     v        v
575    |.............................|20byte|..44byte..|
576                                  <.....64byte......>
577                                         |
578               +-------------------------+
579              Hash
580               v
581    |.............................|20byte|..44byte..|
582    <20byte><20byte><..44byte..>
583
584    and so on until we did this for all blocks.
585
586    To better protect against implementation errors in this code, we
587    xor a digest of the entire pool into the pool before mixing.
588
589    Note: this function must only be called with a locked pool.
590  */
591 static void
592 mix_pool(unsigned char *pool)
593 {
594   static unsigned char failsafe_digest[DIGESTLEN];
595   static int failsafe_digest_valid;
596
597   unsigned char *hashbuf = pool + POOLSIZE;
598   unsigned char *p, *pend;
599   int i, n;
600   RMD160_CONTEXT md;
601
602 #if DIGESTLEN != 20
603 #error must have a digest length of 20 for ripe-md-160
604 #endif
605
606   gcry_assert (pool_is_locked);
607   _gcry_rmd160_init( &md );
608
609   /* Loop over the pool.  */
610   pend = pool + POOLSIZE;
611   memcpy(hashbuf, pend - DIGESTLEN, DIGESTLEN );
612   memcpy(hashbuf+DIGESTLEN, pool, BLOCKLEN-DIGESTLEN);
613   _gcry_rmd160_mixblock( &md, hashbuf);
614   memcpy(pool, hashbuf, 20 );
615
616   if (failsafe_digest_valid && pool == rndpool)
617     {
618       for (i=0; i < 20; i++)
619         pool[i] ^= failsafe_digest[i];
620     }
621
622   p = pool;
623   for (n=1; n < POOLBLOCKS; n++)
624     {
625       memcpy (hashbuf, p, DIGESTLEN);
626
627       p += DIGESTLEN;
628       if (p+DIGESTLEN+BLOCKLEN < pend)
629         memcpy (hashbuf+DIGESTLEN, p+DIGESTLEN, BLOCKLEN-DIGESTLEN);
630       else
631         {
632           unsigned char *pp = p + DIGESTLEN;
633
634           for (i=DIGESTLEN; i < BLOCKLEN; i++ )
635             {
636               if ( pp >= pend )
637                 pp = pool;
638               hashbuf[i] = *pp++;
639             }
640         }
641
642       _gcry_rmd160_mixblock ( &md, hashbuf);
643       memcpy(p, hashbuf, 20 );
644     }
645
646     /* Our hash implementation does only leave small parts (64 bytes)
647        of the pool on the stack, so it is okay not to require secure
648        memory here.  Before we use this pool, it will be copied to the
649        help buffer anyway. */
650     if ( pool == rndpool)
651       {
652         _gcry_rmd160_hash_buffer (failsafe_digest, pool, POOLSIZE);
653         failsafe_digest_valid = 1;
654       }
655
656     _gcry_burn_stack (384); /* for the rmd160_mixblock(), rmd160_hash_buffer */
657 }
658
659
660 void
661 _gcry_rngcsprng_set_seed_file (const char *name)
662 {
663   if (seed_file_name)
664     BUG ();
665   seed_file_name = gcry_xstrdup (name);
666 }
667
668
669 /* Lock an open file identified by file descriptor FD and wait a
670    reasonable time to succeed.  With FOR_WRITE set to true a write
671    lock will be taken.  FNAME is used only for diagnostics. Returns 0
672    on success or -1 on error. */
673 static int
674 lock_seed_file (int fd, const char *fname, int for_write)
675 {
676 #ifdef __GCC__
677 #warning Check whether we can lock on Windows.
678 #endif
679 #if LOCK_SEED_FILE
680   struct flock lck;
681   struct timeval tv;
682   int backoff=0;
683
684   /* We take a lock on the entire file. */
685   memset (&lck, 0, sizeof lck);
686   lck.l_type = for_write? F_WRLCK : F_RDLCK;
687   lck.l_whence = SEEK_SET;
688
689   while (fcntl (fd, F_SETLK, &lck) == -1)
690     {
691       if (errno != EAGAIN && errno != EACCES)
692         {
693           log_info (_("can't lock `%s': %s\n"), fname, strerror (errno));
694           return -1;
695         }
696
697       if (backoff > 2) /* Show the first message after ~2.25 seconds. */
698         log_info( _("waiting for lock on `%s'...\n"), fname);
699
700       tv.tv_sec = backoff;
701       tv.tv_usec = 250000;
702       select (0, NULL, NULL, NULL, &tv);
703       if (backoff < 10)
704         backoff++ ;
705     }
706 #endif /*!LOCK_SEED_FILE*/
707   return 0;
708 }
709
710
711 /* Read in a seed from the random_seed file and return true if this
712    was successful.
713
714    Note: Multiple instances of applications sharing the same random
715    seed file can be started in parallel, in which case they will read
716    out the same pool and then race for updating it (the last update
717    overwrites earlier updates).  They will differentiate only by the
718    weak entropy that is added in read_seed_file based on the PID and
719    clock, and up to 16 bytes of weak random non-blockingly.  The
720    consequence is that the output of these different instances is
721    correlated to some extent.  In the perfect scenario, the attacker
722    can control (or at least guess) the PID and clock of the
723    application, and drain the system's entropy pool to reduce the "up
724    to 16 bytes" above to 0.  Then the dependencies of the initial
725    states of the pools are completely known.  */
726 static int
727 read_seed_file (void)
728 {
729   int fd;
730   struct stat sb;
731   unsigned char buffer[POOLSIZE];
732   int n;
733
734   gcry_assert (pool_is_locked);
735
736   if (!seed_file_name)
737     return 0;
738
739 #ifdef HAVE_DOSISH_SYSTEM
740   fd = open( seed_file_name, O_RDONLY | O_BINARY );
741 #else
742   fd = open( seed_file_name, O_RDONLY );
743 #endif
744   if( fd == -1 && errno == ENOENT)
745     {
746       allow_seed_file_update = 1;
747       return 0;
748     }
749
750   if (fd == -1 )
751     {
752       log_info(_("can't open `%s': %s\n"), seed_file_name, strerror(errno) );
753       return 0;
754     }
755   if (lock_seed_file (fd, seed_file_name, 0))
756     {
757       close (fd);
758       return 0;
759     }
760   if (fstat( fd, &sb ) )
761     {
762       log_info(_("can't stat `%s': %s\n"), seed_file_name, strerror(errno) );
763       close(fd);
764       return 0;
765     }
766   if (!S_ISREG(sb.st_mode) )
767     {
768       log_info(_("`%s' is not a regular file - ignored\n"), seed_file_name );
769       close(fd);
770       return 0;
771     }
772   if (!sb.st_size )
773     {
774       log_info(_("note: random_seed file is empty\n") );
775       close(fd);
776       allow_seed_file_update = 1;
777       return 0;
778     }
779   if (sb.st_size != POOLSIZE )
780     {
781       log_info(_("warning: invalid size of random_seed file - not used\n") );
782       close(fd);
783       return 0;
784     }
785
786   do
787     {
788       n = read( fd, buffer, POOLSIZE );
789     }
790   while (n == -1 && errno == EINTR );
791
792   if (n != POOLSIZE)
793     {
794       log_fatal(_("can't read `%s': %s\n"), seed_file_name,strerror(errno) );
795       close(fd);/*NOTREACHED*/
796       return 0;
797     }
798
799   close(fd);
800
801   add_randomness( buffer, POOLSIZE, RANDOM_ORIGIN_INIT );
802   /* add some minor entropy to the pool now (this will also force a mixing) */
803   {
804     pid_t x = getpid();
805     add_randomness( &x, sizeof(x), RANDOM_ORIGIN_INIT );
806   }
807   {
808     time_t x = time(NULL);
809     add_randomness( &x, sizeof(x), RANDOM_ORIGIN_INIT );
810   }
811   {
812     clock_t x = clock();
813     add_randomness( &x, sizeof(x), RANDOM_ORIGIN_INIT );
814   }
815
816   /* And read a few bytes from our entropy source.  By using a level
817    * of 0 this will not block and might not return anything with some
818    * entropy drivers, however the rndlinux driver will use
819    * /dev/urandom and return some stuff - Do not read too much as we
820    * want to be friendly to the scare system entropy resource. */
821   read_random_source ( RANDOM_ORIGIN_INIT, 16, GCRY_WEAK_RANDOM );
822
823   allow_seed_file_update = 1;
824   return 1;
825 }
826
827
828 void
829 _gcry_rngcsprng_update_seed_file (void)
830 {
831   unsigned long *sp, *dp;
832   int fd, i;
833
834   /* We do only a basic initialization so that we can lock the pool.
835      This is required to cope with the case that this function is
836      called by some cleanup code at a point where the RNG has never
837      been initialized.  */
838   initialize_basics ();
839   lock_pool ();
840
841   if ( !seed_file_name || !rndpool || !pool_filled )
842     {
843       unlock_pool ();
844       return;
845     }
846   if ( !allow_seed_file_update )
847     {
848       unlock_pool ();
849       log_info(_("note: random_seed file not updated\n"));
850       return;
851     }
852
853   /* At this point we know that there is something in the pool and
854      thus we can conclude that the pool has been fully initialized.  */
855
856
857   /* Copy the entropy pool to a scratch pool and mix both of them. */
858   for (i=0,dp=(unsigned long*)keypool, sp=(unsigned long*)rndpool;
859        i < POOLWORDS; i++, dp++, sp++ )
860     {
861       *dp = *sp + ADD_VALUE;
862     }
863   mix_pool(rndpool); rndstats.mixrnd++;
864   mix_pool(keypool); rndstats.mixkey++;
865
866 #if defined(HAVE_DOSISH_SYSTEM) || defined(__CYGWIN__)
867   fd = open (seed_file_name, O_WRONLY|O_CREAT|O_TRUNC|O_BINARY,
868              S_IRUSR|S_IWUSR );
869 #else
870 # if LOCK_SEED_FILE
871     fd = open (seed_file_name, O_WRONLY|O_CREAT, S_IRUSR|S_IWUSR );
872 # else
873     fd = open (seed_file_name, O_WRONLY|O_CREAT|O_TRUNC, S_IRUSR|S_IWUSR );
874 # endif
875 #endif
876
877   if (fd == -1 )
878     log_info (_("can't create `%s': %s\n"), seed_file_name, strerror(errno) );
879   else if (lock_seed_file (fd, seed_file_name, 1))
880     {
881       close (fd);
882     }
883 #if LOCK_SEED_FILE
884   else if (ftruncate (fd, 0))
885     {
886       log_info(_("can't write `%s': %s\n"), seed_file_name, strerror(errno));
887       close (fd);
888     }
889 #endif /*LOCK_SEED_FILE*/
890   else
891     {
892       do
893         {
894           i = write (fd, keypool, POOLSIZE );
895         }
896       while (i == -1 && errno == EINTR);
897       if (i != POOLSIZE)
898         log_info (_("can't write `%s': %s\n"),seed_file_name, strerror(errno));
899       if (close(fd))
900         log_info (_("can't close `%s': %s\n"),seed_file_name, strerror(errno));
901     }
902
903   unlock_pool ();
904 }
905
906
907 /* Read random out of the pool.  This function is the core of the
908    public random functions.  Note that Level GCRY_WEAK_RANDOM is not
909    anymore handled special and in fact is an alias in the API for
910    level GCRY_STRONG_RANDOM.  Must be called with the pool already
911    locked.  */
912 static void
913 read_pool (byte *buffer, size_t length, int level)
914 {
915   int i;
916   unsigned long *sp, *dp;
917   /* The volatile is there to make sure the compiler does not optimize
918      the code away in case the getpid function is badly attributed.
919      Note that we keep a pid in a static variable as well as in a
920      stack based one; the latter is to detect ill behaving thread
921      libraries, ignoring the pool mutexes. */
922   static volatile pid_t my_pid = (pid_t)(-1);
923   volatile pid_t my_pid2;
924
925   gcry_assert (pool_is_locked);
926
927  retry:
928   /* Get our own pid, so that we can detect a fork. */
929   my_pid2 = getpid ();
930   if (my_pid == (pid_t)(-1))
931     my_pid = my_pid2;
932   if ( my_pid != my_pid2 )
933     {
934       /* We detected a plain fork; i.e. we are now the child.  Update
935          the static pid and add some randomness. */
936       pid_t x;
937
938       my_pid = my_pid2;
939       x = my_pid;
940       add_randomness (&x, sizeof(x), RANDOM_ORIGIN_INIT);
941       just_mixed = 0; /* Make sure it will get mixed. */
942     }
943
944   gcry_assert (pool_is_locked);
945
946   /* Our code does not allow to extract more than POOLSIZE.  Better
947      check it here. */
948   if (length > POOLSIZE)
949     {
950       log_bug("too many random bits requested\n");
951     }
952
953   if (!pool_filled)
954     {
955       if (read_seed_file() )
956         pool_filled = 1;
957     }
958
959   /* For level 2 quality (key generation) we always make sure that the
960      pool has been seeded enough initially. */
961   if (level == GCRY_VERY_STRONG_RANDOM && !did_initial_extra_seeding)
962     {
963       size_t needed;
964
965       pool_balance = 0;
966       needed = length - pool_balance;
967       if (needed < POOLSIZE/2)
968         needed = POOLSIZE/2;
969       else if( needed > POOLSIZE )
970         BUG ();
971       read_random_source (RANDOM_ORIGIN_EXTRAPOLL, needed,
972                           GCRY_VERY_STRONG_RANDOM);
973       pool_balance += needed;
974       did_initial_extra_seeding = 1;
975     }
976
977   /* For level 2 make sure that there is enough random in the pool. */
978   if (level == GCRY_VERY_STRONG_RANDOM && pool_balance < length)
979     {
980       size_t needed;
981
982       if (pool_balance < 0)
983         pool_balance = 0;
984       needed = length - pool_balance;
985       if (needed > POOLSIZE)
986         BUG ();
987       read_random_source (RANDOM_ORIGIN_EXTRAPOLL, needed,
988                           GCRY_VERY_STRONG_RANDOM);
989       pool_balance += needed;
990     }
991
992   /* Make sure the pool is filled. */
993   while (!pool_filled)
994     random_poll();
995
996   /* Always do a fast random poll (we have to use the unlocked version). */
997   do_fast_random_poll();
998
999   /* Mix the pid in so that we for sure won't deliver the same random
1000      after a fork. */
1001   {
1002     pid_t apid = my_pid;
1003     add_randomness (&apid, sizeof (apid), RANDOM_ORIGIN_INIT);
1004   }
1005
1006   /* Mix the pool (if add_randomness() didn't it). */
1007   if (!just_mixed)
1008     {
1009       mix_pool(rndpool);
1010       rndstats.mixrnd++;
1011     }
1012
1013   /* Create a new pool. */
1014   for(i=0,dp=(unsigned long*)keypool, sp=(unsigned long*)rndpool;
1015       i < POOLWORDS; i++, dp++, sp++ )
1016     *dp = *sp + ADD_VALUE;
1017
1018   /* Mix both pools. */
1019   mix_pool(rndpool); rndstats.mixrnd++;
1020   mix_pool(keypool); rndstats.mixkey++;
1021
1022   /* Read the requested data.  We use a read pointer to read from a
1023      different position each time.  */
1024   while (length--)
1025     {
1026       *buffer++ = keypool[pool_readpos++];
1027       if (pool_readpos >= POOLSIZE)
1028         pool_readpos = 0;
1029       pool_balance--;
1030     }
1031
1032   if (pool_balance < 0)
1033     pool_balance = 0;
1034
1035   /* Clear the keypool. */
1036   memset (keypool, 0, POOLSIZE);
1037
1038   /* We need to detect whether a fork has happened.  A fork might have
1039      an identical pool and thus the child and the parent could emit
1040      the very same random number.  This test here is to detect forks
1041      in a multi-threaded process.  It does not work with all thread
1042      implementations in particular not with pthreads.  However it is
1043      good enough for GNU Pth. */
1044   if ( getpid () != my_pid2 )
1045     {
1046       pid_t x = getpid();
1047       add_randomness (&x, sizeof(x), RANDOM_ORIGIN_INIT);
1048       just_mixed = 0; /* Make sure it will get mixed. */
1049       my_pid = x;     /* Also update the static pid. */
1050       goto retry;
1051     }
1052 }
1053
1054
1055
1056 /* Add LENGTH bytes of randomness from buffer to the pool.  ORIGIN is
1057    used to specify the randomness origin.  This is one of the
1058    RANDOM_ORIGIN_* values. */
1059 static void
1060 add_randomness (const void *buffer, size_t length, enum random_origins origin)
1061 {
1062   const unsigned char *p = buffer;
1063   size_t count = 0;
1064
1065   gcry_assert (pool_is_locked);
1066
1067   rndstats.addbytes += length;
1068   rndstats.naddbytes++;
1069   while (length-- )
1070     {
1071       rndpool[pool_writepos++] ^= *p++;
1072       count++;
1073       if (pool_writepos >= POOLSIZE )
1074         {
1075           /* It is possible that we are invoked before the pool is
1076              filled using an unreliable origin of entropy, for example
1077              the fast random poll.  To avoid flagging the pool as
1078              filled in this case, we track the initial filling state
1079              separately.  See also the remarks about the seed file. */
1080           if (origin >= RANDOM_ORIGIN_SLOWPOLL && !pool_filled)
1081             {
1082               pool_filled_counter += count;
1083               count = 0;
1084               if (pool_filled_counter >= POOLSIZE)
1085                 pool_filled = 1;
1086             }
1087           pool_writepos = 0;
1088           mix_pool(rndpool); rndstats.mixrnd++;
1089           just_mixed = !length;
1090         }
1091     }
1092 }
1093
1094
1095
1096 static void
1097 random_poll()
1098 {
1099   rndstats.slowpolls++;
1100   read_random_source (RANDOM_ORIGIN_SLOWPOLL, POOLSIZE/5, GCRY_STRONG_RANDOM);
1101 }
1102
1103
1104 /* Runtime determination of the slow entropy gathering module.  */
1105 static int (*
1106 getfnc_gather_random (void))(void (*)(const void*, size_t,
1107                                       enum random_origins),
1108                              enum random_origins, size_t, int)
1109 {
1110   int (*fnc)(void (*)(const void*, size_t, enum random_origins),
1111              enum random_origins, size_t, int);
1112
1113 #if USE_RNDLINUX
1114   if ( !access (NAME_OF_DEV_RANDOM, R_OK)
1115        && !access (NAME_OF_DEV_URANDOM, R_OK))
1116     {
1117       fnc = _gcry_rndlinux_gather_random;
1118       return fnc;
1119     }
1120 #endif
1121
1122 #if USE_RNDEGD
1123   if ( _gcry_rndegd_connect_socket (1) != -1 )
1124     {
1125       fnc = _gcry_rndegd_gather_random;
1126       return fnc;
1127     }
1128 #endif
1129
1130 #if USE_RNDUNIX
1131   fnc = _gcry_rndunix_gather_random;
1132   return fnc;
1133 #endif
1134
1135 #if USE_RNDW32
1136   fnc = _gcry_rndw32_gather_random;
1137   return fnc;
1138 #endif
1139
1140 #if USE_RNDW32CE
1141   fnc = _gcry_rndw32ce_gather_random;
1142   return fnc;
1143 #endif
1144
1145   log_fatal (_("no entropy gathering module detected\n"));
1146
1147   return NULL; /*NOTREACHED*/
1148 }
1149
1150 /* Runtime determination of the fast entropy gathering function.
1151    (Currently a compile time method is used.)  */
1152 static void (*
1153 getfnc_fast_random_poll (void))( void (*)(const void*, size_t,
1154                                           enum random_origins),
1155                                  enum random_origins)
1156 {
1157 #if USE_RNDW32
1158   return _gcry_rndw32_gather_random_fast;
1159 #endif
1160 #if USE_RNDW32CE
1161   return _gcry_rndw32ce_gather_random_fast;
1162 #endif
1163   return NULL;
1164 }
1165
1166
1167
1168 static void
1169 do_fast_random_poll (void)
1170 {
1171   gcry_assert (pool_is_locked);
1172
1173   rndstats.fastpolls++;
1174
1175   if (fast_gather_fnc)
1176     fast_gather_fnc (add_randomness, RANDOM_ORIGIN_FASTPOLL);
1177
1178   /* Continue with the generic functions. */
1179 #if HAVE_GETHRTIME
1180   {
1181     hrtime_t tv;
1182     tv = gethrtime();
1183     add_randomness( &tv, sizeof(tv), RANDOM_ORIGIN_FASTPOLL );
1184   }
1185 #elif HAVE_GETTIMEOFDAY
1186   {
1187     struct timeval tv;
1188     if( gettimeofday( &tv, NULL ) )
1189       BUG();
1190     add_randomness( &tv.tv_sec, sizeof(tv.tv_sec), RANDOM_ORIGIN_FASTPOLL );
1191     add_randomness( &tv.tv_usec, sizeof(tv.tv_usec), RANDOM_ORIGIN_FASTPOLL );
1192   }
1193 #elif HAVE_CLOCK_GETTIME
1194   {     struct timespec tv;
1195   if( clock_gettime( CLOCK_REALTIME, &tv ) == -1 )
1196     BUG();
1197   add_randomness( &tv.tv_sec, sizeof(tv.tv_sec), RANDOM_ORIGIN_FASTPOLL );
1198   add_randomness( &tv.tv_nsec, sizeof(tv.tv_nsec), RANDOM_ORIGIN_FASTPOLL );
1199   }
1200 #else /* use times */
1201 # ifndef HAVE_DOSISH_SYSTEM
1202   {     struct tms buf;
1203   times( &buf );
1204   add_randomness( &buf, sizeof buf, RANDOM_ORIGIN_FASTPOLL );
1205   }
1206 # endif
1207 #endif
1208
1209 #ifdef HAVE_GETRUSAGE
1210 # ifdef RUSAGE_SELF
1211   {
1212     struct rusage buf;
1213     /* QNX/Neutrino does return ENOSYS - so we just ignore it and add
1214        whatever is in buf.  In a chroot environment it might not work
1215        at all (i.e. because /proc/ is not accessible), so we better
1216        ignore all error codes and hope for the best. */
1217     getrusage (RUSAGE_SELF, &buf );
1218     add_randomness( &buf, sizeof buf, RANDOM_ORIGIN_FASTPOLL );
1219     memset( &buf, 0, sizeof buf );
1220   }
1221 # else /*!RUSAGE_SELF*/
1222 #  ifdef __GCC__
1223 #   warning There is no RUSAGE_SELF on this system
1224 #  endif
1225 # endif /*!RUSAGE_SELF*/
1226 #endif /*HAVE_GETRUSAGE*/
1227
1228   /* Time and clock are availabe on all systems - so we better do it
1229      just in case one of the above functions didn't work.  */
1230   {
1231     time_t x = time(NULL);
1232     add_randomness( &x, sizeof(x), RANDOM_ORIGIN_FASTPOLL );
1233   }
1234   {
1235     clock_t x = clock();
1236     add_randomness( &x, sizeof(x), RANDOM_ORIGIN_FASTPOLL );
1237   }
1238
1239   /* If the system features a fast hardware RNG, read some bytes from
1240      there.  */
1241   _gcry_rndhw_poll_fast (add_randomness, RANDOM_ORIGIN_FASTPOLL);
1242 }
1243
1244
1245 /* The fast random pool function as called at some places in
1246    libgcrypt.  This is merely a wrapper to make sure that this module
1247    is initialized and to lock the pool.  Note, that this function is a
1248    NOP unless a random function has been used or _gcry_initialize (1)
1249    has been used.  We use this hack so that the internal use of this
1250    function in cipher_open and md_open won't start filling up the
1251    random pool, even if no random will be required by the process. */
1252 void
1253 _gcry_rngcsprng_fast_poll (void)
1254 {
1255   initialize_basics ();
1256
1257   lock_pool ();
1258   if (rndpool)
1259     {
1260       /* Yes, we are fully initialized. */
1261       do_fast_random_poll ();
1262     }
1263   unlock_pool ();
1264 }
1265
1266
1267
1268 static void
1269 read_random_source (enum random_origins orgin, size_t length, int level )
1270 {
1271   if ( !slow_gather_fnc )
1272     log_fatal ("Slow entropy gathering module not yet initialized\n");
1273
1274   if ( slow_gather_fnc (add_randomness, orgin, length, level) < 0)
1275     log_fatal ("No way to gather entropy for the RNG\n");
1276 }
1277
1278
1279 static int
1280 gather_faked (void (*add)(const void*, size_t, enum random_origins),
1281               enum random_origins origin, size_t length, int level )
1282 {
1283   static int initialized=0;
1284   size_t n;
1285   char *buffer, *p;
1286
1287   (void)add;
1288   (void)level;
1289
1290   if ( !initialized )
1291     {
1292       log_info(_("WARNING: using insecure random number generator!!\n"));
1293       initialized=1;
1294 #ifdef HAVE_RAND
1295       srand( time(NULL)*getpid());
1296 #else
1297       srandom( time(NULL)*getpid());
1298 #endif
1299     }
1300
1301   p = buffer = gcry_xmalloc( length );
1302   n = length;
1303 #ifdef HAVE_RAND
1304   while ( n-- )
1305     *p++ = ((unsigned)(1 + (int) (256.0*rand()/(RAND_MAX+1.0)))-1);
1306 #else
1307   while ( n-- )
1308     *p++ = ((unsigned)(1 + (int) (256.0*random()/(RAND_MAX+1.0)))-1);
1309 #endif
1310   add_randomness ( buffer, length, origin );
1311   gcry_free (buffer);
1312   return 0; /* okay */
1313 }