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