| 1 |
/* SPDX-License-Identifier: LGPL-2.1-or-later */ |
| 2 |
|
| 3 |
#include <elf.h> |
| 4 |
#include <fcntl.h> |
| 5 |
#include <linux/random.h> |
| 6 |
#include <string.h> |
| 7 |
#include <sys/auxv.h> |
| 8 |
#include <sys/ioctl.h> |
| 9 |
#include <sys/random.h> |
| 10 |
#include <threads.h> |
| 11 |
#include <unistd.h> |
| 12 |
|
| 13 |
#include "alloc-util.h" |
| 14 |
#include "fd-util.h" |
| 15 |
#include "fileio.h" |
| 16 |
#include "io-util.h" |
| 17 |
#include "iovec-util.h" |
| 18 |
#include "log.h" |
| 19 |
#include "parse-util.h" |
| 20 |
#include "pidfd-util.h" |
| 21 |
#include "process-util.h" |
| 22 |
#include "random-util.h" |
| 23 |
#include "sha256.h" |
| 24 |
#include "time-util.h" |
| 25 |
|
| 26 |
/* This is a "best effort" kind of thing, but has no real security value. So, this should only be used by |
| 27 |
* random_bytes(), which is not meant for crypto. This could be made better, but we're *not* trying to roll a |
| 28 |
* userspace prng here, or even have forward secrecy, but rather just do the shortest thing that is at least |
| 29 |
* better than libc rand(). */ |
| 30 |
static void fallback_random_bytes(void *p, size_t n) { |
| 31 |
static thread_local uint64_t fallback_counter = 0; |
| 32 |
struct { |
| 33 |
char label[32]; |
| 34 |
uint64_t call_id, block_id; |
| 35 |
usec_t stamp_mono, stamp_real; |
| 36 |
pid_t pid, tid; |
| 37 |
uint64_t pidfdid; |
| 38 |
uint8_t auxval[16]; |
| 39 |
} state = { |
| 40 |
/* Arbitrary domain separation to prevent other usage of AT_RANDOM from clashing. */ |
| 41 |
.call_id = fallback_counter++, |
| 42 |
.stamp_mono = now(CLOCK_MONOTONIC), |
| 43 |
.stamp_real = now(CLOCK_REALTIME), |
| 44 |
.pid = getpid_cached(), |
| 45 |
.tid = gettid(), |
| 46 |
}; |
| 47 |
|
| 48 |
memcpy(state.label, "systemd fallback random bytes v1", sizeof(state.label)); |
| 49 |
memcpy(state.auxval, ULONG_TO_PTR(getauxval(AT_RANDOM)), sizeof(state.auxval)); |
| 50 |
(void) pidfd_get_inode_id_self_cached(&state.pidfdid); |
| 51 |
|
| 52 |
while (n > 0) { |
| 53 |
struct sha256_ctx ctx; |
| 54 |
|
| 55 |
sha256_init_ctx(&ctx); |
| 56 |
sha256_process_bytes(&state, sizeof(state), &ctx); |
| 57 |
if (n < SHA256_DIGEST_SIZE) { |
| 58 |
uint8_t partial[SHA256_DIGEST_SIZE]; |
| 59 |
sha256_finish_ctx(&ctx, partial); |
| 60 |
memcpy(p, partial, n); |
| 61 |
break; |
| 62 |
} |
| 63 |
sha256_finish_ctx(&ctx, p); |
| 64 |
p = (uint8_t *) p + SHA256_DIGEST_SIZE; |
| 65 |
n -= SHA256_DIGEST_SIZE; |
| 66 |
++state.block_id; |
| 67 |
} |
| 68 |
} |
| 69 |
|
| 70 |
void random_bytes(void *p, size_t n) { |
| 71 |
assert(p || n == 0); |
| 72 |
|
| 73 |
if (n == 0) |
| 74 |
return; |
| 75 |
|
| 76 |
for (;;) { |
| 77 |
ssize_t l; |
| 78 |
|
| 79 |
l = getrandom(p, n, GRND_INSECURE); |
| 80 |
if (l <= 0) |
| 81 |
break; /* Unexpected error. Give up and fallback to /dev/urandom. */ |
| 82 |
|
| 83 |
if ((size_t) l == n) |
| 84 |
return; /* Done reading, success. */ |
| 85 |
|
| 86 |
p = (uint8_t *) p + l; |
| 87 |
n -= l; |
| 88 |
/* Interrupted by a signal; keep going. */ |
| 89 |
} |
| 90 |
|
| 91 |
_cleanup_close_ int fd = open("/dev/urandom", O_RDONLY|O_CLOEXEC|O_NOCTTY); |
| 92 |
if (fd >= 0 && loop_read_exact(fd, p, n, false) >= 0) |
| 93 |
return; |
| 94 |
|
| 95 |
/* This is a terrible fallback. Oh well. */ |
| 96 |
fallback_random_bytes(p, n); |
| 97 |
} |
| 98 |
|
| 99 |
int random_bytes_allocate_iovec(size_t n, struct iovec *ret) { |
| 100 |
assert(ret); |
| 101 |
|
| 102 |
void *p = malloc(MAX(n, 1U)); |
| 103 |
if (!p) |
| 104 |
return -ENOMEM; |
| 105 |
|
| 106 |
random_bytes(p, n); |
| 107 |
|
| 108 |
*ret = IOVEC_MAKE(TAKE_PTR(p), n); |
| 109 |
return 0; |
| 110 |
} |
| 111 |
|
| 112 |
int crypto_random_bytes(void *p, size_t n) { |
| 113 |
assert(p || n == 0); |
| 114 |
|
| 115 |
if (n == 0) |
| 116 |
return 0; |
| 117 |
|
| 118 |
for (;;) { |
| 119 |
ssize_t l; |
| 120 |
|
| 121 |
l = getrandom(p, n, 0); |
| 122 |
if (l < 0) |
| 123 |
return -errno; |
| 124 |
if (l == 0) |
| 125 |
return -EIO; /* Weird, should never happen. */ |
| 126 |
|
| 127 |
if ((size_t) l == n) |
| 128 |
return 0; /* Done reading, success. */ |
| 129 |
|
| 130 |
p = (uint8_t *) p + l; |
| 131 |
n -= l; |
| 132 |
/* Interrupted by a signal; keep going. */ |
| 133 |
} |
| 134 |
} |
| 135 |
|
| 136 |
int crypto_random_bytes_allocate_iovec(size_t n, struct iovec *ret) { |
| 137 |
_cleanup_free_ void *p = NULL; |
| 138 |
int r; |
| 139 |
|
| 140 |
assert(ret); |
| 141 |
|
| 142 |
p = malloc(MAX(n, 1U)); |
| 143 |
if (!p) |
| 144 |
return -ENOMEM; |
| 145 |
|
| 146 |
r = crypto_random_bytes(p, n); |
| 147 |
if (r < 0) |
| 148 |
return r; |
| 149 |
|
| 150 |
*ret = IOVEC_MAKE(TAKE_PTR(p), n); |
| 151 |
return 0; |
| 152 |
} |
| 153 |
|
| 154 |
size_t random_pool_size(void) { |
| 155 |
_cleanup_free_ char *s = NULL; |
| 156 |
int r; |
| 157 |
|
| 158 |
/* Read pool size, if possible */ |
| 159 |
r = read_one_line_file("/proc/sys/kernel/random/poolsize", &s); |
| 160 |
if (r < 0) |
| 161 |
log_debug_errno(r, "Failed to read pool size from kernel: %m"); |
| 162 |
else { |
| 163 |
unsigned sz; |
| 164 |
|
| 165 |
r = safe_atou(s, &sz); |
| 166 |
if (r < 0) |
| 167 |
log_debug_errno(r, "Failed to parse pool size: %s", s); |
| 168 |
else |
| 169 |
/* poolsize is in bits on 2.6, but we want bytes */ |
| 170 |
return CLAMP(sz / 8, RANDOM_POOL_SIZE_MIN, RANDOM_POOL_SIZE_MAX); |
| 171 |
} |
| 172 |
|
| 173 |
/* Use the minimum as default, if we can't retrieve the correct value */ |
| 174 |
return RANDOM_POOL_SIZE_MIN; |
| 175 |
} |
| 176 |
|
| 177 |
int random_write_entropy(int fd, const void *seed, size_t size, bool credit) { |
| 178 |
_cleanup_close_ int opened_fd = -EBADF; |
| 179 |
int r; |
| 180 |
|
| 181 |
assert(seed || size == 0); |
| 182 |
|
| 183 |
if (size == 0) |
| 184 |
return 0; |
| 185 |
|
| 186 |
if (fd < 0) { |
| 187 |
opened_fd = open("/dev/urandom", O_WRONLY|O_CLOEXEC|O_NOCTTY); |
| 188 |
if (opened_fd < 0) |
| 189 |
return -errno; |
| 190 |
|
| 191 |
fd = opened_fd; |
| 192 |
} |
| 193 |
|
| 194 |
if (credit) { |
| 195 |
_cleanup_free_ struct rand_pool_info *info = NULL; |
| 196 |
|
| 197 |
/* The kernel API only accepts "int" as entropy count (which is in bits), let's avoid any |
| 198 |
* chance for confusion here. */ |
| 199 |
if (size > INT_MAX / 8) |
| 200 |
return -EOVERFLOW; |
| 201 |
|
| 202 |
info = malloc(offsetof(struct rand_pool_info, buf) + size); |
| 203 |
if (!info) |
| 204 |
return -ENOMEM; |
| 205 |
|
| 206 |
info->entropy_count = size * 8; |
| 207 |
info->buf_size = size; |
| 208 |
memcpy(info->buf, seed, size); |
| 209 |
|
| 210 |
if (ioctl(fd, RNDADDENTROPY, info) < 0) |
| 211 |
return -errno; |
| 212 |
} else { |
| 213 |
r = loop_write(fd, seed, size); |
| 214 |
if (r < 0) |
| 215 |
return r; |
| 216 |
} |
| 217 |
|
| 218 |
return 1; |
| 219 |
} |
| 220 |
|
| 221 |
uint64_t random_u64_range(uint64_t m) { |
| 222 |
uint64_t x, remainder; |
| 223 |
|
| 224 |
/* Generates a random number in the range 0…m-1, unbiased. (Java's algorithm) */ |
| 225 |
|
| 226 |
if (m == 0) /* Let's take m == 0 as special case to return an integer from the full range */ |
| 227 |
return random_u64(); |
| 228 |
if (m == 1) |
| 229 |
return 0; |
| 230 |
|
| 231 |
remainder = UINT64_MAX % m; |
| 232 |
|
| 233 |
do { |
| 234 |
x = random_u64(); |
| 235 |
} while (x >= UINT64_MAX - remainder); |
| 236 |
|
| 237 |
return x % m; |
| 238 |
} |