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