entropy.c

   1 /*
   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.
  12  *
  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
  27 #include <openssl/rand.h>
  28 #include <openssl/sha.h>
  29
  30 /* SunOS 4.4.4 needs this */
  31 #ifdef HAVE_FLOATINGPOINT_H
  32 # include <floatingpoint.h>
  33 #endif /* HAVE_FLOATINGPOINT_H */
  34
  35 #include "ssh.h"
  36 #include "misc.h"
  37 #include "xmalloc.h"
  38 #include "atomicio.h"
  39 #include "pathnames.h"
  40 #include "log.h"
  41
  42 RCSID("$Id$");
  43
  44 #ifndef offsetof
  45 # define offsetof(type, member) ((size_t) &((type *)0)->member)
  46 #endif
  47
  48 /* Number of times to pass through command list gathering entropy */
  49 #define NUM_ENTROPY_RUNS        1
  50
  51 /* Scale entropy estimates back by this amount on subsequent runs */
  52 #define SCALE_PER_RUN           10.0
  53
  54 /* Minimum number of commands to be considered valid */
  55 #define MIN_ENTROPY_SOURCES 16
  56
  57 #define WHITESPACE " \t\n"
  58
  59 #ifndef RUSAGE_SELF
  60 # define RUSAGE_SELF 0
  61 #endif
  62 #ifndef RUSAGE_CHILDREN
  63 # define RUSAGE_CHILDREN 0
  64 #endif
  65
  66 #if defined(_POSIX_SAVED_IDS) && !defined(BROKEN_SAVED_UIDS)
  67 # define SAVED_IDS_WORK_WITH_SETEUID
  68 #endif
  69
  70 #if defined(EGD_SOCKET) || defined(RANDOM_POOL)
  71
  72 #ifdef EGD_SOCKET
  73 /* Collect entropy from EGD */
  74 int get_random_bytes(unsigned char *buf, int len)
  75 {
  76         int fd;
  77         char msg[2];
  78         struct sockaddr_un addr;
  79         int addr_len, rval, errors;
  80         mysig_t old_sigpipe;
  81
  82         /* Sanity checks */
  83         if (sizeof(EGD_SOCKET) > sizeof(addr.sun_path))
  84                 fatal("Random pool path is too long");
  85         if (len > 255)
  86                 fatal("Too many bytes to read from EGD");
  87
  88         memset(&addr, '\0', sizeof(addr));
  89         addr.sun_family = AF_UNIX;
  90         strlcpy(addr.sun_path, EGD_SOCKET, sizeof(addr.sun_path));
  91         addr_len = offsetof(struct sockaddr_un, sun_path) + sizeof(EGD_SOCKET);
  92
  93         old_sigpipe = mysignal(SIGPIPE, SIG_IGN);
  94
  95         errors = rval = 0;
  96 reopen:
  97         fd = socket(AF_UNIX, SOCK_STREAM, 0);
  98         if (fd == -1) {
  99                 error("Couldn't create AF_UNIX socket: %s", strerror(errno));
 100                 goto done;
 101         }
 102
 103         if (connect(fd, (struct sockaddr*)&addr, addr_len) == -1) {
 104                 error("Couldn't connect to EGD socket \"%s\": %s",
 105                         addr.sun_path, strerror(errno));
 106                 goto done;
 107         }
 108
 109         /* Send blocking read request to EGD */
 110         msg[0] = 0x02;
 111         msg[1] = len;
 112
 113         if (atomicio(write, fd, msg, sizeof(msg)) != sizeof(msg)) {
 114                 if (errno == EPIPE && errors < 10) {
 115                         close(fd);
 116                         errors++;
 117                         goto reopen;
 118                 }
 119                 error("Couldn't write to EGD socket \"%s\": %s",
 120                         EGD_SOCKET, strerror(errno));
 121                 goto done;
 122         }
 123
 124         if (atomicio(read, fd, buf, len) != len) {
 125                 if (errno == EPIPE && errors < 10) {
 126                         close(fd);
 127                         errors++;
 128                         goto reopen;
 129                 }
 130                 error("Couldn't read from EGD socket \"%s\": %s",
 131                         EGD_SOCKET, strerror(errno));
 132                 goto done;
 133         }
 134
 135         rval = 1;
 136 done:
 137         mysignal(SIGPIPE, old_sigpipe);
 138         if (fd != -1)
 139                 close(fd);
 140         return(rval);
 141 }
 142 #else /* !EGD_SOCKET */
 143 #ifdef RANDOM_POOL
 144 /* Collect entropy from /dev/urandom or pipe */
 145 int get_random_bytes(unsigned char *buf, int len)
 146 {
 147         int random_pool;
 148
 149         random_pool = open(RANDOM_POOL, O_RDONLY);
 150         if (random_pool == -1) {
 151                 error("Couldn't open random pool \"%s\": %s",
 152                         RANDOM_POOL, strerror(errno));
 153                 return(0);
 154         }
 155
 156         if (atomicio(read, random_pool, buf, len) != len) {
 157                 error("Couldn't read from random pool \"%s\": %s",
 158                         RANDOM_POOL, strerror(errno));
 159                 close(random_pool);
 160                 return(0);
 161         }
 162
 163         close(random_pool);
 164
 165         return(1);
 166 }
 167 #endif /* RANDOM_POOL */
 168 #endif /* EGD_SOCKET */
 169
 170 /*
 171  * Seed OpenSSL's random number pool from Kernel random number generator
 172  * or EGD
 173  */
 174 void
 175 seed_rng(void)
 176 {
 177         char buf[32];
 178
 179         debug("Seeding random number generator");
 180
 181         if (!get_random_bytes(buf, sizeof(buf))) {
 182                 if (!RAND_status())
 183                         fatal("Entropy collection failed and entropy exhausted");
 184         } else {
 185                 RAND_add(buf, sizeof(buf), sizeof(buf));
 186         }
 187
 188         memset(buf, '\0', sizeof(buf));
 189 }
 190
 191 /* No-op */
 192 void init_rng(void) {}
 193
 194 #else /* defined(EGD_SOCKET) || defined(RANDOM_POOL) */
 195
 196 /*
 197  * FIXME: proper entropy estimations. All current values are guesses
 198  * FIXME: (ATL) do estimates at compile time?
 199  * FIXME: More entropy sources
 200  */
 201
 202 /* slow command timeouts (all in milliseconds) */
 203 /* static int entropy_timeout_default = ENTROPY_TIMEOUT_MSEC; */
 204 static int entropy_timeout_current = ENTROPY_TIMEOUT_MSEC;
 205
 206 static int prng_seed_saved = 0;
 207 static int prng_initialised = 0;
 208 uid_t original_uid;
 209
 210 typedef struct
 211 {
 212         /* Proportion of data that is entropy */
 213         double rate;
 214         /* Counter goes positive if this command times out */
 215         unsigned int badness;
 216         /* Increases by factor of two each timeout */
 217         unsigned int sticky_badness;
 218         /* Path to executable */
 219         char *path;
 220         /* argv to pass to executable */
 221         char *args[5];
 222         /* full command string (debug) */
 223         char *cmdstring;
 224 } entropy_source_t;
 225
 226 double stir_from_system(void);
 227 double stir_from_programs(void);
 228 double stir_gettimeofday(double entropy_estimate);
 229 double stir_clock(double entropy_estimate);
 230 double stir_rusage(int who, double entropy_estimate);
 231 double hash_output_from_command(entropy_source_t *src, char *hash);
 232
 233 /* this is initialised from a file, by prng_read_commands() */
 234 entropy_source_t *entropy_sources = NULL;
 235
 236 double
 237 stir_from_system(void)
 238 {
 239         double total_entropy_estimate;
 240         long int i;
 241
 242         total_entropy_estimate = 0;
 243
 244         i = getpid();
 245         RAND_add(&i, sizeof(i), 0.5);
 246         total_entropy_estimate += 0.1;
 247
 248         i = getppid();
 249         RAND_add(&i, sizeof(i), 0.5);
 250         total_entropy_estimate += 0.1;
 251
 252         i = getuid();
 253         RAND_add(&i, sizeof(i), 0.0);
 254         i = getgid();
 255         RAND_add(&i, sizeof(i), 0.0);
 256
 257         total_entropy_estimate += stir_gettimeofday(1.0);
 258         total_entropy_estimate += stir_clock(0.5);
 259         total_entropy_estimate += stir_rusage(RUSAGE_SELF, 2.0);
 260
 261         return(total_entropy_estimate);
 262 }
 263
 264 double
 265 stir_from_programs(void)
 266 {
 267         int i;
 268         int c;
 269         double entropy_estimate;
 270         double total_entropy_estimate;
 271         char hash[SHA_DIGEST_LENGTH];
 272
 273         total_entropy_estimate = 0;
 274         for(i = 0; i < NUM_ENTROPY_RUNS; i++) {
 275                 c = 0;
 276                 while (entropy_sources[c].path != NULL) {
 277
 278                         if (!entropy_sources[c].badness) {
 279                                 /* Hash output from command */
 280                                 entropy_estimate = hash_output_from_command(&entropy_sources[c], hash);
 281
 282                                 /* Scale back entropy estimate according to command's rate */
 283                                 entropy_estimate *= entropy_sources[c].rate;
 284
 285                                 /* Upper bound of entropy estimate is SHA_DIGEST_LENGTH */
 286                                 if (entropy_estimate > SHA_DIGEST_LENGTH)
 287                                         entropy_estimate = SHA_DIGEST_LENGTH;
 288
 289                                 /* Scale back estimates for subsequent passes through list */
 290                                 entropy_estimate /= SCALE_PER_RUN * (i + 1.0);
 291
 292                                 /* Stir it in */
 293                                 RAND_add(hash, sizeof(hash), entropy_estimate);
 294
 295                                 debug3("Got %0.2f bytes of entropy from '%s'", entropy_estimate,
 296                                         entropy_sources[c].cmdstring);
 297
 298                                 total_entropy_estimate += entropy_estimate;
 299
 300                         /* Execution times should be a little unpredictable */
 301                                 total_entropy_estimate += stir_gettimeofday(0.05);
 302                                 total_entropy_estimate += stir_clock(0.05);
 303                                 total_entropy_estimate += stir_rusage(RUSAGE_SELF, 0.1);
 304                                 total_entropy_estimate += stir_rusage(RUSAGE_CHILDREN, 0.1);
 305                         } else {
 306                                 debug2("Command '%s' disabled (badness %d)",
 307                                         entropy_sources[c].cmdstring, entropy_sources[c].badness);
 308
 309                                 if (entropy_sources[c].badness > 0)
 310                                         entropy_sources[c].badness--;
 311                         }
 312
 313                         c++;
 314                 }
 315         }
 316
 317         return(total_entropy_estimate);
 318 }
 319
 320 double
 321 stir_gettimeofday(double entropy_estimate)
 322 {
 323         struct timeval tv;
 324
 325         if (gettimeofday(&tv, NULL) == -1)
 326                 fatal("Couldn't gettimeofday: %s", strerror(errno));
 327
 328         RAND_add(&tv, sizeof(tv), entropy_estimate);
 329
 330         return(entropy_estimate);
 331 }
 332
 333 double
 334 stir_clock(double entropy_estimate)
 335 {
 336 #ifdef HAVE_CLOCK
 337         clock_t c;
 338
 339         c = clock();
 340         RAND_add(&c, sizeof(c), entropy_estimate);
 341
 342         return(entropy_estimate);
 343 #else /* _HAVE_CLOCK */
 344         return(0);
 345 #endif /* _HAVE_CLOCK */
 346 }
 347
 348 double
 349 stir_rusage(int who, double entropy_estimate)
 350 {
 351 #ifdef HAVE_GETRUSAGE
 352         struct rusage ru;
 353
 354         if (getrusage(who, &ru) == -1)
 355                 return(0);
 356
 357         RAND_add(&ru, sizeof(ru), entropy_estimate);
 358
 359         return(entropy_estimate);
 360 #else /* _HAVE_GETRUSAGE */
 361         return(0);
 362 #endif /* _HAVE_GETRUSAGE */
 363 }
 364
 365
 366 static
 367 int
 368 _get_timeval_msec_difference(struct timeval *t1, struct timeval *t2) {
 369         int secdiff, usecdiff;
 370
 371         secdiff = t2->tv_sec - t1->tv_sec;
 372         usecdiff = (secdiff*1000000) + (t2->tv_usec - t1->tv_usec);
 373         return (int)(usecdiff / 1000);
 374 }
 375
 376 double
 377 hash_output_from_command(entropy_source_t *src, char *hash)
 378 {
 379         static int devnull = -1;
 380         int p[2];
 381         fd_set rdset;
 382         int cmd_eof = 0, error_abort = 0;
 383         struct timeval tv_start, tv_current;
 384         int msec_elapsed = 0;
 385         pid_t pid;
 386         int status;
 387         char buf[16384];
 388         int bytes_read;
 389         int total_bytes_read;
 390         SHA_CTX sha;
 391
 392         debug3("Reading output from \'%s\'", src->cmdstring);
 393
 394         if (devnull == -1) {
 395                 devnull = open("/dev/null", O_RDWR);
 396                 if (devnull == -1)
 397                         fatal("Couldn't open /dev/null: %s", strerror(errno));
 398         }
 399
 400         if (pipe(p) == -1)
 401                 fatal("Couldn't open pipe: %s", strerror(errno));
 402
 403         (void)gettimeofday(&tv_start, NULL); /* record start time */
 404
 405         switch (pid = fork()) {
 406                 case -1: /* Error */
 407                         close(p[0]);
 408                         close(p[1]);
 409                         fatal("Couldn't fork: %s", strerror(errno));
 410                         /* NOTREACHED */
 411                 case 0: /* Child */
 412                         dup2(devnull, STDIN_FILENO);
 413                         dup2(p[1], STDOUT_FILENO);
 414                         dup2(p[1], STDERR_FILENO);
 415                         close(p[0]);
 416                         close(p[1]);
 417                         close(devnull);
 418
 419                         setuid(original_uid);
 420                         execv(src->path, (char**)(src->args));
 421                         debug("(child) Couldn't exec '%s': %s", src->cmdstring,
 422                               strerror(errno));
 423                         _exit(-1);
 424                 default: /* Parent */
 425                         break;
 426         }
 427
 428         RAND_add(&pid, sizeof(&pid), 0.0);
 429
 430         close(p[1]);
 431
 432         /* Hash output from child */
 433         SHA1_Init(&sha);
 434         total_bytes_read = 0;
 435
 436         while (!error_abort && !cmd_eof) {
 437                 int ret;
 438                 struct timeval tv;
 439                 int msec_remaining;
 440
 441                 (void) gettimeofday(&tv_current, 0);
 442                 msec_elapsed = _get_timeval_msec_difference(&tv_start, &tv_current);
 443                 if (msec_elapsed >= entropy_timeout_current) {
 444                         error_abort=1;
 445                         continue;
 446                 }
 447                 msec_remaining = entropy_timeout_current - msec_elapsed;
 448
 449                 FD_ZERO(&rdset);
 450                 FD_SET(p[0], &rdset);
 451                 tv.tv_sec =  msec_remaining / 1000;
 452                 tv.tv_usec = (msec_remaining % 1000) * 1000;
 453
 454                 ret = select(p[0]+1, &rdset, NULL, NULL, &tv);
 455
 456                 RAND_add(&tv, sizeof(tv), 0.0);
 457
 458                 switch (ret) {
 459                 case 0:
 460                         /* timer expired */
 461                         error_abort = 1;
 462                         break;
 463                 case 1:
 464                         /* command input */
 465                         bytes_read = read(p[0], buf, sizeof(buf));
 466                         RAND_add(&bytes_read, sizeof(&bytes_read), 0.0);
 467                         if (bytes_read == -1) {
 468                                 error_abort = 1;
 469                                 break;
 470                         } else if (bytes_read) {
 471                                 SHA1_Update(&sha, buf, bytes_read);
 472                                 total_bytes_read += bytes_read;
 473                         } else {
 474                                 cmd_eof = 1;
 475                         }
 476                         break;
 477                 case -1:
 478                 default:
 479                         /* error */
 480                         debug("Command '%s': select() failed: %s", src->cmdstring,
 481                               strerror(errno));
 482                         error_abort = 1;
 483                         break;
 484                 }
 485         }
 486
 487         SHA1_Final(hash, &sha);
 488
 489         close(p[0]);
 490
 491         debug3("Time elapsed: %d msec", msec_elapsed);
 492
 493         if (waitpid(pid, &status, 0) == -1) {
 494                error("Couldn't wait for child '%s' completion: %s", src->cmdstring,
 495                      strerror(errno));
 496                 return(0.0);
 497         }
 498
 499         RAND_add(&status, sizeof(&status), 0.0);
 500
 501         if (error_abort) {
 502                 /* closing p[0] on timeout causes the entropy command to
 503                  * SIGPIPE. Take whatever output we got, and mark this command
 504                  * as slow */
 505                 debug2("Command '%s' timed out", src->cmdstring);
 506                 src->sticky_badness *= 2;
 507                 src->badness = src->sticky_badness;
 508                 return(total_bytes_read);
 509         }
 510
 511         if (WIFEXITED(status)) {
 512                 if (WEXITSTATUS(status)==0) {
 513                         return(total_bytes_read);
 514                 } else {
 515                         debug2("Command '%s' exit status was %d", src->cmdstring,
 516                                 WEXITSTATUS(status));
 517                         src->badness = src->sticky_badness = 128;
 518                         return (0.0);
 519                 }
 520         } else if (WIFSIGNALED(status)) {
 521                 debug2("Command '%s' returned on uncaught signal %d !", src->cmdstring,
 522                         status);
 523                 src->badness = src->sticky_badness = 128;
 524                 return(0.0);
 525         } else
 526                 return(0.0);
 527 }
 528
 529 /*
 530  * prng seedfile functions
 531  */
 532 int
 533 prng_check_seedfile(char *filename) {
 534
 535         struct stat st;
 536
 537         /* FIXME raceable: eg replace seed between this stat and subsequent open */
 538         /* Not such a problem because we don't trust the seed file anyway */
 539         if (lstat(filename, &st) == -1) {
 540                 /* Give up on hard errors */
 541                 if (errno != ENOENT)
 542                         debug("WARNING: Couldn't stat random seed file \"%s\": %s",
 543                            filename, strerror(errno));
 544
 545                 return(0);
 546         }
 547
 548         /* regular file? */
 549         if (!S_ISREG(st.st_mode))
 550                 fatal("PRNG seedfile %.100s is not a regular file", filename);
 551
 552         /* mode 0600, owned by root or the current user? */
 553         if (((st.st_mode & 0177) != 0) || !(st.st_uid == original_uid)) {
 554                 debug("WARNING: PRNG seedfile %.100s must be mode 0600, owned by uid %d",
 555                          filename, getuid());
 556                 return(0);
 557         }
 558
 559         return(1);
 560 }
 561
 562 void
 563 prng_write_seedfile(void) {
 564         int fd;
 565         char seed[1024];
 566         char filename[1024];
 567         struct passwd *pw;
 568
 569         /* Don't bother if we have already saved a seed */
 570         if (prng_seed_saved)
 571                 return;
 572
 573         setuid(original_uid);
 574
 575         prng_seed_saved = 1;
 576
 577         pw = getpwuid(original_uid);
 578         if (pw == NULL)
 579                 fatal("Couldn't get password entry for current user (%i): %s",
 580                         original_uid, strerror(errno));
 581
 582         /* Try to ensure that the parent directory is there */
 583         snprintf(filename, sizeof(filename), "%.512s/%s", pw->pw_dir,
 584                 _PATH_SSH_USER_DIR);
 585         mkdir(filename, 0700);
 586
 587         snprintf(filename, sizeof(filename), "%.512s/%s", pw->pw_dir,
 588                 SSH_PRNG_SEED_FILE);
 589
 590         debug("writing PRNG seed to file %.100s", filename);
 591
 592         RAND_bytes(seed, sizeof(seed));
 593
 594         /* Don't care if the seed doesn't exist */
 595         prng_check_seedfile(filename);
 596
 597         if ((fd = open(filename, O_WRONLY|O_TRUNC|O_CREAT, 0600)) == -1) {
 598                 debug("WARNING: couldn't access PRNG seedfile %.100s (%.100s)",
 599                    filename, strerror(errno));
 600         } else {
 601                 if (atomicio(write, fd, &seed, sizeof(seed)) != sizeof(seed))
 602                         fatal("problem writing PRNG seedfile %.100s (%.100s)", filename,
 603                                  strerror(errno));
 604
 605                 close(fd);
 606         }
 607 }
 608
 609 void
 610 prng_read_seedfile(void) {
 611         int fd;
 612         char seed[1024];
 613         char filename[1024];
 614         struct passwd *pw;
 615
 616         pw = getpwuid(original_uid);
 617         if (pw == NULL)
 618                 fatal("Couldn't get password entry for current user (%i): %s",
 619                         original_uid, strerror(errno));
 620
 621         snprintf(filename, sizeof(filename), "%.512s/%s", pw->pw_dir,
 622                 SSH_PRNG_SEED_FILE);
 623
 624         debug("loading PRNG seed from file %.100s", filename);
 625
 626         if (!prng_check_seedfile(filename)) {
 627                 verbose("Random seed file not found or not valid, ignoring.");
 628                 return;
 629         }
 630
 631         /* open the file and read in the seed */
 632         fd = open(filename, O_RDONLY);
 633         if (fd == -1)
 634                 fatal("could not open PRNG seedfile %.100s (%.100s)", filename,
 635                         strerror(errno));
 636
 637         if (atomicio(read, fd, &seed, sizeof(seed)) != sizeof(seed)) {
 638                 verbose("invalid or short read from PRNG seedfile %.100s - ignoring",
 639                         filename);
 640                 memset(seed, '\0', sizeof(seed));
 641         }
 642         close(fd);
 643
 644         /* stir in the seed, with estimated entropy zero */
 645         RAND_add(&seed, sizeof(seed), 0.0);
 646 }
 647
 648
 649 /*
 650  * entropy command initialisation functions
 651  */
 652 int
 653 prng_read_commands(char *cmdfilename)
 654 {
 655         FILE *f;
 656         char *cp;
 657         char line[1024];
 658         char cmd[1024];
 659         char path[256];
 660         int linenum;
 661         int num_cmds = 64;
 662         int cur_cmd = 0;
 663         double est;
 664         entropy_source_t *entcmd;
 665
 666         f = fopen(cmdfilename, "r");
 667         if (!f) {
 668                 fatal("couldn't read entropy commands file %.100s: %.100s",
 669                     cmdfilename, strerror(errno));
 670         }
 671
 672         entcmd = (entropy_source_t *)xmalloc(num_cmds * sizeof(entropy_source_t));
 673         memset(entcmd, '\0', num_cmds * sizeof(entropy_source_t));
 674
 675         /* Read in file */
 676         linenum = 0;
 677         while (fgets(line, sizeof(line), f)) {
 678                 int arg;
 679                 char *argv;
 680
 681                 linenum++;
 682
 683                 /* skip leading whitespace, test for blank line or comment */
 684                 cp = line + strspn(line, WHITESPACE);
 685                 if ((*cp == 0) || (*cp == '#'))
 686                         continue; /* done with this line */
 687
 688                 /* First non-whitespace char should be double quote delimiting */
 689                 /* commandline */
 690                 if (*cp != '"') {
 691                         error("bad entropy command, %.100s line %d", cmdfilename,
 692                              linenum);
 693                         continue;
 694                 }
 695
 696                 /* first token, command args (incl. argv[0]) in double quotes */
 697                 cp = strtok(cp, "\"");
 698                 if (cp == NULL) {
 699                         error("missing or bad command string, %.100s line %d -- ignored",
 700                               cmdfilename, linenum);
 701                         continue;
 702                 }
 703                 strlcpy(cmd, cp, sizeof(cmd));
 704
 705                 /* second token, full command path */
 706                 if ((cp = strtok(NULL, WHITESPACE)) == NULL) {
 707                         error("missing command path, %.100s line %d -- ignored",
 708                               cmdfilename, linenum);
 709                         continue;
 710                 }
 711
 712                 /* did configure mark this as dead? */
 713                 if (strncmp("undef", cp, 5) == 0)
 714                         continue;
 715
 716                 strlcpy(path, cp, sizeof(path));
 717
 718                 /* third token, entropy rate estimate for this command */
 719                 if ((cp = strtok(NULL, WHITESPACE)) == NULL) {
 720                         error("missing entropy estimate, %.100s line %d -- ignored",
 721                               cmdfilename, linenum);
 722                         continue;
 723                 }
 724                 est = strtod(cp, &argv);
 725
 726                 /* end of line */
 727                 if ((cp = strtok(NULL, WHITESPACE)) != NULL) {
 728                         error("garbage at end of line %d in %.100s -- ignored", linenum,
 729                                 cmdfilename);
 730                         continue;
 731                 }
 732
 733                 /* save the command for debug messages */
 734                 entcmd[cur_cmd].cmdstring = xstrdup(cmd);
 735
 736                 /* split the command args */
 737                 cp = strtok(cmd, WHITESPACE);
 738                 arg = 0;
 739                 argv = NULL;
 740                 do {
 741                         char *s = (char*)xmalloc(strlen(cp) + 1);
 742                         strncpy(s, cp, strlen(cp) + 1);
 743                         entcmd[cur_cmd].args[arg] = s;
 744                         arg++;
 745                 } while ((arg < 5) && (cp = strtok(NULL, WHITESPACE)));
 746
 747                 if (strtok(NULL, WHITESPACE))
 748                         error("ignored extra command elements (max 5), %.100s line %d",
 749                               cmdfilename, linenum);
 750
 751                 /* Copy the command path and rate estimate */
 752                 entcmd[cur_cmd].path = xstrdup(path);
 753                 entcmd[cur_cmd].rate = est;
 754
 755                 /* Initialise other values */
 756                 entcmd[cur_cmd].sticky_badness = 1;
 757
 758                 cur_cmd++;
 759
 760                 /* If we've filled the array, reallocate it twice the size */
 761                 /* Do this now because even if this we're on the last command,
 762                    we need another slot to mark the last entry */
 763                 if (cur_cmd == num_cmds) {
 764                         num_cmds *= 2;
 765                         entcmd = xrealloc(entcmd, num_cmds * sizeof(entropy_source_t));
 766                 }
 767         }
 768
 769         /* zero the last entry */
 770         memset(&entcmd[cur_cmd], '\0', sizeof(entropy_source_t));
 771
 772         /* trim to size */
 773         entropy_sources = xrealloc(entcmd, (cur_cmd+1) * sizeof(entropy_source_t));
 774
 775         debug("Loaded %d entropy commands from %.100s", cur_cmd, cmdfilename);
 776
 777         return (cur_cmd >= MIN_ENTROPY_SOURCES);
 778 }
 779
 780 /*
 781  * Write a keyfile at exit
 782  */
 783 void
 784 prng_seed_cleanup(void *junk)
 785 {
 786         prng_write_seedfile();
 787 }
 788
 789 /*
 790  * Conditionally Seed OpenSSL's random number pool from
 791  * syscalls and program output
 792  */
 793 void
 794 seed_rng(void)
 795 {
 796         mysig_t old_sigchld_handler;
 797
 798         if (!prng_initialised)
 799                 fatal("RNG not initialised");
 800
 801         /* Make sure some other sigchld handler doesn't reap our entropy */
 802         /* commands */
 803         old_sigchld_handler = mysignal(SIGCHLD, SIG_DFL);
 804
 805         debug("Seeded RNG with %i bytes from programs", (int)stir_from_programs());
 806         debug("Seeded RNG with %i bytes from system calls", (int)stir_from_system());
 807
 808         if (!RAND_status())
 809                 fatal("Not enough entropy in RNG");
 810
 811         mysignal(SIGCHLD, old_sigchld_handler);
 812
 813         if (!RAND_status())
 814                 fatal("Couldn't initialise builtin random number generator -- exiting.");
 815 }
 816
 817 void init_rng(void)
 818 {
 819         int original_euid;
 820
 821         original_uid = getuid();
 822         original_euid = geteuid();
 823
 824         /* Read in collection commands */
 825         if (!prng_read_commands(SSH_PRNG_COMMAND_FILE))
 826                 fatal("PRNG initialisation failed -- exiting.");
 827
 828         /* Set ourselves up to save a seed upon exit */
 829         prng_seed_saved = 0;
 830
 831         /* Give up privs while reading seed file */
 832 #ifdef SAVED_IDS_WORK_WITH_SETEUID
 833         if ((original_uid != original_euid) && (seteuid(original_uid) == -1))
 834                 fatal("Couldn't give up privileges");
 835 #else /* SAVED_IDS_WORK_WITH_SETEUID */
 836         /*
 837          * Propagate the privileged uid to all of our uids.
 838          * Set the effective uid to the given (unprivileged) uid.
 839          */
 840         if (original_uid != original_euid && setuid(original_euid) == -1 ||
 841             seteuid(original_uid) == -1)
 842                 fatal("Couldn't give up privileges");
 843 #endif /* SAVED_IDS_WORK_WITH_SETEUID */
 844
 845         prng_read_seedfile();
 846
 847 #ifdef SAVED_IDS_WORK_WITH_SETEUID
 848         if ((original_uid != original_euid) && (seteuid(original_euid) == -1))
 849                 fatal("Couldn't restore privileges");
 850 #else /* SAVED_IDS_WORK_WITH_SETEUID */
 851         /*
 852          * We are unable to restore the real uid to its unprivileged value.
 853          * Propagate the real uid (usually more privileged) to effective uid
 854          * as well.
 855          */
 856         if (original_uid != original_euid && seteuid(original_euid) == -1 ||
 857             setuid(original_uid) == -1)
 858                 fatal("Couldn't restore privileges");
 859 #endif /* SAVED_IDS_WORK_WITH_SETEUID */
 860
 861         fatal_add_cleanup(prng_seed_cleanup, NULL);
 862         atexit(prng_write_seedfile);
 863
 864         prng_initialised = 1;
 865 }
 866
 867 #endif /* defined(EGD_SOCKET) || defined(RANDOM_POOL) */