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