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