Remove trailing white space from one file
[gnupg.git] / cipher / random.c
1 /* random.c  -  random number generator
2  * Copyright (C) 1998, 1999, 2000, 2001, 2002,
3  *               2003, 2006 Free Software Foundation, Inc.
4  *
5  * This file is part of GnuPG.
6  *
7  * GnuPG is free software; you can redistribute it and/or modify
8  * it under the terms of the GNU General Public License as published by
9  * the Free Software Foundation; either version 3 of the License, or
10  * (at your option) any later version.
11  *
12  * GnuPG 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 General Public License for more details.
16  *
17  * You should have received a copy of the GNU General Public License
18  * along with this program; if not, see <http://www.gnu.org/licenses/>.
19  */
20
21
22 /****************
23  * This random number generator is modelled after the one described
24  * in Peter Gutmann's Paper: "Software Generation of Practically
25  * Strong Random Numbers".
26  */
27
28
29 #include <config.h>
30 #include <stdio.h>
31 #include <stdlib.h>
32 #include <assert.h>
33 #include <errno.h>
34 #include <string.h>
35 #include <time.h>
36 #ifndef _WIN32
37 #include <sys/time.h>
38 #endif
39 #include <sys/types.h>
40 #include <sys/stat.h>
41 #include <unistd.h>
42 #include <fcntl.h>
43 #ifdef HAVE_GETHRTIME
44 #include <sys/times.h>
45 #endif
46 #ifdef HAVE_GETTIMEOFDAY
47 #include <sys/time.h>
48 #endif
49 #ifdef HAVE_TIMES
50 #include <sys/times.h>
51 #endif
52 #ifdef HAVE_GETRUSAGE
53 #include <sys/resource.h>
54 #endif
55 #ifdef _WIN32
56 #include <process.h>
57 #endif
58 #include "util.h"
59 #include "rmd.h"
60 #include "ttyio.h"
61 #include "i18n.h"
62 #include "random.h"
63 #include "rand-internal.h"
64 #include "algorithms.h"
65
66 #ifdef __VMS
67 # include <rmsdef.h>
68 # include "vms.h"
69 #endif /* def __VMS */
70
71 #ifndef RAND_MAX   /* for SunOS */
72 #define RAND_MAX 32767
73 #endif
74
75 /* 2008-03-31  SMS.
76  * VMS C RTL before V8.3 lacks byte-range file locking, but by default,
77  * a file opened for write access is not shared, so mutual exclusion can
78  * most generally be handled at the open().  */
79
80 /* Check whether we can lock the seed file read write. */
81 #if defined(HAVE_FCNTL) && defined(HAVE_FTRUNCATE)      \
82   && !defined(HAVE_W32_SYSTEM) && !defined(__VMS)
83 #define LOCK_SEED_FILE 1
84 #else
85 #define LOCK_SEED_FILE 0
86 #endif
87
88
89 #if SIZEOF_UNSIGNED_LONG == 8
90 #define ADD_VALUE 0xa5a5a5a5a5a5a5a5
91 #elif SIZEOF_UNSIGNED_LONG == 4
92 #define ADD_VALUE 0xa5a5a5a5
93 #else
94 #error weird size for an unsigned long
95 #endif
96
97 #define BLOCKLEN  64   /* hash this amount of bytes */
98 #define DIGESTLEN 20   /* into a digest of this length (rmd160) */
99 /* poolblocks is the number of digests which make up the pool
100  * and poolsize must be a multiple of the digest length
101  * to make the AND operations faster, the size should also be
102  * a multiple of ulong
103  */
104 #define POOLBLOCKS 30
105 #define POOLSIZE (POOLBLOCKS*DIGESTLEN)
106 #if (POOLSIZE % SIZEOF_UNSIGNED_LONG)
107 #error Please make sure that poolsize is a multiple of ulong
108 #endif
109 #define POOLWORDS (POOLSIZE / SIZEOF_UNSIGNED_LONG)
110
111
112 static int is_initialized;
113 #define MASK_LEVEL(a) do {if( a > 2 ) a = 2; else if( a < 0 ) a = 0; } while(0)
114 static char *rndpool;   /* allocated size is POOLSIZE+BLOCKLEN */
115 static char *keypool;   /* allocated size is POOLSIZE+BLOCKLEN */
116 static size_t pool_readpos;
117 static size_t pool_writepos;
118 static int pool_filled;
119 static int pool_balance;
120 static int just_mixed;
121 static int did_initial_extra_seeding;
122 static char *seed_file_name;
123 static int allow_seed_file_update;
124 static int no_seed_file_locking;
125
126 static int secure_alloc;
127 static int quick_test;
128 static int faked_rng;
129
130
131 static void read_pool( byte *buffer, size_t length, int level );
132 static void add_randomness( const void *buffer, size_t length, int source );
133 static void random_poll(void);
134 static void read_random_source( int requester, size_t length, int level);
135 static int gather_faked( void (*add)(const void*, size_t, int), int requester,
136                                                     size_t length, int level );
137
138 static struct {
139     ulong mixrnd;
140     ulong mixkey;
141     ulong slowpolls;
142     ulong fastpolls;
143     ulong getbytes1;
144     ulong ngetbytes1;
145     ulong getbytes2;
146     ulong ngetbytes2;
147     ulong addbytes;
148     ulong naddbytes;
149 } rndstats;
150
151
152 static int (*
153 getfnc_gather_random (void))(void (*)(const void*, size_t, int), int,
154                         size_t, int)
155 {
156 #ifdef USE_ALL_RANDOM_MODULES
157   static int (*fnc)(void (*)(const void*, size_t, int), int, size_t, int);
158
159   if (fnc)
160     return fnc;
161 # ifdef USE_RNDLINUX
162   if ( !access (NAME_OF_DEV_RANDOM, R_OK)
163        && !access (NAME_OF_DEV_URANDOM, R_OK))
164     {
165       fnc = rndlinux_gather_random;
166       return fnc;
167     }
168 # endif
169 # ifdef USE_RNDEGD
170   if ( rndegd_connect_socket (1) != -1 )
171     {
172       fnc = rndegd_gather_random;
173       return fnc;
174     }
175 # endif
176 # ifdef USE_RNDUNIX
177   fnc = rndunix_gather_random;
178   return fnc;
179 # endif
180
181   log_fatal (_("no entropy gathering module detected\n"));
182
183 #else
184 # ifdef USE_RNDLINUX
185   return rndlinux_gather_random;
186 # endif
187 # ifdef USE_RNDUNIX
188   return rndunix_gather_random;
189 # endif
190 # ifdef USE_RNDVMS
191   return rndvms_gather_random;
192 # endif
193 # ifdef USE_RNDEGD
194   return rndegd_gather_random;
195 # endif
196 # ifdef USE_RNDW32
197   return rndw32_gather_random;
198 # endif
199 # ifdef USE_RNDRISCOS
200   return rndriscos_gather_random;
201 # endif
202 #endif
203   return NULL;
204 }
205
206 static int (*
207 getfnc_fast_random_poll (void))( void (*)(const void*, size_t, int), int)
208 {
209 #ifdef USE_RNDW32
210   return rndw32_gather_random_fast;
211 #endif
212   return NULL;
213 }
214
215
216
217 static void
218 initialize(void)
219 {
220     /* The data buffer is allocated somewhat larger, so that
221      * we can use this extra space (which is allocated in secure memory)
222      * as a temporary hash buffer */
223     rndpool = secure_alloc ? xmalloc_secure_clear(POOLSIZE+BLOCKLEN)
224                            : xmalloc_clear(POOLSIZE+BLOCKLEN);
225     keypool = secure_alloc ? xmalloc_secure_clear(POOLSIZE+BLOCKLEN)
226                            : xmalloc_clear(POOLSIZE+BLOCKLEN);
227     is_initialized = 1;
228 }
229
230 static void
231 burn_stack (int bytes)
232 {
233     char buf[128];
234
235     wipememory(buf,sizeof buf);
236     bytes -= sizeof buf;
237     if (bytes > 0)
238         burn_stack (bytes);
239 }
240
241 void
242 random_dump_stats()
243 {
244     fprintf(stderr,
245             "random usage: poolsize=%d mixed=%lu polls=%lu/%lu added=%lu/%lu\n"
246             "              outmix=%lu getlvl1=%lu/%lu getlvl2=%lu/%lu\n",
247         POOLSIZE, rndstats.mixrnd, rndstats.slowpolls, rndstats.fastpolls,
248                   rndstats.naddbytes, rndstats.addbytes,
249         rndstats.mixkey, rndstats.ngetbytes1, rndstats.getbytes1,
250                     rndstats.ngetbytes2, rndstats.getbytes2 );
251 }
252
253 void
254 secure_randoxmalloc()
255 {
256     secure_alloc = 1;
257 }
258
259
260 int
261 quick_random_gen( int onoff )
262 {
263     int last;
264
265     read_random_source(0,0,0); /* init */
266     last = quick_test;
267     if( onoff != -1 )
268         quick_test = onoff;
269     return faked_rng? 1 : last;
270 }
271
272
273 /****************
274  * Fill the buffer with LENGTH bytes of cryptographically strong
275  * random bytes. level 0 is not very strong, 1 is strong enough
276  * for most usage, 2 is good for key generation stuff but may be very slow.
277  */
278 void
279 randomize_buffer( byte *buffer, size_t length, int level )
280 {
281     char *p = get_random_bits( length*8, level, 1 );
282     memcpy( buffer, p, length );
283     xfree(p);
284 }
285
286
287 int
288 random_is_faked()
289 {
290     if( !is_initialized )
291         initialize();
292     return faked_rng || quick_test;
293 }
294
295 /* Disable locking of seed files. */
296 void
297 random_disable_locking ()
298 {
299   no_seed_file_locking = 1;
300 }
301
302 /****************
303  * Return a pointer to a randomized buffer of level 0 and LENGTH bits
304  * caller must free the buffer.
305  * Note: The returned value is rounded up to bytes.
306  */
307 byte *
308 get_random_bits( size_t nbits, int level, int secure )
309 {
310     byte *buf, *p;
311     size_t nbytes = (nbits+7)/8;
312
313     if( quick_test && level > 1 )
314         level = 1;
315     MASK_LEVEL(level);
316     if( level == 1 ) {
317         rndstats.getbytes1 += nbytes;
318         rndstats.ngetbytes1++;
319     }
320     else if( level >= 2 ) {
321         rndstats.getbytes2 += nbytes;
322         rndstats.ngetbytes2++;
323     }
324
325     buf = secure && secure_alloc ? xmalloc_secure( nbytes ) : xmalloc( nbytes );
326     for( p = buf; nbytes > 0; ) {
327         size_t n = nbytes > POOLSIZE? POOLSIZE : nbytes;
328         read_pool( p, n, level );
329         nbytes -= n;
330         p += n;
331     }
332     return buf;
333 }
334
335
336 /****************
337  * Mix the pool
338  */
339 static void
340 mix_pool(byte *pool)
341 {
342     char *hashbuf = pool + POOLSIZE;
343     char *p, *pend;
344     int i, n;
345     RMD160_CONTEXT md;
346
347     rmd160_init( &md );
348 #if DIGESTLEN != 20
349 #error must have a digest length of 20 for ripe-md-160
350 #endif
351     /* loop over the pool */
352     pend = pool + POOLSIZE;
353     memcpy(hashbuf, pend - DIGESTLEN, DIGESTLEN );
354     memcpy(hashbuf+DIGESTLEN, pool, BLOCKLEN-DIGESTLEN);
355     rmd160_mixblock( &md, hashbuf);
356     memcpy(pool, hashbuf, 20 );
357
358     p = pool;
359     for( n=1; n < POOLBLOCKS; n++ ) {
360         memcpy(hashbuf, p, DIGESTLEN );
361
362         p += DIGESTLEN;
363         if( p+DIGESTLEN+BLOCKLEN < pend )
364             memcpy(hashbuf+DIGESTLEN, p+DIGESTLEN, BLOCKLEN-DIGESTLEN);
365         else {
366             char *pp = p+DIGESTLEN;
367             for(i=DIGESTLEN; i < BLOCKLEN; i++ ) {
368                 if( pp >= pend )
369                     pp = pool;
370                 hashbuf[i] = *pp++;
371             }
372         }
373
374         rmd160_mixblock( &md, hashbuf);
375         memcpy(p, hashbuf, 20 );
376     }
377     burn_stack (384); /* for the rmd160_mixblock() */
378 }
379
380
381 void
382 set_random_seed_file( const char *name )
383 {
384     if( seed_file_name )
385         BUG();
386     seed_file_name = xstrdup( name );
387 }
388
389
390 /* Lock an open file identified by file descriptor FD and wait a
391    reasonable time to succeed.  With FOR_WRITE set to true a Rite lock
392    will be taken.  FNAME is used only for diagnostics. Returns 0 on
393    success or -1 on error. */
394 static int
395 lock_seed_file (int fd, const char *fname, int for_write)
396 {
397 #if LOCK_SEED_FILE
398   struct flock lck;
399   struct timeval tv;
400   int backoff=0;
401
402   if (no_seed_file_locking)
403     return 0;
404
405   /* We take a lock on the entire file. */
406   memset (&lck, 0, sizeof lck);
407   lck.l_type = for_write? F_WRLCK : F_RDLCK;
408   lck.l_whence = SEEK_SET;
409
410   while (fcntl (fd, F_SETLK, &lck) == -1)
411     {
412       if (errno != EAGAIN && errno != EACCES)
413         {
414           log_info (_("can't lock `%s': %s\n"), fname, strerror (errno));
415           return -1;
416         }
417
418       if (backoff > 2) /* Show the first message after ~3.75 seconds. */
419         log_info( _("waiting for lock on `%s'...\n"), fname);
420
421       tv.tv_sec = backoff;
422       tv.tv_usec = 250000;
423       select (0, NULL, NULL, NULL, &tv);
424       if (backoff < 10)
425         backoff++ ;
426     }
427 #endif /*LOCK_SEED_FILE*/
428   return 0;
429 }
430
431
432
433 /****************
434  * Read in a seed form the random_seed file
435  * and return true if this was successful
436  */
437 static int
438 read_seed_file(void)
439 {
440     int fd;
441     struct stat sb;
442     unsigned char buffer[POOLSIZE];
443     int n;
444
445     if( !seed_file_name )
446         return 0;
447
448 #if defined(HAVE_DOSISH_SYSTEM) || defined(__CYGWIN__)
449     fd = open( seed_file_name, O_RDONLY | O_BINARY );
450 #elif defined( __VMS)
451     /* We're only reading, so allow others to do anything. */
452     fd = open( seed_file_name, O_RDONLY, 0777, "shr=get,put,upd" );
453 #else
454     fd = open( seed_file_name, O_RDONLY );
455 #endif
456     if( fd == -1 && errno == ENOENT) {
457         allow_seed_file_update = 1;
458         return 0;
459     }
460
461     if( fd == -1 ) {
462         log_info(_("can't open `%s': %s\n"), seed_file_name, strerror(errno) );
463         return 0;
464     }
465     if (lock_seed_file (fd, seed_file_name, 0))
466       {
467         close (fd);
468         return 0;
469       }
470
471     if( fstat( fd, &sb ) ) {
472         log_info(_("can't stat `%s': %s\n"), seed_file_name, strerror(errno) );
473         close(fd);
474         return 0;
475     }
476     if( !S_ISREG(sb.st_mode) ) {
477         log_info(_("`%s' is not a regular file - ignored\n"), seed_file_name );
478         close(fd);
479         return 0;
480     }
481     if( !sb.st_size ) {
482         log_info(_("note: random_seed file is empty\n") );
483         close(fd);
484         allow_seed_file_update = 1;
485         return 0;
486     }
487     if( sb.st_size != POOLSIZE ) {
488         log_info(_("WARNING: invalid size of random_seed file - not used\n") );
489         close(fd);
490         return 0;
491     }
492     do {
493         n = read( fd, buffer, POOLSIZE );
494     } while( n == -1 && errno == EINTR );
495     if( n != POOLSIZE ) {
496         log_fatal(_("can't read `%s': %s\n"), seed_file_name,strerror(errno) );
497         close(fd);
498         return 0;
499     }
500
501     close(fd);
502
503     add_randomness( buffer, POOLSIZE, 0 );
504     /* add some minor entropy to the pool now (this will also force a mixing) */
505     {   pid_t x = getpid();
506         add_randomness( &x, sizeof(x), 0 );
507     }
508     {   time_t x = time(NULL);
509         add_randomness( &x, sizeof(x), 0 );
510     }
511     {   clock_t x = clock();
512         add_randomness( &x, sizeof(x), 0 );
513     }
514     /* And read a few bytes from our entropy source.  By using
515      * a level of 0 this will not block and might not return anything
516      * with some entropy drivers, however the rndlinux driver will use
517      * /dev/urandom and return some stuff - Do not read too much as we
518      * want to be friendly to the scarce system entropy resource. */
519     read_random_source( 0, 16, 0 );
520
521     allow_seed_file_update = 1;
522     return 1;
523 }
524
525 void
526 update_random_seed_file()
527 {
528     ulong *sp, *dp;
529     int fd, i;
530
531     if( !seed_file_name || !is_initialized || !pool_filled )
532         return;
533     if( !allow_seed_file_update ) {
534         log_info(_("note: random_seed file not updated\n"));
535         return;
536     }
537
538
539     /* copy the entropy pool to a scratch pool and mix both of them */
540     for(i=0,dp=(ulong*)keypool, sp=(ulong*)rndpool;
541                                     i < POOLWORDS; i++, dp++, sp++ ) {
542         *dp = *sp + ADD_VALUE;
543     }
544     mix_pool(rndpool); rndstats.mixrnd++;
545     mix_pool(keypool); rndstats.mixkey++;
546
547 #if defined(HAVE_DOSISH_SYSTEM) || defined(__CYGWIN__)
548     fd = open( seed_file_name, O_WRONLY|O_CREAT|O_TRUNC|O_BINARY,
549                                                         S_IRUSR|S_IWUSR );
550 #else
551 # if LOCK_SEED_FILE
552     fd = open( seed_file_name, O_WRONLY|O_CREAT, S_IRUSR|S_IWUSR );
553 # else
554 #  ifdef __VMS
555     /* Open the seed file for exclusive write access, but allow other
556      * readers.  Loop until success.  Complain after a few failures.  */
557     {
558         int backoff = 0;
559
560         while ((fd = open( seed_file_name,
561                            O_WRONLY|O_CREAT,
562                            S_IRUSR|S_IWUSR,
563                            "shr=get")) == -1 )
564         {
565           if ((errno != EVMSERR) || (vaxc$errno != RMS$_FLK))
566             {
567               /* Some unexpected open failure. */
568               log_info (_("can't lock `%s': %s\n"),
569                         seed_file_name, strerror (errno));
570               return;
571             }
572
573           if (backoff > 2) /* Show the first message after ~3.75 seconds. */
574             log_info( _("waiting for lock on `%s'...\n"), seed_file_name);
575
576           wait_vms( backoff+ 0.25);
577           if (backoff < 10)
578             backoff++ ;
579         }
580     }
581 #  else /* !def __VMS */
582     fd = open( seed_file_name, O_WRONLY|O_CREAT|O_TRUNC, S_IRUSR|S_IWUSR );
583 #  endif /* !def __VMS */
584 # endif
585 #endif
586     if( fd == -1 ) {
587         log_info(_("can't create `%s': %s\n"), seed_file_name, strerror(errno));
588         return;
589     }
590
591     if (lock_seed_file (fd, seed_file_name, 1))
592       {
593         close (fd);
594         return;
595       }
596 #if LOCK_SEED_FILE
597     if (ftruncate (fd, 0))
598       {
599         log_info(_("can't write `%s': %s\n"), seed_file_name, strerror(errno));
600         close (fd);
601         return;
602       }
603 #endif /*LOCK_SEED_FILE*/
604
605     do {
606         i = write( fd, keypool, POOLSIZE );
607     } while( i == -1 && errno == EINTR );
608     if( i != POOLSIZE ) {
609         log_info(_("can't write `%s': %s\n"), seed_file_name, strerror(errno) );
610     }
611     if( close(fd) )
612         log_info(_("can't close `%s': %s\n"), seed_file_name, strerror(errno) );
613 }
614
615
616 static void
617 read_pool( byte *buffer, size_t length, int level )
618 {
619     int i;
620     ulong *sp, *dp;
621
622     if( length > POOLSIZE ) {
623         log_bug("too many random bits requested\n");
624     }
625
626     if( !pool_filled ) {
627         if( read_seed_file() )
628             pool_filled = 1;
629     }
630
631     /* For level 2 quality (key generation) we alwas make
632      * sure that the pool has been seeded enough initially */
633     if( level == 2 && !did_initial_extra_seeding ) {
634         size_t needed;
635
636         pool_balance = 0;
637         needed = length - pool_balance;
638         if( needed < POOLSIZE/2 )
639             needed = POOLSIZE/2;
640         else if( needed > POOLSIZE )
641             BUG();
642         read_random_source( 3, needed, 2 );
643         pool_balance += needed;
644         did_initial_extra_seeding=1;
645     }
646
647     /* for level 2 make sure that there is enough random in the pool */
648     if( level == 2 && pool_balance < length ) {
649         size_t needed;
650
651         if( pool_balance < 0 )
652             pool_balance = 0;
653         needed = length - pool_balance;
654         if( needed > POOLSIZE )
655             BUG();
656         read_random_source( 3, needed, 2 );
657         pool_balance += needed;
658     }
659
660     /* make sure the pool is filled */
661     while( !pool_filled )
662         random_poll();
663
664     /* do always a fast random poll */
665     fast_random_poll();
666
667     if( !level ) { /* no need for cryptographic strong random */
668         /* create a new pool */
669         for(i=0,dp=(ulong*)keypool, sp=(ulong*)rndpool;
670                                     i < POOLWORDS; i++, dp++, sp++ )
671             *dp = *sp + ADD_VALUE;
672         /* must mix both pools */
673         mix_pool(rndpool); rndstats.mixrnd++;
674         mix_pool(keypool); rndstats.mixkey++;
675         memcpy( buffer, keypool, length );
676     }
677     else {
678         /* mix the pool (if add_randomness() didn't it) */
679         if( !just_mixed ) {
680             mix_pool(rndpool);
681             rndstats.mixrnd++;
682         }
683         /* create a new pool */
684         for(i=0,dp=(ulong*)keypool, sp=(ulong*)rndpool;
685                                     i < POOLWORDS; i++, dp++, sp++ )
686             *dp = *sp + ADD_VALUE;
687         /* and mix both pools */
688         mix_pool(rndpool); rndstats.mixrnd++;
689         mix_pool(keypool); rndstats.mixkey++;
690         /* read the required data
691          * we use a readpoiter to read from a different postion each
692          * time */
693         while( length-- ) {
694             *buffer++ = keypool[pool_readpos++];
695             if( pool_readpos >= POOLSIZE )
696                 pool_readpos = 0;
697             pool_balance--;
698         }
699         if( pool_balance < 0 )
700             pool_balance = 0;
701         /* and clear the keypool */
702         wipememory(keypool, POOLSIZE);
703     }
704 }
705
706
707 /****************
708  * Add LENGTH bytes of randomness from buffer to the pool.
709  * source may be used to specify the randomness source.
710  * Source is:
711  *      0 - used ony for initialization
712  *      1 - fast random poll function
713  *      2 - normal poll function
714  *      3 - used when level 2 random quality has been requested
715  *          to do an extra pool seed.
716  */
717 static void
718 add_randomness( const void *buffer, size_t length, int source )
719 {
720     const byte *p = buffer;
721
722     if( !is_initialized )
723         initialize();
724     rndstats.addbytes += length;
725     rndstats.naddbytes++;
726     while( length-- ) {
727         rndpool[pool_writepos++] ^= *p++;
728         if( pool_writepos >= POOLSIZE ) {
729             if( source > 1 )
730                 pool_filled = 1;
731             pool_writepos = 0;
732             mix_pool(rndpool); rndstats.mixrnd++;
733             just_mixed = !length;
734         }
735     }
736 }
737
738
739
740 static void
741 random_poll()
742 {
743     rndstats.slowpolls++;
744     read_random_source( 2, POOLSIZE/5, 1 );
745 }
746
747
748 void
749 fast_random_poll()
750 {
751     static int (*fnc)( void (*)(const void*, size_t, int), int) = NULL;
752     static int initialized = 0;
753
754     rndstats.fastpolls++;
755     if( !initialized ) {
756         if( !is_initialized )
757             initialize();
758         initialized = 1;
759         fnc = getfnc_fast_random_poll();
760     }
761     if( fnc ) {
762         (*fnc)( add_randomness, 1 );
763         return;
764     }
765
766     /* fall back to the generic function */
767 #if defined(HAVE_GETHRTIME) && !defined(HAVE_BROKEN_GETHRTIME)
768     {   hrtime_t tv;
769         /* On some Solaris and HPUX system gethrtime raises an SIGILL, but we
770          * checked this with configure */
771         tv = gethrtime();
772         add_randomness( &tv, sizeof(tv), 1 );
773     }
774 #elif defined (HAVE_GETTIMEOFDAY)
775     {   struct timeval tv;
776         if( gettimeofday( &tv, NULL ) )
777             BUG();
778         add_randomness( &tv.tv_sec, sizeof(tv.tv_sec), 1 );
779         add_randomness( &tv.tv_usec, sizeof(tv.tv_usec), 1 );
780     }
781 #elif defined (HAVE_CLOCK_GETTIME)
782     {   struct timespec tv;
783         if( clock_gettime( CLOCK_REALTIME, &tv ) == -1 )
784             BUG();
785         add_randomness( &tv.tv_sec, sizeof(tv.tv_sec), 1 );
786         add_randomness( &tv.tv_nsec, sizeof(tv.tv_nsec), 1 );
787     }
788 #elif defined (HAVE_TIMES)
789     {   struct tms buf;
790         if( times( &buf ) == -1 )
791             BUG();
792         add_randomness( &buf, sizeof buf, 1 );
793     }
794 #endif
795 #ifdef HAVE_GETRUSAGE
796 #ifndef RUSAGE_SELF
797 #ifdef __GCC__
798 #warning There is no RUSAGE_SELF on this system
799 #endif
800 #else
801     {   struct rusage buf;
802         /* QNX/Neutrino does return ENOSYS - so we just ignore it and
803          * add whatever is in buf.  In a chroot environment it might not
804          * work at all (i.e. because /proc/ is not accessible), so we better
805          * ignore all error codes and hope for the best
806          */
807         getrusage( RUSAGE_SELF, &buf );
808
809         add_randomness( &buf, sizeof buf, 1 );
810         wipememory( &buf, sizeof buf );
811     }
812 #endif
813 #endif
814     /* time and clock are available on all systems - so
815      * we better do it just in case one of the above functions
816      * didn't work */
817     {   time_t x = time(NULL);
818         add_randomness( &x, sizeof(x), 1 );
819     }
820     {   clock_t x = clock();
821         add_randomness( &x, sizeof(x), 1 );
822     }
823 }
824
825
826
827 static void
828 read_random_source( int requester, size_t length, int level )
829 {
830     static int (*fnc)(void (*)(const void*, size_t, int), int,
831                                                     size_t, int) = NULL;
832     if( !fnc ) {
833         if( !is_initialized )
834             initialize();
835         fnc = getfnc_gather_random();
836         if( !fnc ) {
837             faked_rng = 1;
838             fnc = gather_faked;
839         }
840         if( !requester && !length && !level )
841             return; /* init only */
842     }
843     if( (*fnc)( add_randomness, requester, length, level ) < 0 )
844         log_fatal("No way to gather entropy for the RNG\n");
845 }
846
847
848 static int
849 gather_faked( void (*add)(const void*, size_t, int), int requester,
850               size_t length, int level )
851 {
852     static int initialized=0;
853     size_t n;
854     char *buffer, *p;
855
856     if( !initialized ) {
857         log_info(_("WARNING: using insecure random number generator!!\n"));
858         tty_printf(_("The random number generator is only a kludge to let\n"
859                    "it run - it is in no way a strong RNG!\n\n"
860                    "DON'T USE ANY DATA GENERATED BY THIS PROGRAM!!\n\n"));
861         initialized=1;
862 #ifdef HAVE_RAND
863         srand(make_timestamp()*getpid());
864 #else
865         srandom(make_timestamp()*getpid());
866 #endif
867     }
868
869     p = buffer = xmalloc( length );
870     n = length;
871 #ifdef HAVE_RAND
872     while( n-- )
873         *p++ = ((unsigned)(1 + (int) (256.0*rand()/(RAND_MAX+1.0)))-1);
874 #else
875     while( n-- )
876         *p++ = ((unsigned)(1 + (int) (256.0*random()/(RAND_MAX+1.0)))-1);
877 #endif
878     add_randomness( buffer, length, requester );
879     xfree(buffer);
880     return 0; /* okay */
881 }