Generic interface.

[u/mdw/catacomb] / noise.c

/* -*-c-*-
 *
 * $Id: noise.c,v 1.2 1999/11/11 00:59:08 mdw Exp $
 *
 * Acquisition of environmental noise (Unix specific)
 *
 * (c) 1998 Straylight/Edgeware
 */

/*----- Licensing notice --------------------------------------------------* 
 *
 * This file is part of Catacomb.
 *
 * Catacomb is free software; you can redistribute it and/or modify
 * it under the terms of the GNU Library General Public License as
 * published by the Free Software Foundation; either version 2 of the
 * License, or (at your option) any later version.
 * 
 * Catacomb is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU Library General Public License for more details.
 * 
 * You should have received a copy of the GNU Library General Public
 * License along with Catacomb; if not, write to the Free
 * Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,
 * MA 02111-1307, USA.
 */

/*----- Revision history --------------------------------------------------* 
 *
 * $Log: noise.c,v $
 * Revision 1.2  1999/11/11 00:59:08  mdw
 * A bit of reformatting.  Initialize the uid and gid correctly.
 *
 * Revision 1.1  1999/09/03 08:41:12  mdw
 * Initial import.
 *
 */

/*----- Header files ------------------------------------------------------*/

#include "config.h"

#include <stdio.h>
#include <string.h>
#include <signal.h>

#include <sys/types.h>
#include <sys/time.h>
#include <sys/wait.h>

#include <fcntl.h>
#include <unistd.h>

#ifdef HAVE_SETGROUPS
#  include <grp.h>
#endif

#include <mLib/bits.h>
#include <mLib/tv.h>

#include "noise.h"
#include "paranoia.h"
#include "rand.h"

/*----- Magical numbers ---------------------------------------------------*/

#define NOISE_KIDLIFE 100000		/* @noise_filter@ child lifetime */
#define MILLION 1000000			/* One million */

/*----- Noise source definition -------------------------------------------*/

rand_source noise_source = { noise_acquire, noise_timer };

/*----- Static variables --------------------------------------------------*/

/* --- Timer differences --- */

static unsigned long noise_last;	/* Last time recorded */
static unsigned long noise_diff;	/* Last first order difference */

/* --- Setuid program handling --- */

static uid_t noise_uid = NOISE_NOSETUID; /* Uid to set to spawn processes */
static gid_t noise_gid = NOISE_NOSETGID; /* Gid to set to spawn processes */

/*----- Main code ---------------------------------------------------------*/

/* --- @bitcount@ --- *
 *
 * Arguments:	@unsigned long x@ = a word containing bits
 *
 * Returns:	The number of bits set in the word.
 */

static int bitcount(unsigned long x)
{
  char ctab[] = { 0, 1, 1, 2, 1, 2, 2, 3,
		  1, 2, 2, 3, 2, 3, 3, 4 };
  int count = 0;
  while (x) {
    count += ctab[x & 0xfu];
    x >>= 4;
  }
  return (count);
}

/* --- @timer@ --- *
 *
 * Arguments:	@rand_pool *r@ = pointer to randomness pool
 *		@struct timeval *tv@ = pointer to time block
 *
 * Returns:	Nonzer if some randomness was contributed.
 *
 * Use:		Low-level timer contributor.
 */

static int timer(rand_pool *r, struct timeval *tv)
{
  unsigned long x, d, dd;
  int de, dde;
  int ret;
  
  x = tv->tv_usec + MILLION * tv->tv_sec;
  d = x ^ noise_last;
  dd = d ^ noise_diff;
  noise_diff = d;
  de = bitcount(d);
  dde = bitcount(dd);
  rand_add(r, tv, sizeof(*tv), de <= dde ? de : dde);
  ret = (de || dde);
  BURN(tv); x = d = dd = de = dde = 0;
  return (ret);
}

/* --- @noise_timer@ --- *
 *
 * Arguments:	@rand_pool *r@ = pointer to a randomness pool
 *
 * Returns:	Nonzero if some randomness was contributed.
 *
 * Use:		Contributes the current time to the randomness pool.
 *		A guess at the number of useful bits contributed is made,
 *		based on first and second order bit differences.  This isn't
 *		ever-so	reliable, but it's better than nothing.
 */

int noise_timer(rand_pool *r)
{
  struct timeval tv;
  gettimeofday(&tv, 0);
  return (timer(r, &tv));
}

/* --- @noise_devrandom@ --- *
 *
 * Arguments:	@rand_pool *r@ = pointer to a randomness pool
 *
 * Returns:	Nonzero if some randomness was contributed.
 *
 * Use:		Attempts to obtain some randomness from the system entropy
 *		pool.  All bits from the device are assumed to be good.
 */

int noise_devrandom(rand_pool *r)
{
  int fd;
  octet buf[RAND_POOLSZ];
  ssize_t len;
  int ret = 0;

  /* --- Be nice to other clients of the random device --- *
   *
   * Attempt to open the device nonblockingly.  If that works, take up to
   * one bufferful and then close again.  If there's no data to be read,
   * then that's tough and we go away again, on the grounds that the device
   * needs to get some more entropy from somewhere.
   */

  if ((fd = open("/dev/random", O_RDONLY | O_NONBLOCK)) >= 0) {
    if ((len = read(fd, buf, sizeof(buf))) > 0) {
      rand_add(r, buf, len, len * 8);
      BURN(buf);
      ret = 1;
    }
    close(fd);
  }
  noise_timer(r);
  return (ret);
}

/* --- @noise_setid@ --- *
 *
 * Arguments:	@uid_t uid@ = uid to set
 *		@gid_t gid@ = gid to set
 *
 * Returns:	---
 *
 * Use:		Sets the user and group ids to be used by @noise_filter@
 *		when running child processes.  This is useful to avoid
 *		giving shell commands (even carefully written ones) undue
 *		privileges.
 */

void noise_setid(uid_t uid, gid_t gid)
{
  noise_uid = uid;
  noise_gid = gid;
}

/* --- @noise_filter@ --- *
 *
 * Arguments:	@rand_pool *r@ = pointer to a randomness pool
 *		@int good@ = number of good bits per 1024 bits
 *		@const char *c@ = shell command to run
 *
 * Returns:	Nonzero if some randomness was contributed.
 *
 * Use:		Attempts to execute a shell command, and dump it into the
 *		randomness pool.  A very rough estimate of the number of
 *		good bits is made, based on the size of the command's output.
 *		This function calls @waitpid@, so be careful.  Before execing
 *		the command, the process uid and gid are set to the values
 *		given to @noise_setid@, and an attempt is made to reset the
 *		list of supplementary groups.  The environment passed to
 *		the command has been severly lobotimized.  If the command
 *		fails to complete within a short time period, it is killed.
 *		Paranoid use of close-on-exec flags for file descriptors is
 *		recommended.
 */

int noise_filter(rand_pool *r, int good, const char *c)
{
  char buf[4096];
  pid_t kid;
  int fd[2];
  struct timeval dead;
  int ret = 0;
  const char *env[] = {
    "PATH=/bin:/usr/bin:/sbin:/usr/sbin:/etc",
    0
  };

  /* --- Remember when this business started --- */

  gettimeofday(&dead, 0);
  timer(r, &dead);

  /* --- Create a pipe --- */

  if (pipe(fd))
    return (ret);

  /* --- Fork a child off --- */

  kid = fork();
  if (kid < 0) {
    close(fd[0]);
    close(fd[1]);
    return (ret);
  }

  /* --- Handle the child end of the deal --- */

  fflush(0);
  if (kid == 0) {
    int f;

    /* --- Set the pipe as standard output, close standard input --- */

    close(0); close(1); close(2);

    if (fd[1] != 1) {
      if (dup2(fd[1], 1) < 0) _exit(127);
      close(fd[1]);
    }

    if ((f = open("/dev/null", O_RDONLY)) != 0 ||
	(f = open("/dev/null", O_WRONLY)) != 2)
      _exit(127);

    /* --- Play games with uids --- */

    if (noise_gid != NOISE_NOSETGID) {
      setgid(noise_gid);
      setegid(noise_gid);
#ifdef HAVE_SETGROUPS
      setgroups(1, &noise_gid);
#endif
    }

    if (noise_uid != NOISE_NOSETUID) {
      setuid(noise_uid);
      seteuid(noise_uid);
    }

    /* --- Start the process up --- */

    execle("/bin/sh", "-c", c, (char *)0, env);
    _exit(127);
  }

  /* --- Sort out my end of the deal --- */

  close(fd[1]);

  /* --- Decide on the deadline --- */

  TV_ADDL(&dead, &dead, 0, NOISE_KIDLIFE);

  /* --- Now read, and think --- */

  for (;;) {
    struct timeval now, diff;
    fd_set rd;

    gettimeofday(&now, 0);
    timer(r, &now);
    if (TV_CMP(&now, >, &dead))
      break;
    TV_SUB(&diff, &dead, &now);

    FD_ZERO(&rd);
    FD_SET(fd[0], &rd);

    if (select(fd[0] + 1, &rd, 0, 0, &diff) < 0)
      break;
    if (FD_ISSET(fd[0], &rd)) {
      ssize_t sz;
      int goodbits;

      if ((sz = read(fd[0], buf, sizeof(buf))) <= 0)
	break;
      goodbits = (sz * good) / 128;
      rand_add(r, buf, sz, goodbits);
      ret = 1;
    }
  }

  /* --- We've finished with it: kill the child process --- *
   *
   * This is morally questionable.  On the other hand, I don't want to be
   * held up in the @waitpid@ call if I can possibly help it.  Maybe a
   * double-fork is worth doing here.
   */

  close(fd[0]);
  BURN(buf);
  noise_timer(r);
  kill(kid, SIGKILL);
  waitpid(kid, 0, 0);
  return (ret);
}

/* --- @noise_acquire@ --- *
 *
 * Arguments:	@rand_pool *r@ = pointer to a randomness pool
 *
 * Returns:	---
 *
 * Use:		Acquires some randomness from somewhere.
 */

void noise_acquire(rand_pool *r)
{
  if (!noise_devrandom(r)) {

    /* --- Output of `ps' --- *
     *
     * This is a hopefully cheap way of getting a bit of noise.  I'm guessing
     * the good bit ratio based on about 90 bytes per line of output, and
     * each line containing maybe 12 bits worth of interesting data.  (Some
     * quick experiments with gzip seem to bear this idea out.)  So, 12 good
     * bits per 90 bytes of output gives slightly more than 17 good bits per
     * 1024 bits of output.  So I'll be a pessimist and say 16 bits.
     */

    (void)
      (noise_filter(r, 16, "ps alxww") ||
       noise_filter(r, 16, "ps -elf"));

    /* --- Output of `netstat' --- *
     *
     * Another possibly cheap way of getting noise.  My output has about
     * 72 bytes per line of output.  My wild guesses are telling me that
     * there are probably only about four good bits per line (gzip tells
     * me there's six, but I want to underestimate).  Four bits per 72 bytes
     * is 7 good bits per 1024 bits of output.  Pessimist that I am, I'll
     * call it six.
     */

    noise_filter(r, 6, "netstat -n");
  }
}

/*----- That's all, folks -------------------------------------------------*/