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