chiark - git - mdw - catacomb/blob - rand/noise.c

   1 /* -*-c-*-
   2  *
   3  * Acquisition of environmental noise (Unix-specific)
   4  *
   5  * (c) 1998 Straylight/Edgeware
   6  */
   7
   8 /*----- Licensing notice --------------------------------------------------*
   9  *
  10  * This file is part of Catacomb.
  11  *
  12  * Catacomb is free software; you can redistribute it and/or modify
  13  * it under the terms of the GNU Library General Public License as
  14  * published by the Free Software Foundation; either version 2 of the
  15  * License, or (at your option) any later version.
  16  *
  17  * Catacomb is distributed in the hope that it will be useful,
  18  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  19  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  20  * GNU Library General Public License for more details.
  21  *
  22  * You should have received a copy of the GNU Library General Public
  23  * License along with Catacomb; if not, write to the Free
  24  * Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,
  25  * MA 02111-1307, USA.
  26  */
  27
  28 /*----- Header files ------------------------------------------------------*/
  29
  30 #include "config.h"
  31
  32 #include <errno.h>
  33 #include <setjmp.h>
  34 #include <signal.h>
  35 #include <stdio.h>
  36 #include <stdlib.h>
  37 #include <string.h>
  38
  39 #include <sys/types.h>
  40 #include <sys/time.h>
  41 #include <sys/wait.h>
  42
  43 #include <fcntl.h>
  44 #include <unistd.h>
  45
  46 #ifdef HAVE_SETGROUPS
  47 #  include <grp.h>
  48 #endif
  49
  50 #if defined(HAVE_LINUX_RANDOM_H)
  51 #  include <linux/random.h>
  52 #  include <sys/syscall.h>
  53 #endif
  54
  55 #include <mLib/bits.h>
  56 #include <mLib/mdup.h>
  57 #include <mLib/sel.h>
  58 #include <mLib/tv.h>
  59
  60 #include "noise.h"
  61 #include "paranoia.h"
  62 #include "rand.h"
  63
  64 /*----- Magical numbers ---------------------------------------------------*/
  65
  66 #define NOISE_KIDLIFE 100000            /* @noise_filter@ child lifetime */
  67 #define MILLION 1000000                 /* One million */
  68
  69 /*----- Noise source definition -------------------------------------------*/
  70
  71 const rand_source noise_source = { noise_acquire, noise_timer };
  72
  73 /*----- Static variables --------------------------------------------------*/
  74
  75 /* --- Timer differences --- */
  76
  77 static unsigned long noise_last;        /* Last time recorded */
  78 static unsigned long noise_diff;        /* Last first order difference */
  79
  80 /* --- Setuid program handling --- */
  81
  82 static uid_t noise_uid = NOISE_NOSETUID; /* Uid to set to spawn processes */
  83 static gid_t noise_gid = NOISE_NOSETGID; /* Gid to set to spawn processes */
  84
  85 /*----- Main code ---------------------------------------------------------*/
  86
  87 /* --- @bitcount@ --- *
  88  *
  89  * Arguments:   @unsigned long x@ = a word containing bits
  90  *
  91  * Returns:     The number of bits set in the word.
  92  */
  93
  94 static int bitcount(unsigned long x)
  95 {
  96   static const char ctab[] = { 0, 1, 1, 2, 1, 2, 2, 3,
  97                                1, 2, 2, 3, 2, 3, 3, 4 };
  98   int count = 0;
  99   while (x) {
 100     count += ctab[x & 0xfu];
 101     x >>= 4;
 102   }
 103   return (count);
 104 }
 105
 106 /* --- @timer@ --- *
 107  *
 108  * Arguments:   @rand_pool *r@ = pointer to randomness pool
 109  *              @struct timeval *tv@ = pointer to time block
 110  *
 111  * Returns:     Nonzero if some randomness was contributed.
 112  *
 113  * Use:         Low-level timer contributor.
 114  */
 115
 116 static int timer(rand_pool *r, struct timeval *tv)
 117 {
 118   unsigned long x, d, dd;
 119   int de, dde;
 120   int ret;
 121
 122   x = tv->tv_usec + MILLION * tv->tv_sec;
 123   d = x ^ noise_last;
 124   dd = d ^ noise_diff;
 125   noise_last = x;
 126   noise_diff = d;
 127   de = bitcount(d);
 128   dde = bitcount(dd);
 129   rand_add(r, tv, sizeof(*tv), de <= dde ? de : dde);
 130   ret = (de || dde);
 131   BURN(tv); x = d = dd = de = dde = 0;
 132   return (ret);
 133 }
 134
 135 /* --- @noise_timer@ --- *
 136  *
 137  * Arguments:   @rand_pool *r@ = pointer to a randomness pool
 138  *
 139  * Returns:     Nonzero if some randomness was contributed.
 140  *
 141  * Use:         Contributes the current time to the randomness pool.
 142  *              A guess at the number of useful bits contributed is made,
 143  *              based on first and second order bit differences.  This isn't
 144  *              ever-so reliable, but it's better than nothing.
 145  */
 146
 147 int noise_timer(rand_pool *r)
 148 {
 149   struct timeval tv;
 150   gettimeofday(&tv, 0);
 151   return (timer(r, &tv));
 152 }
 153
 154 /* --- @noise_devrandom@ --- *
 155  *
 156  * Arguments:   @rand_pool *r@ = pointer to a randomness pool
 157  *
 158  * Returns:     Nonzero if some randomness was contributed.
 159  *
 160  * Use:         Attempts to obtain some randomness from the system entropy
 161  *              pool.  All bits from the device are assumed to be good.
 162  */
 163
 164 int noise_devrandom(rand_pool *r)
 165 {
 166   int fd = -1;
 167   octet buf[RAND_POOLSZ];
 168   ssize_t len;
 169   size_t n = 0;
 170   int ret = 0;
 171 #ifdef __linux__
 172   fd_set infd;
 173   struct timeval tv = { 0, 0 };
 174 #endif
 175 #ifdef HAVE_GETENTROPY
 176   size_t nn;
 177 #endif
 178
 179 #if defined(HAVE_LINUX_RANDOM_H) &&                                     \
 180     defined(GRND_NONBLOCK) &&                                           \
 181     defined(SYS_getrandom)
 182   /* --- Use the new shinies if available --- */
 183
 184   while (n < sizeof(buf)) {
 185     if ((len = syscall(SYS_getrandom, buf + n, sizeof(buf) - n,
 186                        GRND_NONBLOCK)) <= 0) {
 187       if (errno == ENOSYS) break;
 188       else goto done;
 189     }
 190     n += len;
 191   }
 192   if (n == sizeof(buf)) goto win;
 193 #endif
 194
 195 #ifdef HAVE_GETENTROPY
 196   /* --- OpenBSD-flavoured shinies --- */
 197
 198   while (n < sizeof(buf)) {
 199     nn = sizeof(buf) - nn;
 200     if (nn > 256) nn = 256;
 201     if (getentropy(buf + n, nn)) break;
 202     n += nn;
 203   }
 204   if (n == sizeof(buf)) goto win;
 205 #endif
 206
 207 #ifdef __linux__
 208   /* --- Don't take from `/dev/urandom' if `/dev/random' would block --- */
 209
 210   if ((fd = open("/dev/random", O_RDONLY | O_NONBLOCK)) < 0) goto done;
 211   FD_ZERO(&infd);
 212   FD_SET(fd, &infd);
 213   if (select(fd + 1, &infd, 0, 0, &tv) < 0 || !FD_ISSET(fd, &infd))
 214     goto done;
 215   close(fd); fd = -1;
 216 #endif
 217
 218   /* --- Be nice to other clients of the random device --- *
 219    *
 220    * Attempt to open the device nonblockingly.  If that works, take up to
 221    * one bufferful and then close again.  If there's no data to be read,
 222    * then that's tough and we go away again, on the grounds that the device
 223    * needs to get some more entropy from somewhere.
 224    */
 225
 226   if (fd >= 0 ||
 227       (fd = open("/dev/urandom", O_RDONLY | O_NONBLOCK)) >= 0 ||
 228       (fd = open("/dev/arandom", O_RDONLY | O_NONBLOCK)) >= 0 ||
 229       (fd = open("/dev/random", O_RDONLY | O_NONBLOCK)) >= 0) {
 230     while (n < sizeof(buf)) {
 231       if ((len = read(fd, buf + n, sizeof(buf) - n)) <= 0) break;
 232       n += len;
 233     }
 234     if (n == sizeof(buf)) goto win;
 235   }
 236   goto done;
 237
 238 win:
 239   ret = 1;
 240 done:
 241   if (fd >= 0) close(fd);
 242   rand_add(r, buf, n, 8*n);
 243   BURN(buf);
 244   noise_timer(r);
 245   return (ret);
 246 }
 247
 248 /* --- @noise_setid@ --- *
 249  *
 250  * Arguments:   @uid_t uid@ = uid to set
 251  *              @gid_t gid@ = gid to set
 252  *
 253  * Returns:     ---
 254  *
 255  * Use:         Sets the user and group ids to be used by @noise_filter@
 256  *              when running child processes.  This is useful to avoid
 257  *              giving shell commands (even carefully written ones) undue
 258  *              privileges.  This interface is Unix-specific
 259  */
 260
 261 void noise_setid(uid_t uid, gid_t gid)
 262 {
 263   noise_uid = uid;
 264   noise_gid = gid;
 265 }
 266
 267 /* --- @noise_filter@ --- *
 268  *
 269  * Arguments:   @rand_pool *r@ = pointer to a randomness pool
 270  *              @int good@ = number of good bits per 1024 bits
 271  *              @const char *c@ = shell command to run
 272  *
 273  * Returns:     Nonzero if some randomness was contributed.
 274  *
 275  * Use:         Attempts to execute a shell command, and dump it into the
 276  *              randomness pool.  A very rough estimate of the number of
 277  *              good bits is made, based on the size of the command's output.
 278  *              This function calls @waitpid@, so be careful.  Before execing
 279  *              the command, the process uid and gid are set to the values
 280  *              given to @noise_setid@, and an attempt is made to reset the
 281  *              list of supplementary groups.  The environment passed to
 282  *              the command has been severly lobotimized.  If the command
 283  *              fails to complete within a short time period, it is killed.
 284  *              Paranoid use of close-on-exec flags for file descriptors is
 285  *              recommended.
 286  *
 287  *              This interface is Unix-specific.
 288  */
 289
 290 struct noisekid {
 291   rand_pool *r;
 292   int good;
 293   char buf[4096];
 294   int donep;
 295   int ret;
 296 };
 297
 298 static void kid_read(int fd, unsigned mode, void *p)
 299 {
 300   struct noisekid *nk = p;
 301   ssize_t sz;
 302   int goodbits;
 303
 304   noise_timer(nk->r);
 305   if ((sz = read(fd, nk->buf, sizeof(nk->buf))) <= 0)
 306     nk->donep = 1;
 307   else {
 308     goodbits = (sz * nk->good) / 128;
 309     rand_add(nk->r, nk->buf, sz, goodbits);
 310     nk->ret = 1;
 311   }
 312 }
 313
 314 static void kid_dead(struct timeval *tv, void *p)
 315   { struct noisekid *nk = p; nk->donep = 1; }
 316
 317 int noise_filter(rand_pool *r, int good, const char *c)
 318 {
 319   pid_t kid;
 320   int fd[2];
 321   struct timeval dead;
 322   int ret = 0;
 323   struct noisekid nk = { 0 };
 324   sel_state sel;
 325   sel_file sf;
 326   sel_timer st;
 327   const char *env[] = {
 328     "PATH=/bin:/usr/bin:/sbin:/usr/sbin:/etc",
 329     0
 330   };
 331
 332   /* --- Remember when this business started --- */
 333
 334   gettimeofday(&dead, 0);
 335   timer(r, &dead);
 336
 337   /* --- Create a pipe --- */
 338
 339   if (pipe(fd))
 340     return (ret);
 341
 342   /* --- Fork a child off --- */
 343
 344   fflush(0);
 345   kid = fork();
 346   if (kid < 0) {
 347     close(fd[0]);
 348     close(fd[1]);
 349     return (ret);
 350   }
 351
 352   /* --- Handle the child end of the deal --- */
 353
 354   if (kid == 0) {
 355     mdup_fd mfd[3];
 356     int f, i = 0;
 357
 358     /* --- Set the pipe as standard output, close standard input --- */
 359
 360     if ((f = open("/dev/null", O_RDONLY)) < 0) _exit(127);
 361     mfd[i].cur = f; mfd[i].want = 0; i++;
 362     mfd[i].cur = fd[1]; mfd[i].want = 1; i++;
 363     mfd[i].cur = f; mfd[i].want = 2; i++;
 364     if (mdup(mfd, i)) _exit(127);
 365
 366     /* --- Play games with uids --- */
 367
 368     if (noise_gid != NOISE_NOSETGID) {
 369       setgid(noise_gid);
 370       setegid(noise_gid);
 371 #ifdef HAVE_SETGROUPS
 372       setgroups(1, &noise_gid);
 373 #endif
 374     }
 375
 376     if (noise_uid != NOISE_NOSETUID) {
 377       setuid(noise_uid);
 378       seteuid(noise_uid);
 379     }
 380
 381     /* --- Start the process up --- */
 382
 383     execle("/bin/sh", "sh", "-c", c, (char *)0, env);
 384     _exit(127);
 385   }
 386
 387   /* --- Sort out my end of the deal --- */
 388
 389   close(fd[1]);
 390   sel_init(&sel);
 391   nk.r = r; nk.good = good;
 392   TV_ADDL(&dead, &dead, 0, NOISE_KIDLIFE);
 393   sel_initfile(&sel, &sf, fd[0], SEL_READ, kid_read, &nk);
 394   sel_addfile(&sf);
 395   sel_addtimer(&sel, &st, &dead, kid_dead, &nk);
 396   while (!nk.donep && !sel_select(&sel));
 397
 398   /* --- We've finished with it: kill the child process --- *
 399    *
 400    * This is morally questionable.  On the other hand, I don't want to be
 401    * held up in the @waitpid@ call if I can possibly help it.  Maybe a
 402    * double-fork is worth doing here.
 403    */
 404
 405   close(fd[0]);
 406   BURN(nk.buf);
 407   noise_timer(r);
 408   kill(kid, SIGKILL);
 409   waitpid(kid, 0, 0);
 410   return (nk.ret);
 411 }
 412
 413 /* --- @noise_freewheel@ --- *
 414  *
 415  * Arguments:   @rand_pool *r@ = pointer to a randomness pool
 416  *
 417  * Returns:     Nonzero if some randomness was contributed.
 418  *
 419  * Use:         Runs a free counter for a short while as a desparate attempt
 420  *              to get randomness from somewhere.  This is actually quite
 421  *              effective.
 422  */
 423
 424 #ifdef USE_FREEWHEEL
 425
 426 static sigjmp_buf fwjmp;
 427
 428 static void fwalarm(int sig)
 429 {
 430   siglongjmp(fwjmp, 1);
 431 }
 432
 433 int noise_freewheel(rand_pool *r)
 434 {
 435   void (*sigal)(int) = 0;
 436   struct itimerval oitv, itv = { { 0, 0 }, { 0, 5000 } };
 437   int rc = 0;
 438   volatile uint32 fwcount = 0;
 439
 440   if (!sigsetjmp(fwjmp, 1)) {
 441     if ((sigal = signal(SIGALRM, fwalarm)) == SIG_ERR)
 442       return (0);
 443     if (setitimer(ITIMER_REAL, &itv, &oitv))
 444       goto done;
 445     for (;;)
 446       fwcount++;
 447   } else {
 448     octet buf[4];
 449     STORE32(buf, fwcount);
 450     rand_add(r, buf, sizeof(buf), 16);
 451     rc = 1;
 452   }
 453
 454 done:
 455   signal(SIGALRM, sigal);
 456   if (oitv.it_value.tv_sec || oitv.it_value.tv_usec)
 457     TV_SUB(&oitv.it_value, &oitv.it_value, &itv.it_value);
 458   setitimer(ITIMER_REAL, &oitv, 0);
 459   return (rc);
 460 }
 461
 462 #else
 463
 464 int noise_freewheel(rand_pool *r)
 465 {
 466   return (0);
 467 }
 468
 469 #endif
 470
 471 /* --- @noise_enquire@ --- *
 472  *
 473  * Arguments:   @rand_pool *r@ = pointer to a randomness pool
 474  *
 475  * Returns:     Nonzero if some randomness was contributed.
 476  *
 477  * Use:         Runs some shell commands to enquire about the prevailing
 478  *              environment.  This can gather quite a lot of low-quality
 479  *              entropy.
 480  */
 481
 482 int noise_enquire(rand_pool *r)
 483 {
 484   struct tab {
 485     const char *cmd;
 486     unsigned rate;
 487   } tab[] = {
 488     { "ps alxww || ps -elf",    16 },
 489     { "netstat -n",              6 },
 490     { "ifconfig -a",             8 },
 491     { "df",                     20 },
 492     { "w",                       6 },
 493     { "ls -align /tmp/.",       10 },
 494     { 0,                         0 }
 495   };
 496   int i;
 497
 498   for (i = 0; tab[i].cmd; i++)
 499     noise_filter(r, tab[i].rate, tab[i].cmd);
 500   return (1);
 501 }
 502
 503 /* --- @noise_acquire@ --- *
 504  *
 505  * Arguments:   @rand_pool *r@ = pointer to a randomness pool
 506  *
 507  * Returns:     ---
 508  *
 509  * Use:         Acquires some randomness from somewhere.
 510  */
 511
 512 void noise_acquire(rand_pool *r)
 513 {
 514   unsigned i;
 515   for (i = 0; i < 8; i++)
 516     noise_freewheel(r);
 517   if (!noise_devrandom(r) || getenv("CATACOMB_FORCE_ESOTERIC_SOURCES")) {
 518     noise_enquire(r);
 519     for (i = 0; i < 8; i++)
 520       noise_freewheel(r);
 521   }
 522 }
 523
 524 /*----- That's all, folks -------------------------------------------------*/