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