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