src/basic/random-util.c

   1 /* SPDX-License-Identifier: LGPL-2.1+ */
   2
   3 #include <elf.h>
   4 #include <errno.h>
   5 #include <fcntl.h>
   6 //#include <linux/random.h>
   7 #include <stdbool.h>
   8 //#include <stdint.h>
   9 #include <stdlib.h>
  10 #include <string.h>
  11 #include <sys/time.h>
  12
  13 #if HAVE_SYS_AUXV_H
  14 #  include <sys/auxv.h>
  15 #endif
  16
  17 #if USE_SYS_RANDOM_H
  18 #  include <sys/random.h>
  19 #else
  20 #  include <linux/random.h>
  21 #endif
  22
  23 #include "fd-util.h"
  24 #include "io-util.h"
  25 #include "missing.h"
  26 #include "random-util.h"
  27 #include "time-util.h"
  28
  29 int acquire_random_bytes(void *p, size_t n, bool high_quality_required) {
  30         static int have_syscall = -1;
  31
  32         _cleanup_close_ int fd = -1;
  33         size_t already_done = 0;
  34         int r;
  35
  36         /* Gathers some randomness from the kernel. This call will never block. If
  37          * high_quality_required, it will always return some data from the kernel,
  38          * regardless of whether the random pool is fully initialized or not.
  39          * Otherwise, it will return success if at least some random bytes were
  40          * successfully acquired, and an error if the kernel has no entropy whatsover
  41          * for us. */
  42
  43         /* Use the getrandom() syscall unless we know we don't have it. */
  44         if (have_syscall != 0 && !HAS_FEATURE_MEMORY_SANITIZER) {
  45                 r = getrandom(p, n, GRND_NONBLOCK);
  46                 if (r > 0) {
  47                         have_syscall = true;
  48                         if ((size_t) r == n)
  49                                 return 0;
  50                         if (!high_quality_required) {
  51                                 /* Fill in the remaining bytes using pseudorandom values */
  52                                 pseudorandom_bytes((uint8_t*) p + r, n - r);
  53                                 return 0;
  54                         }
  55
  56                         already_done = r;
  57                 } else if (errno == ENOSYS)
  58                           /* We lack the syscall, continue with reading from /dev/urandom. */
  59                           have_syscall = false;
  60                 else if (errno == EAGAIN) {
  61                         /* The kernel has no entropy whatsoever. Let's remember to
  62                          * use the syscall the next time again though.
  63                          *
  64                          * If high_quality_required is false, return an error so that
  65                          * random_bytes() can produce some pseudorandom
  66                          * bytes. Otherwise, fall back to /dev/urandom, which we know
  67                          * is empty, but the kernel will produce some bytes for us on
  68                          * a best-effort basis. */
  69                         have_syscall = true;
  70
  71                         if (!high_quality_required)
  72                                 return -ENODATA;
  73                 } else
  74                         return -errno;
  75         }
  76
  77         fd = open("/dev/urandom", O_RDONLY|O_CLOEXEC|O_NOCTTY);
  78         if (fd < 0)
  79                 return errno == ENOENT ? -ENOSYS : -errno;
  80
  81         return loop_read_exact(fd, (uint8_t*) p + already_done, n - already_done, true);
  82 }
  83
  84 void initialize_srand(void) {
  85         static bool srand_called = false;
  86         unsigned x;
  87 #if HAVE_SYS_AUXV_H
  88         void *auxv;
  89 #endif
  90
  91         if (srand_called)
  92                 return;
  93
  94 #if HAVE_SYS_AUXV_H
  95         /* The kernel provides us with 16 bytes of entropy in auxv, so let's
  96          * try to make use of that to seed the pseudo-random generator. It's
  97          * better than nothing... */
  98
  99         auxv = (void*) getauxval(AT_RANDOM);
 100         if (auxv) {
 101                 assert_cc(sizeof(x) <= 16);
 102                 memcpy(&x, auxv, sizeof(x));
 103         } else
 104 #endif
 105                 x = 0;
 106
 107         x ^= (unsigned) now(CLOCK_REALTIME);
 108         x ^= (unsigned) gettid();
 109
 110         srand(x);
 111         srand_called = true;
 112 }
 113
 114 /* INT_MAX gives us only 31 bits, so use 24 out of that. */
 115 #if RAND_MAX >= INT_MAX
 116 #  define RAND_STEP 3
 117 #else
 118 /* SHORT_INT_MAX or lower gives at most 15 bits, we just just 8 out of that. */
 119 #  define RAND_STEP 1
 120 #endif
 121
 122 void pseudorandom_bytes(void *p, size_t n) {
 123         uint8_t *q;
 124
 125         initialize_srand();
 126
 127         for (q = p; q < (uint8_t*) p + n; q += RAND_STEP) {
 128                 unsigned rr;
 129
 130                 rr = (unsigned) rand();
 131
 132 #if RAND_STEP >= 3
 133                 if ((size_t) (q - (uint8_t*) p + 2) < n)
 134                         q[2] = rr >> 16;
 135 #endif
 136 #if RAND_STEP >= 2
 137                 if ((size_t) (q - (uint8_t*) p + 1) < n)
 138                         q[1] = rr >> 8;
 139 #endif
 140                 q[0] = rr;
 141         }
 142 }
 143
 144 void random_bytes(void *p, size_t n) {
 145         int r;
 146
 147         r = acquire_random_bytes(p, n, false);
 148         if (r >= 0)
 149                 return;
 150
 151         /* If some idiot made /dev/urandom unavailable to us, or the
 152          * kernel has no entropy, use a PRNG instead. */
 153         return pseudorandom_bytes(p, n);
 154 }