Fixed memory leak inthe ac functions.
[libgcrypt.git] / cipher / rndunix.c
1 /****************************************************************************
2  *                                                                          *
3  *                                                                          *
4  *   Unix Randomness-Gathering Code                                         *
5  *                                                                          *
6  *   Copyright Peter Gutmann, Paul Kendall, and Chris Wedgwood 1996-1999.   *
7  *   Heavily modified for GnuPG by Werner Koch                              *
8  *                                                                          *
9  *                                                                          *
10  ****************************************************************************/
11
12 /* This module is part of the cryptlib continuously seeded pseudorandom
13    number generator.  For usage conditions, see lib_rand.c
14
15    [Here is the notice from lib_rand.c:]
16
17    This module and the misc/rnd*.c modules represent the cryptlib
18    continuously seeded pseudorandom number generator (CSPRNG) as described in
19    my 1998 Usenix Security Symposium paper "The generation of random numbers
20    for cryptographic purposes".
21
22    The CSPRNG code is copyright Peter Gutmann (and various others) 1996,
23    1997, 1998, 1999, all rights reserved.  Redistribution of the CSPRNG
24    modules and use in source and binary forms, with or without modification,
25    are permitted provided that the following conditions are met:
26
27    1. Redistributions of source code must retain the above copyright notice
28       and this permission notice in its entirety.
29
30    2. Redistributions in binary form must reproduce the copyright notice in
31       the documentation and/or other materials provided with the distribution.
32
33    3. A copy of any bugfixes or enhancements made must be provided to the
34       author, <pgut001@cs.auckland.ac.nz> to allow them to be added to the
35       baseline version of the code.
36
37   ALTERNATIVELY, the code may be distributed under the terms of the
38   GNU Lesser General Public License, version 2.1 or any later version
39   published by the Free Software Foundation, in which case the
40   provisions of the GNU LGPL are required INSTEAD OF the above
41   restrictions.
42
43   Although not required under the terms of the LGPL, it would still be
44   nice if you could make any changes available to the author to allow
45   a consistent code base to be maintained.  */
46 /*************************************************************************
47  The above alternative was changed from GPL to LGPL on 2007-08-22 with
48  permission from Peter Gutmann:
49  ==========
50  From: pgut001 <pgut001@cs.auckland.ac.nz>
51  Subject: Re: LGPL for the windows entropy gatherer
52  To: wk@gnupg.org
53  Date: Wed, 22 Aug 2007 03:05:42 +1200
54  
55  Hi,
56  
57  >As of now libgcrypt is GPL under Windows due to that module and some people
58  >would really like to see it under LGPL too.  Can you do such a license change
59  >to LGPL version 2?  Note that LGPL give the user the option to relicense it
60  >under GPL, so the change would be pretty easy and backwar compatible.
61  
62  Sure.  I assumed that since GPG was GPLd, you'd prefer the GPL for the entropy
63  code as well, but Ian asked for LGPL as an option so as of the next release
64  I'll have LGPL in there.  You can consider it to be retroactive, so your
65  current version will be LGPLd as well.
66  
67  Peter.
68  ==========
69  From: pgut001 <pgut001@cs.auckland.ac.nz>
70  Subject: Re: LGPL for the windows entropy gatherer
71  To: wk@gnupg.org
72  Date: Wed, 22 Aug 2007 20:50:08 +1200
73  
74  >Would you mind to extend this also to the Unix entropy gatherer which is
75  >still used on systems without /dev/random and when EGD is not installed? That
76  >would be the last GPLed piece in Libgcrypt.
77  
78  Sure, it covers the entire entropy-gathering subsystem.
79  
80  Peter.
81  =========
82 */
83
84 /* Fixme: We use plain mallocs here because it may be used as a module.
85  * Should be changed. */
86
87 /* General includes */
88
89 #include <config.h>
90 #include <stdlib.h>
91 #include <stdio.h>
92 #include <string.h>
93
94 /* OS-specific includes */
95
96 #ifdef __osf__
97   /* Somewhere in the morass of system-specific cruft which OSF/1 pulls in
98    * via the following includes are various endianness defines, so we
99    * undefine the cryptlib ones, which aren't really needed for this module
100    * anyway */
101 #undef BIG_ENDIAN
102 #undef LITTLE_ENDIAN
103 #endif                          /* __osf__ */
104
105 #include <unistd.h>
106 #include <fcntl.h>
107 #include <pwd.h>
108 #ifndef __QNX__
109 #include <sys/errno.h>
110 #include <sys/ipc.h>
111 #endif                          /* __QNX__ */
112 #include <sys/time.h>           /* SCO and SunOS need this before resource.h */
113 #ifndef __QNX__
114 #include <sys/resource.h>
115 #endif                          /* __QNX__ */
116 #if defined( _AIX ) || defined( __QNX__ )
117 #include <sys/select.h>
118 #endif                          /* _AIX */
119 #ifndef __QNX__
120 #include <sys/shm.h>
121 #include <signal.h>
122 #include <sys/signal.h>
123 #endif                          /* __QNX__ */
124 #include <sys/stat.h>
125 #include <sys/types.h>          /* Verschiedene komische Typen */
126 #if defined( __hpux ) && ( OS_VERSION == 9 )
127 #include <vfork.h>
128 #endif                          /* __hpux 9.x, after that it's in unistd.h */
129 #include <sys/wait.h>
130 /* #include <kitchensink.h> */
131 #ifdef __QNX__
132 #include <signal.h>
133 #include <process.h>
134 #endif                /* __QNX__ */
135 #include <errno.h>
136
137 #include "types.h"  /* for byte and u32 typedefs */
138 #include "g10lib.h"
139 #include "rand-internal.h"
140
141 #ifndef EAGAIN
142 #define EAGAIN  EWOULDBLOCK
143 #endif
144 #ifndef STDIN_FILENO
145 #define STDIN_FILENO 0
146 #endif
147 #ifndef STDOUT_FILENO
148 #define STDOUT_FILENO 1
149 #endif
150
151 #define GATHER_BUFSIZE          49152   /* Usually about 25K are filled */
152
153 /* The structure containing information on random-data sources.  Each
154  * record contains the source and a relative estimate of its usefulness
155  * (weighting) which is used to scale the number of kB of output from the
156  * source (total = data_bytes / usefulness).  Usually the weighting is in the
157  * range 1-3 (or 0 for especially useless sources), resulting in a usefulness
158  * rating of 1...3 for each kB of source output (or 0 for the useless
159  * sources).
160  *
161  * If the source is constantly changing (certain types of network statistics
162  * have this characteristic) but the amount of output is small, the weighting
163  * is given as a negative value to indicate that the output should be treated
164  * as if a minimum of 1K of output had been obtained.  If the source produces
165  * a lot of output then the scale factor is fractional, resulting in a
166  * usefulness rating of < 1 for each kB of source output.
167  *
168  * In order to provide enough randomness to satisfy the requirements for a
169  * slow poll, we need to accumulate at least 20 points of usefulness (a
170  * typical system should get about 30 points).
171  *
172  * Some potential options are missed out because of special considerations.
173  * pstat -i and pstat -f can produce amazing amounts of output (the record
174  * is 600K on an Oracle server) which floods the buffer and doesn't yield
175  * anything useful (apart from perhaps increasing the entropy of the vmstat
176  * output a bit), so we don't bother with this.  pstat in general produces
177  * quite a bit of output, but it doesn't change much over time, so it gets
178  * very low weightings.  netstat -s produces constantly-changing output but
179  * also produces quite a bit of it, so it only gets a weighting of 2 rather
180  * than 3.  The same holds for netstat -in, which gets 1 rather than 2.
181  *
182  * Some binaries are stored in different locations on different systems so
183  * alternative paths are given for them.  The code sorts out which one to
184  * run by itself, once it finds an exectable somewhere it moves on to the
185  * next source.  The sources are arranged roughly in their order of
186  * usefulness, occasionally sources which provide a tiny amount of
187  * relatively useless data are placed ahead of ones which provide a large
188  * amount of possibly useful data because another 100 bytes can't hurt, and
189  * it means the buffer won't be swamped by one or two high-output sources.
190  * All the high-output sources are clustered towards the end of the list
191  * for this reason.  Some binaries are checked for in a certain order, for
192  * example under Slowaris /usr/ucb/ps understands aux as an arg, but the
193  * others don't.  Some systems have conditional defines enabling alternatives
194  * to commands which don't understand the usual options but will provide
195  * enough output (in the form of error messages) to look like they're the
196  * real thing, causing alternative options to be skipped (we can't check the
197  * return either because some commands return peculiar, non-zero status even
198  * when they're working correctly).
199  *
200  * In order to maximise use of the buffer, the code performs a form of run-
201  * length compression on its input where a repeated sequence of bytes is
202  * replaced by the occurrence count mod 256.  Some commands output an awful
203  * lot of whitespace, this measure greatly increases the amount of data we
204  * can fit in the buffer.
205  *
206  * When we scale the weighting using the SC() macro, some preprocessors may
207  * give a division by zero warning for the most obvious expression
208  * 'weight ? 1024 / weight : 0' (and gcc 2.7.2.2 dies with a division by zero
209  * trap), so we define a value SC_0 which evaluates to zero when fed to
210  * '1024 / SC_0' */
211
212 #define SC( weight )    ( 1024 / weight )       /* Scale factor */
213 #define SC_0                    16384   /* SC( SC_0 ) evalutes to 0 */
214
215 static struct RI {
216     const char *path;           /* Path to check for existence of source */
217     const char *arg;            /* Args for source */
218     const int usefulness;       /* Usefulness of source */
219     FILE *pipe;                 /* Pipe to source as FILE * */
220     int pipeFD;                 /* Pipe to source as FD */
221     pid_t pid;                  /* pid of child for waitpid() */
222     int length;                 /* Quantity of output produced */
223     const int hasAlternative;       /* Whether source has alt.location */
224 } dataSources[] = {
225
226     {   "/bin/vmstat", "-s", SC(-3), NULL, 0, 0, 0, 1    },
227     {   "/usr/bin/vmstat", "-s", SC(-3), NULL, 0, 0, 0, 0},
228     {   "/bin/vmstat", "-c", SC(-3), NULL, 0, 0, 0, 1     },
229     {   "/usr/bin/vmstat", "-c", SC(-3), NULL, 0, 0, 0, 0},
230     {   "/usr/bin/pfstat", NULL, SC(-2), NULL, 0, 0, 0, 0},
231     {   "/bin/vmstat", "-i", SC(-2), NULL, 0, 0, 0, 1     },
232     {   "/usr/bin/vmstat", "-i", SC(-2), NULL, 0, 0, 0, 0},
233     {   "/usr/ucb/netstat", "-s", SC(2), NULL, 0, 0, 0, 1 },
234     {   "/usr/bin/netstat", "-s", SC(2), NULL, 0, 0, 0, 1 },
235     {   "/usr/sbin/netstat", "-s", SC(2), NULL, 0, 0, 0, 1},
236     {   "/usr/etc/netstat", "-s", SC(2), NULL, 0, 0, 0, 0},
237     {   "/usr/bin/nfsstat", NULL, SC(2), NULL, 0, 0, 0, 0},
238     {   "/usr/ucb/netstat", "-m", SC(-1), NULL, 0, 0, 0, 1  },
239     {   "/usr/bin/netstat", "-m", SC(-1), NULL, 0, 0, 0, 1  },
240     {   "/usr/sbin/netstat", "-m", SC(-1), NULL, 0, 0, 0, 1 },
241     {   "/usr/etc/netstat", "-m", SC(-1), NULL, 0, 0, 0, 0 },
242     {   "/bin/netstat",     "-in", SC(-1), NULL, 0, 0, 0, 1 },
243     {   "/usr/ucb/netstat", "-in", SC(-1), NULL, 0, 0, 0, 1 },
244     {   "/usr/bin/netstat", "-in", SC(-1), NULL, 0, 0, 0, 1 },
245     {   "/usr/sbin/netstat", "-in", SC(-1), NULL, 0, 0, 0, 1},
246     {   "/usr/etc/netstat", "-in", SC(-1), NULL, 0, 0, 0, 0},
247     {   "/usr/sbin/snmp_request", "localhost public get 1.3.6.1.2.1.7.1.0",
248                                     SC(-1), NULL, 0, 0, 0, 0 }, /* UDP in */
249     {   "/usr/sbin/snmp_request", "localhost public get 1.3.6.1.2.1.7.4.0",
250                                     SC(-1), NULL, 0, 0, 0, 0 },  /* UDP out */
251     {   "/usr/sbin/snmp_request", "localhost public get 1.3.6.1.2.1.4.3.0",
252                                     SC(-1), NULL, 0, 0, 0, 0 }, /* IP ? */
253     {   "/usr/sbin/snmp_request", "localhost public get 1.3.6.1.2.1.6.10.0",
254                                     SC(-1), NULL, 0, 0, 0, 0 }, /* TCP ? */
255     {   "/usr/sbin/snmp_request", "localhost public get 1.3.6.1.2.1.6.11.0",
256                                     SC(-1), NULL, 0, 0, 0, 0 }, /* TCP ? */
257     {   "/usr/sbin/snmp_request", "localhost public get 1.3.6.1.2.1.6.13.0",
258                                     SC(-1), NULL, 0, 0, 0, 0 }, /* TCP ? */
259     {   "/usr/bin/mpstat", NULL, SC(1), NULL, 0, 0, 0, 0     },
260     {   "/usr/bin/w", NULL, SC(1), NULL, 0, 0, 0, 1           },
261     {   "/usr/bsd/w", NULL, SC(1), NULL, 0, 0, 0, 0          },
262     {   "/usr/bin/df", NULL, SC(1), NULL, 0, 0, 0, 1          },
263     {   "/bin/df", NULL, SC(1), NULL, 0, 0, 0, 0             },
264     {   "/usr/sbin/portstat", NULL, SC(1), NULL, 0, 0, 0, 0  },
265     {   "/usr/bin/iostat", NULL, SC(SC_0), NULL, 0, 0, 0, 0  },
266     {   "/usr/bin/uptime", NULL, SC(SC_0), NULL, 0, 0, 0, 1   },
267     {   "/usr/bsd/uptime", NULL, SC(SC_0), NULL, 0, 0, 0, 0  },
268     {   "/bin/vmstat", "-f", SC(SC_0), NULL, 0, 0, 0, 1       },
269     {   "/usr/bin/vmstat", "-f", SC(SC_0), NULL, 0, 0, 0, 0  },
270     {   "/bin/vmstat", NULL, SC(SC_0), NULL, 0, 0, 0, 1       },
271     {   "/usr/bin/vmstat", NULL, SC(SC_0), NULL, 0, 0, 0, 0  },
272     {   "/usr/ucb/netstat", "-n", SC(0.5), NULL, 0, 0, 0, 1   },
273     {   "/usr/bin/netstat", "-n", SC(0.5), NULL, 0, 0, 0, 1   },
274     {   "/usr/sbin/netstat", "-n", SC(0.5), NULL, 0, 0, 0, 1  },
275     {   "/usr/etc/netstat", "-n", SC(0.5), NULL, 0, 0, 0, 0  },
276 #if defined( __sgi ) || defined( __hpux )
277     {   "/bin/ps", "-el", SC(0.3), NULL, 0, 0, 0, 1           },
278 #endif                          /* __sgi || __hpux */
279     {   "/usr/ucb/ps", "aux", SC(0.3), NULL, 0, 0, 0, 1       },
280     {   "/usr/bin/ps", "aux", SC(0.3), NULL, 0, 0, 0, 1       },
281     {   "/bin/ps", "aux", SC(0.3), NULL, 0, 0, 0, 0          },
282     {   "/bin/ps", "-A", SC(0.3), NULL, 0, 0, 0, 0           }, /*QNX*/
283     {   "/usr/bin/ipcs", "-a", SC(0.5), NULL, 0, 0, 0, 1      },
284     {   "/bin/ipcs", "-a", SC(0.5), NULL, 0, 0, 0, 0         },
285     /* Unreliable source, depends on system usage */
286     {   "/etc/pstat", "-p", SC(0.5), NULL, 0, 0, 0, 1         },
287     {   "/bin/pstat", "-p", SC(0.5), NULL, 0, 0, 0, 0        },
288     {   "/etc/pstat", "-S", SC(0.2), NULL, 0, 0, 0, 1         },
289     {   "/bin/pstat", "-S", SC(0.2), NULL, 0, 0, 0, 0        },
290     {   "/etc/pstat", "-v", SC(0.2), NULL, 0, 0, 0, 1         },
291     {   "/bin/pstat", "-v", SC(0.2), NULL, 0, 0, 0, 0        },
292     {   "/etc/pstat", "-x", SC(0.2), NULL, 0, 0, 0, 1         },
293     {   "/bin/pstat", "-x", SC(0.2), NULL, 0, 0, 0, 0        },
294     {   "/etc/pstat", "-t", SC(0.1), NULL, 0, 0, 0, 1         },
295     {   "/bin/pstat", "-t", SC(0.1), NULL, 0, 0, 0, 0        },
296     /* pstat is your friend */
297     {   "/usr/bin/last", "-n 50", SC(0.3), NULL, 0, 0, 0, 1   },
298 #ifdef __sgi
299     {   "/usr/bsd/last", "-50", SC(0.3), NULL, 0, 0, 0, 0    },
300 #endif                          /* __sgi */
301 #ifdef __hpux
302     {   "/etc/last", "-50", SC(0.3), NULL, 0, 0, 0, 0        },
303 #endif                          /* __hpux */
304     {   "/usr/bsd/last", "-n 50", SC(0.3), NULL, 0, 0, 0, 0  },
305     {   "/usr/sbin/snmp_request", "localhost public get 1.3.6.1.2.1.5.1.0",
306                                 SC(0.1), NULL, 0, 0, 0, 0 }, /* ICMP ? */
307     {   "/usr/sbin/snmp_request", "localhost public get 1.3.6.1.2.1.5.3.0",
308                                 SC(0.1), NULL, 0, 0, 0, 0 }, /* ICMP ? */
309     {   "/etc/arp", "-a", SC(0.1), NULL, 0, 0, 0, 1  },
310     {   "/usr/etc/arp", "-a", SC(0.1), NULL, 0, 0, 0, 1  },
311     {   "/usr/bin/arp", "-a", SC(0.1), NULL, 0, 0, 0, 1  },
312     {   "/usr/sbin/arp", "-a", SC(0.1), NULL, 0, 0, 0, 0 },
313     {   "/usr/sbin/ripquery", "-nw 1 127.0.0.1",
314                                 SC(0.1), NULL, 0, 0, 0, 0 },
315     {   "/bin/lpstat", "-t", SC(0.1), NULL, 0, 0, 0, 1     },
316     {   "/usr/bin/lpstat", "-t", SC(0.1), NULL, 0, 0, 0, 1 },
317     {   "/usr/ucb/lpstat", "-t", SC(0.1), NULL, 0, 0, 0, 0 },
318     {   "/usr/bin/tcpdump", "-c 5 -efvvx", SC(1), NULL, 0, 0, 0, 0 },
319     /* This is very environment-dependant.  If network traffic is low, it'll
320      * probably time out before delivering 5 packets, which is OK because
321      * it'll probably be fixed stuff like ARP anyway */
322     {   "/usr/sbin/advfsstat", "-b usr_domain",
323                                 SC(SC_0), NULL, 0, 0, 0, 0},
324     {   "/usr/sbin/advfsstat", "-l 2 usr_domain",
325                                 SC(0.5), NULL, 0, 0, 0, 0},
326     {   "/usr/sbin/advfsstat", "-p usr_domain",
327                                 SC(SC_0), NULL, 0, 0, 0, 0},
328     /* This is a complex and screwball program.  Some systems have things
329      * like rX_dmn, x = integer, for RAID systems, but the statistics are
330      * pretty dodgy */
331 #ifdef __QNXNTO__                                                             
332     { "/bin/pidin", "-F%A%B%c%d%E%I%J%K%m%M%n%N%p%P%S%s%T", SC(0.3),
333              NULL, 0, 0, 0, 0       },
334 #endif     
335 #if 0
336     /* The following aren't enabled since they're somewhat slow and not very
337      * unpredictable, however they give an indication of the sort of sources
338      * you can use (for example the finger might be more useful on a
339      * firewalled internal network) */
340     {   "/usr/bin/finger", "@ml.media.mit.edu", SC(0.9), NULL, 0, 0, 0, 0 },
341     {   "/usr/local/bin/wget", "-O - http://lavarand.sgi.com/block.html",
342                                 SC(0.9), NULL, 0, 0, 0, 0 },
343     {   "/bin/cat", "/usr/spool/mqueue/syslog", SC(0.9), NULL, 0, 0, 0, 0 },
344 #endif                          /* 0 */
345     {   NULL, NULL, 0, NULL, 0, 0, 0, 0 }
346 };
347
348 static byte *gather_buffer;         /* buffer for gathering random noise */
349 static int gather_buffer_size;      /* size of the memory buffer */
350 static uid_t gatherer_uid;
351
352 /* The message structure used to communicate with the parent */
353 typedef struct {
354     int  usefulness;    /* usefulness of data */
355     int  ndata;         /* valid bytes in data */
356     char data[500];     /* gathered data */
357 } GATHER_MSG;
358
359 #ifndef HAVE_WAITPID
360 static pid_t
361 waitpid(pid_t pid, int *statptr, int options)
362 {
363 #ifdef HAVE_WAIT4
364         return wait4(pid, statptr, options, NULL);
365 #else
366         /* If wait4 is also not available, try wait3 for SVR3 variants */
367         /* Less ideal because can't actually request a specific pid */
368         /* For that reason, first check to see if pid is for an */
369         /*   existing process. */
370         int tmp_pid, dummystat;;
371         if (kill(pid, 0) == -1) {
372                 errno = ECHILD;
373                 return -1;
374         }
375         if (statptr == NULL)
376                 statptr = &dummystat;
377         while (((tmp_pid = wait3(statptr, options, 0)) != pid) &&
378                     (tmp_pid != -1) && (tmp_pid != 0) && (pid != -1))
379             ;
380         return tmp_pid;
381 #endif
382 }
383 #endif
384
385 /* Under SunOS popen() doesn't record the pid of the child process.  When
386  * pclose() is called, instead of calling waitpid() for the correct child, it
387  * calls wait() repeatedly until the right child is reaped.  The problem is
388  * that this reaps any other children that happen to have died at that
389  * moment, and when their pclose() comes along, the process hangs forever.
390  * The fix is to use a wrapper for popen()/pclose() which saves the pid in
391  * the dataSources structure (code adapted from GNU-libc's popen() call).
392  *
393  * Aut viam inveniam aut faciam */
394
395 static FILE *
396 my_popen(struct RI *entry)
397 {
398     int pipedes[2];
399     FILE *stream;
400
401     /* Create the pipe */
402     if (pipe(pipedes) < 0)
403         return (NULL);
404
405     /* Fork off the child ("vfork() is like an OS orgasm.  All OS's want to
406      * do it, but most just end up faking it" - Chris Wedgwood).  If your OS
407      * supports it, you should try to use vfork() here because it's somewhat
408      * more efficient */
409 #if defined( sun ) || defined( __ultrix__ ) || defined( __osf__ ) || \
410         defined(__hpux)
411     entry->pid = vfork();
412 #else                           /*  */
413     entry->pid = fork();
414 #endif                          /* Unixen which have vfork() */
415     if (entry->pid == (pid_t) - 1) {
416         /* The fork failed */
417         close(pipedes[0]);
418         close(pipedes[1]);
419         return (NULL);
420     }
421
422     if (entry->pid == (pid_t) 0) {
423         struct passwd *passwd;
424
425         /* We are the child.  Make the read side of the pipe be stdout */
426         if (dup2(pipedes[STDOUT_FILENO], STDOUT_FILENO) < 0)
427             exit(127);
428
429         /* Now that everything is set up, give up our permissions to make
430          * sure we don't read anything sensitive.  If the getpwnam() fails,
431          * we default to -1, which is usually nobody */
432         if (gatherer_uid == (uid_t)-1 && \
433             (passwd = getpwnam("nobody")) != NULL)
434             gatherer_uid = passwd->pw_uid;
435
436         setuid(gatherer_uid);
437
438         /* Close the pipe descriptors */
439         close(pipedes[STDIN_FILENO]);
440         close(pipedes[STDOUT_FILENO]);
441
442         /* Try and exec the program */
443         execl(entry->path, entry->path, entry->arg, NULL);
444
445         /* Die if the exec failed */
446         exit(127);
447     }
448
449     /* We are the parent.  Close the irrelevant side of the pipe and open
450      * the relevant side as a new stream.  Mark our side of the pipe to
451      * close on exec, so new children won't see it */
452     close(pipedes[STDOUT_FILENO]);
453
454 #ifdef FD_CLOEXEC
455     fcntl(pipedes[STDIN_FILENO], F_SETFD, FD_CLOEXEC);
456 #endif
457
458     stream = fdopen(pipedes[STDIN_FILENO], "r");
459
460     if (stream == NULL) {
461         int savedErrno = errno;
462
463         /* The stream couldn't be opened or the child structure couldn't be
464          * allocated.  Kill the child and close the other side of the pipe */
465         kill(entry->pid, SIGKILL);
466         if (stream == NULL)
467             close(pipedes[STDOUT_FILENO]);
468         else
469             fclose(stream);
470
471         waitpid(entry->pid, NULL, 0);
472
473         entry->pid = 0;
474         errno = savedErrno;
475         return (NULL);
476     }
477
478     return (stream);
479 }
480
481 static int
482 my_pclose(struct RI *entry)
483 {
484     int status = 0;
485
486     if (fclose(entry->pipe))
487         return (-1);
488
489     /* We ignore the return value from the process because some
490        programs return funny values which would result in the input
491        being discarded even if they executed successfully.  This isn't
492        a problem because the result data size threshold will filter
493        out any programs which exit with a usage message without
494        producing useful output.  */
495     if (waitpid(entry->pid, NULL, 0) != entry->pid)
496         status = -1;
497
498     entry->pipe = NULL;
499     entry->pid = 0;
500     return (status);
501 }
502
503
504 /* Unix slow poll (without special support for Linux)
505  *
506  * If a few of the randomness sources create a large amount of output then
507  * the slowPoll() stops once the buffer has been filled (but before all the
508  * randomness sources have been sucked dry) so that the 'usefulness' factor
509  * remains below the threshold.  For this reason the gatherer buffer has to
510  * be fairly sizeable on moderately loaded systems.  This is something of a
511  * bug since the usefulness should be influenced by the amount of output as
512  * well as the source type */
513
514
515 static int
516 slow_poll(FILE *dbgfp, int dbgall, size_t *nbytes )
517 {
518     int moreSources;
519     struct timeval tv;
520     fd_set fds;
521 #if defined( __hpux )
522     size_t maxFD = 0;
523 #else
524     int maxFD = 0;
525 #endif /* OS-specific brokenness */
526     int bufPos, i, usefulness = 0;
527
528
529     /* Fire up each randomness source */
530     FD_ZERO(&fds);
531     for (i = 0; dataSources[i].path != NULL; i++) {
532         /* Since popen() is a fairly heavy function, we check to see whether
533          * the executable exists before we try to run it */
534         if (access(dataSources[i].path, X_OK)) {
535             if( dbgfp && dbgall )
536                 fprintf(dbgfp, "%s not present%s\n", dataSources[i].path,
537                                dataSources[i].hasAlternative ?
538                                         ", has alternatives" : "");
539             dataSources[i].pipe = NULL;
540         }
541         else
542             dataSources[i].pipe = my_popen(&dataSources[i]);
543
544         if (dataSources[i].pipe != NULL) {
545             dataSources[i].pipeFD = fileno(dataSources[i].pipe);
546             if (dataSources[i].pipeFD > maxFD)
547                 maxFD = dataSources[i].pipeFD;
548
549 #ifdef O_NONBLOCK /* Ohhh what a hack (used for Atari) */
550             fcntl(dataSources[i].pipeFD, F_SETFL, O_NONBLOCK);
551 #else
552 #error O_NONBLOCK is missing
553 #endif
554
555             FD_SET(dataSources[i].pipeFD, &fds);
556             dataSources[i].length = 0;
557
558             /* If there are alternatives for this command, don't try and
559              * execute them */
560             while (dataSources[i].hasAlternative) {
561                 if( dbgfp && dbgall )
562                     fprintf(dbgfp, "Skipping %s\n", dataSources[i + 1].path);
563                 i++;
564             }
565         }
566     }
567
568
569     /* Suck all the data we can get from each of the sources */
570     bufPos = 0;
571     moreSources = 1;
572     while (moreSources && bufPos <= gather_buffer_size) {
573         /* Wait for data to become available from any of the sources, with a
574          * timeout of 10 seconds.  This adds even more randomness since data
575          * becomes available in a nondeterministic fashion.  Kudos to HP's QA
576          * department for managing to ship a select() which breaks its own
577          * prototype */
578         tv.tv_sec = 10;
579         tv.tv_usec = 0;
580
581 #if defined( __hpux ) && ( OS_VERSION == 9 )
582         if (select(maxFD + 1, (int *)&fds, NULL, NULL, &tv) == -1)
583 #else  /*  */
584         if (select(maxFD + 1, &fds, NULL, NULL, &tv) == -1)
585 #endif /* __hpux */
586             break;
587
588         /* One of the sources has data available, read it into the buffer */
589         for (i = 0; dataSources[i].path != NULL; i++) {
590             if( dataSources[i].pipe && FD_ISSET(dataSources[i].pipeFD, &fds)) {
591                 size_t noBytes;
592
593                 if ((noBytes = fread(gather_buffer + bufPos, 1,
594                                      gather_buffer_size - bufPos,
595                                      dataSources[i].pipe)) == 0) {
596                     if (my_pclose(&dataSources[i]) == 0) {
597                         int total = 0;
598
599                         /* Try and estimate how much entropy we're getting
600                          * from a data source */
601                         if (dataSources[i].usefulness) {
602                             if (dataSources[i].usefulness < 0)
603                                 total = (dataSources[i].length + 999)
604                                         / -dataSources[i].usefulness;
605                             else
606                                 total = dataSources[i].length
607                                         / dataSources[i].usefulness;
608                         }
609                         if( dbgfp )
610                             fprintf(dbgfp,
611                                "%s %s contributed %d bytes, "
612                                "usefulness = %d\n", dataSources[i].path,
613                                (dataSources[i].arg != NULL) ?
614                                        dataSources[i].arg : "",
615                                       dataSources[i].length, total);
616                         if( dataSources[i].length )
617                             usefulness += total;
618                     }
619                     dataSources[i].pipe = NULL;
620                 }
621                 else {
622                     int currPos = bufPos;
623                     int endPos = bufPos + noBytes;
624
625                     /* Run-length compress the input byte sequence */
626                     while (currPos < endPos) {
627                         int ch = gather_buffer[currPos];
628
629                         /* If it's a single byte, just copy it over */
630                         if (ch != gather_buffer[currPos + 1]) {
631                             gather_buffer[bufPos++] = ch;
632                             currPos++;
633                         }
634                         else {
635                             int count = 0;
636
637                             /* It's a run of repeated bytes, replace them
638                              * with the byte count mod 256 */
639                             while ((ch == gather_buffer[currPos])
640                                     && currPos < endPos) {
641                                 count++;
642                                 currPos++;
643                             }
644                             gather_buffer[bufPos++] = count;
645                             noBytes -= count - 1;
646                         }
647                     }
648
649                     /* Remember the number of (compressed) bytes of input we
650                      * obtained */
651                     dataSources[i].length += noBytes;
652                 }
653             }
654         }
655
656         /* Check if there is more input available on any of the sources */
657         moreSources = 0;
658         FD_ZERO(&fds);
659         for (i = 0; dataSources[i].path != NULL; i++) {
660             if (dataSources[i].pipe != NULL) {
661                 FD_SET(dataSources[i].pipeFD, &fds);
662                 moreSources = 1;
663             }
664         }
665     }
666
667     if( dbgfp ) {
668         fprintf(dbgfp, "Got %d bytes, usefulness = %d\n", bufPos, usefulness);
669         fflush(dbgfp);
670     }
671     *nbytes = bufPos;
672     return usefulness;
673 }
674
675 /****************
676  * Start the gatherer process which writes messages of
677  * type GATHERER_MSG to pipedes
678  */
679 static void
680 start_gatherer( int pipefd )
681 {
682     FILE *dbgfp = NULL;
683     int dbgall;
684
685     {
686         const char *s = getenv("GNUPG_RNDUNIX_DBG");
687         if( s ) {
688             dbgfp = (*s=='-' && !s[1])? stdout : fopen(s, "a");
689             if( !dbgfp )
690                 log_info("can't open debug file `%s': %s\n",
691                              s, strerror(errno) );
692             else
693                 fprintf(dbgfp,"\nSTART RNDUNIX DEBUG pid=%d\n", (int)getpid());
694         }
695         dbgall = !!getenv("GNUPG_RNDUNIX_DBGALL");
696     }
697     /* close all files but the ones we need */
698     {   int nmax, n1, n2, i;
699 #ifdef _SC_OPEN_MAX
700         if( (nmax=sysconf( _SC_OPEN_MAX )) < 0 ) {
701 #ifdef _POSIX_OPEN_MAX
702             nmax = _POSIX_OPEN_MAX;
703 #else
704             nmax = 20; /* assume a reasonable value */
705 #endif
706         }
707 #else /*!_SC_OPEN_MAX*/
708         nmax = 20; /* assume a reasonable value */
709 #endif /*!_SC_OPEN_MAX*/
710         n1 = fileno( stderr );
711         n2 = dbgfp? fileno( dbgfp ) : -1;
712         for(i=0; i < nmax; i++ ) {
713             if( i != n1 && i != n2 && i != pipefd )
714                 close(i);
715         }
716         errno = 0;
717     }
718
719
720     /* Set up the buffer */
721     gather_buffer_size = GATHER_BUFSIZE;
722     gather_buffer = malloc( gather_buffer_size );
723     if( !gather_buffer ) {
724         log_error("out of core while allocating the gatherer buffer\n");
725         exit(2);
726     }
727
728     /* Reset the SIGC(H)LD handler to the system default.  This is necessary
729      * because if the program which cryptlib is a part of installs its own
730      * SIGC(H)LD handler, it will end up reaping the cryptlib children before
731      * cryptlib can.  As a result, my_pclose() will call waitpid() on a
732      * process which has already been reaped by the installed handler and
733      * return an error, so the read data won't be added to the randomness
734      * pool.  There are two types of SIGC(H)LD naming, the SysV SIGCLD and
735      * the BSD/Posix SIGCHLD, so we need to handle either possibility */
736 #ifdef SIGCLD
737     signal(SIGCLD, SIG_DFL);
738 #else
739     signal(SIGCHLD, SIG_DFL);
740 #endif
741
742     fclose(stderr);             /* Arrghh!!  It's Stuart code!! */
743
744     for(;;) {
745         GATHER_MSG msg;
746         size_t nbytes;
747         const char *p;
748
749         msg.usefulness = slow_poll( dbgfp, dbgall, &nbytes );
750         p = gather_buffer;
751         while( nbytes ) {
752             msg.ndata = nbytes > sizeof(msg.data)? sizeof(msg.data) : nbytes;
753             memcpy( msg.data, p, msg.ndata );
754             nbytes -= msg.ndata;
755             p += msg.ndata;
756
757             while( write( pipefd, &msg, sizeof(msg) ) != sizeof(msg) ) {
758                 if( errno == EINTR )
759                     continue;
760                 if( errno == EAGAIN ) {
761                     struct timeval tv;
762                     tv.tv_sec = 0;
763                     tv.tv_usec = 50000;
764                     select(0, NULL, NULL, NULL, &tv);
765                     continue;
766                 }
767                 if( errno == EPIPE ) /* parent has exited, so give up */
768                    exit(0);
769
770                 /* we can't do very much here because stderr is closed */
771                 if( dbgfp )
772                     fprintf(dbgfp, "gatherer can't write to pipe: %s\n",
773                                     strerror(errno) );
774                 /* we start a new poll to give the system some time */
775                 nbytes = 0;
776                 break;
777             }
778         }
779     }
780     /* we are killed when the parent dies */
781 }
782
783
784 static int
785 read_a_msg( int fd, GATHER_MSG *msg )
786 {
787     char *buffer = (char*)msg;
788     size_t length = sizeof( *msg );
789     int n;
790
791     do {
792         do {
793             n = read(fd, buffer, length );
794         } while( n == -1 && errno == EINTR );
795         if( n == -1 )
796             return -1;
797         buffer += n;
798         length -= n;
799     } while( length );
800     return 0;
801 }
802
803
804 /****************
805  * Using a level of 0 should never block and better add nothing
806  * to the pool.  So this is just a dummy for this gatherer.
807  */
808 int
809 _gcry_rndunix_gather_random (void (*add)(const void*, size_t,
810                                          enum random_origins),
811                              enum random_origins origin,
812                              size_t length, int level )
813 {
814     static pid_t gatherer_pid = 0;
815     static int pipedes[2];
816     GATHER_MSG msg;
817     size_t n;
818
819     if( !level )
820         return 0;
821
822     if( !gatherer_pid ) {
823         /* make sure we are not setuid */
824         if( getuid() != geteuid() )
825             BUG();
826         /* time to start the gatherer process */
827         if( pipe( pipedes ) ) {
828             log_error("pipe() failed: %s\n", strerror(errno));
829             return -1;
830         }
831         gatherer_pid = fork();
832         if( gatherer_pid == -1 ) {
833             log_error("can't for gatherer process: %s\n", strerror(errno));
834             return -1;
835         }
836         if( !gatherer_pid ) {
837             start_gatherer( pipedes[1] );
838             /* oops, can't happen */
839             return -1;
840         }
841     }
842
843     /* now read from the gatherer */
844     while( length ) {
845         int goodness;
846         ulong subtract;
847
848         if( read_a_msg( pipedes[0], &msg ) ) {
849             log_error("reading from gatherer pipe failed: %s\n",
850                                                             strerror(errno));
851             return -1;
852         }
853
854
855         if( level > 1 ) {
856             if( msg.usefulness > 30 )
857                 goodness = 100;
858             else if ( msg.usefulness )
859                 goodness = msg.usefulness * 100 / 30;
860             else
861                 goodness = 0;
862         }
863         else if( level ) {
864             if( msg.usefulness > 15 )
865                 goodness = 100;
866             else if ( msg.usefulness )
867                 goodness = msg.usefulness * 100 / 15;
868             else
869                 goodness = 0;
870         }
871         else
872             goodness = 100; /* goodness of level 0 is always 100 % */
873
874         n = msg.ndata;
875         if( n > length )
876             n = length;
877         (*add)( msg.data, n, origin );
878
879         /* this is the trick how we cope with the goodness */
880         subtract = (ulong)n * goodness / 100;
881         /* subtract at least 1 byte to avoid infinite loops */
882         length -= subtract ? subtract : 1;
883     }
884
885     return 0;
886 }