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