rngd.c

   1 /*
   2  * rngd.c -- Random Number Generator daemon
   3  *
   4  * rngd reads data from a hardware random number generator, verifies it
   5  * looks like random data, and adds it to /dev/random's entropy store.
   6  *
   7  * In theory, this should allow you to read very quickly from
   8  * /dev/random; rngd also adds bytes to the entropy store periodically
   9  * when it's full, which makes predicting the entropy store's contents
  10  * harder.
  11  *
  12  * Copyright (C) 2001 Philipp Rumpf
  13  *
  14  * This program is free software; you can redistribute it and/or modify
  15  * it under the terms of the GNU General Public License as published by
  16  * the Free Software Foundation; either version 2 of the License, or
  17  * (at your option) any later version.
  18  *
  19  * This program is distributed in the hope that it will be useful,
  20  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  21  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  22  * GNU General Public License for more details.
  23  *
  24  * You should have received a copy of the GNU General Public License
  25  * along with this program; if not, write to the Free Software
  26  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  27  */
  28
  29 #define _GNU_SOURCE
  30
  31 #ifndef HAVE_CONFIG_H
  32 #error Invalid or missing autoconf build environment
  33 #endif
  34
  35 #include "rng-tools-config.h"
  36
  37 #include <unistd.h>
  38 #include <stdint.h>
  39 #include <stdio.h>
  40 #include <stdlib.h>
  41 #include <sys/types.h>
  42 #include <sys/stat.h>
  43 #include <fcntl.h>
  44 #include <errno.h>
  45 #include <string.h>
  46 #include <argp.h>
  47 #include <syslog.h>
  48 #include <signal.h>
  49
  50 #include "rngd.h"
  51 #include "fips.h"
  52 #include "exits.h"
  53 #include "rngd_entsource.h"
  54 #include "rngd_linux.h"
  55
  56 /*
  57  * Globals
  58  */
  59
  60 /* Background/daemon mode */
  61 bool am_daemon;                         /* True if we went daemon */
  62
  63 bool server_running = true;             /* set to false, to stop daemon */
  64
  65 /* Command line arguments and processing */
  66 const char *argp_program_version =
  67         "rngd " VERSION "\n"
  68         "Copyright 2001-2004 Jeff Garzik\n"
  69         "Copyright (c) 2001 by Philipp Rumpf\n"
  70         "This is free software; see the source for copying conditions.  There is NO "
  71         "warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.";
  72
  73 const char *argp_program_bug_address = PACKAGE_BUGREPORT;
  74
  75 static char doc[] =
  76         "Check and feed random data from hardware device to kernel entropy pool.\n";
  77
  78 static struct argp_option options[] = {
  79         { "foreground", 'f', 0, 0, "Do not fork and become a daemon" },
  80
  81         { "background", 'b', 0, 0, "Become a daemon (default)" },
  82
  83         { "random-device", 'o', "file", 0,
  84           "Kernel device used for random number output (default: /dev/random)" },
  85
  86         { "rng-device", 'r', "file", 0,
  87           "Kernel device used for random number input (default: /dev/hwrng)" },
  88
  89         { "pid-file", 'p', "file", 0,
  90           "File used for recording daemon PID, and multiple exclusion (default: /var/run/rngd.pid)" },
  91
  92         { "random-step", 's', "nnn", 0,
  93           "Number of bytes written to random-device at a time (default: 64)" },
  94
  95         { "fill-watermark", 'W', "n", 0,
  96           "Do not stop feeding entropy to random-device until at least n bits of entropy are available in the pool (default: 2048), 0 <= n <= 4096" },
  97
  98         { "quiet", 'q', 0, 0, "Suppress error messages" },
  99
 100         { "verbose" ,'v', 0, 0, "Report available entropy sources" },
 101
 102         { "no-drng", 'd', "1|0", 0,
 103           "Do not use drng as a source of random number input (default: 0)" },
 104
 105         { "no-tpm", 'n', "1|0", 0,
 106           "Do not use tpm as a source of random number input (default: 0)" },
 107
 108         { 0 },
 109 };
 110
 111 static struct arguments default_arguments = {
 112         .random_name    = "/dev/random",
 113         .pid_file       = "/var/run/rngd.pid",
 114         .random_step    = 64,
 115         .daemon         = true,
 116         .enable_drng    = true,
 117         .enable_tpm     = true,
 118         .quiet          = false,
 119         .verbose        = false,
 120 };
 121 struct arguments *arguments = &default_arguments;
 122
 123 static struct rng rng_default = {
 124         .rng_name       = "/dev/hwrng",
 125         .rng_fd         = -1,
 126         .xread          = xread,
 127 };
 128
 129 static struct rng rng_drng = {
 130         .rng_name       = "drng",
 131         .rng_fd         = -1,
 132         .xread          = xread_drng,
 133 };
 134
 135 static struct rng rng_tpm = {
 136         .rng_name       = "/dev/tpm0",
 137         .rng_fd         = -1,
 138         .xread          = xread_tpm,
 139 };
 140
 141 struct rng *rng_list;
 142
 143 /*
 144  * command line processing
 145  */
 146 static error_t parse_opt (int key, char *arg, struct argp_state *state)
 147 {
 148         switch(key) {
 149         case 'o':
 150                 arguments->random_name = arg;
 151                 break;
 152         case 'p':
 153                 arguments->pid_file = arg;
 154                 break;
 155         case 'r':
 156                 rng_default.rng_name = arg;
 157                 break;
 158         case 'f':
 159                 arguments->daemon = false;
 160                 break;
 161         case 'b':
 162                 arguments->daemon = true;
 163                 break;
 164         case 's':
 165                 if (sscanf(arg, "%i", &arguments->random_step) == 0)
 166                         argp_usage(state);
 167                 break;
 168         case 'W': {
 169                 int n;
 170                 if ((sscanf(arg, "%i", &n) == 0) || (n < 0) || (n > 4096))
 171                         argp_usage(state);
 172                 else
 173                         arguments->fill_watermark = n;
 174                 break;
 175         }
 176         case 'q':
 177                 arguments->quiet = true;
 178                 break;
 179         case 'v':
 180                 arguments->verbose = true;
 181                 break;
 182         case 'd': {
 183                 int n;
 184                 if ((sscanf(arg,"%i", &n) == 0) || ((n | 1)!=1))
 185                         argp_usage(state);
 186                 else
 187                         arguments->enable_drng = false;
 188                 break;
 189         }
 190         case 'n': {
 191                 int n;
 192                 if ((sscanf(arg,"%i", &n) == 0) || ((n | 1)!=1))
 193                         argp_usage(state);
 194                 else
 195                         arguments->enable_tpm = false;
 196                 break;
 197         }
 198
 199         default:
 200                 return ARGP_ERR_UNKNOWN;
 201         }
 202
 203         return 0;
 204 }
 205
 206 static struct argp argp = { options, parse_opt, NULL, doc };
 207
 208
 209 static int update_kernel_random(int random_step,
 210         unsigned char *buf, fips_ctx_t *fipsctx_in)
 211 {
 212         unsigned char *p;
 213         int fips;
 214
 215         fips = fips_run_rng_test(fipsctx_in, buf);
 216         if (fips)
 217                 return 1;
 218
 219         for (p = buf; p + random_step <= &buf[FIPS_RNG_BUFFER_SIZE];
 220                  p += random_step) {
 221                 random_add_entropy(p, random_step);
 222                 random_sleep();
 223         }
 224         return 0;
 225 }
 226
 227 static void do_loop(int random_step)
 228 {
 229         unsigned char buf[FIPS_RNG_BUFFER_SIZE];
 230         int retval = 0;
 231         int no_work = 0;
 232
 233         while (no_work < 100) {
 234                 struct rng *iter;
 235                 bool work_done;
 236
 237                 work_done = false;
 238                 for (iter = rng_list; iter; iter = iter->next)
 239                 {
 240                         int rc;
 241
 242                         if (!server_running)
 243                                 return;
 244
 245                 retry_same:
 246                         if (iter->disabled)
 247                                 continue;       /* failed, no work */
 248
 249                         retval = iter->xread(buf, sizeof buf, iter);
 250                         if (retval)
 251                                 continue;       /* failed, no work */
 252
 253                         work_done = true;
 254
 255                         rc = update_kernel_random(random_step,
 256                                              buf, iter->fipsctx);
 257                         if (rc == 0) {
 258                                 iter->success++;
 259                                 if (iter->success >= RNG_OK_CREDIT) {
 260                                         if (iter->failures)
 261                                                 iter->failures--;
 262                                         iter->success = 0;
 263                                 }
 264                                 break;  /* succeeded, work done */
 265                         }
 266
 267                         iter->failures++;
 268                         if (iter->failures <= MAX_RNG_FAILURES/4) {
 269                                 /* FIPS tests have false positives */
 270                                 goto retry_same;
 271                         } else if (iter->failures >= MAX_RNG_FAILURES) {
 272                                 if (!arguments->quiet)
 273                                         message(LOG_DAEMON|LOG_ERR,
 274                                         "too many FIPS failures, disabling entropy source\n");
 275                                 iter->disabled = true;
 276                         }
 277                 }
 278
 279                 if (!work_done)
 280                         no_work++;
 281         }
 282
 283         if (!arguments->quiet)
 284                 message(LOG_DAEMON|LOG_ERR,
 285                 "No entropy sources working, exiting rngd\n");
 286 }
 287
 288 static void term_signal(int signo)
 289 {
 290         server_running = false;
 291 }
 292
 293 int main(int argc, char **argv)
 294 {
 295         int rc_rng = 1;
 296         int rc_drng = 1;
 297         int rc_tpm = 1;
 298         int pid_fd = -1;
 299
 300         openlog("rngd", 0, LOG_DAEMON);
 301
 302         /* Get the default watermark level for this platform */
 303         arguments->fill_watermark = default_watermark();
 304
 305         /* Parsing of commandline parameters */
 306         argp_parse(&argp, argc, argv, 0, 0, arguments);
 307
 308         /* Init entropy sources, and open TRNG device */
 309         if (arguments->enable_drng)
 310                 rc_drng = init_drng_entropy_source(&rng_drng);
 311         rc_rng = init_entropy_source(&rng_default);
 312         if (arguments->enable_tpm && rc_rng)
 313                 rc_tpm = init_tpm_entropy_source(&rng_tpm);
 314
 315         if (rc_rng && rc_drng && rc_tpm) {
 316                 if (!arguments->quiet) {
 317                         message(LOG_DAEMON|LOG_ERR,
 318                                 "can't open any entropy source");
 319                         message(LOG_DAEMON|LOG_ERR,
 320                                 "Maybe RNG device modules are not loaded\n");
 321                 }
 322                 return 1;
 323         }
 324
 325         if (arguments->verbose) {
 326                 printf("Available entropy sources:\n");
 327                 if (!rc_rng)
 328                         printf("\tIntel/AMD hardware rng\n");
 329                 if (!rc_drng)
 330                         printf("\tDRNG\n");
 331                 if (!rc_tpm)
 332                         printf("\tTPM\n");
 333         }
 334
 335         if (rc_rng
 336                 && (rc_drng || !arguments->enable_drng)
 337                 && (rc_tpm || !arguments->enable_tpm)) {
 338                 if (!arguments->quiet)
 339                         message(LOG_DAEMON|LOG_ERR,
 340                 "No entropy source available, shutting down\n");
 341                 return 1;
 342         }
 343
 344         /* Init entropy sink and open random device */
 345         init_kernel_rng(arguments->random_name);
 346
 347         if (arguments->daemon) {
 348                 am_daemon = true;
 349
 350                 if (daemon(0, 0) < 0) {
 351                         if(!arguments->quiet)
 352                                 fprintf(stderr, "can't daemonize: %s\n",
 353                                 strerror(errno));
 354                         return 1;
 355                 }
 356
 357                 /* require valid, locked PID file to proceed */
 358                 pid_fd = write_pid_file(arguments->pid_file);
 359                 if (pid_fd < 0)
 360                         return 1;
 361
 362                 signal(SIGHUP, SIG_IGN);
 363                 signal(SIGPIPE, SIG_IGN);
 364                 signal(SIGINT, term_signal);
 365                 signal(SIGTERM, term_signal);
 366         }
 367
 368         do_loop(arguments->random_step);
 369
 370         if (pid_fd >= 0)
 371                 unlink(arguments->pid_file);
 372
 373         return 0;
 374 }