blob: 554a72b0d1fabbd6530213e768c7e83575fad30e [file] [log] [blame]
Damien Miller040f3832000-04-03 14:50:43 +10001/*
2 * Copyright (c) 2000 Damien Miller. All rights reserved.
3 *
4 * Redistribution and use in source and binary forms, with or without
5 * modification, are permitted provided that the following conditions
6 * are met:
7 * 1. Redistributions of source code must retain the above copyright
8 * notice, this list of conditions and the following disclaimer.
9 * 2. Redistributions in binary form must reproduce the above copyright
10 * notice, this list of conditions and the following disclaimer in the
11 * documentation and/or other materials provided with the distribution.
Damien Miller040f3832000-04-03 14:50:43 +100012 *
13 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
14 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
15 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
16 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
17 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
18 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
19 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
20 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
21 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
22 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
23 */
24
25#include "includes.h"
26
Damien Miller5f056372000-04-16 12:31:48 +100027#include <openssl/rand.h>
28#include <openssl/sha.h>
Damien Miller767c7fc2001-02-27 09:20:57 +110029#include <openssl/crypto.h>
Damien Miller040f3832000-04-03 14:50:43 +100030
Damien Millerecbb26d2000-07-15 14:59:14 +100031/* SunOS 4.4.4 needs this */
32#ifdef HAVE_FLOATINGPOINT_H
33# include <floatingpoint.h>
34#endif /* HAVE_FLOATINGPOINT_H */
35
Ben Lindstrom226cfa02001-01-22 05:34:40 +000036#include "ssh.h"
Damien Millera1072a82001-02-18 15:28:11 +110037#include "misc.h"
Ben Lindstrom226cfa02001-01-22 05:34:40 +000038#include "xmalloc.h"
39#include "atomicio.h"
Ben Lindstromcb577332001-01-22 21:06:19 +000040#include "pathnames.h"
Ben Lindstrom226cfa02001-01-22 05:34:40 +000041#include "log.h"
42
Damien Miller79b332d2001-06-27 23:36:08 +100043RCSID("$Id: entropy.c,v 1.37 2001/06/27 13:36:08 djm Exp $");
Damien Miller040f3832000-04-03 14:50:43 +100044
Damien Miller040f3832000-04-03 14:50:43 +100045#ifndef offsetof
46# define offsetof(type, member) ((size_t) &((type *)0)->member)
47#endif
Damien Miller14c12cb2000-06-07 22:20:23 +100048
Damien Miller14c12cb2000-06-07 22:20:23 +100049/* Number of times to pass through command list gathering entropy */
50#define NUM_ENTROPY_RUNS 1
51
52/* Scale entropy estimates back by this amount on subsequent runs */
53#define SCALE_PER_RUN 10.0
54
55/* Minimum number of commands to be considered valid */
56#define MIN_ENTROPY_SOURCES 16
57
58#define WHITESPACE " \t\n"
59
Damien Miller7b22d652000-06-18 14:07:04 +100060#ifndef RUSAGE_SELF
61# define RUSAGE_SELF 0
62#endif
63#ifndef RUSAGE_CHILDREN
64# define RUSAGE_CHILDREN 0
65#endif
66
Damien Millerfbd884a2001-02-27 08:39:07 +110067#if defined(_POSIX_SAVED_IDS) && !defined(BROKEN_SAVED_UIDS)
68# define SAVED_IDS_WORK_WITH_SETEUID
69#endif
70
Damien Miller79b332d2001-06-27 23:36:08 +100071static void
Damien Miller60bc5172001-03-19 09:38:15 +110072check_openssl_version(void)
Damien Miller767c7fc2001-02-27 09:20:57 +110073{
74 if (SSLeay() != OPENSSL_VERSION_NUMBER)
Damien Miller3456d322001-02-27 11:00:52 +110075 fatal("OpenSSL version mismatch. Built against %lx, you "
76 "have %lx", OPENSSL_VERSION_NUMBER, SSLeay());
Damien Miller767c7fc2001-02-27 09:20:57 +110077}
78
Damien Millerd0ccb982001-03-04 00:29:20 +110079#if defined(PRNGD_SOCKET) || defined(PRNGD_PORT)
80# define USE_PRNGD
81#endif
Damien Miller767c7fc2001-02-27 09:20:57 +110082
Damien Millerd0ccb982001-03-04 00:29:20 +110083#if defined(USE_PRNGD) || defined(RANDOM_POOL)
Damien Miller14c12cb2000-06-07 22:20:23 +100084
Damien Millerd0ccb982001-03-04 00:29:20 +110085#ifdef USE_PRNGD
86/* Collect entropy from PRNGD/EGD */
Damien Miller60bc5172001-03-19 09:38:15 +110087int
88get_random_bytes(unsigned char *buf, int len)
Damien Miller040f3832000-04-03 14:50:43 +100089{
Damien Miller64681252000-06-26 13:01:33 +100090 int fd;
91 char msg[2];
Damien Millerd0ccb982001-03-04 00:29:20 +110092#ifdef PRNGD_PORT
93 struct sockaddr_in addr;
94#else
Damien Miller040f3832000-04-03 14:50:43 +100095 struct sockaddr_un addr;
Damien Millerd0ccb982001-03-04 00:29:20 +110096#endif
Damien Millerb3ffc5f2001-02-18 12:44:29 +110097 int addr_len, rval, errors;
Damien Millera1072a82001-02-18 15:28:11 +110098 mysig_t old_sigpipe;
Damien Miller040f3832000-04-03 14:50:43 +100099
Damien Millerd0ccb982001-03-04 00:29:20 +1100100 memset(&addr, '\0', sizeof(addr));
101
102#ifdef PRNGD_PORT
103 addr.sin_family = AF_INET;
104 addr.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
105 addr.sin_port = htons(PRNGD_PORT);
106 addr_len = sizeof(struct sockaddr_in);
107#else /* use IP socket PRNGD_SOCKET instead */
Damien Miller64681252000-06-26 13:01:33 +1000108 /* Sanity checks */
Damien Millerd0ccb982001-03-04 00:29:20 +1100109 if (sizeof(PRNGD_SOCKET) > sizeof(addr.sun_path))
Damien Miller040f3832000-04-03 14:50:43 +1000110 fatal("Random pool path is too long");
Damien Miller040f3832000-04-03 14:50:43 +1000111 if (len > 255)
Damien Millerd0ccb982001-03-04 00:29:20 +1100112 fatal("Too many bytes to read from PRNGD");
Damien Miller64681252000-06-26 13:01:33 +1000113
Damien Miller64681252000-06-26 13:01:33 +1000114 addr.sun_family = AF_UNIX;
Damien Millerd0ccb982001-03-04 00:29:20 +1100115 strlcpy(addr.sun_path, PRNGD_SOCKET, sizeof(addr.sun_path));
116 addr_len = offsetof(struct sockaddr_un, sun_path) +
117 sizeof(PRNGD_SOCKET);
118#endif
Kevin Stevesef4eea92001-02-05 12:42:17 +0000119
Damien Millera1072a82001-02-18 15:28:11 +1100120 old_sigpipe = mysignal(SIGPIPE, SIG_IGN);
Damien Millerb3ffc5f2001-02-18 12:44:29 +1100121
122 errors = rval = 0;
123reopen:
Damien Millerd0ccb982001-03-04 00:29:20 +1100124#ifdef PRNGD_PORT
125 fd = socket(addr.sin_family, SOCK_STREAM, 0);
126 if (fd == -1) {
127 error("Couldn't create AF_INET socket: %s", strerror(errno));
128 goto done;
129 }
130#else
131 fd = socket(addr.sun_family, SOCK_STREAM, 0);
Damien Miller64681252000-06-26 13:01:33 +1000132 if (fd == -1) {
133 error("Couldn't create AF_UNIX socket: %s", strerror(errno));
Damien Millerb3ffc5f2001-02-18 12:44:29 +1100134 goto done;
Damien Miller64681252000-06-26 13:01:33 +1000135 }
Damien Millerd0ccb982001-03-04 00:29:20 +1100136#endif
Damien Miller64681252000-06-26 13:01:33 +1000137
138 if (connect(fd, (struct sockaddr*)&addr, addr_len) == -1) {
Damien Millerd0ccb982001-03-04 00:29:20 +1100139#ifdef PRNGD_PORT
140 error("Couldn't connect to PRNGD port %d: %s",
141 PRNGD_PORT, strerror(errno));
142#else
143 error("Couldn't connect to PRNGD socket \"%s\": %s",
144 addr.sun_path, strerror(errno));
145#endif
Damien Millerb3ffc5f2001-02-18 12:44:29 +1100146 goto done;
Damien Miller64681252000-06-26 13:01:33 +1000147 }
148
Damien Millerd0ccb982001-03-04 00:29:20 +1100149 /* Send blocking read request to PRNGD */
Damien Miller64681252000-06-26 13:01:33 +1000150 msg[0] = 0x02;
151 msg[1] = len;
Damien Miller040f3832000-04-03 14:50:43 +1000152
Damien Miller64681252000-06-26 13:01:33 +1000153 if (atomicio(write, fd, msg, sizeof(msg)) != sizeof(msg)) {
Damien Millerb3ffc5f2001-02-18 12:44:29 +1100154 if (errno == EPIPE && errors < 10) {
155 close(fd);
156 errors++;
157 goto reopen;
158 }
Damien Millerd0ccb982001-03-04 00:29:20 +1100159 error("Couldn't write to PRNGD socket: %s",
160 strerror(errno));
Damien Millerb3ffc5f2001-02-18 12:44:29 +1100161 goto done;
Damien Miller64681252000-06-26 13:01:33 +1000162 }
Damien Miller040f3832000-04-03 14:50:43 +1000163
Damien Miller64681252000-06-26 13:01:33 +1000164 if (atomicio(read, fd, buf, len) != len) {
Damien Millerb3ffc5f2001-02-18 12:44:29 +1100165 if (errno == EPIPE && errors < 10) {
166 close(fd);
167 errors++;
168 goto reopen;
169 }
Damien Millerd0ccb982001-03-04 00:29:20 +1100170 error("Couldn't read from PRNGD socket: %s",
171 strerror(errno));
Damien Millerb3ffc5f2001-02-18 12:44:29 +1100172 goto done;
Damien Miller64681252000-06-26 13:01:33 +1000173 }
Kevin Stevesef4eea92001-02-05 12:42:17 +0000174
Damien Millerb3ffc5f2001-02-18 12:44:29 +1100175 rval = 1;
176done:
Kevin Steves4679f5b2001-02-18 11:34:32 +0000177 mysignal(SIGPIPE, old_sigpipe);
Damien Millerb3ffc5f2001-02-18 12:44:29 +1100178 if (fd != -1)
179 close(fd);
180 return(rval);
Damien Miller040f3832000-04-03 14:50:43 +1000181}
Damien Millerd0ccb982001-03-04 00:29:20 +1100182#else /* !USE_PRNGD */
Damien Miller040f3832000-04-03 14:50:43 +1000183#ifdef RANDOM_POOL
184/* Collect entropy from /dev/urandom or pipe */
Damien Miller79b332d2001-06-27 23:36:08 +1000185static int
Damien Miller60bc5172001-03-19 09:38:15 +1100186get_random_bytes(unsigned char *buf, int len)
Damien Miller040f3832000-04-03 14:50:43 +1000187{
Damien Miller64681252000-06-26 13:01:33 +1000188 int random_pool;
Damien Miller040f3832000-04-03 14:50:43 +1000189
Damien Miller64681252000-06-26 13:01:33 +1000190 random_pool = open(RANDOM_POOL, O_RDONLY);
Damien Miller040f3832000-04-03 14:50:43 +1000191 if (random_pool == -1) {
Kevin Stevesef4eea92001-02-05 12:42:17 +0000192 error("Couldn't open random pool \"%s\": %s",
Damien Miller64681252000-06-26 13:01:33 +1000193 RANDOM_POOL, strerror(errno));
194 return(0);
Damien Miller040f3832000-04-03 14:50:43 +1000195 }
Kevin Stevesef4eea92001-02-05 12:42:17 +0000196
Damien Miller64681252000-06-26 13:01:33 +1000197 if (atomicio(read, random_pool, buf, len) != len) {
Kevin Stevesef4eea92001-02-05 12:42:17 +0000198 error("Couldn't read from random pool \"%s\": %s",
Damien Miller64681252000-06-26 13:01:33 +1000199 RANDOM_POOL, strerror(errno));
200 close(random_pool);
201 return(0);
202 }
Kevin Stevesef4eea92001-02-05 12:42:17 +0000203
Damien Miller64681252000-06-26 13:01:33 +1000204 close(random_pool);
Kevin Stevesef4eea92001-02-05 12:42:17 +0000205
Damien Miller64681252000-06-26 13:01:33 +1000206 return(1);
Damien Miller040f3832000-04-03 14:50:43 +1000207}
208#endif /* RANDOM_POOL */
Damien Millerd0ccb982001-03-04 00:29:20 +1100209#endif /* USE_PRNGD */
Damien Miller040f3832000-04-03 14:50:43 +1000210
Damien Miller14c12cb2000-06-07 22:20:23 +1000211/*
212 * Seed OpenSSL's random number pool from Kernel random number generator
Damien Millerd0ccb982001-03-04 00:29:20 +1100213 * or PRNGD/EGD
Damien Miller14c12cb2000-06-07 22:20:23 +1000214 */
215void
216seed_rng(void)
217{
Damien Millerd0ccb982001-03-04 00:29:20 +1100218 unsigned char buf[32];
Kevin Stevesef4eea92001-02-05 12:42:17 +0000219
Damien Miller14c12cb2000-06-07 22:20:23 +1000220 debug("Seeding random number generator");
Damien Miller64681252000-06-26 13:01:33 +1000221
Damien Miller08006472000-06-26 13:55:31 +1000222 if (!get_random_bytes(buf, sizeof(buf))) {
223 if (!RAND_status())
224 fatal("Entropy collection failed and entropy exhausted");
225 } else {
226 RAND_add(buf, sizeof(buf), sizeof(buf));
227 }
Kevin Stevesef4eea92001-02-05 12:42:17 +0000228
Damien Miller14c12cb2000-06-07 22:20:23 +1000229 memset(buf, '\0', sizeof(buf));
230}
231
Damien Miller60bc5172001-03-19 09:38:15 +1100232void
233init_rng(void)
Damien Miller767c7fc2001-02-27 09:20:57 +1100234{
235 check_openssl_version();
236}
Damien Millerf9b625c2000-07-09 22:42:32 +1000237
Damien Millerd0ccb982001-03-04 00:29:20 +1100238#else /* defined(USE_PRNGD) || defined(RANDOM_POOL) */
Damien Miller14c12cb2000-06-07 22:20:23 +1000239
Kevin Stevesef4eea92001-02-05 12:42:17 +0000240/*
Damien Miller040f3832000-04-03 14:50:43 +1000241 * FIXME: proper entropy estimations. All current values are guesses
Damien Miller4018c192000-04-30 09:30:44 +1000242 * FIXME: (ATL) do estimates at compile time?
Damien Miller040f3832000-04-03 14:50:43 +1000243 * FIXME: More entropy sources
244 */
245
Damien Miller4018c192000-04-30 09:30:44 +1000246/* slow command timeouts (all in milliseconds) */
247/* static int entropy_timeout_default = ENTROPY_TIMEOUT_MSEC; */
248static int entropy_timeout_current = ENTROPY_TIMEOUT_MSEC;
249
Damien Miller0437b332000-05-02 09:56:41 +1000250static int prng_seed_saved = 0;
Damien Millerf9b625c2000-07-09 22:42:32 +1000251static int prng_initialised = 0;
252uid_t original_uid;
Damien Miller040f3832000-04-03 14:50:43 +1000253
254typedef struct
255{
256 /* Proportion of data that is entropy */
257 double rate;
Damien Miller4018c192000-04-30 09:30:44 +1000258 /* Counter goes positive if this command times out */
259 unsigned int badness;
260 /* Increases by factor of two each timeout */
261 unsigned int sticky_badness;
Damien Miller040f3832000-04-03 14:50:43 +1000262 /* Path to executable */
Damien Miller0437b332000-05-02 09:56:41 +1000263 char *path;
Damien Miller040f3832000-04-03 14:50:43 +1000264 /* argv to pass to executable */
Damien Miller0437b332000-05-02 09:56:41 +1000265 char *args[5];
Damien Miller8d1fd572000-05-17 21:34:07 +1000266 /* full command string (debug) */
267 char *cmdstring;
Damien Miller040f3832000-04-03 14:50:43 +1000268} entropy_source_t;
269
Damien Miller4018c192000-04-30 09:30:44 +1000270double stir_from_system(void);
271double stir_from_programs(void);
272double stir_gettimeofday(double entropy_estimate);
273double stir_clock(double entropy_estimate);
274double stir_rusage(int who, double entropy_estimate);
275double hash_output_from_command(entropy_source_t *src, char *hash);
276
Damien Miller0437b332000-05-02 09:56:41 +1000277/* this is initialised from a file, by prng_read_commands() */
278entropy_source_t *entropy_sources = NULL;
Damien Miller040f3832000-04-03 14:50:43 +1000279
Kevin Stevesef4eea92001-02-05 12:42:17 +0000280double
Damien Miller040f3832000-04-03 14:50:43 +1000281stir_from_system(void)
282{
283 double total_entropy_estimate;
284 long int i;
Kevin Stevesef4eea92001-02-05 12:42:17 +0000285
Damien Miller040f3832000-04-03 14:50:43 +1000286 total_entropy_estimate = 0;
Kevin Stevesef4eea92001-02-05 12:42:17 +0000287
Damien Miller040f3832000-04-03 14:50:43 +1000288 i = getpid();
Damien Miller7b22d652000-06-18 14:07:04 +1000289 RAND_add(&i, sizeof(i), 0.5);
Damien Miller040f3832000-04-03 14:50:43 +1000290 total_entropy_estimate += 0.1;
Kevin Stevesef4eea92001-02-05 12:42:17 +0000291
Damien Miller040f3832000-04-03 14:50:43 +1000292 i = getppid();
Damien Miller7b22d652000-06-18 14:07:04 +1000293 RAND_add(&i, sizeof(i), 0.5);
Damien Miller040f3832000-04-03 14:50:43 +1000294 total_entropy_estimate += 0.1;
295
296 i = getuid();
297 RAND_add(&i, sizeof(i), 0.0);
298 i = getgid();
299 RAND_add(&i, sizeof(i), 0.0);
300
301 total_entropy_estimate += stir_gettimeofday(1.0);
Damien Miller7b22d652000-06-18 14:07:04 +1000302 total_entropy_estimate += stir_clock(0.5);
Damien Miller040f3832000-04-03 14:50:43 +1000303 total_entropy_estimate += stir_rusage(RUSAGE_SELF, 2.0);
304
305 return(total_entropy_estimate);
306}
307
Kevin Stevesef4eea92001-02-05 12:42:17 +0000308double
Damien Miller040f3832000-04-03 14:50:43 +1000309stir_from_programs(void)
310{
311 int i;
312 int c;
313 double entropy_estimate;
314 double total_entropy_estimate;
315 char hash[SHA_DIGEST_LENGTH];
316
Damien Miller040f3832000-04-03 14:50:43 +1000317 total_entropy_estimate = 0;
Damien Miller14c12cb2000-06-07 22:20:23 +1000318 for(i = 0; i < NUM_ENTROPY_RUNS; i++) {
Damien Miller040f3832000-04-03 14:50:43 +1000319 c = 0;
320 while (entropy_sources[c].path != NULL) {
Damien Miller040f3832000-04-03 14:50:43 +1000321
Damien Miller4018c192000-04-30 09:30:44 +1000322 if (!entropy_sources[c].badness) {
323 /* Hash output from command */
324 entropy_estimate = hash_output_from_command(&entropy_sources[c], hash);
325
326 /* Scale back entropy estimate according to command's rate */
327 entropy_estimate *= entropy_sources[c].rate;
Kevin Stevesef4eea92001-02-05 12:42:17 +0000328
Damien Miller4018c192000-04-30 09:30:44 +1000329 /* Upper bound of entropy estimate is SHA_DIGEST_LENGTH */
330 if (entropy_estimate > SHA_DIGEST_LENGTH)
331 entropy_estimate = SHA_DIGEST_LENGTH;
Damien Miller040f3832000-04-03 14:50:43 +1000332
Kevin Stevesef4eea92001-02-05 12:42:17 +0000333 /* Scale back estimates for subsequent passes through list */
Damien Miller14c12cb2000-06-07 22:20:23 +1000334 entropy_estimate /= SCALE_PER_RUN * (i + 1.0);
Kevin Stevesef4eea92001-02-05 12:42:17 +0000335
Damien Miller4018c192000-04-30 09:30:44 +1000336 /* Stir it in */
337 RAND_add(hash, sizeof(hash), entropy_estimate);
Damien Miller040f3832000-04-03 14:50:43 +1000338
Kevin Stevesef4eea92001-02-05 12:42:17 +0000339 debug3("Got %0.2f bytes of entropy from '%s'", entropy_estimate,
Damien Miller8d1fd572000-05-17 21:34:07 +1000340 entropy_sources[c].cmdstring);
Damien Miller040f3832000-04-03 14:50:43 +1000341
Damien Miller4018c192000-04-30 09:30:44 +1000342 total_entropy_estimate += entropy_estimate;
Damien Miller040f3832000-04-03 14:50:43 +1000343
344 /* Execution times should be a little unpredictable */
Damien Miller4018c192000-04-30 09:30:44 +1000345 total_entropy_estimate += stir_gettimeofday(0.05);
346 total_entropy_estimate += stir_clock(0.05);
347 total_entropy_estimate += stir_rusage(RUSAGE_SELF, 0.1);
348 total_entropy_estimate += stir_rusage(RUSAGE_CHILDREN, 0.1);
349 } else {
Damien Millercb5e44a2000-09-29 12:12:36 +1100350 debug2("Command '%s' disabled (badness %d)",
Damien Miller8d1fd572000-05-17 21:34:07 +1000351 entropy_sources[c].cmdstring, entropy_sources[c].badness);
Damien Miller4018c192000-04-30 09:30:44 +1000352
353 if (entropy_sources[c].badness > 0)
354 entropy_sources[c].badness--;
355 }
356
Damien Miller040f3832000-04-03 14:50:43 +1000357 c++;
358 }
359 }
Kevin Stevesef4eea92001-02-05 12:42:17 +0000360
Damien Miller040f3832000-04-03 14:50:43 +1000361 return(total_entropy_estimate);
362}
363
364double
365stir_gettimeofday(double entropy_estimate)
366{
367 struct timeval tv;
Kevin Stevesef4eea92001-02-05 12:42:17 +0000368
Damien Miller040f3832000-04-03 14:50:43 +1000369 if (gettimeofday(&tv, NULL) == -1)
370 fatal("Couldn't gettimeofday: %s", strerror(errno));
371
372 RAND_add(&tv, sizeof(tv), entropy_estimate);
Kevin Stevesef4eea92001-02-05 12:42:17 +0000373
Damien Miller040f3832000-04-03 14:50:43 +1000374 return(entropy_estimate);
375}
376
377double
378stir_clock(double entropy_estimate)
379{
380#ifdef HAVE_CLOCK
381 clock_t c;
Kevin Stevesef4eea92001-02-05 12:42:17 +0000382
Damien Miller040f3832000-04-03 14:50:43 +1000383 c = clock();
384 RAND_add(&c, sizeof(c), entropy_estimate);
Kevin Stevesef4eea92001-02-05 12:42:17 +0000385
Damien Miller040f3832000-04-03 14:50:43 +1000386 return(entropy_estimate);
387#else /* _HAVE_CLOCK */
388 return(0);
389#endif /* _HAVE_CLOCK */
390}
391
392double
393stir_rusage(int who, double entropy_estimate)
394{
395#ifdef HAVE_GETRUSAGE
396 struct rusage ru;
Kevin Stevesef4eea92001-02-05 12:42:17 +0000397
Damien Miller4018c192000-04-30 09:30:44 +1000398 if (getrusage(who, &ru) == -1)
Damien Miller7b22d652000-06-18 14:07:04 +1000399 return(0);
Damien Miller040f3832000-04-03 14:50:43 +1000400
Damien Miller7b22d652000-06-18 14:07:04 +1000401 RAND_add(&ru, sizeof(ru), entropy_estimate);
Damien Miller040f3832000-04-03 14:50:43 +1000402
403 return(entropy_estimate);
404#else /* _HAVE_GETRUSAGE */
405 return(0);
406#endif /* _HAVE_GETRUSAGE */
407}
408
Damien Miller8d1fd572000-05-17 21:34:07 +1000409
Damien Miller60bc5172001-03-19 09:38:15 +1100410static int
Damien Miller8d1fd572000-05-17 21:34:07 +1000411_get_timeval_msec_difference(struct timeval *t1, struct timeval *t2) {
412 int secdiff, usecdiff;
413
414 secdiff = t2->tv_sec - t1->tv_sec;
415 usecdiff = (secdiff*1000000) + (t2->tv_usec - t1->tv_usec);
416 return (int)(usecdiff / 1000);
417}
418
Damien Miller040f3832000-04-03 14:50:43 +1000419double
Damien Miller4018c192000-04-30 09:30:44 +1000420hash_output_from_command(entropy_source_t *src, char *hash)
Damien Miller040f3832000-04-03 14:50:43 +1000421{
422 static int devnull = -1;
423 int p[2];
Damien Miller4018c192000-04-30 09:30:44 +1000424 fd_set rdset;
425 int cmd_eof = 0, error_abort = 0;
Damien Miller8d1fd572000-05-17 21:34:07 +1000426 struct timeval tv_start, tv_current;
427 int msec_elapsed = 0;
Damien Miller040f3832000-04-03 14:50:43 +1000428 pid_t pid;
429 int status;
Damien Miller8d1fd572000-05-17 21:34:07 +1000430 char buf[16384];
Damien Miller040f3832000-04-03 14:50:43 +1000431 int bytes_read;
432 int total_bytes_read;
433 SHA_CTX sha;
Kevin Stevesef4eea92001-02-05 12:42:17 +0000434
Damien Millercb5e44a2000-09-29 12:12:36 +1100435 debug3("Reading output from \'%s\'", src->cmdstring);
436
Damien Miller040f3832000-04-03 14:50:43 +1000437 if (devnull == -1) {
438 devnull = open("/dev/null", O_RDWR);
439 if (devnull == -1)
440 fatal("Couldn't open /dev/null: %s", strerror(errno));
441 }
Kevin Stevesef4eea92001-02-05 12:42:17 +0000442
Damien Miller040f3832000-04-03 14:50:43 +1000443 if (pipe(p) == -1)
444 fatal("Couldn't open pipe: %s", strerror(errno));
445
Damien Miller8d1fd572000-05-17 21:34:07 +1000446 (void)gettimeofday(&tv_start, NULL); /* record start time */
447
Damien Miller040f3832000-04-03 14:50:43 +1000448 switch (pid = fork()) {
449 case -1: /* Error */
450 close(p[0]);
451 close(p[1]);
452 fatal("Couldn't fork: %s", strerror(errno));
453 /* NOTREACHED */
454 case 0: /* Child */
Damien Miller4018c192000-04-30 09:30:44 +1000455 dup2(devnull, STDIN_FILENO);
456 dup2(p[1], STDOUT_FILENO);
457 dup2(p[1], STDERR_FILENO);
Damien Miller040f3832000-04-03 14:50:43 +1000458 close(p[0]);
459 close(p[1]);
460 close(devnull);
461
Damien Millerf9b625c2000-07-09 22:42:32 +1000462 setuid(original_uid);
Damien Miller4018c192000-04-30 09:30:44 +1000463 execv(src->path, (char**)(src->args));
Damien Miller8d1fd572000-05-17 21:34:07 +1000464 debug("(child) Couldn't exec '%s': %s", src->cmdstring,
465 strerror(errno));
Damien Miller040f3832000-04-03 14:50:43 +1000466 _exit(-1);
467 default: /* Parent */
468 break;
469 }
470
471 RAND_add(&pid, sizeof(&pid), 0.0);
472
473 close(p[1]);
474
475 /* Hash output from child */
476 SHA1_Init(&sha);
477 total_bytes_read = 0;
Damien Miller4018c192000-04-30 09:30:44 +1000478
479 while (!error_abort && !cmd_eof) {
480 int ret;
481 struct timeval tv;
Damien Miller8d1fd572000-05-17 21:34:07 +1000482 int msec_remaining;
483
484 (void) gettimeofday(&tv_current, 0);
Damien Miller14c12cb2000-06-07 22:20:23 +1000485 msec_elapsed = _get_timeval_msec_difference(&tv_start, &tv_current);
Damien Miller8d1fd572000-05-17 21:34:07 +1000486 if (msec_elapsed >= entropy_timeout_current) {
487 error_abort=1;
488 continue;
489 }
490 msec_remaining = entropy_timeout_current - msec_elapsed;
Damien Miller4018c192000-04-30 09:30:44 +1000491
492 FD_ZERO(&rdset);
493 FD_SET(p[0], &rdset);
Damien Miller8d1fd572000-05-17 21:34:07 +1000494 tv.tv_sec = msec_remaining / 1000;
495 tv.tv_usec = (msec_remaining % 1000) * 1000;
Damien Miller4018c192000-04-30 09:30:44 +1000496
497 ret = select(p[0]+1, &rdset, NULL, NULL, &tv);
Damien Miller8d1fd572000-05-17 21:34:07 +1000498
Damien Millerf9b625c2000-07-09 22:42:32 +1000499 RAND_add(&tv, sizeof(tv), 0.0);
500
Damien Miller4018c192000-04-30 09:30:44 +1000501 switch (ret) {
502 case 0:
503 /* timer expired */
504 error_abort = 1;
505 break;
Damien Miller4018c192000-04-30 09:30:44 +1000506 case 1:
507 /* command input */
508 bytes_read = read(p[0], buf, sizeof(buf));
Damien Millerf9b625c2000-07-09 22:42:32 +1000509 RAND_add(&bytes_read, sizeof(&bytes_read), 0.0);
Damien Miller4018c192000-04-30 09:30:44 +1000510 if (bytes_read == -1) {
511 error_abort = 1;
512 break;
Damien Millerf9b625c2000-07-09 22:42:32 +1000513 } else if (bytes_read) {
Damien Miller8d1fd572000-05-17 21:34:07 +1000514 SHA1_Update(&sha, buf, bytes_read);
515 total_bytes_read += bytes_read;
Damien Millerf9b625c2000-07-09 22:42:32 +1000516 } else {
Damien Miller8d1fd572000-05-17 21:34:07 +1000517 cmd_eof = 1;
Damien Millerf9b625c2000-07-09 22:42:32 +1000518 }
Damien Miller4018c192000-04-30 09:30:44 +1000519 break;
Damien Miller4018c192000-04-30 09:30:44 +1000520 case -1:
521 default:
Damien Millerf9b625c2000-07-09 22:42:32 +1000522 /* error */
Damien Miller8d1fd572000-05-17 21:34:07 +1000523 debug("Command '%s': select() failed: %s", src->cmdstring,
524 strerror(errno));
Damien Miller4018c192000-04-30 09:30:44 +1000525 error_abort = 1;
526 break;
Damien Millerf9b625c2000-07-09 22:42:32 +1000527 }
528 }
Damien Miller4018c192000-04-30 09:30:44 +1000529
Damien Miller040f3832000-04-03 14:50:43 +1000530 SHA1_Final(hash, &sha);
531
532 close(p[0]);
Damien Miller8d1fd572000-05-17 21:34:07 +1000533
Damien Millercb5e44a2000-09-29 12:12:36 +1100534 debug3("Time elapsed: %d msec", msec_elapsed);
Kevin Stevesef4eea92001-02-05 12:42:17 +0000535
Damien Miller040f3832000-04-03 14:50:43 +1000536 if (waitpid(pid, &status, 0) == -1) {
Damien Millercb5e44a2000-09-29 12:12:36 +1100537 error("Couldn't wait for child '%s' completion: %s", src->cmdstring,
Damien Miller8d1fd572000-05-17 21:34:07 +1000538 strerror(errno));
Damien Miller4018c192000-04-30 09:30:44 +1000539 return(0.0);
Damien Miller040f3832000-04-03 14:50:43 +1000540 }
541
542 RAND_add(&status, sizeof(&status), 0.0);
543
Damien Miller4018c192000-04-30 09:30:44 +1000544 if (error_abort) {
545 /* closing p[0] on timeout causes the entropy command to
546 * SIGPIPE. Take whatever output we got, and mark this command
547 * as slow */
Damien Millercb5e44a2000-09-29 12:12:36 +1100548 debug2("Command '%s' timed out", src->cmdstring);
Damien Miller4018c192000-04-30 09:30:44 +1000549 src->sticky_badness *= 2;
550 src->badness = src->sticky_badness;
Damien Miller040f3832000-04-03 14:50:43 +1000551 return(total_bytes_read);
Damien Miller4018c192000-04-30 09:30:44 +1000552 }
553
554 if (WIFEXITED(status)) {
555 if (WEXITSTATUS(status)==0) {
556 return(total_bytes_read);
557 } else {
Kevin Stevesef4eea92001-02-05 12:42:17 +0000558 debug2("Command '%s' exit status was %d", src->cmdstring,
Damien Miller14c12cb2000-06-07 22:20:23 +1000559 WEXITSTATUS(status));
Damien Miller4018c192000-04-30 09:30:44 +1000560 src->badness = src->sticky_badness = 128;
561 return (0.0);
562 }
563 } else if (WIFSIGNALED(status)) {
Kevin Stevesef4eea92001-02-05 12:42:17 +0000564 debug2("Command '%s' returned on uncaught signal %d !", src->cmdstring,
Damien Miller14c12cb2000-06-07 22:20:23 +1000565 status);
Damien Miller4018c192000-04-30 09:30:44 +1000566 src->badness = src->sticky_badness = 128;
567 return(0.0);
568 } else
569 return(0.0);
Damien Miller040f3832000-04-03 14:50:43 +1000570}
Damien Miller4018c192000-04-30 09:30:44 +1000571
572/*
573 * prng seedfile functions
574 */
575int
576prng_check_seedfile(char *filename) {
577
578 struct stat st;
579
580 /* FIXME raceable: eg replace seed between this stat and subsequent open */
581 /* Not such a problem because we don't trust the seed file anyway */
582 if (lstat(filename, &st) == -1) {
Damien Miller52dc96b2000-10-16 20:13:43 +1100583 /* Give up on hard errors */
Damien Miller4018c192000-04-30 09:30:44 +1000584 if (errno != ENOENT)
Kevin Stevesef4eea92001-02-05 12:42:17 +0000585 debug("WARNING: Couldn't stat random seed file \"%s\": %s",
Damien Miller52dc96b2000-10-16 20:13:43 +1100586 filename, strerror(errno));
Damien Miller4018c192000-04-30 09:30:44 +1000587
588 return(0);
589 }
590
591 /* regular file? */
592 if (!S_ISREG(st.st_mode))
593 fatal("PRNG seedfile %.100s is not a regular file", filename);
594
595 /* mode 0600, owned by root or the current user? */
Damien Miller52dc96b2000-10-16 20:13:43 +1100596 if (((st.st_mode & 0177) != 0) || !(st.st_uid == original_uid)) {
597 debug("WARNING: PRNG seedfile %.100s must be mode 0600, owned by uid %d",
Damien Miller4018c192000-04-30 09:30:44 +1000598 filename, getuid());
Damien Miller52dc96b2000-10-16 20:13:43 +1100599 return(0);
600 }
Kevin Stevesef4eea92001-02-05 12:42:17 +0000601
Damien Miller4018c192000-04-30 09:30:44 +1000602 return(1);
603}
604
605void
606prng_write_seedfile(void) {
607 int fd;
608 char seed[1024];
609 char filename[1024];
610 struct passwd *pw;
611
612 /* Don't bother if we have already saved a seed */
613 if (prng_seed_saved)
614 return;
Kevin Stevesef4eea92001-02-05 12:42:17 +0000615
Damien Millerf9b625c2000-07-09 22:42:32 +1000616 setuid(original_uid);
Kevin Stevesef4eea92001-02-05 12:42:17 +0000617
Damien Millerfc0b11b2000-05-02 00:03:55 +1000618 prng_seed_saved = 1;
Kevin Stevesef4eea92001-02-05 12:42:17 +0000619
Damien Millerf9b625c2000-07-09 22:42:32 +1000620 pw = getpwuid(original_uid);
Damien Miller4018c192000-04-30 09:30:44 +1000621 if (pw == NULL)
Kevin Stevesef4eea92001-02-05 12:42:17 +0000622 fatal("Couldn't get password entry for current user (%i): %s",
Damien Millerf9b625c2000-07-09 22:42:32 +1000623 original_uid, strerror(errno));
Kevin Stevesef4eea92001-02-05 12:42:17 +0000624
Damien Miller4018c192000-04-30 09:30:44 +1000625 /* Try to ensure that the parent directory is there */
Kevin Stevesef4eea92001-02-05 12:42:17 +0000626 snprintf(filename, sizeof(filename), "%.512s/%s", pw->pw_dir,
Ben Lindstromcb577332001-01-22 21:06:19 +0000627 _PATH_SSH_USER_DIR);
Damien Miller4018c192000-04-30 09:30:44 +1000628 mkdir(filename, 0700);
629
Kevin Stevesef4eea92001-02-05 12:42:17 +0000630 snprintf(filename, sizeof(filename), "%.512s/%s", pw->pw_dir,
Damien Miller4018c192000-04-30 09:30:44 +1000631 SSH_PRNG_SEED_FILE);
632
633 debug("writing PRNG seed to file %.100s", filename);
634
635 RAND_bytes(seed, sizeof(seed));
636
637 /* Don't care if the seed doesn't exist */
638 prng_check_seedfile(filename);
Kevin Stevesef4eea92001-02-05 12:42:17 +0000639
Damien Miller52dc96b2000-10-16 20:13:43 +1100640 if ((fd = open(filename, O_WRONLY|O_TRUNC|O_CREAT, 0600)) == -1) {
Kevin Stevesef4eea92001-02-05 12:42:17 +0000641 debug("WARNING: couldn't access PRNG seedfile %.100s (%.100s)",
Damien Miller52dc96b2000-10-16 20:13:43 +1100642 filename, strerror(errno));
Kevin Stevesef4eea92001-02-05 12:42:17 +0000643 } else {
Damien Miller52dc96b2000-10-16 20:13:43 +1100644 if (atomicio(write, fd, &seed, sizeof(seed)) != sizeof(seed))
Kevin Stevesef4eea92001-02-05 12:42:17 +0000645 fatal("problem writing PRNG seedfile %.100s (%.100s)", filename,
Damien Miller52dc96b2000-10-16 20:13:43 +1100646 strerror(errno));
Damien Miller4018c192000-04-30 09:30:44 +1000647
Damien Miller52dc96b2000-10-16 20:13:43 +1100648 close(fd);
649 }
Damien Miller4018c192000-04-30 09:30:44 +1000650}
651
652void
653prng_read_seedfile(void) {
654 int fd;
655 char seed[1024];
656 char filename[1024];
657 struct passwd *pw;
Kevin Stevesef4eea92001-02-05 12:42:17 +0000658
Damien Millerf9b625c2000-07-09 22:42:32 +1000659 pw = getpwuid(original_uid);
Damien Miller4018c192000-04-30 09:30:44 +1000660 if (pw == NULL)
Kevin Stevesef4eea92001-02-05 12:42:17 +0000661 fatal("Couldn't get password entry for current user (%i): %s",
Damien Millerf9b625c2000-07-09 22:42:32 +1000662 original_uid, strerror(errno));
Kevin Stevesef4eea92001-02-05 12:42:17 +0000663
664 snprintf(filename, sizeof(filename), "%.512s/%s", pw->pw_dir,
Damien Miller4018c192000-04-30 09:30:44 +1000665 SSH_PRNG_SEED_FILE);
666
667 debug("loading PRNG seed from file %.100s", filename);
668
669 if (!prng_check_seedfile(filename)) {
Damien Miller21de4502001-01-17 09:37:15 +1100670 verbose("Random seed file not found or not valid, ignoring.");
Damien Miller4018c192000-04-30 09:30:44 +1000671 return;
672 }
673
674 /* open the file and read in the seed */
675 fd = open(filename, O_RDONLY);
676 if (fd == -1)
Kevin Stevesef4eea92001-02-05 12:42:17 +0000677 fatal("could not open PRNG seedfile %.100s (%.100s)", filename,
Damien Miller4018c192000-04-30 09:30:44 +1000678 strerror(errno));
679
680 if (atomicio(read, fd, &seed, sizeof(seed)) != sizeof(seed)) {
681 verbose("invalid or short read from PRNG seedfile %.100s - ignoring",
682 filename);
683 memset(seed, '\0', sizeof(seed));
684 }
685 close(fd);
686
687 /* stir in the seed, with estimated entropy zero */
688 RAND_add(&seed, sizeof(seed), 0.0);
689}
690
Damien Miller0437b332000-05-02 09:56:41 +1000691
692/*
693 * entropy command initialisation functions
694 */
Damien Miller0437b332000-05-02 09:56:41 +1000695int
696prng_read_commands(char *cmdfilename)
697{
698 FILE *f;
Damien Miller0437b332000-05-02 09:56:41 +1000699 char *cp;
Damien Miller14c12cb2000-06-07 22:20:23 +1000700 char line[1024];
701 char cmd[1024];
702 char path[256];
Damien Miller0437b332000-05-02 09:56:41 +1000703 int linenum;
Damien Miller0437b332000-05-02 09:56:41 +1000704 int num_cmds = 64;
705 int cur_cmd = 0;
Damien Miller14c12cb2000-06-07 22:20:23 +1000706 double est;
707 entropy_source_t *entcmd;
Damien Miller0437b332000-05-02 09:56:41 +1000708
709 f = fopen(cmdfilename, "r");
710 if (!f) {
711 fatal("couldn't read entropy commands file %.100s: %.100s",
712 cmdfilename, strerror(errno));
713 }
714
Damien Miller0437b332000-05-02 09:56:41 +1000715 entcmd = (entropy_source_t *)xmalloc(num_cmds * sizeof(entropy_source_t));
716 memset(entcmd, '\0', num_cmds * sizeof(entropy_source_t));
717
Damien Miller14c12cb2000-06-07 22:20:23 +1000718 /* Read in file */
719 linenum = 0;
Damien Miller0437b332000-05-02 09:56:41 +1000720 while (fgets(line, sizeof(line), f)) {
Damien Miller14c12cb2000-06-07 22:20:23 +1000721 int arg;
722 char *argv;
723
Damien Miller0437b332000-05-02 09:56:41 +1000724 linenum++;
725
726 /* skip leading whitespace, test for blank line or comment */
727 cp = line + strspn(line, WHITESPACE);
728 if ((*cp == 0) || (*cp == '#'))
729 continue; /* done with this line */
730
Damien Miller14c12cb2000-06-07 22:20:23 +1000731 /* First non-whitespace char should be double quote delimiting */
732 /* commandline */
733 if (*cp != '"') {
Damien Miller0437b332000-05-02 09:56:41 +1000734 error("bad entropy command, %.100s line %d", cmdfilename,
735 linenum);
736 continue;
Kevin Stevesef4eea92001-02-05 12:42:17 +0000737 }
Damien Miller14c12cb2000-06-07 22:20:23 +1000738
739 /* first token, command args (incl. argv[0]) in double quotes */
740 cp = strtok(cp, "\"");
741 if (cp == NULL) {
742 error("missing or bad command string, %.100s line %d -- ignored",
743 cmdfilename, linenum);
744 continue;
745 }
746 strlcpy(cmd, cp, sizeof(cmd));
Kevin Stevesef4eea92001-02-05 12:42:17 +0000747
Damien Miller14c12cb2000-06-07 22:20:23 +1000748 /* second token, full command path */
749 if ((cp = strtok(NULL, WHITESPACE)) == NULL) {
750 error("missing command path, %.100s line %d -- ignored",
751 cmdfilename, linenum);
752 continue;
753 }
754
755 /* did configure mark this as dead? */
756 if (strncmp("undef", cp, 5) == 0)
757 continue;
758
Kevin Stevesef4eea92001-02-05 12:42:17 +0000759 strlcpy(path, cp, sizeof(path));
Damien Miller14c12cb2000-06-07 22:20:23 +1000760
761 /* third token, entropy rate estimate for this command */
762 if ((cp = strtok(NULL, WHITESPACE)) == NULL) {
763 error("missing entropy estimate, %.100s line %d -- ignored",
764 cmdfilename, linenum);
765 continue;
766 }
767 est = strtod(cp, &argv);
768
769 /* end of line */
770 if ((cp = strtok(NULL, WHITESPACE)) != NULL) {
Kevin Stevesef4eea92001-02-05 12:42:17 +0000771 error("garbage at end of line %d in %.100s -- ignored", linenum,
Damien Miller14c12cb2000-06-07 22:20:23 +1000772 cmdfilename);
773 continue;
774 }
775
776 /* save the command for debug messages */
777 entcmd[cur_cmd].cmdstring = xstrdup(cmd);
Kevin Stevesef4eea92001-02-05 12:42:17 +0000778
Damien Miller14c12cb2000-06-07 22:20:23 +1000779 /* split the command args */
780 cp = strtok(cmd, WHITESPACE);
781 arg = 0;
782 argv = NULL;
783 do {
784 char *s = (char*)xmalloc(strlen(cp) + 1);
785 strncpy(s, cp, strlen(cp) + 1);
786 entcmd[cur_cmd].args[arg] = s;
787 arg++;
788 } while ((arg < 5) && (cp = strtok(NULL, WHITESPACE)));
Kevin Stevesef4eea92001-02-05 12:42:17 +0000789
Damien Miller14c12cb2000-06-07 22:20:23 +1000790 if (strtok(NULL, WHITESPACE))
791 error("ignored extra command elements (max 5), %.100s line %d",
792 cmdfilename, linenum);
793
794 /* Copy the command path and rate estimate */
795 entcmd[cur_cmd].path = xstrdup(path);
796 entcmd[cur_cmd].rate = est;
797
798 /* Initialise other values */
799 entcmd[cur_cmd].sticky_badness = 1;
800
801 cur_cmd++;
802
803 /* If we've filled the array, reallocate it twice the size */
804 /* Do this now because even if this we're on the last command,
805 we need another slot to mark the last entry */
806 if (cur_cmd == num_cmds) {
807 num_cmds *= 2;
808 entcmd = xrealloc(entcmd, num_cmds * sizeof(entropy_source_t));
Damien Miller0437b332000-05-02 09:56:41 +1000809 }
810 }
811
812 /* zero the last entry */
813 memset(&entcmd[cur_cmd], '\0', sizeof(entropy_source_t));
Damien Miller14c12cb2000-06-07 22:20:23 +1000814
Damien Miller0437b332000-05-02 09:56:41 +1000815 /* trim to size */
816 entropy_sources = xrealloc(entcmd, (cur_cmd+1) * sizeof(entropy_source_t));
817
Damien Millerf9b625c2000-07-09 22:42:32 +1000818 debug("Loaded %d entropy commands from %.100s", cur_cmd, cmdfilename);
Damien Miller0437b332000-05-02 09:56:41 +1000819
820 return (cur_cmd >= MIN_ENTROPY_SOURCES);
821}
822
Damien Miller040f3832000-04-03 14:50:43 +1000823/*
Damien Miller4018c192000-04-30 09:30:44 +1000824 * Write a keyfile at exit
Kevin Stevesef4eea92001-02-05 12:42:17 +0000825 */
Damien Miller4018c192000-04-30 09:30:44 +1000826void
827prng_seed_cleanup(void *junk)
828{
829 prng_write_seedfile();
830}
831
832/*
833 * Conditionally Seed OpenSSL's random number pool from
834 * syscalls and program output
Damien Miller040f3832000-04-03 14:50:43 +1000835 */
836void
837seed_rng(void)
838{
Damien Millera1072a82001-02-18 15:28:11 +1100839 mysig_t old_sigchld_handler;
Damien Miller0437b332000-05-02 09:56:41 +1000840
Damien Millerf9b625c2000-07-09 22:42:32 +1000841 if (!prng_initialised)
842 fatal("RNG not initialised");
Kevin Stevesef4eea92001-02-05 12:42:17 +0000843
Damien Millerf3c6cf12000-05-17 22:08:29 +1000844 /* Make sure some other sigchld handler doesn't reap our entropy */
845 /* commands */
Damien Millera1072a82001-02-18 15:28:11 +1100846 old_sigchld_handler = mysignal(SIGCHLD, SIG_DFL);
Damien Millerf3c6cf12000-05-17 22:08:29 +1000847
Damien Miller60bc5172001-03-19 09:38:15 +1100848 debug("Seeded RNG with %i bytes from programs",
849 (int)stir_from_programs());
850 debug("Seeded RNG with %i bytes from system calls",
851 (int)stir_from_system());
Damien Millerf9b625c2000-07-09 22:42:32 +1000852
853 if (!RAND_status())
854 fatal("Not enough entropy in RNG");
Damien Miller4018c192000-04-30 09:30:44 +1000855
Damien Millera1072a82001-02-18 15:28:11 +1100856 mysignal(SIGCHLD, old_sigchld_handler);
Damien Millerf3c6cf12000-05-17 22:08:29 +1000857
Damien Miller8d1fd572000-05-17 21:34:07 +1000858 if (!RAND_status())
859 fatal("Couldn't initialise builtin random number generator -- exiting.");
Damien Miller040f3832000-04-03 14:50:43 +1000860}
Damien Millerf9b625c2000-07-09 22:42:32 +1000861
Damien Miller60bc5172001-03-19 09:38:15 +1100862void
863init_rng(void)
Damien Millerf9b625c2000-07-09 22:42:32 +1000864{
Damien Millerd592b632000-11-25 10:09:32 +1100865 int original_euid;
Kevin Stevesef4eea92001-02-05 12:42:17 +0000866
Damien Miller767c7fc2001-02-27 09:20:57 +1100867 check_openssl_version();
868
Damien Millerf9b625c2000-07-09 22:42:32 +1000869 original_uid = getuid();
Damien Millerd592b632000-11-25 10:09:32 +1100870 original_euid = geteuid();
Damien Millerf9b625c2000-07-09 22:42:32 +1000871
872 /* Read in collection commands */
873 if (!prng_read_commands(SSH_PRNG_COMMAND_FILE))
874 fatal("PRNG initialisation failed -- exiting.");
875
876 /* Set ourselves up to save a seed upon exit */
Kevin Stevesef4eea92001-02-05 12:42:17 +0000877 prng_seed_saved = 0;
Damien Millerd592b632000-11-25 10:09:32 +1100878
879 /* Give up privs while reading seed file */
Damien Millerbb7c9762001-02-26 20:49:58 +1100880#ifdef SAVED_IDS_WORK_WITH_SETEUID
Damien Millerd592b632000-11-25 10:09:32 +1100881 if ((original_uid != original_euid) && (seteuid(original_uid) == -1))
882 fatal("Couldn't give up privileges");
Damien Millerbb7c9762001-02-26 20:49:58 +1100883#else /* SAVED_IDS_WORK_WITH_SETEUID */
884 /*
885 * Propagate the privileged uid to all of our uids.
886 * Set the effective uid to the given (unprivileged) uid.
887 */
Damien Miller248131a2001-02-27 09:47:16 +1100888 if (original_uid != original_euid && (setuid(original_euid) == -1 ||
889 seteuid(original_uid) == -1))
Damien Millerbb7c9762001-02-26 20:49:58 +1100890 fatal("Couldn't give up privileges");
891#endif /* SAVED_IDS_WORK_WITH_SETEUID */
Kevin Stevesef4eea92001-02-05 12:42:17 +0000892
Damien Millerf9b625c2000-07-09 22:42:32 +1000893 prng_read_seedfile();
Damien Millerd592b632000-11-25 10:09:32 +1100894
Damien Millerbb7c9762001-02-26 20:49:58 +1100895#ifdef SAVED_IDS_WORK_WITH_SETEUID
Damien Millerd592b632000-11-25 10:09:32 +1100896 if ((original_uid != original_euid) && (seteuid(original_euid) == -1))
897 fatal("Couldn't restore privileges");
Damien Millerbb7c9762001-02-26 20:49:58 +1100898#else /* SAVED_IDS_WORK_WITH_SETEUID */
899 /*
900 * We are unable to restore the real uid to its unprivileged value.
901 * Propagate the real uid (usually more privileged) to effective uid
902 * as well.
903 */
Damien Miller248131a2001-02-27 09:47:16 +1100904 if (original_uid != original_euid && (seteuid(original_euid) == -1 ||
905 setuid(original_uid) == -1))
Damien Millerbb7c9762001-02-26 20:49:58 +1100906 fatal("Couldn't restore privileges");
907#endif /* SAVED_IDS_WORK_WITH_SETEUID */
Damien Millerd592b632000-11-25 10:09:32 +1100908
Damien Millerf9b625c2000-07-09 22:42:32 +1000909 fatal_add_cleanup(prng_seed_cleanup, NULL);
910 atexit(prng_write_seedfile);
911
912 prng_initialised = 1;
913}
914
Damien Millerd0ccb982001-03-04 00:29:20 +1100915#endif /* defined(USE_PRNGD) || defined(RANDOM_POOL) */