39c49a70bef9c80dce3842a5933acd8fd27f7424
[libgcrypt.git] / random / random-csprng.c
1 /* random-csprng.c - CSPRNG style random number generator (libgcrypt clssic)
2  * Copyright (C) 1998, 2000, 2001, 2002, 2003, 2004, 2005, 2006,
3  *               2007, 2008  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 paper: "Software Generation of Practically Strong
24    Random Numbers". See also chapter 6 in his book "Cryptographic
25    Security Architecture", New York, 2004, ISBN 0-387-95387-6.
26  */
27
28
29 #include <config.h>
30 #include <stdio.h>
31 #include <stdlib.h>
32 #include <errno.h>
33 #include <string.h>
34 #include <sys/time.h>
35 #include <sys/types.h>
36 #include <sys/stat.h>
37 #include <unistd.h>
38 #include <fcntl.h>
39 #include <time.h>
40 #ifdef  HAVE_GETHRTIME
41 #include <sys/times.h>
42 #endif
43 #ifdef HAVE_GETTIMEOFDAY
44 #include <sys/time.h>
45 #endif
46 #ifdef HAVE_GETRUSAGE
47 #include <sys/resource.h>
48 #endif
49 #ifdef __MINGW32__
50 #include <process.h>
51 #endif
52 #include "g10lib.h"
53 #include "../cipher/rmd.h"
54 #include "random.h"
55 #include "rand-internal.h"
56 #include "cipher.h" /* Required for the rmd160_hash_buffer() prototype.  */
57 #include "ath.h"
58
59 #ifndef RAND_MAX   /* For SunOS. */
60 #define RAND_MAX 32767
61 #endif
62
63 /* Check whether we can lock the seed file read write. */
64 #if defined(HAVE_FCNTL) && defined(HAVE_FTRUNCATE) && !defined(HAVE_W32_SYSTEM)
65 #define LOCK_SEED_FILE 1
66 #else
67 #define LOCK_SEED_FILE 0
68 #endif
69
70 /* Define the constant we use for transforming the pool at read-out. */
71 #if SIZEOF_UNSIGNED_LONG == 8
72 #define ADD_VALUE 0xa5a5a5a5a5a5a5a5
73 #elif SIZEOF_UNSIGNED_LONG == 4
74 #define ADD_VALUE 0xa5a5a5a5
75 #else
76 #error weird size for an unsigned long
77 #endif
78
79 /* Contstants pertaining to the hash pool. */
80 #define BLOCKLEN  64   /* Hash this amount of bytes... */
81 #define DIGESTLEN 20   /* ... into a digest of this length (rmd160). */
82 /* POOLBLOCKS is the number of digests which make up the pool.  */
83 #define POOLBLOCKS 30
84 /* POOLSIZE must be a multiple of the digest length to make the AND
85    operations faster, the size should also be a multiple of unsigned
86    long.  */
87 #define POOLSIZE (POOLBLOCKS*DIGESTLEN)
88 #if (POOLSIZE % SIZEOF_UNSIGNED_LONG)
89 #error Please make sure that poolsize is a multiple of unsigned long
90 #endif
91 #define POOLWORDS (POOLSIZE / SIZEOF_UNSIGNED_LONG)
92
93
94 /* RNDPOOL is the pool we use to collect the entropy and to stir it
95    up.  Its allocated size is POOLSIZE+BLOCKLEN.  Note that this is
96    also an indication on whether the module has been fully
97    initialized. */
98 static unsigned char *rndpool;  
99
100 /* KEYPOOL is used as a scratch copy to read out random from RNDPOOL.
101    Its allocated size is also POOLSIZE+BLOCKLEN.  */
102 static unsigned char *keypool;  
103
104 /* This is the offset into RNDPOOL where the next random bytes are to
105    be mixed in.  */
106 static size_t pool_writepos;
107
108 /* When reading data out of KEYPOOL, we start the read at different
109    positions.  This variable keeps track on where to read next.  */
110 static size_t pool_readpos;
111
112 /* This flag is set to true as soon as the pool has been completely
113    filled the first time.  This may happen either by rereading a seed
114    file or by adding enough entropy.  */
115 static int pool_filled;
116
117 /* This counter is used to track whether the initial seeding has been
118    done with enough bytes from a reliable entropy source.  */
119 static size_t pool_filled_counter;
120
121 /* If random of level GCRY_VERY_STRONG_RANDOM has been requested we
122    have stricter requirements on what kind of entropy is in the pool.
123    In particular POOL_FILLED is not sufficient.  Thus we add some
124    extra seeding and set this flag to true if the extra seeding has
125    been done.  */
126 static int did_initial_extra_seeding;
127
128 /* This variable is used to estimated the amount of fresh entropy
129    available in RNDPOOL.  */
130 static int pool_balance;
131
132 /* After a mixing operation this variable will be set to true and
133    cleared if new entropy has been added or a remix is required for
134    otehr reasons.  */
135 static int just_mixed;
136
137 /* The name of the seed file or NULL if no seed file has been defined.
138    The seed file needs to be regsitered at initialiation time.  We
139    keep a malloced copy here.  */
140 static char *seed_file_name;
141
142 /* If a seed file has been registered and maybe updated on exit this
143    flag set. */
144 static int allow_seed_file_update;
145
146 /* Option flag set at initialiation time to force allocation of the
147    pool in secure memory.  */
148 static int secure_alloc;
149
150 /* This function pointer is set to the actual entropy gathering
151    function during initailization.  After initialization it is
152    guaranteed to point to function.  (On systems without a random
153    gatherer module a dummy function is used).*/
154 static int (*slow_gather_fnc)(void (*)(const void*, size_t,
155                                        enum random_origins),
156                               enum random_origins, size_t, int);
157
158 /* This function is set to the actual fast entropy gathering fucntion
159    during initialization.  If it is NULL, no such function is
160    available. */
161 static void (*fast_gather_fnc)(void (*)(const void*, size_t,
162                                         enum random_origins),
163                                enum random_origins);
164
165
166 /* Option flag useful for debugging and the test suite.  If set
167    requests for very strong random are degraded to strong random.  Not
168    used by regular applications.  */
169 static int quick_test;
170
171 /* On systems without entropy gathering modules, this flag is set to
172    indicate that the random generator is not working properly.  A
173    warning message is issued as well.  This is useful only for
174    debugging and during development.  */
175 static int faked_rng;
176
177 /* This is the lock we use to protect all pool operations.  */
178 static ath_mutex_t pool_lock = ATH_MUTEX_INITIALIZER;
179
180 /* This is a helper for assert calls.  These calls are used to assert
181    that functions are called in a locked state.  It is not meant to be
182    thread-safe but as a method to get aware of missing locks in the
183    test suite.  */
184 static int pool_is_locked;
185
186 /* This is the lock we use to protect the buffer used by the nonce
187    generation.  */
188 static ath_mutex_t nonce_buffer_lock = ATH_MUTEX_INITIALIZER;
189
190
191 /* We keep some counters in this structure for the sake of the
192    _gcry_random_dump_stats () function.  */
193 static struct
194 {
195   unsigned long mixrnd;
196   unsigned long mixkey;
197   unsigned long slowpolls;
198   unsigned long fastpolls;
199   unsigned long getbytes1;
200   unsigned long ngetbytes1;
201   unsigned long getbytes2;
202   unsigned long ngetbytes2;
203   unsigned long addbytes;
204   unsigned long naddbytes;
205 } rndstats;
206
207
208
209 /* --- Stuff pertaining to the random daemon support. --- */
210 #ifdef USE_RANDOM_DAEMON
211
212 /* If ALLOW_DAEMON is true, the module will try to use the random
213    daemon first.  If the daemon has failed, this variable is set to
214    back to false and the code continues as normal.  Note, we don't
215    test this flag in a locked state because a wrong value does not
216    harm and the trhead will find out itself that the daemon does not
217    work and set it (again) to false.  */
218 static int allow_daemon;       
219
220 /* During initialization, the user may set a non-default socket name
221    for accessing the random daemon.  If this value is NULL, the
222    default name will be used. */
223 static char *daemon_socket_name;
224
225 #endif /*USE_RANDOM_DAEMON*/
226
227
228
229 /* ---  Prototypes  --- */
230 static void read_pool (byte *buffer, size_t length, int level );
231 static void add_randomness (const void *buffer, size_t length, 
232                             enum random_origins origin);
233 static void random_poll (void);
234 static void do_fast_random_poll (void);
235 static int (*getfnc_gather_random (void))(void (*)(const void*, size_t, 
236                                                    enum random_origins), 
237                                           enum random_origins, size_t, int);
238 static void (*getfnc_fast_random_poll (void))(void (*)(const void*, size_t,
239                                                        enum random_origins),
240                                               enum random_origins);
241 static void read_random_source (enum random_origins origin,
242                                 size_t length, int level);
243 static int gather_faked (void (*add)(const void*, size_t, enum random_origins),
244                          enum random_origins, size_t length, int level );
245
246
247 \f
248 /* ---  Functions  --- */
249
250
251 /* Basic initialization which is required to initialize mutexes and
252    such.  It does not run a full initialization so that the filling of
253    the random pool can be delayed until it is actually needed.  We
254    assume that this function is used before any concurrent access
255    happens. */
256 static void
257 initialize_basics(void)
258 {
259   static int initialized;
260   int err;
261
262   if (!initialized)
263     {
264       initialized = 1;
265       err = ath_mutex_init (&pool_lock);
266       if (err)
267         log_fatal ("failed to create the pool lock: %s\n", strerror (err) );
268       
269       err = ath_mutex_init (&nonce_buffer_lock);
270       if (err)
271         log_fatal ("failed to create the nonce buffer lock: %s\n",
272                    strerror (err) );
273
274 #ifdef USE_RANDOM_DAEMON
275       _gcry_daemon_initialize_basics ();
276 #endif /*USE_RANDOM_DAEMON*/
277
278       /* Make sure that we are still using the values we have
279          traditionally used for the random levels.  */
280       gcry_assert (GCRY_WEAK_RANDOM == 0 
281                    && GCRY_STRONG_RANDOM == 1
282                    && GCRY_VERY_STRONG_RANDOM == 2);
283     }
284 }
285
286 /* Take the pool lock. */
287 static void
288 lock_pool (void)
289 {
290   int err; 
291
292   err = ath_mutex_lock (&pool_lock);
293   if (err)
294     log_fatal ("failed to acquire the pool lock: %s\n", strerror (err));
295   pool_is_locked = 1;
296 }
297
298 /* Release the pool lock. */
299 static void
300 unlock_pool (void)
301 {
302   int err; 
303
304   pool_is_locked = 0;
305   err = ath_mutex_unlock (&pool_lock);
306   if (err)
307     log_fatal ("failed to release the pool lock: %s\n", strerror (err));
308 }
309
310
311 /* Full initialization of this module. */
312 static void
313 initialize(void)
314 {
315   /* Although the basic initialization should have happened already,
316      we call it here to make sure that all prerequisites are met.  */
317   initialize_basics ();
318
319   /* Now we can look the pool and complete the initialization if
320      necessary.  */
321   lock_pool ();
322   if (!rndpool)
323     {
324       /* The data buffer is allocated somewhat larger, so that we can
325          use this extra space (which is allocated in secure memory) as
326          a temporary hash buffer */
327       rndpool = (secure_alloc
328                  ? gcry_xcalloc_secure (1, POOLSIZE + BLOCKLEN)
329                  : gcry_xcalloc (1, POOLSIZE + BLOCKLEN));
330       keypool = (secure_alloc
331                  ? gcry_xcalloc_secure (1, POOLSIZE + BLOCKLEN)
332                  : gcry_xcalloc (1, POOLSIZE + BLOCKLEN));
333
334       /* Setup the slow entropy gathering function.  The code requires
335          that this function exists. */
336       slow_gather_fnc = getfnc_gather_random ();
337       if (!slow_gather_fnc)
338         {
339           faked_rng = 1;
340           slow_gather_fnc = gather_faked;
341         }
342       
343       /* Setup the fast entropy gathering function.  */
344       fast_gather_fnc = getfnc_fast_random_poll ();
345
346     }
347   unlock_pool ();
348 }
349
350
351
352
353 /* Initialize this random subsystem.  If FULL is false, this function
354    merely calls the initialize and does not do anything more.  Doing
355    this is not really required but when running in a threaded
356    environment we might get a race condition otherwise. */
357 void
358 _gcry_rngcsprng_initialize (int full)
359 {
360   if (!full)
361     initialize_basics ();
362   else
363     initialize ();
364 }
365
366
367 void
368 _gcry_rngcsprng_dump_stats (void)
369 {
370   /* In theory we would need to lock the stats here.  However this
371      function is usually called during cleanup and then we _might_ run
372      into problems.  */
373
374   log_info ("random usage: poolsize=%d mixed=%lu polls=%lu/%lu added=%lu/%lu\n"
375             "              outmix=%lu getlvl1=%lu/%lu getlvl2=%lu/%lu%s\n",
376             POOLSIZE, rndstats.mixrnd, rndstats.slowpolls, rndstats.fastpolls,
377             rndstats.naddbytes, rndstats.addbytes,
378             rndstats.mixkey, rndstats.ngetbytes1, rndstats.getbytes1,
379             rndstats.ngetbytes2, rndstats.getbytes2,
380             _gcry_rndhw_failed_p()? " (hwrng failed)":"");
381 }
382
383
384 /* This function should be called during initialization and before
385    intialization of this module to place the random pools into secure
386    memory.  */
387 void
388 _gcry_rngcsprng_secure_alloc (void)
389 {
390   secure_alloc = 1;
391 }
392
393
394 /* This may be called before full initialization to degrade the
395    quality of the RNG for the sake of a faster running test suite.  */
396 void
397 _gcry_rngcsprng_enable_quick_gen (void)
398 {
399   quick_test = 1;
400 }
401
402
403 void
404 _gcry_rngcsprng_set_daemon_socket (const char *socketname)
405 {
406 #ifdef USE_RANDOM_DAEMON
407   if (daemon_socket_name)
408     BUG ();
409
410   daemon_socket_name = gcry_xstrdup (socketname);
411 #else /*!USE_RANDOM_DAEMON*/
412   (void)socketname;
413 #endif /*!USE_RANDOM_DAEMON*/
414 }
415
416 /* With ONOFF set to 1, enable the use of the daemon.  With ONOFF set
417    to 0, disable the use of the daemon.  With ONOF set to -1, return
418    whether the daemon has been enabled. */
419 int
420 _gcry_rngcsprng_use_daemon (int onoff)
421 {
422 #ifdef USE_RANDOM_DAEMON
423   int last;
424   
425   /* This is not really thread safe.  However it is expected that this
426      function is being called during initialization and at that point
427      we are for other reasons not really thread safe.  We do not want
428      to lock it because we might eventually decide that this function
429      may even be called prior to gcry_check_version.  */
430   last = allow_daemon;
431   if (onoff != -1)
432     allow_daemon = onoff;
433
434   return last;
435 #else /*!USE_RANDOM_DAEMON*/
436   (void)onoff;
437   return 0;
438 #endif /*!USE_RANDOM_DAEMON*/
439 }
440
441
442 /* This function returns true if no real RNG is available or the
443    quality of the RNG has been degraded for test purposes.  */
444 int
445 _gcry_rngcsprng_is_faked (void)
446 {
447   /* We need to initialize due to the runtime determination of
448      available entropy gather modules.  */
449   initialize();
450   return (faked_rng || quick_test);
451 }
452
453
454 /* Add BUFLEN bytes from BUF to the internal random pool.  QUALITY
455    should be in the range of 0..100 to indicate the goodness of the
456    entropy added, or -1 for goodness not known.  */
457 gcry_error_t
458 _gcry_rngcsprng_add_bytes (const void *buf, size_t buflen, int quality)
459 {
460   size_t nbytes;
461   const char *bufptr;
462
463   if (quality == -1)
464     quality = 35;
465   else if (quality > 100)
466     quality = 100;
467   else if (quality < 0)
468     quality = 0;
469       
470   if (!buf)
471     return gpg_error (GPG_ERR_INV_ARG);
472
473   if (!buflen || quality < 10)
474     return 0; /* Take a shortcut. */
475
476   /* Because we don't increment the entropy estimation with FASTPOLL,
477      we don't need to take lock that estimation while adding from an
478      external source.  This limited entropy estimation also means that
479      we can't take QUALITY into account.  */
480   initialize_basics ();
481   bufptr = buf;
482   while (buflen)
483     {
484       nbytes = buflen > POOLSIZE? POOLSIZE : buflen;
485       lock_pool ();
486       if (rndpool)
487         add_randomness (bufptr, nbytes, RANDOM_ORIGIN_EXTERNAL);
488       unlock_pool ();
489       bufptr += nbytes;
490       buflen -= nbytes;
491     }
492   return 0;
493 }   
494
495     
496 /* Public function to fill the buffer with LENGTH bytes of
497    cryptographically strong random bytes.  Level GCRY_WEAK_RANDOM is
498    not very strong, GCRY_STRONG_RANDOM is strong enough for most
499    usage, GCRY_VERY_STRONG_RANDOM is good for key generation stuff but
500    may be very slow.  */
501 void
502 _gcry_rngcsprng_randomize (void *buffer, size_t length,
503                            enum gcry_random_level level)
504 {
505   unsigned char *p;
506
507   /* Make sure we are initialized. */
508   initialize ();
509
510   /* Handle our hack used for regression tests of Libgcrypt. */
511   if ( quick_test && level > GCRY_STRONG_RANDOM )
512     level = GCRY_STRONG_RANDOM;
513
514   /* Make sure the level is okay. */
515   level &= 3;
516
517 #ifdef USE_RANDOM_DAEMON
518   if (allow_daemon
519       && !_gcry_daemon_randomize (daemon_socket_name, buffer, length, level))
520     return; /* The daemon succeeded. */
521   allow_daemon = 0; /* Daemon failed - switch off. */
522 #endif /*USE_RANDOM_DAEMON*/
523
524   /* Acquire the pool lock. */
525   lock_pool ();
526
527   /* Update the statistics. */
528   if (level >= GCRY_VERY_STRONG_RANDOM)
529     {
530       rndstats.getbytes2 += length;
531       rndstats.ngetbytes2++;
532     }
533   else
534     {
535       rndstats.getbytes1 += length;
536       rndstats.ngetbytes1++;
537     }
538
539   /* Read the random into the provided buffer. */
540   for (p = buffer; length > 0;)
541     {
542       size_t n;
543
544       n = length > POOLSIZE? POOLSIZE : length;
545       read_pool (p, n, level);
546       length -= n;
547       p += n;
548     }
549
550   /* Release the pool lock. */
551   unlock_pool ();
552 }
553
554
555
556
557 /*
558    Mix the pool:
559
560    |........blocks*20byte........|20byte|..44byte..|
561    <..44byte..>           <20byte> 
562         |                    |
563         |                    +------+
564         +---------------------------|----------+
565                                     v          v
566    |........blocks*20byte........|20byte|..44byte..|
567                                  <.....64bytes.....>   
568                                          |
569       +----------------------------------+
570      Hash
571       v
572    |.............................|20byte|..44byte..|
573    <20byte><20byte><..44byte..>
574       |                |
575       |                +---------------------+
576       +-----------------------------+        |
577                                     v        v
578    |.............................|20byte|..44byte..|
579                                  <.....64byte......>
580                                         |
581               +-------------------------+
582              Hash
583               v
584    |.............................|20byte|..44byte..|
585    <20byte><20byte><..44byte..>
586
587    and so on until we did this for all blocks. 
588
589    To better protect against implementation errors in this code, we
590    xor a digest of the entire pool into the pool before mixing.
591
592    Note: this function must only be called with a locked pool.
593  */
594 static void
595 mix_pool(unsigned char *pool)
596 {
597   static unsigned char failsafe_digest[DIGESTLEN];
598   static int failsafe_digest_valid;
599
600   unsigned char *hashbuf = pool + POOLSIZE;
601   unsigned char *p, *pend;
602   int i, n;
603   RMD160_CONTEXT md;
604
605 #if DIGESTLEN != 20
606 #error must have a digest length of 20 for ripe-md-160
607 #endif
608
609   gcry_assert (pool_is_locked);
610   _gcry_rmd160_init( &md );
611
612   /* Loop over the pool.  */
613   pend = pool + POOLSIZE;
614   memcpy(hashbuf, pend - DIGESTLEN, DIGESTLEN );
615   memcpy(hashbuf+DIGESTLEN, pool, BLOCKLEN-DIGESTLEN);
616   _gcry_rmd160_mixblock( &md, hashbuf);
617   memcpy(pool, hashbuf, 20 );
618
619   if (failsafe_digest_valid && pool == rndpool)
620     {
621       for (i=0; i < 20; i++)
622         pool[i] ^= failsafe_digest[i];
623     }
624   
625   p = pool;
626   for (n=1; n < POOLBLOCKS; n++)
627     {
628       memcpy (hashbuf, p, DIGESTLEN);
629
630       p += DIGESTLEN;
631       if (p+DIGESTLEN+BLOCKLEN < pend)
632         memcpy (hashbuf+DIGESTLEN, p+DIGESTLEN, BLOCKLEN-DIGESTLEN);
633       else 
634         {
635           unsigned char *pp = p + DIGESTLEN;
636           
637           for (i=DIGESTLEN; i < BLOCKLEN; i++ )
638             {
639               if ( pp >= pend )
640                 pp = pool;
641               hashbuf[i] = *pp++;
642             }
643         }
644       
645       _gcry_rmd160_mixblock ( &md, hashbuf);
646       memcpy(p, hashbuf, 20 );
647     }
648
649     /* Our hash implementation does only leave small parts (64 bytes)
650        of the pool on the stack, so it is okay not to require secure
651        memory here.  Before we use this pool, it will be copied to the
652        help buffer anyway. */
653     if ( pool == rndpool)
654       {
655         _gcry_rmd160_hash_buffer (failsafe_digest, pool, POOLSIZE);
656         failsafe_digest_valid = 1;
657       }
658
659     _gcry_burn_stack (384); /* for the rmd160_mixblock(), rmd160_hash_buffer */
660 }
661
662
663 void
664 _gcry_rngcsprng_set_seed_file (const char *name)
665 {
666   if (seed_file_name)
667     BUG ();
668   seed_file_name = gcry_xstrdup (name);
669 }
670
671
672 /* Lock an open file identified by file descriptor FD and wait a
673    reasonable time to succeed.  With FOR_WRITE set to true a write
674    lock will be taken.  FNAME is used only for diagnostics. Returns 0
675    on success or -1 on error. */
676 static int
677 lock_seed_file (int fd, const char *fname, int for_write)
678 {
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 inital
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   log_fatal (_("no entropy gathering module detected\n"));
1141
1142   return NULL; /*NOTREACHED*/
1143 }
1144
1145 /* Runtime determination of the fast entropy gathering function.
1146    (Currently a compile time method is used.)  */
1147 static void (*
1148 getfnc_fast_random_poll (void))( void (*)(const void*, size_t,
1149                                           enum random_origins),
1150                                  enum random_origins)
1151 {
1152 #if USE_RNDW32
1153   return _gcry_rndw32_gather_random_fast;
1154 #endif
1155   return NULL;
1156 }
1157
1158
1159
1160 static void
1161 do_fast_random_poll (void)
1162 {
1163   gcry_assert (pool_is_locked);
1164
1165   rndstats.fastpolls++;
1166
1167   if (fast_gather_fnc)
1168     fast_gather_fnc (add_randomness, RANDOM_ORIGIN_FASTPOLL);
1169
1170   /* Continue with the generic functions. */
1171 #if HAVE_GETHRTIME
1172   {     
1173     hrtime_t tv;
1174     tv = gethrtime();
1175     add_randomness( &tv, sizeof(tv), RANDOM_ORIGIN_FASTPOLL );
1176   }
1177 #elif HAVE_GETTIMEOFDAY
1178   {     
1179     struct timeval tv;
1180     if( gettimeofday( &tv, NULL ) )
1181       BUG();
1182     add_randomness( &tv.tv_sec, sizeof(tv.tv_sec), RANDOM_ORIGIN_FASTPOLL );
1183     add_randomness( &tv.tv_usec, sizeof(tv.tv_usec), RANDOM_ORIGIN_FASTPOLL );
1184   }
1185 #elif HAVE_CLOCK_GETTIME
1186   {     struct timespec tv;
1187   if( clock_gettime( CLOCK_REALTIME, &tv ) == -1 )
1188     BUG();
1189   add_randomness( &tv.tv_sec, sizeof(tv.tv_sec), RANDOM_ORIGIN_FASTPOLL );
1190   add_randomness( &tv.tv_nsec, sizeof(tv.tv_nsec), RANDOM_ORIGIN_FASTPOLL );
1191   }
1192 #else /* use times */
1193 # ifndef HAVE_DOSISH_SYSTEM
1194   {     struct tms buf;
1195   times( &buf );
1196   add_randomness( &buf, sizeof buf, RANDOM_ORIGIN_FASTPOLL );
1197   }
1198 # endif
1199 #endif
1200
1201 #ifdef HAVE_GETRUSAGE
1202 # ifdef RUSAGE_SELF
1203   {     
1204     struct rusage buf;
1205     /* QNX/Neutrino does return ENOSYS - so we just ignore it and add
1206        whatever is in buf.  In a chroot environment it might not work
1207        at all (i.e. because /proc/ is not accessible), so we better
1208        ignore all error codes and hope for the best. */
1209     getrusage (RUSAGE_SELF, &buf );
1210     add_randomness( &buf, sizeof buf, RANDOM_ORIGIN_FASTPOLL );
1211     memset( &buf, 0, sizeof buf );
1212   }
1213 # else /*!RUSAGE_SELF*/
1214 #  ifdef __GCC__
1215 #   warning There is no RUSAGE_SELF on this system
1216 #  endif
1217 # endif /*!RUSAGE_SELF*/
1218 #endif /*HAVE_GETRUSAGE*/
1219
1220   /* Time and clock are availabe on all systems - so we better do it
1221      just in case one of the above functions didn't work.  */
1222   {
1223     time_t x = time(NULL);
1224     add_randomness( &x, sizeof(x), RANDOM_ORIGIN_FASTPOLL );
1225   }
1226   {     
1227     clock_t x = clock();
1228     add_randomness( &x, sizeof(x), RANDOM_ORIGIN_FASTPOLL );
1229   }
1230
1231   /* If the system features a fast hardware RNG, read some bytes from
1232      there.  */
1233   _gcry_rndhw_poll_fast (add_randomness, RANDOM_ORIGIN_FASTPOLL);
1234 }
1235
1236
1237 /* The fast random pool function as called at some places in
1238    libgcrypt.  This is merely a wrapper to make sure that this module
1239    is initalized and to look the pool.  Note, that this function is a
1240    NOP unless a random function has been used or _gcry_initialize (1)
1241    has been used.  We use this hack so that the internal use of this
1242    function in cipher_open and md_open won't start filling up the
1243    random pool, even if no random will be required by the process. */
1244 void
1245 _gcry_rngcsprng_fast_poll (void)
1246 {
1247   initialize_basics ();
1248
1249   lock_pool ();
1250   if (rndpool)
1251     {
1252       /* Yes, we are fully initialized. */
1253       do_fast_random_poll ();
1254     }
1255   unlock_pool ();
1256 }
1257
1258
1259
1260 static void
1261 read_random_source (enum random_origins orgin, size_t length, int level )
1262 {
1263   if ( !slow_gather_fnc )
1264     log_fatal ("Slow entropy gathering module not yet initialized\n");
1265
1266   if ( slow_gather_fnc (add_randomness, orgin, length, level) < 0)
1267     log_fatal ("No way to gather entropy for the RNG\n");
1268 }
1269
1270
1271 static int
1272 gather_faked (void (*add)(const void*, size_t, enum random_origins),
1273               enum random_origins origin, size_t length, int level )
1274 {
1275   static int initialized=0;
1276   size_t n;
1277   char *buffer, *p;
1278   
1279   (void)add;
1280   (void)level;
1281   
1282   if ( !initialized )
1283     {
1284       log_info(_("WARNING: using insecure random number generator!!\n"));
1285       initialized=1;
1286 #ifdef HAVE_RAND
1287       srand( time(NULL)*getpid());
1288 #else
1289       srandom( time(NULL)*getpid());
1290 #endif
1291     }
1292
1293   p = buffer = gcry_xmalloc( length );
1294   n = length;
1295 #ifdef HAVE_RAND
1296   while ( n-- )
1297     *p++ = ((unsigned)(1 + (int) (256.0*rand()/(RAND_MAX+1.0)))-1);
1298 #else
1299   while ( n-- )
1300     *p++ = ((unsigned)(1 + (int) (256.0*random()/(RAND_MAX+1.0)))-1);
1301 #endif
1302   add_randomness ( buffer, length, origin );
1303   gcry_free (buffer);
1304   return 0; /* okay */
1305 }
1306
1307
1308 /* Create an unpredicable nonce of LENGTH bytes in BUFFER. */
1309 void
1310 _gcry_rngcsprng_create_nonce (void *buffer, size_t length)
1311 {
1312   static unsigned char nonce_buffer[20+8];
1313   static int nonce_buffer_initialized = 0;
1314   static volatile pid_t my_pid; /* The volatile is there to make sure the
1315                                    compiler does not optimize the code away
1316                                    in case the getpid function is badly
1317                                    attributed. */
1318   volatile pid_t apid;
1319   unsigned char *p;
1320   size_t n;
1321   int err;
1322
1323   /* Make sure we are initialized. */
1324   initialize ();
1325
1326 #ifdef USE_RANDOM_DAEMON
1327   if (allow_daemon
1328       && !_gcry_daemon_create_nonce (daemon_socket_name, buffer, length))
1329     return; /* The daemon succeeded. */
1330   allow_daemon = 0; /* Daemon failed - switch off. */
1331 #endif /*USE_RANDOM_DAEMON*/
1332
1333   /* Acquire the nonce buffer lock. */
1334   err = ath_mutex_lock (&nonce_buffer_lock);
1335   if (err)
1336     log_fatal ("failed to acquire the nonce buffer lock: %s\n",
1337                strerror (err));
1338
1339   apid = getpid ();
1340   /* The first time intialize our buffer. */
1341   if (!nonce_buffer_initialized)
1342     {
1343       time_t atime = time (NULL);
1344       pid_t xpid = apid;
1345
1346       my_pid = apid;
1347
1348       if ((sizeof apid + sizeof atime) > sizeof nonce_buffer)
1349         BUG ();
1350
1351       /* Initialize the first 20 bytes with a reasonable value so that
1352          a failure of gcry_randomize won't affect us too much.  Don't
1353          care about the uninitialized remaining bytes. */
1354       p = nonce_buffer;
1355       memcpy (p, &xpid, sizeof xpid);
1356       p += sizeof xpid;
1357       memcpy (p, &atime, sizeof atime); 
1358
1359       /* Initialize the never changing private part of 64 bits. */
1360       gcry_randomize (nonce_buffer+20, 8, GCRY_WEAK_RANDOM);
1361
1362       nonce_buffer_initialized = 1;
1363     }
1364   else if ( my_pid != apid )
1365     {
1366       /* We forked. Need to reseed the buffer - doing this for the
1367          private part should be sufficient. */
1368       gcry_randomize (nonce_buffer+20, 8, GCRY_WEAK_RANDOM);
1369       /* Update the pid so that we won't run into here again and
1370          again. */
1371       my_pid = apid;
1372     }
1373
1374   /* Create the nonce by hashing the entire buffer, returning the hash
1375      and updating the first 20 bytes of the buffer with this hash. */
1376   for (p = buffer; length > 0; length -= n, p += n)
1377     {
1378       _gcry_sha1_hash_buffer (nonce_buffer,
1379                               nonce_buffer, sizeof nonce_buffer);
1380       n = length > 20? 20 : length;
1381       memcpy (p, nonce_buffer, n);
1382     }
1383
1384
1385   /* Release the nonce buffer lock. */
1386   err = ath_mutex_unlock (&nonce_buffer_lock);
1387   if (err)
1388     log_fatal ("failed to release the nonce buffer lock: %s\n",
1389                strerror (err));
1390
1391 }