3 * $Id: noise.c,v 1.6 2000/06/17 12:57:47 mdw Exp $
5 * Acquisition of environmental noise (Unix-specific)
7 * (c) 1998 Straylight/Edgeware
10 /*----- Licensing notice --------------------------------------------------*
12 * This file is part of Catacomb.
14 * Catacomb is free software; you can redistribute it and/or modify
15 * it under the terms of the GNU Library General Public License as
16 * published by the Free Software Foundation; either version 2 of the
17 * License, or (at your option) any later version.
19 * Catacomb is distributed in the hope that it will be useful,
20 * but WITHOUT ANY WARRANTY; without even the implied warranty of
21 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
22 * GNU Library General Public License for more details.
24 * You should have received a copy of the GNU Library General Public
25 * License along with Catacomb; if not, write to the Free
26 * Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,
30 /*----- Revision history --------------------------------------------------*
33 * Revision 1.6 2000/06/17 12:57:47 mdw
34 * New free counter noise generator, for use if /dev/random is
37 * Revision 1.5 1999/12/22 15:57:55 mdw
38 * Label system-specific parts more clearly.
40 * Revision 1.4 1999/12/10 23:25:15 mdw
41 * Bug fix: remove old spurious fflush.
43 * Revision 1.3 1999/12/10 23:24:11 mdw
44 * Bug fix: flush buffers before forking.
46 * Revision 1.2 1999/11/11 00:59:08 mdw
47 * A bit of reformatting. Initialize the uid and gid correctly.
49 * Revision 1.1 1999/09/03 08:41:12 mdw
54 /*----- Header files ------------------------------------------------------*/
63 #include <sys/types.h>
74 #include <mLib/bits.h>
81 /*----- Magical numbers ---------------------------------------------------*/
83 #define NOISE_KIDLIFE 100000 /* @noise_filter@ child lifetime */
84 #define MILLION 1000000 /* One million */
86 /*----- Noise source definition -------------------------------------------*/
88 rand_source noise_source = { noise_acquire, noise_timer };
90 /*----- Static variables --------------------------------------------------*/
92 /* --- Timer differences --- */
94 static unsigned long noise_last; /* Last time recorded */
95 static unsigned long noise_diff; /* Last first order difference */
97 /* --- Setuid program handling --- */
99 static uid_t noise_uid = NOISE_NOSETUID; /* Uid to set to spawn processes */
100 static gid_t noise_gid = NOISE_NOSETGID; /* Gid to set to spawn processes */
102 /*----- Main code ---------------------------------------------------------*/
104 /* --- @bitcount@ --- *
106 * Arguments: @unsigned long x@ = a word containing bits
108 * Returns: The number of bits set in the word.
111 static int bitcount(unsigned long x)
113 char ctab[] = { 0, 1, 1, 2, 1, 2, 2, 3,
114 1, 2, 2, 3, 2, 3, 3, 4 };
117 count += ctab[x & 0xfu];
125 * Arguments: @rand_pool *r@ = pointer to randomness pool
126 * @struct timeval *tv@ = pointer to time block
128 * Returns: Nonzero if some randomness was contributed.
130 * Use: Low-level timer contributor.
133 static int timer(rand_pool *r, struct timeval *tv)
135 unsigned long x, d, dd;
139 x = tv->tv_usec + MILLION * tv->tv_sec;
145 rand_add(r, tv, sizeof(*tv), de <= dde ? de : dde);
147 BURN(tv); x = d = dd = de = dde = 0;
151 /* --- @noise_timer@ --- *
153 * Arguments: @rand_pool *r@ = pointer to a randomness pool
155 * Returns: Nonzero if some randomness was contributed.
157 * Use: Contributes the current time to the randomness pool.
158 * A guess at the number of useful bits contributed is made,
159 * based on first and second order bit differences. This isn't
160 * ever-so reliable, but it's better than nothing.
163 int noise_timer(rand_pool *r)
166 gettimeofday(&tv, 0);
167 return (timer(r, &tv));
170 /* --- @noise_devrandom@ --- *
172 * Arguments: @rand_pool *r@ = pointer to a randomness pool
174 * Returns: Nonzero if some randomness was contributed.
176 * Use: Attempts to obtain some randomness from the system entropy
177 * pool. All bits from the device are assumed to be good.
180 int noise_devrandom(rand_pool *r)
183 octet buf[RAND_POOLSZ];
187 /* --- Be nice to other clients of the random device --- *
189 * Attempt to open the device nonblockingly. If that works, take up to
190 * one bufferful and then close again. If there's no data to be read,
191 * then that's tough and we go away again, on the grounds that the device
192 * needs to get some more entropy from somewhere.
195 if ((fd = open("/dev/urandom", O_RDONLY | O_NONBLOCK)) >= 0 ||
196 (fd = open("/dev/arandom", O_RDONLY | O_NONBLOCK)) >= 0 ||
197 (fd = open("/dev/random", O_RDONLY | O_NONBLOCK)) >= 0) {
198 if ((len = read(fd, buf, sizeof(buf))) > 0) {
199 rand_add(r, buf, len, len * 8);
209 /* --- @noise_setid@ --- *
211 * Arguments: @uid_t uid@ = uid to set
212 * @gid_t gid@ = gid to set
216 * Use: Sets the user and group ids to be used by @noise_filter@
217 * when running child processes. This is useful to avoid
218 * giving shell commands (even carefully written ones) undue
219 * privileges. This interface is Unix-specific
222 void noise_setid(uid_t uid, gid_t gid)
228 /* --- @noise_filter@ --- *
230 * Arguments: @rand_pool *r@ = pointer to a randomness pool
231 * @int good@ = number of good bits per 1024 bits
232 * @const char *c@ = shell command to run
234 * Returns: Nonzero if some randomness was contributed.
236 * Use: Attempts to execute a shell command, and dump it into the
237 * randomness pool. A very rough estimate of the number of
238 * good bits is made, based on the size of the command's output.
239 * This function calls @waitpid@, so be careful. Before execing
240 * the command, the process uid and gid are set to the values
241 * given to @noise_setid@, and an attempt is made to reset the
242 * list of supplementary groups. The environment passed to
243 * the command has been severly lobotimized. If the command
244 * fails to complete within a short time period, it is killed.
245 * Paranoid use of close-on-exec flags for file descriptors is
248 * This interface is Unix-specific.
251 int noise_filter(rand_pool *r, int good, const char *c)
258 const char *env[] = {
259 "PATH=/bin:/usr/bin:/sbin:/usr/sbin:/etc",
263 /* --- Remember when this business started --- */
265 gettimeofday(&dead, 0);
268 /* --- Create a pipe --- */
273 /* --- Fork a child off --- */
283 /* --- Handle the child end of the deal --- */
288 /* --- Set the pipe as standard output, close standard input --- */
290 close(0); close(1); close(2);
293 if (dup2(fd[1], 1) < 0) _exit(127);
297 if ((f = open("/dev/null", O_RDONLY)) != 0 ||
298 (f = open("/dev/null", O_WRONLY)) != 2)
301 /* --- Play games with uids --- */
303 if (noise_gid != NOISE_NOSETGID) {
306 #ifdef HAVE_SETGROUPS
307 setgroups(1, &noise_gid);
311 if (noise_uid != NOISE_NOSETUID) {
316 /* --- Start the process up --- */
318 execle("/bin/sh", "-c", c, (char *)0, env);
322 /* --- Sort out my end of the deal --- */
326 /* --- Decide on the deadline --- */
328 TV_ADDL(&dead, &dead, 0, NOISE_KIDLIFE);
330 /* --- Now read, and think --- */
333 struct timeval now, diff;
336 gettimeofday(&now, 0);
338 if (TV_CMP(&now, >, &dead))
340 TV_SUB(&diff, &dead, &now);
345 if (select(fd[0] + 1, &rd, 0, 0, &diff) < 0)
347 if (FD_ISSET(fd[0], &rd)) {
351 if ((sz = read(fd[0], buf, sizeof(buf))) <= 0)
353 goodbits = (sz * good) / 128;
354 rand_add(r, buf, sz, goodbits);
359 /* --- We've finished with it: kill the child process --- *
361 * This is morally questionable. On the other hand, I don't want to be
362 * held up in the @waitpid@ call if I can possibly help it. Maybe a
363 * double-fork is worth doing here.
374 /* --- @noise_freewheel@ --- *
376 * Arguments: @rand_pool *r@ = pointer to a randomness pool
378 * Returns: Nonzero if some randomness was contributed.
380 * Use: Runs a free counter for a short while as a desparate attempt
381 * to get randomness from somewhere. This is actually quite
387 static jmp_buf fwjmp;
389 static void fwalarm(int sig)
391 siglongjmp(fwjmp, 1);
394 int noise_freewheel(rand_pool *r)
396 void (*sigal)(int) = 0;
397 struct itimerval oitv, itv = { { 0, 0 }, { 0, 5000 } };
399 volatile uint32 fwcount = 0;
401 if (!sigsetjmp(fwjmp, 1)) {
402 if ((sigal = signal(SIGALRM, fwalarm)) == SIG_ERR)
404 if (setitimer(ITIMER_REAL, &itv, &oitv))
410 STORE32(buf, fwcount);
411 rand_add(r, buf, sizeof(buf), 16);
416 signal(SIGALRM, sigal);
417 TV_SUB(&oitv.it_value, &oitv.it_value, &itv.it_value);
418 setitimer(ITIMER_REAL, &oitv, 0);
424 int noise_freewheel(rand_pool *r)
431 /* --- @noise_enquire@ --- *
433 * Arguments: @rand_pool *r@ = pointer to a randomness pool
435 * Returns: Nonzero if some randomness was contributed.
437 * Use: Runs some shell commands to enquire about the prevailing
438 * environment. This can gather quite a lot of low-quality
442 int noise_enquire(rand_pool *r)
448 { "ps alxww || ps -elf", 16 },
452 { "ls -align /tmp/.", 10 },
457 for (i = 0; tab[i].cmd; i++)
458 noise_filter(r, tab[i].rate, tab[i].cmd);
462 /* --- @noise_acquire@ --- *
464 * Arguments: @rand_pool *r@ = pointer to a randomness pool
468 * Use: Acquires some randomness from somewhere.
471 void noise_acquire(rand_pool *r)
474 for (i = 0; i < 8; i++)
476 if (!noise_devrandom(r)) {
478 for (i = 0; i < 8; i++)
483 /*----- That's all, folks -------------------------------------------------*/