src/random-seed/random-seed.c

   1 /*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/
   2
   3 /***
   4   This file is part of systemd.
   5
   6   Copyright 2010 Lennart Poettering
   7
   8   systemd is free software; you can redistribute it and/or modify it
   9   under the terms of the GNU Lesser General Public License as published by
  10   the Free Software Foundation; either version 2.1 of the License, or
  11   (at your option) any later version.
  12
  13   systemd is distributed in the hope that it will be useful, but
  14   WITHOUT ANY WARRANTY; without even the implied warranty of
  15   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  16   Lesser General Public License for more details.
  17
  18   You should have received a copy of the GNU Lesser General Public License
  19   along with systemd; If not, see <http://www.gnu.org/licenses/>.
  20 ***/
  21
  22 #include <unistd.h>
  23 #include <fcntl.h>
  24 #include <errno.h>
  25 #include <string.h>
  26 #include <sys/stat.h>
  27
  28 #include "log.h"
  29 #include "util.h"
  30 #include "mkdir.h"
  31
  32 #define POOL_SIZE_MIN 512
  33
  34 int main(int argc, char *argv[]) {
  35         _cleanup_close_ int seed_fd = -1, random_fd = -1;
  36         _cleanup_free_ void* buf = NULL;
  37         size_t buf_size = 0;
  38         ssize_t k;
  39         int r;
  40         FILE *f;
  41         bool refresh_seed_file = true;
  42
  43         if (argc != 2) {
  44                 log_error("This program requires one argument.");
  45                 return EXIT_FAILURE;
  46         }
  47
  48         log_set_target(LOG_TARGET_AUTO);
  49         log_parse_environment();
  50         log_open();
  51
  52         umask(0022);
  53
  54         /* Read pool size, if possible */
  55         f = fopen("/proc/sys/kernel/random/poolsize", "re");
  56         if (f) {
  57                 if (fscanf(f, "%zu", &buf_size) > 0)
  58                         /* poolsize is in bits on 2.6, but we want bytes */
  59                         buf_size /= 8;
  60
  61                 fclose(f);
  62         }
  63
  64         if (buf_size <= POOL_SIZE_MIN)
  65                 buf_size = POOL_SIZE_MIN;
  66
  67         buf = malloc(buf_size);
  68         if (!buf) {
  69                 r = log_oom();
  70                 goto finish;
  71         }
  72
  73         r = mkdir_parents_label(RANDOM_SEED, 0755);
  74         if (r < 0) {
  75                 log_error_errno(r, "Failed to create directory " RANDOM_SEED_DIR ": %m");
  76                 goto finish;
  77         }
  78
  79         /* When we load the seed we read it and write it to the device
  80          * and then immediately update the saved seed with new data,
  81          * to make sure the next boot gets seeded differently. */
  82
  83         if (streq(argv[1], "load")) {
  84
  85                 seed_fd = open(RANDOM_SEED, O_RDWR|O_CLOEXEC|O_NOCTTY|O_CREAT, 0600);
  86                 if (seed_fd < 0) {
  87                         seed_fd = open(RANDOM_SEED, O_RDONLY|O_CLOEXEC|O_NOCTTY);
  88                         if (seed_fd < 0) {
  89                                 r = log_error_errno(errno, "Failed to open " RANDOM_SEED ": %m");
  90                                 goto finish;
  91                         }
  92
  93                         refresh_seed_file = false;
  94                 }
  95
  96                 random_fd = open("/dev/urandom", O_RDWR|O_CLOEXEC|O_NOCTTY, 0600);
  97                 if (random_fd < 0) {
  98                         random_fd = open("/dev/urandom", O_WRONLY|O_CLOEXEC|O_NOCTTY, 0600);
  99                         if (random_fd < 0) {
 100                                 r = log_error_errno(errno, "Failed to open /dev/urandom: %m");
 101                                 goto finish;
 102                         }
 103                 }
 104
 105                 k = loop_read(seed_fd, buf, buf_size, false);
 106                 if (k < 0)
 107                         r = log_error_errno(k, "Failed to read seed from " RANDOM_SEED ": %m");
 108                 else if (k == 0)
 109                         log_debug("Seed file " RANDOM_SEED " not yet initialized, proceeding.");
 110                 else {
 111                         (void) lseek(seed_fd, 0, SEEK_SET);
 112
 113                         r = loop_write(random_fd, buf, (size_t) k, false);
 114                         if (r < 0)
 115                                 log_error_errno(r, "Failed to write seed to /dev/urandom: %m");
 116                 }
 117
 118         } else if (streq(argv[1], "save")) {
 119
 120                 seed_fd = open(RANDOM_SEED, O_WRONLY|O_CLOEXEC|O_NOCTTY|O_CREAT, 0600);
 121                 if (seed_fd < 0) {
 122                         r = log_error_errno(errno, "Failed to open " RANDOM_SEED ": %m");
 123                         goto finish;
 124                 }
 125
 126                 random_fd = open("/dev/urandom", O_RDONLY|O_CLOEXEC|O_NOCTTY);
 127                 if (random_fd < 0) {
 128                         r = log_error_errno(errno, "Failed to open /dev/urandom: %m");
 129                         goto finish;
 130                 }
 131
 132         } else {
 133                 log_error("Unknown verb '%s'.", argv[1]);
 134                 r = -EINVAL;
 135                 goto finish;
 136         }
 137
 138         if (refresh_seed_file) {
 139
 140                 /* This is just a safety measure. Given that we are root and
 141                  * most likely created the file ourselves the mode and owner
 142                  * should be correct anyway. */
 143                 (void) fchmod(seed_fd, 0600);
 144                 (void) fchown(seed_fd, 0, 0);
 145
 146                 k = loop_read(random_fd, buf, buf_size, false);
 147                 if (k < 0) {
 148                         r = log_error_errno(k, "Failed to read new seed from /dev/urandom: %m");
 149                         goto finish;
 150                 }
 151                 if (k == 0) {
 152                         log_error("Got EOF while reading from /dev/urandom.");
 153                         r = -EIO;
 154                         goto finish;
 155                 }
 156
 157                 r = loop_write(seed_fd, buf, (size_t) k, false);
 158                 if (r < 0)
 159                         log_error_errno(r, "Failed to write new random seed file: %m");
 160         }
 161
 162 finish:
 163         return r < 0 ? EXIT_FAILURE : EXIT_SUCCESS;
 164 }