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