blob: d9760cc1d4268769f9506e97c95c31d637c81513 [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 Miller2ab59242001-08-06 16:51:49 +100043RCSID("$Id: entropy.c,v 1.38 2001/08/06 06:51:49 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 */
Damien Miller2ab59242001-08-06 16:51:49 +1000508 do {
509 bytes_read = read(p[0], buf, sizeof(buf));
510 } while (bytes_read == -1 && errno == EINTR);
Damien Millerf9b625c2000-07-09 22:42:32 +1000511 RAND_add(&bytes_read, sizeof(&bytes_read), 0.0);
Damien Miller4018c192000-04-30 09:30:44 +1000512 if (bytes_read == -1) {
513 error_abort = 1;
514 break;
Damien Millerf9b625c2000-07-09 22:42:32 +1000515 } else if (bytes_read) {
Damien Miller8d1fd572000-05-17 21:34:07 +1000516 SHA1_Update(&sha, buf, bytes_read);
517 total_bytes_read += bytes_read;
Damien Millerf9b625c2000-07-09 22:42:32 +1000518 } else {
Damien Miller8d1fd572000-05-17 21:34:07 +1000519 cmd_eof = 1;
Damien Millerf9b625c2000-07-09 22:42:32 +1000520 }
Damien Miller4018c192000-04-30 09:30:44 +1000521 break;
Damien Miller4018c192000-04-30 09:30:44 +1000522 case -1:
523 default:
Damien Millerf9b625c2000-07-09 22:42:32 +1000524 /* error */
Damien Miller8d1fd572000-05-17 21:34:07 +1000525 debug("Command '%s': select() failed: %s", src->cmdstring,
526 strerror(errno));
Damien Miller4018c192000-04-30 09:30:44 +1000527 error_abort = 1;
528 break;
Damien Millerf9b625c2000-07-09 22:42:32 +1000529 }
530 }
Damien Miller4018c192000-04-30 09:30:44 +1000531
Damien Miller040f3832000-04-03 14:50:43 +1000532 SHA1_Final(hash, &sha);
533
534 close(p[0]);
Damien Miller8d1fd572000-05-17 21:34:07 +1000535
Damien Millercb5e44a2000-09-29 12:12:36 +1100536 debug3("Time elapsed: %d msec", msec_elapsed);
Kevin Stevesef4eea92001-02-05 12:42:17 +0000537
Damien Miller040f3832000-04-03 14:50:43 +1000538 if (waitpid(pid, &status, 0) == -1) {
Damien Millercb5e44a2000-09-29 12:12:36 +1100539 error("Couldn't wait for child '%s' completion: %s", src->cmdstring,
Damien Miller8d1fd572000-05-17 21:34:07 +1000540 strerror(errno));
Damien Miller4018c192000-04-30 09:30:44 +1000541 return(0.0);
Damien Miller040f3832000-04-03 14:50:43 +1000542 }
543
544 RAND_add(&status, sizeof(&status), 0.0);
545
Damien Miller4018c192000-04-30 09:30:44 +1000546 if (error_abort) {
547 /* closing p[0] on timeout causes the entropy command to
548 * SIGPIPE. Take whatever output we got, and mark this command
549 * as slow */
Damien Millercb5e44a2000-09-29 12:12:36 +1100550 debug2("Command '%s' timed out", src->cmdstring);
Damien Miller4018c192000-04-30 09:30:44 +1000551 src->sticky_badness *= 2;
552 src->badness = src->sticky_badness;
Damien Miller040f3832000-04-03 14:50:43 +1000553 return(total_bytes_read);
Damien Miller4018c192000-04-30 09:30:44 +1000554 }
555
556 if (WIFEXITED(status)) {
557 if (WEXITSTATUS(status)==0) {
558 return(total_bytes_read);
559 } else {
Kevin Stevesef4eea92001-02-05 12:42:17 +0000560 debug2("Command '%s' exit status was %d", src->cmdstring,
Damien Miller14c12cb2000-06-07 22:20:23 +1000561 WEXITSTATUS(status));
Damien Miller4018c192000-04-30 09:30:44 +1000562 src->badness = src->sticky_badness = 128;
563 return (0.0);
564 }
565 } else if (WIFSIGNALED(status)) {
Kevin Stevesef4eea92001-02-05 12:42:17 +0000566 debug2("Command '%s' returned on uncaught signal %d !", src->cmdstring,
Damien Miller14c12cb2000-06-07 22:20:23 +1000567 status);
Damien Miller4018c192000-04-30 09:30:44 +1000568 src->badness = src->sticky_badness = 128;
569 return(0.0);
570 } else
571 return(0.0);
Damien Miller040f3832000-04-03 14:50:43 +1000572}
Damien Miller4018c192000-04-30 09:30:44 +1000573
574/*
575 * prng seedfile functions
576 */
577int
578prng_check_seedfile(char *filename) {
579
580 struct stat st;
581
582 /* FIXME raceable: eg replace seed between this stat and subsequent open */
583 /* Not such a problem because we don't trust the seed file anyway */
584 if (lstat(filename, &st) == -1) {
Damien Miller52dc96b2000-10-16 20:13:43 +1100585 /* Give up on hard errors */
Damien Miller4018c192000-04-30 09:30:44 +1000586 if (errno != ENOENT)
Kevin Stevesef4eea92001-02-05 12:42:17 +0000587 debug("WARNING: Couldn't stat random seed file \"%s\": %s",
Damien Miller52dc96b2000-10-16 20:13:43 +1100588 filename, strerror(errno));
Damien Miller4018c192000-04-30 09:30:44 +1000589
590 return(0);
591 }
592
593 /* regular file? */
594 if (!S_ISREG(st.st_mode))
595 fatal("PRNG seedfile %.100s is not a regular file", filename);
596
597 /* mode 0600, owned by root or the current user? */
Damien Miller52dc96b2000-10-16 20:13:43 +1100598 if (((st.st_mode & 0177) != 0) || !(st.st_uid == original_uid)) {
599 debug("WARNING: PRNG seedfile %.100s must be mode 0600, owned by uid %d",
Damien Miller4018c192000-04-30 09:30:44 +1000600 filename, getuid());
Damien Miller52dc96b2000-10-16 20:13:43 +1100601 return(0);
602 }
Kevin Stevesef4eea92001-02-05 12:42:17 +0000603
Damien Miller4018c192000-04-30 09:30:44 +1000604 return(1);
605}
606
607void
608prng_write_seedfile(void) {
609 int fd;
610 char seed[1024];
611 char filename[1024];
612 struct passwd *pw;
613
614 /* Don't bother if we have already saved a seed */
615 if (prng_seed_saved)
616 return;
Kevin Stevesef4eea92001-02-05 12:42:17 +0000617
Damien Millerf9b625c2000-07-09 22:42:32 +1000618 setuid(original_uid);
Kevin Stevesef4eea92001-02-05 12:42:17 +0000619
Damien Millerfc0b11b2000-05-02 00:03:55 +1000620 prng_seed_saved = 1;
Kevin Stevesef4eea92001-02-05 12:42:17 +0000621
Damien Millerf9b625c2000-07-09 22:42:32 +1000622 pw = getpwuid(original_uid);
Damien Miller4018c192000-04-30 09:30:44 +1000623 if (pw == NULL)
Kevin Stevesef4eea92001-02-05 12:42:17 +0000624 fatal("Couldn't get password entry for current user (%i): %s",
Damien Millerf9b625c2000-07-09 22:42:32 +1000625 original_uid, strerror(errno));
Kevin Stevesef4eea92001-02-05 12:42:17 +0000626
Damien Miller4018c192000-04-30 09:30:44 +1000627 /* Try to ensure that the parent directory is there */
Kevin Stevesef4eea92001-02-05 12:42:17 +0000628 snprintf(filename, sizeof(filename), "%.512s/%s", pw->pw_dir,
Ben Lindstromcb577332001-01-22 21:06:19 +0000629 _PATH_SSH_USER_DIR);
Damien Miller4018c192000-04-30 09:30:44 +1000630 mkdir(filename, 0700);
631
Kevin Stevesef4eea92001-02-05 12:42:17 +0000632 snprintf(filename, sizeof(filename), "%.512s/%s", pw->pw_dir,
Damien Miller4018c192000-04-30 09:30:44 +1000633 SSH_PRNG_SEED_FILE);
634
635 debug("writing PRNG seed to file %.100s", filename);
636
637 RAND_bytes(seed, sizeof(seed));
638
639 /* Don't care if the seed doesn't exist */
640 prng_check_seedfile(filename);
Kevin Stevesef4eea92001-02-05 12:42:17 +0000641
Damien Miller52dc96b2000-10-16 20:13:43 +1100642 if ((fd = open(filename, O_WRONLY|O_TRUNC|O_CREAT, 0600)) == -1) {
Kevin Stevesef4eea92001-02-05 12:42:17 +0000643 debug("WARNING: couldn't access PRNG seedfile %.100s (%.100s)",
Damien Miller52dc96b2000-10-16 20:13:43 +1100644 filename, strerror(errno));
Kevin Stevesef4eea92001-02-05 12:42:17 +0000645 } else {
Damien Miller52dc96b2000-10-16 20:13:43 +1100646 if (atomicio(write, fd, &seed, sizeof(seed)) != sizeof(seed))
Kevin Stevesef4eea92001-02-05 12:42:17 +0000647 fatal("problem writing PRNG seedfile %.100s (%.100s)", filename,
Damien Miller52dc96b2000-10-16 20:13:43 +1100648 strerror(errno));
Damien Miller4018c192000-04-30 09:30:44 +1000649
Damien Miller52dc96b2000-10-16 20:13:43 +1100650 close(fd);
651 }
Damien Miller4018c192000-04-30 09:30:44 +1000652}
653
654void
655prng_read_seedfile(void) {
656 int fd;
657 char seed[1024];
658 char filename[1024];
659 struct passwd *pw;
Kevin Stevesef4eea92001-02-05 12:42:17 +0000660
Damien Millerf9b625c2000-07-09 22:42:32 +1000661 pw = getpwuid(original_uid);
Damien Miller4018c192000-04-30 09:30:44 +1000662 if (pw == NULL)
Kevin Stevesef4eea92001-02-05 12:42:17 +0000663 fatal("Couldn't get password entry for current user (%i): %s",
Damien Millerf9b625c2000-07-09 22:42:32 +1000664 original_uid, strerror(errno));
Kevin Stevesef4eea92001-02-05 12:42:17 +0000665
666 snprintf(filename, sizeof(filename), "%.512s/%s", pw->pw_dir,
Damien Miller4018c192000-04-30 09:30:44 +1000667 SSH_PRNG_SEED_FILE);
668
669 debug("loading PRNG seed from file %.100s", filename);
670
671 if (!prng_check_seedfile(filename)) {
Damien Miller21de4502001-01-17 09:37:15 +1100672 verbose("Random seed file not found or not valid, ignoring.");
Damien Miller4018c192000-04-30 09:30:44 +1000673 return;
674 }
675
676 /* open the file and read in the seed */
677 fd = open(filename, O_RDONLY);
678 if (fd == -1)
Kevin Stevesef4eea92001-02-05 12:42:17 +0000679 fatal("could not open PRNG seedfile %.100s (%.100s)", filename,
Damien Miller4018c192000-04-30 09:30:44 +1000680 strerror(errno));
681
682 if (atomicio(read, fd, &seed, sizeof(seed)) != sizeof(seed)) {
683 verbose("invalid or short read from PRNG seedfile %.100s - ignoring",
684 filename);
685 memset(seed, '\0', sizeof(seed));
686 }
687 close(fd);
688
689 /* stir in the seed, with estimated entropy zero */
690 RAND_add(&seed, sizeof(seed), 0.0);
691}
692
Damien Miller0437b332000-05-02 09:56:41 +1000693
694/*
695 * entropy command initialisation functions
696 */
Damien Miller0437b332000-05-02 09:56:41 +1000697int
698prng_read_commands(char *cmdfilename)
699{
700 FILE *f;
Damien Miller0437b332000-05-02 09:56:41 +1000701 char *cp;
Damien Miller14c12cb2000-06-07 22:20:23 +1000702 char line[1024];
703 char cmd[1024];
704 char path[256];
Damien Miller0437b332000-05-02 09:56:41 +1000705 int linenum;
Damien Miller0437b332000-05-02 09:56:41 +1000706 int num_cmds = 64;
707 int cur_cmd = 0;
Damien Miller14c12cb2000-06-07 22:20:23 +1000708 double est;
709 entropy_source_t *entcmd;
Damien Miller0437b332000-05-02 09:56:41 +1000710
711 f = fopen(cmdfilename, "r");
712 if (!f) {
713 fatal("couldn't read entropy commands file %.100s: %.100s",
714 cmdfilename, strerror(errno));
715 }
716
Damien Miller0437b332000-05-02 09:56:41 +1000717 entcmd = (entropy_source_t *)xmalloc(num_cmds * sizeof(entropy_source_t));
718 memset(entcmd, '\0', num_cmds * sizeof(entropy_source_t));
719
Damien Miller14c12cb2000-06-07 22:20:23 +1000720 /* Read in file */
721 linenum = 0;
Damien Miller0437b332000-05-02 09:56:41 +1000722 while (fgets(line, sizeof(line), f)) {
Damien Miller14c12cb2000-06-07 22:20:23 +1000723 int arg;
724 char *argv;
725
Damien Miller0437b332000-05-02 09:56:41 +1000726 linenum++;
727
728 /* skip leading whitespace, test for blank line or comment */
729 cp = line + strspn(line, WHITESPACE);
730 if ((*cp == 0) || (*cp == '#'))
731 continue; /* done with this line */
732
Damien Miller14c12cb2000-06-07 22:20:23 +1000733 /* First non-whitespace char should be double quote delimiting */
734 /* commandline */
735 if (*cp != '"') {
Damien Miller0437b332000-05-02 09:56:41 +1000736 error("bad entropy command, %.100s line %d", cmdfilename,
737 linenum);
738 continue;
Kevin Stevesef4eea92001-02-05 12:42:17 +0000739 }
Damien Miller14c12cb2000-06-07 22:20:23 +1000740
741 /* first token, command args (incl. argv[0]) in double quotes */
742 cp = strtok(cp, "\"");
743 if (cp == NULL) {
744 error("missing or bad command string, %.100s line %d -- ignored",
745 cmdfilename, linenum);
746 continue;
747 }
748 strlcpy(cmd, cp, sizeof(cmd));
Kevin Stevesef4eea92001-02-05 12:42:17 +0000749
Damien Miller14c12cb2000-06-07 22:20:23 +1000750 /* second token, full command path */
751 if ((cp = strtok(NULL, WHITESPACE)) == NULL) {
752 error("missing command path, %.100s line %d -- ignored",
753 cmdfilename, linenum);
754 continue;
755 }
756
757 /* did configure mark this as dead? */
758 if (strncmp("undef", cp, 5) == 0)
759 continue;
760
Kevin Stevesef4eea92001-02-05 12:42:17 +0000761 strlcpy(path, cp, sizeof(path));
Damien Miller14c12cb2000-06-07 22:20:23 +1000762
763 /* third token, entropy rate estimate for this command */
764 if ((cp = strtok(NULL, WHITESPACE)) == NULL) {
765 error("missing entropy estimate, %.100s line %d -- ignored",
766 cmdfilename, linenum);
767 continue;
768 }
769 est = strtod(cp, &argv);
770
771 /* end of line */
772 if ((cp = strtok(NULL, WHITESPACE)) != NULL) {
Kevin Stevesef4eea92001-02-05 12:42:17 +0000773 error("garbage at end of line %d in %.100s -- ignored", linenum,
Damien Miller14c12cb2000-06-07 22:20:23 +1000774 cmdfilename);
775 continue;
776 }
777
778 /* save the command for debug messages */
779 entcmd[cur_cmd].cmdstring = xstrdup(cmd);
Kevin Stevesef4eea92001-02-05 12:42:17 +0000780
Damien Miller14c12cb2000-06-07 22:20:23 +1000781 /* split the command args */
782 cp = strtok(cmd, WHITESPACE);
783 arg = 0;
784 argv = NULL;
785 do {
786 char *s = (char*)xmalloc(strlen(cp) + 1);
787 strncpy(s, cp, strlen(cp) + 1);
788 entcmd[cur_cmd].args[arg] = s;
789 arg++;
790 } while ((arg < 5) && (cp = strtok(NULL, WHITESPACE)));
Kevin Stevesef4eea92001-02-05 12:42:17 +0000791
Damien Miller14c12cb2000-06-07 22:20:23 +1000792 if (strtok(NULL, WHITESPACE))
793 error("ignored extra command elements (max 5), %.100s line %d",
794 cmdfilename, linenum);
795
796 /* Copy the command path and rate estimate */
797 entcmd[cur_cmd].path = xstrdup(path);
798 entcmd[cur_cmd].rate = est;
799
800 /* Initialise other values */
801 entcmd[cur_cmd].sticky_badness = 1;
802
803 cur_cmd++;
804
805 /* If we've filled the array, reallocate it twice the size */
806 /* Do this now because even if this we're on the last command,
807 we need another slot to mark the last entry */
808 if (cur_cmd == num_cmds) {
809 num_cmds *= 2;
810 entcmd = xrealloc(entcmd, num_cmds * sizeof(entropy_source_t));
Damien Miller0437b332000-05-02 09:56:41 +1000811 }
812 }
813
814 /* zero the last entry */
815 memset(&entcmd[cur_cmd], '\0', sizeof(entropy_source_t));
Damien Miller14c12cb2000-06-07 22:20:23 +1000816
Damien Miller0437b332000-05-02 09:56:41 +1000817 /* trim to size */
818 entropy_sources = xrealloc(entcmd, (cur_cmd+1) * sizeof(entropy_source_t));
819
Damien Millerf9b625c2000-07-09 22:42:32 +1000820 debug("Loaded %d entropy commands from %.100s", cur_cmd, cmdfilename);
Damien Miller0437b332000-05-02 09:56:41 +1000821
822 return (cur_cmd >= MIN_ENTROPY_SOURCES);
823}
824
Damien Miller040f3832000-04-03 14:50:43 +1000825/*
Damien Miller4018c192000-04-30 09:30:44 +1000826 * Write a keyfile at exit
Kevin Stevesef4eea92001-02-05 12:42:17 +0000827 */
Damien Miller4018c192000-04-30 09:30:44 +1000828void
829prng_seed_cleanup(void *junk)
830{
831 prng_write_seedfile();
832}
833
834/*
835 * Conditionally Seed OpenSSL's random number pool from
836 * syscalls and program output
Damien Miller040f3832000-04-03 14:50:43 +1000837 */
838void
839seed_rng(void)
840{
Damien Millera1072a82001-02-18 15:28:11 +1100841 mysig_t old_sigchld_handler;
Damien Miller0437b332000-05-02 09:56:41 +1000842
Damien Millerf9b625c2000-07-09 22:42:32 +1000843 if (!prng_initialised)
844 fatal("RNG not initialised");
Kevin Stevesef4eea92001-02-05 12:42:17 +0000845
Damien Millerf3c6cf12000-05-17 22:08:29 +1000846 /* Make sure some other sigchld handler doesn't reap our entropy */
847 /* commands */
Damien Millera1072a82001-02-18 15:28:11 +1100848 old_sigchld_handler = mysignal(SIGCHLD, SIG_DFL);
Damien Millerf3c6cf12000-05-17 22:08:29 +1000849
Damien Miller60bc5172001-03-19 09:38:15 +1100850 debug("Seeded RNG with %i bytes from programs",
851 (int)stir_from_programs());
852 debug("Seeded RNG with %i bytes from system calls",
853 (int)stir_from_system());
Damien Millerf9b625c2000-07-09 22:42:32 +1000854
855 if (!RAND_status())
856 fatal("Not enough entropy in RNG");
Damien Miller4018c192000-04-30 09:30:44 +1000857
Damien Millera1072a82001-02-18 15:28:11 +1100858 mysignal(SIGCHLD, old_sigchld_handler);
Damien Millerf3c6cf12000-05-17 22:08:29 +1000859
Damien Miller8d1fd572000-05-17 21:34:07 +1000860 if (!RAND_status())
861 fatal("Couldn't initialise builtin random number generator -- exiting.");
Damien Miller040f3832000-04-03 14:50:43 +1000862}
Damien Millerf9b625c2000-07-09 22:42:32 +1000863
Damien Miller60bc5172001-03-19 09:38:15 +1100864void
865init_rng(void)
Damien Millerf9b625c2000-07-09 22:42:32 +1000866{
Damien Millerd592b632000-11-25 10:09:32 +1100867 int original_euid;
Kevin Stevesef4eea92001-02-05 12:42:17 +0000868
Damien Miller767c7fc2001-02-27 09:20:57 +1100869 check_openssl_version();
870
Damien Millerf9b625c2000-07-09 22:42:32 +1000871 original_uid = getuid();
Damien Millerd592b632000-11-25 10:09:32 +1100872 original_euid = geteuid();
Damien Millerf9b625c2000-07-09 22:42:32 +1000873
874 /* Read in collection commands */
875 if (!prng_read_commands(SSH_PRNG_COMMAND_FILE))
876 fatal("PRNG initialisation failed -- exiting.");
877
878 /* Set ourselves up to save a seed upon exit */
Kevin Stevesef4eea92001-02-05 12:42:17 +0000879 prng_seed_saved = 0;
Damien Millerd592b632000-11-25 10:09:32 +1100880
881 /* Give up privs while reading seed file */
Damien Millerbb7c9762001-02-26 20:49:58 +1100882#ifdef SAVED_IDS_WORK_WITH_SETEUID
Damien Millerd592b632000-11-25 10:09:32 +1100883 if ((original_uid != original_euid) && (seteuid(original_uid) == -1))
884 fatal("Couldn't give up privileges");
Damien Millerbb7c9762001-02-26 20:49:58 +1100885#else /* SAVED_IDS_WORK_WITH_SETEUID */
886 /*
887 * Propagate the privileged uid to all of our uids.
888 * Set the effective uid to the given (unprivileged) uid.
889 */
Damien Miller248131a2001-02-27 09:47:16 +1100890 if (original_uid != original_euid && (setuid(original_euid) == -1 ||
891 seteuid(original_uid) == -1))
Damien Millerbb7c9762001-02-26 20:49:58 +1100892 fatal("Couldn't give up privileges");
893#endif /* SAVED_IDS_WORK_WITH_SETEUID */
Kevin Stevesef4eea92001-02-05 12:42:17 +0000894
Damien Millerf9b625c2000-07-09 22:42:32 +1000895 prng_read_seedfile();
Damien Millerd592b632000-11-25 10:09:32 +1100896
Damien Millerbb7c9762001-02-26 20:49:58 +1100897#ifdef SAVED_IDS_WORK_WITH_SETEUID
Damien Millerd592b632000-11-25 10:09:32 +1100898 if ((original_uid != original_euid) && (seteuid(original_euid) == -1))
899 fatal("Couldn't restore privileges");
Damien Millerbb7c9762001-02-26 20:49:58 +1100900#else /* SAVED_IDS_WORK_WITH_SETEUID */
901 /*
902 * We are unable to restore the real uid to its unprivileged value.
903 * Propagate the real uid (usually more privileged) to effective uid
904 * as well.
905 */
Damien Miller248131a2001-02-27 09:47:16 +1100906 if (original_uid != original_euid && (seteuid(original_euid) == -1 ||
907 setuid(original_uid) == -1))
Damien Millerbb7c9762001-02-26 20:49:58 +1100908 fatal("Couldn't restore privileges");
909#endif /* SAVED_IDS_WORK_WITH_SETEUID */
Damien Millerd592b632000-11-25 10:09:32 +1100910
Damien Millerf9b625c2000-07-09 22:42:32 +1000911 fatal_add_cleanup(prng_seed_cleanup, NULL);
912 atexit(prng_write_seedfile);
913
914 prng_initialised = 1;
915}
916
Damien Millerd0ccb982001-03-04 00:29:20 +1100917#endif /* defined(USE_PRNGD) || defined(RANDOM_POOL) */