Debian Codegraph @

src/basic/random-util.c

raw
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 }