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