Branch data Line data Source code
1 : : /*
2 : : * random.c -- A strong random number generator
3 : : *
4 : : * Copyright (C) 2017 Jason A. Donenfeld <Jason@zx2c4.com>. All
5 : : * Rights Reserved.
6 : : *
7 : : * Copyright Matt Mackall <mpm@selenic.com>, 2003, 2004, 2005
8 : : *
9 : : * Copyright Theodore Ts'o, 1994, 1995, 1996, 1997, 1998, 1999. All
10 : : * rights reserved.
11 : : *
12 : : * Redistribution and use in source and binary forms, with or without
13 : : * modification, are permitted provided that the following conditions
14 : : * are met:
15 : : * 1. Redistributions of source code must retain the above copyright
16 : : * notice, and the entire permission notice in its entirety,
17 : : * including the disclaimer of warranties.
18 : : * 2. Redistributions in binary form must reproduce the above copyright
19 : : * notice, this list of conditions and the following disclaimer in the
20 : : * documentation and/or other materials provided with the distribution.
21 : : * 3. The name of the author may not be used to endorse or promote
22 : : * products derived from this software without specific prior
23 : : * written permission.
24 : : *
25 : : * ALTERNATIVELY, this product may be distributed under the terms of
26 : : * the GNU General Public License, in which case the provisions of the GPL are
27 : : * required INSTEAD OF the above restrictions. (This clause is
28 : : * necessary due to a potential bad interaction between the GPL and
29 : : * the restrictions contained in a BSD-style copyright.)
30 : : *
31 : : * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED
32 : : * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
33 : : * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ALL OF
34 : : * WHICH ARE HEREBY DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE
35 : : * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
36 : : * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT
37 : : * OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
38 : : * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
39 : : * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
40 : : * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
41 : : * USE OF THIS SOFTWARE, EVEN IF NOT ADVISED OF THE POSSIBILITY OF SUCH
42 : : * DAMAGE.
43 : : */
44 : :
45 : : /*
46 : : * (now, with legal B.S. out of the way.....)
47 : : *
48 : : * This routine gathers environmental noise from device drivers, etc.,
49 : : * and returns good random numbers, suitable for cryptographic use.
50 : : * Besides the obvious cryptographic uses, these numbers are also good
51 : : * for seeding TCP sequence numbers, and other places where it is
52 : : * desirable to have numbers which are not only random, but hard to
53 : : * predict by an attacker.
54 : : *
55 : : * Theory of operation
56 : : * ===================
57 : : *
58 : : * Computers are very predictable devices. Hence it is extremely hard
59 : : * to produce truly random numbers on a computer --- as opposed to
60 : : * pseudo-random numbers, which can easily generated by using a
61 : : * algorithm. Unfortunately, it is very easy for attackers to guess
62 : : * the sequence of pseudo-random number generators, and for some
63 : : * applications this is not acceptable. So instead, we must try to
64 : : * gather "environmental noise" from the computer's environment, which
65 : : * must be hard for outside attackers to observe, and use that to
66 : : * generate random numbers. In a Unix environment, this is best done
67 : : * from inside the kernel.
68 : : *
69 : : * Sources of randomness from the environment include inter-keyboard
70 : : * timings, inter-interrupt timings from some interrupts, and other
71 : : * events which are both (a) non-deterministic and (b) hard for an
72 : : * outside observer to measure. Randomness from these sources are
73 : : * added to an "entropy pool", which is mixed using a CRC-like function.
74 : : * This is not cryptographically strong, but it is adequate assuming
75 : : * the randomness is not chosen maliciously, and it is fast enough that
76 : : * the overhead of doing it on every interrupt is very reasonable.
77 : : * As random bytes are mixed into the entropy pool, the routines keep
78 : : * an *estimate* of how many bits of randomness have been stored into
79 : : * the random number generator's internal state.
80 : : *
81 : : * When random bytes are desired, they are obtained by taking the SHA
82 : : * hash of the contents of the "entropy pool". The SHA hash avoids
83 : : * exposing the internal state of the entropy pool. It is believed to
84 : : * be computationally infeasible to derive any useful information
85 : : * about the input of SHA from its output. Even if it is possible to
86 : : * analyze SHA in some clever way, as long as the amount of data
87 : : * returned from the generator is less than the inherent entropy in
88 : : * the pool, the output data is totally unpredictable. For this
89 : : * reason, the routine decreases its internal estimate of how many
90 : : * bits of "true randomness" are contained in the entropy pool as it
91 : : * outputs random numbers.
92 : : *
93 : : * If this estimate goes to zero, the routine can still generate
94 : : * random numbers; however, an attacker may (at least in theory) be
95 : : * able to infer the future output of the generator from prior
96 : : * outputs. This requires successful cryptanalysis of SHA, which is
97 : : * not believed to be feasible, but there is a remote possibility.
98 : : * Nonetheless, these numbers should be useful for the vast majority
99 : : * of purposes.
100 : : *
101 : : * Exported interfaces ---- output
102 : : * ===============================
103 : : *
104 : : * There are four exported interfaces; two for use within the kernel,
105 : : * and two or use from userspace.
106 : : *
107 : : * Exported interfaces ---- userspace output
108 : : * -----------------------------------------
109 : : *
110 : : * The userspace interfaces are two character devices /dev/random and
111 : : * /dev/urandom. /dev/random is suitable for use when very high
112 : : * quality randomness is desired (for example, for key generation or
113 : : * one-time pads), as it will only return a maximum of the number of
114 : : * bits of randomness (as estimated by the random number generator)
115 : : * contained in the entropy pool.
116 : : *
117 : : * The /dev/urandom device does not have this limit, and will return
118 : : * as many bytes as are requested. As more and more random bytes are
119 : : * requested without giving time for the entropy pool to recharge,
120 : : * this will result in random numbers that are merely cryptographically
121 : : * strong. For many applications, however, this is acceptable.
122 : : *
123 : : * Exported interfaces ---- kernel output
124 : : * --------------------------------------
125 : : *
126 : : * The primary kernel interface is
127 : : *
128 : : * void get_random_bytes(void *buf, int nbytes);
129 : : *
130 : : * This interface will return the requested number of random bytes,
131 : : * and place it in the requested buffer. This is equivalent to a
132 : : * read from /dev/urandom.
133 : : *
134 : : * For less critical applications, there are the functions:
135 : : *
136 : : * u32 get_random_u32()
137 : : * u64 get_random_u64()
138 : : * unsigned int get_random_int()
139 : : * unsigned long get_random_long()
140 : : *
141 : : * These are produced by a cryptographic RNG seeded from get_random_bytes,
142 : : * and so do not deplete the entropy pool as much. These are recommended
143 : : * for most in-kernel operations *if the result is going to be stored in
144 : : * the kernel*.
145 : : *
146 : : * Specifically, the get_random_int() family do not attempt to do
147 : : * "anti-backtracking". If you capture the state of the kernel (e.g.
148 : : * by snapshotting the VM), you can figure out previous get_random_int()
149 : : * return values. But if the value is stored in the kernel anyway,
150 : : * this is not a problem.
151 : : *
152 : : * It *is* safe to expose get_random_int() output to attackers (e.g. as
153 : : * network cookies); given outputs 1..n, it's not feasible to predict
154 : : * outputs 0 or n+1. The only concern is an attacker who breaks into
155 : : * the kernel later; the get_random_int() engine is not reseeded as
156 : : * often as the get_random_bytes() one.
157 : : *
158 : : * get_random_bytes() is needed for keys that need to stay secret after
159 : : * they are erased from the kernel. For example, any key that will
160 : : * be wrapped and stored encrypted. And session encryption keys: we'd
161 : : * like to know that after the session is closed and the keys erased,
162 : : * the plaintext is unrecoverable to someone who recorded the ciphertext.
163 : : *
164 : : * But for network ports/cookies, stack canaries, PRNG seeds, address
165 : : * space layout randomization, session *authentication* keys, or other
166 : : * applications where the sensitive data is stored in the kernel in
167 : : * plaintext for as long as it's sensitive, the get_random_int() family
168 : : * is just fine.
169 : : *
170 : : * Consider ASLR. We want to keep the address space secret from an
171 : : * outside attacker while the process is running, but once the address
172 : : * space is torn down, it's of no use to an attacker any more. And it's
173 : : * stored in kernel data structures as long as it's alive, so worrying
174 : : * about an attacker's ability to extrapolate it from the get_random_int()
175 : : * CRNG is silly.
176 : : *
177 : : * Even some cryptographic keys are safe to generate with get_random_int().
178 : : * In particular, keys for SipHash are generally fine. Here, knowledge
179 : : * of the key authorizes you to do something to a kernel object (inject
180 : : * packets to a network connection, or flood a hash table), and the
181 : : * key is stored with the object being protected. Once it goes away,
182 : : * we no longer care if anyone knows the key.
183 : : *
184 : : * prandom_u32()
185 : : * -------------
186 : : *
187 : : * For even weaker applications, see the pseudorandom generator
188 : : * prandom_u32(), prandom_max(), and prandom_bytes(). If the random
189 : : * numbers aren't security-critical at all, these are *far* cheaper.
190 : : * Useful for self-tests, random error simulation, randomized backoffs,
191 : : * and any other application where you trust that nobody is trying to
192 : : * maliciously mess with you by guessing the "random" numbers.
193 : : *
194 : : * Exported interfaces ---- input
195 : : * ==============================
196 : : *
197 : : * The current exported interfaces for gathering environmental noise
198 : : * from the devices are:
199 : : *
200 : : * void add_device_randomness(const void *buf, unsigned int size);
201 : : * void add_input_randomness(unsigned int type, unsigned int code,
202 : : * unsigned int value);
203 : : * void add_interrupt_randomness(int irq, int irq_flags);
204 : : * void add_disk_randomness(struct gendisk *disk);
205 : : *
206 : : * add_device_randomness() is for adding data to the random pool that
207 : : * is likely to differ between two devices (or possibly even per boot).
208 : : * This would be things like MAC addresses or serial numbers, or the
209 : : * read-out of the RTC. This does *not* add any actual entropy to the
210 : : * pool, but it initializes the pool to different values for devices
211 : : * that might otherwise be identical and have very little entropy
212 : : * available to them (particularly common in the embedded world).
213 : : *
214 : : * add_input_randomness() uses the input layer interrupt timing, as well as
215 : : * the event type information from the hardware.
216 : : *
217 : : * add_interrupt_randomness() uses the interrupt timing as random
218 : : * inputs to the entropy pool. Using the cycle counters and the irq source
219 : : * as inputs, it feeds the randomness roughly once a second.
220 : : *
221 : : * add_disk_randomness() uses what amounts to the seek time of block
222 : : * layer request events, on a per-disk_devt basis, as input to the
223 : : * entropy pool. Note that high-speed solid state drives with very low
224 : : * seek times do not make for good sources of entropy, as their seek
225 : : * times are usually fairly consistent.
226 : : *
227 : : * All of these routines try to estimate how many bits of randomness a
228 : : * particular randomness source. They do this by keeping track of the
229 : : * first and second order deltas of the event timings.
230 : : *
231 : : * Ensuring unpredictability at system startup
232 : : * ============================================
233 : : *
234 : : * When any operating system starts up, it will go through a sequence
235 : : * of actions that are fairly predictable by an adversary, especially
236 : : * if the start-up does not involve interaction with a human operator.
237 : : * This reduces the actual number of bits of unpredictability in the
238 : : * entropy pool below the value in entropy_count. In order to
239 : : * counteract this effect, it helps to carry information in the
240 : : * entropy pool across shut-downs and start-ups. To do this, put the
241 : : * following lines an appropriate script which is run during the boot
242 : : * sequence:
243 : : *
244 : : * echo "Initializing random number generator..."
245 : : * random_seed=/var/run/random-seed
246 : : * # Carry a random seed from start-up to start-up
247 : : * # Load and then save the whole entropy pool
248 : : * if [ -f $random_seed ]; then
249 : : * cat $random_seed >/dev/urandom
250 : : * else
251 : : * touch $random_seed
252 : : * fi
253 : : * chmod 600 $random_seed
254 : : * dd if=/dev/urandom of=$random_seed count=1 bs=512
255 : : *
256 : : * and the following lines in an appropriate script which is run as
257 : : * the system is shutdown:
258 : : *
259 : : * # Carry a random seed from shut-down to start-up
260 : : * # Save the whole entropy pool
261 : : * echo "Saving random seed..."
262 : : * random_seed=/var/run/random-seed
263 : : * touch $random_seed
264 : : * chmod 600 $random_seed
265 : : * dd if=/dev/urandom of=$random_seed count=1 bs=512
266 : : *
267 : : * For example, on most modern systems using the System V init
268 : : * scripts, such code fragments would be found in
269 : : * /etc/rc.d/init.d/random. On older Linux systems, the correct script
270 : : * location might be in /etc/rcb.d/rc.local or /etc/rc.d/rc.0.
271 : : *
272 : : * Effectively, these commands cause the contents of the entropy pool
273 : : * to be saved at shut-down time and reloaded into the entropy pool at
274 : : * start-up. (The 'dd' in the addition to the bootup script is to
275 : : * make sure that /etc/random-seed is different for every start-up,
276 : : * even if the system crashes without executing rc.0.) Even with
277 : : * complete knowledge of the start-up activities, predicting the state
278 : : * of the entropy pool requires knowledge of the previous history of
279 : : * the system.
280 : : *
281 : : * Configuring the /dev/random driver under Linux
282 : : * ==============================================
283 : : *
284 : : * The /dev/random driver under Linux uses minor numbers 8 and 9 of
285 : : * the /dev/mem major number (#1). So if your system does not have
286 : : * /dev/random and /dev/urandom created already, they can be created
287 : : * by using the commands:
288 : : *
289 : : * mknod /dev/random c 1 8
290 : : * mknod /dev/urandom c 1 9
291 : : *
292 : : * Acknowledgements:
293 : : * =================
294 : : *
295 : : * Ideas for constructing this random number generator were derived
296 : : * from Pretty Good Privacy's random number generator, and from private
297 : : * discussions with Phil Karn. Colin Plumb provided a faster random
298 : : * number generator, which speed up the mixing function of the entropy
299 : : * pool, taken from PGPfone. Dale Worley has also contributed many
300 : : * useful ideas and suggestions to improve this driver.
301 : : *
302 : : * Any flaws in the design are solely my responsibility, and should
303 : : * not be attributed to the Phil, Colin, or any of authors of PGP.
304 : : *
305 : : * Further background information on this topic may be obtained from
306 : : * RFC 1750, "Randomness Recommendations for Security", by Donald
307 : : * Eastlake, Steve Crocker, and Jeff Schiller.
308 : : */
309 : :
310 : : #include <linux/utsname.h>
311 : : #include <linux/module.h>
312 : : #include <linux/kernel.h>
313 : : #include <linux/major.h>
314 : : #include <linux/string.h>
315 : : #include <linux/fcntl.h>
316 : : #include <linux/slab.h>
317 : : #include <linux/random.h>
318 : : #include <linux/poll.h>
319 : : #include <linux/init.h>
320 : : #include <linux/fs.h>
321 : : #include <linux/genhd.h>
322 : : #include <linux/interrupt.h>
323 : : #include <linux/mm.h>
324 : : #include <linux/nodemask.h>
325 : : #include <linux/spinlock.h>
326 : : #include <linux/kthread.h>
327 : : #include <linux/percpu.h>
328 : : #include <linux/cryptohash.h>
329 : : #include <linux/fips.h>
330 : : #include <linux/ptrace.h>
331 : : #include <linux/workqueue.h>
332 : : #include <linux/irq.h>
333 : : #include <linux/ratelimit.h>
334 : : #include <linux/syscalls.h>
335 : : #include <linux/completion.h>
336 : : #include <linux/uuid.h>
337 : : #include <crypto/chacha.h>
338 : :
339 : : #include <asm/processor.h>
340 : : #include <linux/uaccess.h>
341 : : #include <asm/irq.h>
342 : : #include <asm/irq_regs.h>
343 : : #include <asm/io.h>
344 : :
345 : : #define CREATE_TRACE_POINTS
346 : : #include <trace/events/random.h>
347 : :
348 : : /* #define ADD_INTERRUPT_BENCH */
349 : :
350 : : /*
351 : : * Configuration information
352 : : */
353 : : #define INPUT_POOL_SHIFT 12
354 : : #define INPUT_POOL_WORDS (1 << (INPUT_POOL_SHIFT-5))
355 : : #define OUTPUT_POOL_SHIFT 10
356 : : #define OUTPUT_POOL_WORDS (1 << (OUTPUT_POOL_SHIFT-5))
357 : : #define SEC_XFER_SIZE 512
358 : : #define EXTRACT_SIZE 10
359 : :
360 : :
361 : : #define LONGS(x) (((x) + sizeof(unsigned long) - 1)/sizeof(unsigned long))
362 : :
363 : : /*
364 : : * To allow fractional bits to be tracked, the entropy_count field is
365 : : * denominated in units of 1/8th bits.
366 : : *
367 : : * 2*(ENTROPY_SHIFT + poolbitshift) must <= 31, or the multiply in
368 : : * credit_entropy_bits() needs to be 64 bits wide.
369 : : */
370 : : #define ENTROPY_SHIFT 3
371 : : #define ENTROPY_BITS(r) ((r)->entropy_count >> ENTROPY_SHIFT)
372 : :
373 : : /*
374 : : * The minimum number of bits of entropy before we wake up a read on
375 : : * /dev/random. Should be enough to do a significant reseed.
376 : : */
377 : : static int random_read_wakeup_bits = 64;
378 : :
379 : : /*
380 : : * If the entropy count falls under this number of bits, then we
381 : : * should wake up processes which are selecting or polling on write
382 : : * access to /dev/random.
383 : : */
384 : : static int random_write_wakeup_bits = 28 * OUTPUT_POOL_WORDS;
385 : :
386 : : /*
387 : : * Originally, we used a primitive polynomial of degree .poolwords
388 : : * over GF(2). The taps for various sizes are defined below. They
389 : : * were chosen to be evenly spaced except for the last tap, which is 1
390 : : * to get the twisting happening as fast as possible.
391 : : *
392 : : * For the purposes of better mixing, we use the CRC-32 polynomial as
393 : : * well to make a (modified) twisted Generalized Feedback Shift
394 : : * Register. (See M. Matsumoto & Y. Kurita, 1992. Twisted GFSR
395 : : * generators. ACM Transactions on Modeling and Computer Simulation
396 : : * 2(3):179-194. Also see M. Matsumoto & Y. Kurita, 1994. Twisted
397 : : * GFSR generators II. ACM Transactions on Modeling and Computer
398 : : * Simulation 4:254-266)
399 : : *
400 : : * Thanks to Colin Plumb for suggesting this.
401 : : *
402 : : * The mixing operation is much less sensitive than the output hash,
403 : : * where we use SHA-1. All that we want of mixing operation is that
404 : : * it be a good non-cryptographic hash; i.e. it not produce collisions
405 : : * when fed "random" data of the sort we expect to see. As long as
406 : : * the pool state differs for different inputs, we have preserved the
407 : : * input entropy and done a good job. The fact that an intelligent
408 : : * attacker can construct inputs that will produce controlled
409 : : * alterations to the pool's state is not important because we don't
410 : : * consider such inputs to contribute any randomness. The only
411 : : * property we need with respect to them is that the attacker can't
412 : : * increase his/her knowledge of the pool's state. Since all
413 : : * additions are reversible (knowing the final state and the input,
414 : : * you can reconstruct the initial state), if an attacker has any
415 : : * uncertainty about the initial state, he/she can only shuffle that
416 : : * uncertainty about, but never cause any collisions (which would
417 : : * decrease the uncertainty).
418 : : *
419 : : * Our mixing functions were analyzed by Lacharme, Roeck, Strubel, and
420 : : * Videau in their paper, "The Linux Pseudorandom Number Generator
421 : : * Revisited" (see: http://eprint.iacr.org/2012/251.pdf). In their
422 : : * paper, they point out that we are not using a true Twisted GFSR,
423 : : * since Matsumoto & Kurita used a trinomial feedback polynomial (that
424 : : * is, with only three taps, instead of the six that we are using).
425 : : * As a result, the resulting polynomial is neither primitive nor
426 : : * irreducible, and hence does not have a maximal period over
427 : : * GF(2**32). They suggest a slight change to the generator
428 : : * polynomial which improves the resulting TGFSR polynomial to be
429 : : * irreducible, which we have made here.
430 : : */
431 : : static const struct poolinfo {
432 : : int poolbitshift, poolwords, poolbytes, poolfracbits;
433 : : #define S(x) ilog2(x)+5, (x), (x)*4, (x) << (ENTROPY_SHIFT+5)
434 : : int tap1, tap2, tap3, tap4, tap5;
435 : : } poolinfo_table[] = {
436 : : /* was: x^128 + x^103 + x^76 + x^51 +x^25 + x + 1 */
437 : : /* x^128 + x^104 + x^76 + x^51 +x^25 + x + 1 */
438 : : { S(128), 104, 76, 51, 25, 1 },
439 : : /* was: x^32 + x^26 + x^20 + x^14 + x^7 + x + 1 */
440 : : /* x^32 + x^26 + x^19 + x^14 + x^7 + x + 1 */
441 : : { S(32), 26, 19, 14, 7, 1 },
442 : : #if 0
443 : : /* x^2048 + x^1638 + x^1231 + x^819 + x^411 + x + 1 -- 115 */
444 : : { S(2048), 1638, 1231, 819, 411, 1 },
445 : :
446 : : /* x^1024 + x^817 + x^615 + x^412 + x^204 + x + 1 -- 290 */
447 : : { S(1024), 817, 615, 412, 204, 1 },
448 : :
449 : : /* x^1024 + x^819 + x^616 + x^410 + x^207 + x^2 + 1 -- 115 */
450 : : { S(1024), 819, 616, 410, 207, 2 },
451 : :
452 : : /* x^512 + x^411 + x^308 + x^208 + x^104 + x + 1 -- 225 */
453 : : { S(512), 411, 308, 208, 104, 1 },
454 : :
455 : : /* x^512 + x^409 + x^307 + x^206 + x^102 + x^2 + 1 -- 95 */
456 : : { S(512), 409, 307, 206, 102, 2 },
457 : : /* x^512 + x^409 + x^309 + x^205 + x^103 + x^2 + 1 -- 95 */
458 : : { S(512), 409, 309, 205, 103, 2 },
459 : :
460 : : /* x^256 + x^205 + x^155 + x^101 + x^52 + x + 1 -- 125 */
461 : : { S(256), 205, 155, 101, 52, 1 },
462 : :
463 : : /* x^128 + x^103 + x^78 + x^51 + x^27 + x^2 + 1 -- 70 */
464 : : { S(128), 103, 78, 51, 27, 2 },
465 : :
466 : : /* x^64 + x^52 + x^39 + x^26 + x^14 + x + 1 -- 15 */
467 : : { S(64), 52, 39, 26, 14, 1 },
468 : : #endif
469 : : };
470 : :
471 : : /*
472 : : * Static global variables
473 : : */
474 : : static DECLARE_WAIT_QUEUE_HEAD(random_read_wait);
475 : : static DECLARE_WAIT_QUEUE_HEAD(random_write_wait);
476 : : static struct fasync_struct *fasync;
477 : :
478 : : static DEFINE_SPINLOCK(random_ready_list_lock);
479 : : static LIST_HEAD(random_ready_list);
480 : :
481 : : struct crng_state {
482 : : __u32 state[16];
483 : : unsigned long init_time;
484 : : spinlock_t lock;
485 : : };
486 : :
487 : : static struct crng_state primary_crng = {
488 : : .lock = __SPIN_LOCK_UNLOCKED(primary_crng.lock),
489 : : };
490 : :
491 : : /*
492 : : * crng_init = 0 --> Uninitialized
493 : : * 1 --> Initialized
494 : : * 2 --> Initialized from input_pool
495 : : *
496 : : * crng_init is protected by primary_crng->lock, and only increases
497 : : * its value (from 0->1->2).
498 : : */
499 : : static int crng_init = 0;
500 : : #define crng_ready() (likely(crng_init > 1))
501 : : static int crng_init_cnt = 0;
502 : : static unsigned long crng_global_init_time = 0;
503 : : #define CRNG_INIT_CNT_THRESH (2*CHACHA_KEY_SIZE)
504 : : static void _extract_crng(struct crng_state *crng, __u8 out[CHACHA_BLOCK_SIZE]);
505 : : static void _crng_backtrack_protect(struct crng_state *crng,
506 : : __u8 tmp[CHACHA_BLOCK_SIZE], int used);
507 : : static void process_random_ready_list(void);
508 : : static void _get_random_bytes(void *buf, int nbytes);
509 : :
510 : : static struct ratelimit_state unseeded_warning =
511 : : RATELIMIT_STATE_INIT("warn_unseeded_randomness", HZ, 3);
512 : : static struct ratelimit_state urandom_warning =
513 : : RATELIMIT_STATE_INIT("warn_urandom_randomness", HZ, 3);
514 : :
515 : : static int ratelimit_disable __read_mostly;
516 : :
517 : : module_param_named(ratelimit_disable, ratelimit_disable, int, 0644);
518 : : MODULE_PARM_DESC(ratelimit_disable, "Disable random ratelimit suppression");
519 : :
520 : : /**********************************************************************
521 : : *
522 : : * OS independent entropy store. Here are the functions which handle
523 : : * storing entropy in an entropy pool.
524 : : *
525 : : **********************************************************************/
526 : :
527 : : struct entropy_store;
528 : : struct entropy_store {
529 : : /* read-only data: */
530 : : const struct poolinfo *poolinfo;
531 : : __u32 *pool;
532 : : const char *name;
533 : : struct entropy_store *pull;
534 : : struct work_struct push_work;
535 : :
536 : : /* read-write data: */
537 : : unsigned long last_pulled;
538 : : spinlock_t lock;
539 : : unsigned short add_ptr;
540 : : unsigned short input_rotate;
541 : : int entropy_count;
542 : : unsigned int initialized:1;
543 : : unsigned int last_data_init:1;
544 : : __u8 last_data[EXTRACT_SIZE];
545 : : };
546 : :
547 : : static ssize_t extract_entropy(struct entropy_store *r, void *buf,
548 : : size_t nbytes, int min, int rsvd);
549 : : static ssize_t _extract_entropy(struct entropy_store *r, void *buf,
550 : : size_t nbytes, int fips);
551 : :
552 : : static void crng_reseed(struct crng_state *crng, struct entropy_store *r);
553 : : static void push_to_pool(struct work_struct *work);
554 : : static __u32 input_pool_data[INPUT_POOL_WORDS] __latent_entropy;
555 : : static __u32 blocking_pool_data[OUTPUT_POOL_WORDS] __latent_entropy;
556 : :
557 : : static struct entropy_store input_pool = {
558 : : .poolinfo = &poolinfo_table[0],
559 : : .name = "input",
560 : : .lock = __SPIN_LOCK_UNLOCKED(input_pool.lock),
561 : : .pool = input_pool_data
562 : : };
563 : :
564 : : static struct entropy_store blocking_pool = {
565 : : .poolinfo = &poolinfo_table[1],
566 : : .name = "blocking",
567 : : .pull = &input_pool,
568 : : .lock = __SPIN_LOCK_UNLOCKED(blocking_pool.lock),
569 : : .pool = blocking_pool_data,
570 : : .push_work = __WORK_INITIALIZER(blocking_pool.push_work,
571 : : push_to_pool),
572 : : };
573 : :
574 : : static __u32 const twist_table[8] = {
575 : : 0x00000000, 0x3b6e20c8, 0x76dc4190, 0x4db26158,
576 : : 0xedb88320, 0xd6d6a3e8, 0x9b64c2b0, 0xa00ae278 };
577 : :
578 : : /*
579 : : * This function adds bytes into the entropy "pool". It does not
580 : : * update the entropy estimate. The caller should call
581 : : * credit_entropy_bits if this is appropriate.
582 : : *
583 : : * The pool is stirred with a primitive polynomial of the appropriate
584 : : * degree, and then twisted. We twist by three bits at a time because
585 : : * it's cheap to do so and helps slightly in the expected case where
586 : : * the entropy is concentrated in the low-order bits.
587 : : */
588 : 4099012 : static void _mix_pool_bytes(struct entropy_store *r, const void *in,
589 : : int nbytes)
590 : : {
591 : : unsigned long i, tap1, tap2, tap3, tap4, tap5;
592 : : int input_rotate;
593 : 4099012 : int wordmask = r->poolinfo->poolwords - 1;
594 : : const char *bytes = in;
595 : : __u32 w;
596 : :
597 : 4099012 : tap1 = r->poolinfo->tap1;
598 : 4099012 : tap2 = r->poolinfo->tap2;
599 : 4099012 : tap3 = r->poolinfo->tap3;
600 : 4099012 : tap4 = r->poolinfo->tap4;
601 : 4099012 : tap5 = r->poolinfo->tap5;
602 : :
603 : 4099012 : input_rotate = r->input_rotate;
604 : 4099012 : i = r->add_ptr;
605 : :
606 : : /* mix one byte at a time to simplify size handling and churn faster */
607 [ + + ]: 53902452 : while (nbytes--) {
608 : 45704428 : w = rol32(*bytes++, input_rotate);
609 : 45704428 : i = (i - 1) & wordmask;
610 : :
611 : : /* XOR in the various taps */
612 : 45704428 : w ^= r->pool[i];
613 : 45704428 : w ^= r->pool[(i + tap1) & wordmask];
614 : 45704428 : w ^= r->pool[(i + tap2) & wordmask];
615 : 45704428 : w ^= r->pool[(i + tap3) & wordmask];
616 : 45704428 : w ^= r->pool[(i + tap4) & wordmask];
617 : 45704428 : w ^= r->pool[(i + tap5) & wordmask];
618 : :
619 : : /* Mix the result back in with a twist */
620 : 45704428 : r->pool[i] = (w >> 3) ^ twist_table[w & 7];
621 : :
622 : : /*
623 : : * Normally, we add 7 bits of rotation to the pool.
624 : : * At the beginning of the pool, add an extra 7 bits
625 : : * rotation, so that successive passes spread the
626 : : * input bits across the pool evenly.
627 : : */
628 [ + + ]: 45704428 : input_rotate = (input_rotate + (i ? 7 : 14)) & 31;
629 : : }
630 : :
631 : 4099012 : r->input_rotate = input_rotate;
632 : 4099012 : r->add_ptr = i;
633 : 4099012 : }
634 : :
635 : 2042844 : static void __mix_pool_bytes(struct entropy_store *r, const void *in,
636 : : int nbytes)
637 : : {
638 : 2042844 : trace_mix_pool_bytes_nolock(r->name, nbytes, _RET_IP_);
639 : 2042844 : _mix_pool_bytes(r, in, nbytes);
640 : 2042844 : }
641 : :
642 : 79106 : static void mix_pool_bytes(struct entropy_store *r, const void *in,
643 : : int nbytes)
644 : : {
645 : : unsigned long flags;
646 : :
647 : 79106 : trace_mix_pool_bytes(r->name, nbytes, _RET_IP_);
648 : 79106 : spin_lock_irqsave(&r->lock, flags);
649 : 79106 : _mix_pool_bytes(r, in, nbytes);
650 : : spin_unlock_irqrestore(&r->lock, flags);
651 : 79106 : }
652 : :
653 : : struct fast_pool {
654 : : __u32 pool[4];
655 : : unsigned long last;
656 : : unsigned short reg_idx;
657 : : unsigned char count;
658 : : };
659 : :
660 : : /*
661 : : * This is a fast mixing routine used by the interrupt randomness
662 : : * collector. It's hardcoded for an 128 bit pool and assumes that any
663 : : * locks that might be needed are taken by the caller.
664 : : */
665 : 130569936 : static void fast_mix(struct fast_pool *f)
666 : : {
667 : 130569936 : __u32 a = f->pool[0], b = f->pool[1];
668 : 130569936 : __u32 c = f->pool[2], d = f->pool[3];
669 : :
670 : 130569936 : a += b; c += d;
671 : : b = rol32(b, 6); d = rol32(d, 27);
672 : 130569936 : d ^= a; b ^= c;
673 : :
674 : 130569936 : a += b; c += d;
675 : : b = rol32(b, 16); d = rol32(d, 14);
676 : 130569936 : d ^= a; b ^= c;
677 : :
678 : 130569936 : a += b; c += d;
679 : : b = rol32(b, 6); d = rol32(d, 27);
680 : 130569936 : d ^= a; b ^= c;
681 : :
682 : 130569936 : a += b; c += d;
683 : : b = rol32(b, 16); d = rol32(d, 14);
684 : 130569936 : d ^= a; b ^= c;
685 : :
686 : 130569936 : f->pool[0] = a; f->pool[1] = b;
687 : 130569936 : f->pool[2] = c; f->pool[3] = d;
688 : 130569936 : f->count++;
689 : 130569936 : }
690 : :
691 : 404 : static void process_random_ready_list(void)
692 : : {
693 : : unsigned long flags;
694 : : struct random_ready_callback *rdy, *tmp;
695 : :
696 : 404 : spin_lock_irqsave(&random_ready_list_lock, flags);
697 [ + + ]: 808 : list_for_each_entry_safe(rdy, tmp, &random_ready_list, list) {
698 : 404 : struct module *owner = rdy->owner;
699 : :
700 : : list_del_init(&rdy->list);
701 : 404 : rdy->func(rdy);
702 : 404 : module_put(owner);
703 : : }
704 : : spin_unlock_irqrestore(&random_ready_list_lock, flags);
705 : 404 : }
706 : :
707 : : /*
708 : : * Credit (or debit) the entropy store with n bits of entropy.
709 : : * Use credit_entropy_bits_safe() if the value comes from userspace
710 : : * or otherwise should be checked for extreme values.
711 : : */
712 : 2047564 : static void credit_entropy_bits(struct entropy_store *r, int nbits)
713 : : {
714 : : int entropy_count, orig, has_initialized = 0;
715 : 2047564 : const int pool_size = r->poolinfo->poolfracbits;
716 : 2047564 : int nfrac = nbits << ENTROPY_SHIFT;
717 : :
718 [ + + ]: 2047564 : if (!nbits)
719 : : return;
720 : :
721 : : retry:
722 : 2044468 : entropy_count = orig = READ_ONCE(r->entropy_count);
723 [ - + ]: 2044468 : if (nfrac < 0) {
724 : : /* Debit */
725 : 0 : entropy_count += nfrac;
726 : : } else {
727 : : /*
728 : : * Credit: we have to account for the possibility of
729 : : * overwriting already present entropy. Even in the
730 : : * ideal case of pure Shannon entropy, new contributions
731 : : * approach the full value asymptotically:
732 : : *
733 : : * entropy <- entropy + (pool_size - entropy) *
734 : : * (1 - exp(-add_entropy/pool_size))
735 : : *
736 : : * For add_entropy <= pool_size/2 then
737 : : * (1 - exp(-add_entropy/pool_size)) >=
738 : : * (add_entropy/pool_size)*0.7869...
739 : : * so we can approximate the exponential with
740 : : * 3/4*add_entropy/pool_size and still be on the
741 : : * safe side by adding at most pool_size/2 at a time.
742 : : *
743 : : * The use of pool_size-2 in the while statement is to
744 : : * prevent rounding artifacts from making the loop
745 : : * arbitrarily long; this limits the loop to log2(pool_size)*2
746 : : * turns no matter how large nbits is.
747 : : */
748 : : int pnfrac = nfrac;
749 : 2044468 : const int s = r->poolinfo->poolbitshift + ENTROPY_SHIFT + 2;
750 : : /* The +2 corresponds to the /4 in the denominator */
751 : :
752 : : do {
753 : 2044468 : unsigned int anfrac = min(pnfrac, pool_size/2);
754 : 2044468 : unsigned int add =
755 : 2044468 : ((pool_size - entropy_count)*anfrac*3) >> s;
756 : :
757 : 2044468 : entropy_count += add;
758 : 2044468 : pnfrac -= anfrac;
759 [ + - - + ]: 2044468 : } while (unlikely(entropy_count < pool_size-2 && pnfrac));
760 : : }
761 : :
762 [ - + ]: 2044468 : if (unlikely(entropy_count < 0)) {
763 : 0 : pr_warn("random: negative entropy/overflow: pool %s count %d\n",
764 : : r->name, entropy_count);
765 : 0 : WARN_ON(1);
766 : : entropy_count = 0;
767 [ - + ]: 2044468 : } else if (entropy_count > pool_size)
768 : : entropy_count = pool_size;
769 [ + + + + : 2045680 : if ((r == &blocking_pool) && !r->initialized &&
+ + ]
770 : 1212 : (entropy_count >> ENTROPY_SHIFT) > 128)
771 : : has_initialized = 1;
772 [ - + ]: 2044468 : if (cmpxchg(&r->entropy_count, orig, entropy_count) != orig)
773 : : goto retry;
774 : :
775 [ + + ]: 2044466 : if (has_initialized) {
776 : 404 : r->initialized = 1;
777 : 404 : wake_up_interruptible(&random_read_wait);
778 : 404 : kill_fasync(&fasync, SIGIO, POLL_IN);
779 : : }
780 : :
781 : 4088932 : trace_credit_entropy_bits(r->name, nbits,
782 : 2044466 : entropy_count >> ENTROPY_SHIFT, _RET_IP_);
783 : :
784 [ + + ]: 2044466 : if (r == &input_pool) {
785 : : int entropy_bits = entropy_count >> ENTROPY_SHIFT;
786 : : struct entropy_store *other = &blocking_pool;
787 : :
788 [ + + ]: 2042800 : if (crng_init < 2) {
789 [ + + ]: 82820 : if (entropy_bits < 128)
790 : : return;
791 : 404 : crng_reseed(&primary_crng, r);
792 : 404 : entropy_bits = r->entropy_count >> ENTROPY_SHIFT;
793 : : }
794 : :
795 : : /* initialize the blocking pool if necessary */
796 [ + + + + ]: 3779046 : if (entropy_bits >= random_read_wakeup_bits &&
797 : 1818662 : !other->initialized) {
798 : : schedule_work(&other->push_work);
799 : : return;
800 : : }
801 : :
802 : : /* should we wake readers? */
803 [ + + + + ]: 3722242 : if (entropy_bits >= random_read_wakeup_bits &&
804 : : wq_has_sleeper(&random_read_wait)) {
805 : 1589248 : wake_up_interruptible(&random_read_wait);
806 : 1589248 : kill_fasync(&fasync, SIGIO, POLL_IN);
807 : : }
808 : : /* If the input pool is getting full, and the blocking
809 : : * pool has room, send some entropy to the blocking
810 : : * pool.
811 : : */
812 [ + + + + ]: 3863558 : if (!work_pending(&other->push_work) &&
813 [ + - ]: 1932032 : (ENTROPY_BITS(r) > 6 * r->poolinfo->poolbytes) &&
814 : 456 : (ENTROPY_BITS(other) <= 6 * other->poolinfo->poolbytes))
815 : : schedule_work(&other->push_work);
816 : : }
817 : : }
818 : :
819 : : static int credit_entropy_bits_safe(struct entropy_store *r, int nbits)
820 : : {
821 : 3400 : const int nbits_max = r->poolinfo->poolwords * 32;
822 : :
823 [ # # + - ]: 3400 : if (nbits < 0)
824 : : return -EINVAL;
825 : :
826 : : /* Cap the value to avoid overflows */
827 : 3400 : nbits = min(nbits, nbits_max);
828 : :
829 : 3400 : credit_entropy_bits(r, nbits);
830 : : return 0;
831 : : }
832 : :
833 : : /*********************************************************************
834 : : *
835 : : * CRNG using CHACHA20
836 : : *
837 : : *********************************************************************/
838 : :
839 : : #define CRNG_RESEED_INTERVAL (300*HZ)
840 : :
841 : : static DECLARE_WAIT_QUEUE_HEAD(crng_init_wait);
842 : :
843 : : #ifdef CONFIG_NUMA
844 : : /*
845 : : * Hack to deal with crazy userspace progams when they are all trying
846 : : * to access /dev/urandom in parallel. The programs are almost
847 : : * certainly doing something terribly wrong, but we'll work around
848 : : * their brain damage.
849 : : */
850 : : static struct crng_state **crng_node_pool __read_mostly;
851 : : #endif
852 : :
853 : : static void invalidate_batched_entropy(void);
854 : : static void numa_crng_init(void);
855 : :
856 : : static bool trust_cpu __ro_after_init = IS_ENABLED(CONFIG_RANDOM_TRUST_CPU);
857 : 0 : static int __init parse_trust_cpu(char *arg)
858 : : {
859 : 0 : return kstrtobool(arg, &trust_cpu);
860 : : }
861 : : early_param("random.trust_cpu", parse_trust_cpu);
862 : :
863 : 404 : static void crng_initialize(struct crng_state *crng)
864 : : {
865 : : int i;
866 : : int arch_init = 1;
867 : : unsigned long rv;
868 : :
869 : 404 : memcpy(&crng->state[0], "expand 32-byte k", 16);
870 [ + - ]: 404 : if (crng == &primary_crng)
871 : 404 : _extract_entropy(&input_pool, &crng->state[4],
872 : : sizeof(__u32) * 12, 0);
873 : : else
874 : 0 : _get_random_bytes(&crng->state[4], sizeof(__u32) * 12);
875 [ + + ]: 4848 : for (i = 4; i < 16; i++) {
876 : : if (!arch_get_random_seed_long(&rv) &&
877 : : !arch_get_random_long(&rv)) {
878 [ - + ]: 4848 : rv = random_get_entropy();
879 : : arch_init = 0;
880 : : }
881 : 4848 : crng->state[i] ^= rv;
882 : : }
883 [ - + # # : 404 : if (trust_cpu && arch_init && crng == &primary_crng) {
# # ]
884 : 0 : invalidate_batched_entropy();
885 : : numa_crng_init();
886 : 0 : crng_init = 2;
887 : 0 : pr_notice("random: crng done (trusting CPU's manufacturer)\n");
888 : : }
889 : 404 : crng->init_time = jiffies - CRNG_RESEED_INTERVAL - 1;
890 : 404 : }
891 : :
892 : : #ifdef CONFIG_NUMA
893 : : static void do_numa_crng_init(struct work_struct *work)
894 : : {
895 : : int i;
896 : : struct crng_state *crng;
897 : : struct crng_state **pool;
898 : :
899 : : pool = kcalloc(nr_node_ids, sizeof(*pool), GFP_KERNEL|__GFP_NOFAIL);
900 : : for_each_online_node(i) {
901 : : crng = kmalloc_node(sizeof(struct crng_state),
902 : : GFP_KERNEL | __GFP_NOFAIL, i);
903 : : spin_lock_init(&crng->lock);
904 : : crng_initialize(crng);
905 : : pool[i] = crng;
906 : : }
907 : : mb();
908 : : if (cmpxchg(&crng_node_pool, NULL, pool)) {
909 : : for_each_node(i)
910 : : kfree(pool[i]);
911 : : kfree(pool);
912 : : }
913 : : }
914 : :
915 : : static DECLARE_WORK(numa_crng_init_work, do_numa_crng_init);
916 : :
917 : : static void numa_crng_init(void)
918 : : {
919 : : schedule_work(&numa_crng_init_work);
920 : : }
921 : : #else
922 : : static void numa_crng_init(void) {}
923 : : #endif
924 : :
925 : : /*
926 : : * crng_fast_load() can be called by code in the interrupt service
927 : : * path. So we can't afford to dilly-dally.
928 : : */
929 : 1616 : static int crng_fast_load(const char *cp, size_t len)
930 : : {
931 : : unsigned long flags;
932 : : char *p;
933 : :
934 [ - + # # : 3232 : if (!spin_trylock_irqsave(&primary_crng.lock, flags))
+ - ]
935 : : return 0;
936 [ + - ]: 1616 : if (crng_init != 0) {
937 : : spin_unlock_irqrestore(&primary_crng.lock, flags);
938 : 0 : return 0;
939 : : }
940 : : p = (unsigned char *) &primary_crng.state[4];
941 [ + + + - ]: 27472 : while (len > 0 && crng_init_cnt < CRNG_INIT_CNT_THRESH) {
942 : 25856 : p[crng_init_cnt % CHACHA_KEY_SIZE] ^= *cp;
943 : 25856 : cp++; crng_init_cnt++; len--;
944 : : }
945 : : spin_unlock_irqrestore(&primary_crng.lock, flags);
946 [ + + ]: 1616 : if (crng_init_cnt >= CRNG_INIT_CNT_THRESH) {
947 : 404 : invalidate_batched_entropy();
948 : 404 : crng_init = 1;
949 : 404 : wake_up_interruptible(&crng_init_wait);
950 : 404 : pr_notice("random: fast init done\n");
951 : : }
952 : : return 1;
953 : : }
954 : :
955 : : /*
956 : : * crng_slow_load() is called by add_device_randomness, which has two
957 : : * attributes. (1) We can't trust the buffer passed to it is
958 : : * guaranteed to be unpredictable (so it might not have any entropy at
959 : : * all), and (2) it doesn't have the performance constraints of
960 : : * crng_fast_load().
961 : : *
962 : : * So we do something more comprehensive which is guaranteed to touch
963 : : * all of the primary_crng's state, and which uses a LFSR with a
964 : : * period of 255 as part of the mixing algorithm. Finally, we do
965 : : * *not* advance crng_init_cnt since buffer we may get may be something
966 : : * like a fixed DMI table (for example), which might very well be
967 : : * unique to the machine, but is otherwise unvarying.
968 : : */
969 : 17498 : static int crng_slow_load(const char *cp, size_t len)
970 : : {
971 : : unsigned long flags;
972 : : static unsigned char lfsr = 1;
973 : : unsigned char tmp;
974 : : unsigned i, max = CHACHA_KEY_SIZE;
975 : : const char * src_buf = cp;
976 : : char * dest_buf = (char *) &primary_crng.state[4];
977 : :
978 [ + + + - : 35000 : if (!spin_trylock_irqsave(&primary_crng.lock, flags))
+ + ]
979 : : return 0;
980 [ + + ]: 17496 : if (crng_init != 0) {
981 : : spin_unlock_irqrestore(&primary_crng.lock, flags);
982 : 7004 : return 0;
983 : : }
984 [ + + ]: 10492 : if (len > max)
985 : : max = len;
986 : :
987 [ + + ]: 383000 : for (i = 0; i < max ; i++) {
988 : 372508 : tmp = lfsr;
989 : 372508 : lfsr >>= 1;
990 [ + + ]: 372508 : if (tmp & 1)
991 : 185006 : lfsr ^= 0xE1;
992 : 372508 : tmp = dest_buf[i % CHACHA_KEY_SIZE];
993 : 372508 : dest_buf[i % CHACHA_KEY_SIZE] ^= src_buf[i % len] ^ lfsr;
994 : 372508 : lfsr += (tmp << 3) | (tmp >> 5);
995 : : }
996 : : spin_unlock_irqrestore(&primary_crng.lock, flags);
997 : 10492 : return 1;
998 : : }
999 : :
1000 : 404 : static void crng_reseed(struct crng_state *crng, struct entropy_store *r)
1001 : : {
1002 : : unsigned long flags;
1003 : : int i, num;
1004 : : union {
1005 : : __u8 block[CHACHA_BLOCK_SIZE];
1006 : : __u32 key[8];
1007 : : } buf;
1008 : :
1009 [ + - ]: 404 : if (r) {
1010 : 404 : num = extract_entropy(r, &buf, 32, 16, 0);
1011 [ + - ]: 404 : if (num == 0)
1012 : 0 : return;
1013 : : } else {
1014 : 0 : _extract_crng(&primary_crng, buf.block);
1015 : 0 : _crng_backtrack_protect(&primary_crng, buf.block,
1016 : : CHACHA_KEY_SIZE);
1017 : : }
1018 : 404 : spin_lock_irqsave(&crng->lock, flags);
1019 [ + + ]: 3636 : for (i = 0; i < 8; i++) {
1020 : : unsigned long rv;
1021 : : if (!arch_get_random_seed_long(&rv) &&
1022 : : !arch_get_random_long(&rv))
1023 [ + - ]: 3232 : rv = random_get_entropy();
1024 : 3232 : crng->state[i+4] ^= buf.key[i] ^ rv;
1025 : : }
1026 : : memzero_explicit(&buf, sizeof(buf));
1027 : 404 : crng->init_time = jiffies;
1028 : : spin_unlock_irqrestore(&crng->lock, flags);
1029 [ + - + - ]: 404 : if (crng == &primary_crng && crng_init < 2) {
1030 : 404 : invalidate_batched_entropy();
1031 : : numa_crng_init();
1032 : 404 : crng_init = 2;
1033 : 404 : process_random_ready_list();
1034 : 404 : wake_up_interruptible(&crng_init_wait);
1035 : 404 : pr_notice("random: crng init done\n");
1036 [ - + ]: 404 : if (unseeded_warning.missed) {
1037 : 0 : pr_notice("random: %d get_random_xx warning(s) missed "
1038 : : "due to ratelimiting\n",
1039 : : unseeded_warning.missed);
1040 : 0 : unseeded_warning.missed = 0;
1041 : : }
1042 [ - + ]: 404 : if (urandom_warning.missed) {
1043 : 0 : pr_notice("random: %d urandom warning(s) missed "
1044 : : "due to ratelimiting\n",
1045 : : urandom_warning.missed);
1046 : 0 : urandom_warning.missed = 0;
1047 : : }
1048 : : }
1049 : : }
1050 : :
1051 : 2451672 : static void _extract_crng(struct crng_state *crng,
1052 : : __u8 out[CHACHA_BLOCK_SIZE])
1053 : : {
1054 : : unsigned long v, flags;
1055 : :
1056 [ + + ]: 2451672 : if (crng_ready() &&
1057 [ + + ]: 2432652 : (time_after(crng_global_init_time, crng->init_time) ||
1058 [ + + ]: 2432594 : time_after(jiffies, crng->init_time + CRNG_RESEED_INTERVAL)))
1059 [ # # ]: 0 : crng_reseed(crng, crng == &primary_crng ? &input_pool : NULL);
1060 : 2451672 : spin_lock_irqsave(&crng->lock, flags);
1061 : : if (arch_get_random_long(&v))
1062 : : crng->state[14] ^= v;
1063 : 2451724 : chacha20_block(&crng->state[0], out);
1064 [ - + ]: 2451724 : if (crng->state[12] == 0)
1065 : 0 : crng->state[13]++;
1066 : : spin_unlock_irqrestore(&crng->lock, flags);
1067 : 2451724 : }
1068 : :
1069 : : static void extract_crng(__u8 out[CHACHA_BLOCK_SIZE])
1070 : : {
1071 : : struct crng_state *crng = NULL;
1072 : :
1073 : : #ifdef CONFIG_NUMA
1074 : : if (crng_node_pool)
1075 : : crng = crng_node_pool[numa_node_id()];
1076 : : if (crng == NULL)
1077 : : #endif
1078 : : crng = &primary_crng;
1079 : 2451698 : _extract_crng(crng, out);
1080 : : }
1081 : :
1082 : : /*
1083 : : * Use the leftover bytes from the CRNG block output (if there is
1084 : : * enough) to mutate the CRNG key to provide backtracking protection.
1085 : : */
1086 : 2140040 : static void _crng_backtrack_protect(struct crng_state *crng,
1087 : : __u8 tmp[CHACHA_BLOCK_SIZE], int used)
1088 : : {
1089 : : unsigned long flags;
1090 : : __u32 *s, *d;
1091 : : int i;
1092 : :
1093 : 2140040 : used = round_up(used, sizeof(__u32));
1094 [ + + ]: 2140040 : if (used + CHACHA_KEY_SIZE > CHACHA_BLOCK_SIZE) {
1095 : : extract_crng(tmp);
1096 : : used = 0;
1097 : : }
1098 : 2140040 : spin_lock_irqsave(&crng->lock, flags);
1099 : 2140078 : s = (__u32 *) &tmp[used];
1100 : 2140078 : d = &crng->state[4];
1101 [ + + ]: 19260702 : for (i=0; i < 8; i++)
1102 : 17120624 : *d++ ^= *s++;
1103 : : spin_unlock_irqrestore(&crng->lock, flags);
1104 : 2140068 : }
1105 : :
1106 : : static void crng_backtrack_protect(__u8 tmp[CHACHA_BLOCK_SIZE], int used)
1107 : : {
1108 : : struct crng_state *crng = NULL;
1109 : :
1110 : : #ifdef CONFIG_NUMA
1111 : : if (crng_node_pool)
1112 : : crng = crng_node_pool[numa_node_id()];
1113 : : if (crng == NULL)
1114 : : #endif
1115 : : crng = &primary_crng;
1116 : 2140042 : _crng_backtrack_protect(crng, tmp, used);
1117 : : }
1118 : :
1119 : 1094522 : static ssize_t extract_crng_user(void __user *buf, size_t nbytes)
1120 : : {
1121 : : ssize_t ret = 0, i = CHACHA_BLOCK_SIZE;
1122 : : __u8 tmp[CHACHA_BLOCK_SIZE] __aligned(4);
1123 : : int large_request = (nbytes > 256);
1124 : :
1125 [ + + ]: 3289616 : while (nbytes) {
1126 [ + + + + ]: 1107074 : if (large_request && need_resched()) {
1127 [ - + ]: 4 : if (signal_pending(current)) {
1128 [ # # ]: 0 : if (ret == 0)
1129 : : ret = -ERESTARTSYS;
1130 : : break;
1131 : : }
1132 : 2 : schedule();
1133 : : }
1134 : :
1135 : : extract_crng(tmp);
1136 : 1100596 : i = min_t(int, nbytes, CHACHA_BLOCK_SIZE);
1137 [ + - ]: 2201168 : if (copy_to_user(buf, tmp, i)) {
1138 : : ret = -EFAULT;
1139 : : break;
1140 : : }
1141 : :
1142 : 1100572 : nbytes -= i;
1143 : 1100572 : buf += i;
1144 : 1100572 : ret += i;
1145 : : }
1146 : : crng_backtrack_protect(tmp, i);
1147 : :
1148 : : /* Wipe data just written to memory */
1149 : : memzero_explicit(tmp, sizeof(tmp));
1150 : :
1151 : 1094434 : return ret;
1152 : : }
1153 : :
1154 : :
1155 : : /*********************************************************************
1156 : : *
1157 : : * Entropy input management
1158 : : *
1159 : : *********************************************************************/
1160 : :
1161 : : /* There is one of these per entropy source */
1162 : : struct timer_rand_state {
1163 : : cycles_t last_time;
1164 : : long last_delta, last_delta2;
1165 : : };
1166 : :
1167 : : #define INIT_TIMER_RAND_STATE { INITIAL_JIFFIES, };
1168 : :
1169 : : /*
1170 : : * Add device- or boot-specific data to the input pool to help
1171 : : * initialize it.
1172 : : *
1173 : : * None of this adds any entropy; it is meant to avoid the problem of
1174 : : * the entropy pool having similar initial state across largely
1175 : : * identical devices.
1176 : : */
1177 : 988530 : void add_device_randomness(const void *buf, unsigned int size)
1178 : : {
1179 [ + + ]: 988530 : unsigned long time = random_get_entropy() ^ jiffies;
1180 : : unsigned long flags;
1181 : :
1182 [ + + + - ]: 988530 : if (!crng_ready() && size)
1183 : 17498 : crng_slow_load(buf, size);
1184 : :
1185 : 988530 : trace_add_device_randomness(size, _RET_IP_);
1186 : 988530 : spin_lock_irqsave(&input_pool.lock, flags);
1187 : 988530 : _mix_pool_bytes(&input_pool, buf, size);
1188 : 988530 : _mix_pool_bytes(&input_pool, &time, sizeof(time));
1189 : : spin_unlock_irqrestore(&input_pool.lock, flags);
1190 : 988530 : }
1191 : : EXPORT_SYMBOL(add_device_randomness);
1192 : :
1193 : : static struct timer_rand_state input_timer_state = INIT_TIMER_RAND_STATE;
1194 : :
1195 : : /*
1196 : : * This function adds entropy to the entropy "pool" by using timing
1197 : : * delays. It uses the timer_rand_state structure to make an estimate
1198 : : * of how many bits of entropy this call has added to the pool.
1199 : : *
1200 : : * The number "num" is also added to the pool - it should somehow describe
1201 : : * the type of event which just happened. This is currently 0-255 for
1202 : : * keyboard scan codes, and 256 upwards for interrupts.
1203 : : *
1204 : : */
1205 : 4128 : static void add_timer_randomness(struct timer_rand_state *state, unsigned num)
1206 : : {
1207 : : struct entropy_store *r;
1208 : : struct {
1209 : : long jiffies;
1210 : : unsigned cycles;
1211 : : unsigned num;
1212 : : } sample;
1213 : : long delta, delta2, delta3;
1214 : :
1215 : 4128 : sample.jiffies = jiffies;
1216 [ + - ]: 4128 : sample.cycles = random_get_entropy();
1217 : 4128 : sample.num = num;
1218 : : r = &input_pool;
1219 : 4128 : mix_pool_bytes(r, &sample, sizeof(sample));
1220 : :
1221 : : /*
1222 : : * Calculate number of bits of randomness we probably added.
1223 : : * We take into account the first, second and third-order deltas
1224 : : * in order to make our estimate.
1225 : : */
1226 : 4128 : delta = sample.jiffies - state->last_time;
1227 : 4128 : state->last_time = sample.jiffies;
1228 : :
1229 : 4128 : delta2 = delta - state->last_delta;
1230 : 4128 : state->last_delta = delta;
1231 : :
1232 : 4128 : delta3 = delta2 - state->last_delta2;
1233 : 4128 : state->last_delta2 = delta2;
1234 : :
1235 [ - + ]: 4128 : if (delta < 0)
1236 : 0 : delta = -delta;
1237 [ + + ]: 4128 : if (delta2 < 0)
1238 : 1746 : delta2 = -delta2;
1239 [ + + ]: 4128 : if (delta3 < 0)
1240 : 1808 : delta3 = -delta3;
1241 [ + + ]: 4128 : if (delta > delta2)
1242 : : delta = delta2;
1243 [ + + ]: 4128 : if (delta > delta3)
1244 : : delta = delta3;
1245 : :
1246 : : /*
1247 : : * delta is now minimum absolute delta.
1248 : : * Round down by 1 bit on general principles,
1249 : : * and limit entropy entimate to 12 bits.
1250 : : */
1251 : 8256 : credit_entropy_bits(r, min_t(int, fls(delta>>1), 11));
1252 : 4128 : }
1253 : :
1254 : 4582 : void add_input_randomness(unsigned int type, unsigned int code,
1255 : : unsigned int value)
1256 : : {
1257 : : static unsigned char last_value;
1258 : :
1259 : : /* ignore autorepeat and the like */
1260 [ + + ]: 4582 : if (value == last_value)
1261 : 4582 : return;
1262 : :
1263 : 4128 : last_value = value;
1264 : 4128 : add_timer_randomness(&input_timer_state,
1265 : 4128 : (type << 4) ^ code ^ (code >> 4) ^ value);
1266 : 4128 : trace_add_input_randomness(ENTROPY_BITS(&input_pool));
1267 : : }
1268 : : EXPORT_SYMBOL_GPL(add_input_randomness);
1269 : :
1270 : : static DEFINE_PER_CPU(struct fast_pool, irq_randomness);
1271 : :
1272 : : #ifdef ADD_INTERRUPT_BENCH
1273 : : static unsigned long avg_cycles, avg_deviation;
1274 : :
1275 : : #define AVG_SHIFT 8 /* Exponential average factor k=1/256 */
1276 : : #define FIXED_1_2 (1 << (AVG_SHIFT-1))
1277 : :
1278 : : static void add_interrupt_bench(cycles_t start)
1279 : : {
1280 : : long delta = random_get_entropy() - start;
1281 : :
1282 : : /* Use a weighted moving average */
1283 : : delta = delta - ((avg_cycles + FIXED_1_2) >> AVG_SHIFT);
1284 : : avg_cycles += delta;
1285 : : /* And average deviation */
1286 : : delta = abs(delta) - ((avg_deviation + FIXED_1_2) >> AVG_SHIFT);
1287 : : avg_deviation += delta;
1288 : : }
1289 : : #else
1290 : : #define add_interrupt_bench(x)
1291 : : #endif
1292 : :
1293 : : static __u32 get_reg(struct fast_pool *f, struct pt_regs *regs)
1294 : : {
1295 : : __u32 *ptr = (__u32 *) regs;
1296 : : unsigned int idx;
1297 : :
1298 [ # # ]: 0 : if (regs == NULL)
1299 : : return 0;
1300 : 0 : idx = READ_ONCE(f->reg_idx);
1301 [ # # ]: 0 : if (idx >= sizeof(struct pt_regs) / sizeof(__u32))
1302 : : idx = 0;
1303 : 0 : ptr += idx++;
1304 : 0 : WRITE_ONCE(f->reg_idx, idx);
1305 : 0 : return *ptr;
1306 : : }
1307 : :
1308 : 130569640 : void add_interrupt_randomness(int irq, int irq_flags)
1309 : : {
1310 : : struct entropy_store *r;
1311 : 261139280 : struct fast_pool *fast_pool = this_cpu_ptr(&irq_randomness);
1312 : : struct pt_regs *regs = get_irq_regs();
1313 : 130569640 : unsigned long now = jiffies;
1314 [ + - ]: 130569640 : cycles_t cycles = random_get_entropy();
1315 : : __u32 c_high, j_high;
1316 : : __u64 ip;
1317 : : unsigned long seed;
1318 : : int credit = 0;
1319 : :
1320 [ - + ]: 130569640 : if (cycles == 0)
1321 : : cycles = get_reg(fast_pool, regs);
1322 : : c_high = (sizeof(cycles) > 4) ? cycles >> 32 : 0;
1323 : : j_high = (sizeof(now) > 4) ? now >> 32 : 0;
1324 : 130569640 : fast_pool->pool[0] ^= cycles ^ j_high ^ irq;
1325 : 130569640 : fast_pool->pool[1] ^= now ^ c_high;
1326 [ + - ]: 130569640 : ip = regs ? instruction_pointer(regs) : _RET_IP_;
1327 : 130569640 : fast_pool->pool[2] ^= ip;
1328 : 130569640 : fast_pool->pool[3] ^= (sizeof(ip) > 4) ? ip >> 32 :
1329 : : get_reg(fast_pool, regs);
1330 : :
1331 : 130569640 : fast_mix(fast_pool);
1332 : : add_interrupt_bench(cycles);
1333 : 261139280 : this_cpu_add(net_rand_state.s1, fast_pool->pool[cycles & 3]);
1334 : :
1335 [ + + ]: 130569640 : if (unlikely(crng_init == 0)) {
1336 [ + + + - ]: 105040 : if ((fast_pool->count >= 64) &&
1337 : 1616 : crng_fast_load((char *) fast_pool->pool,
1338 : : sizeof(fast_pool->pool))) {
1339 : 1616 : fast_pool->count = 0;
1340 : 1616 : fast_pool->last = now;
1341 : : }
1342 : : return;
1343 : : }
1344 : :
1345 [ + + ]: 130466216 : if ((fast_pool->count < 64) &&
1346 [ + + ]: 128427570 : !time_after(now, fast_pool->last + HZ))
1347 : : return;
1348 : :
1349 : : r = &input_pool;
1350 [ + + ]: 2038664 : if (!spin_trylock(&r->lock))
1351 : : return;
1352 : :
1353 : 2038348 : fast_pool->last = now;
1354 : 2038348 : __mix_pool_bytes(r, &fast_pool->pool, sizeof(fast_pool->pool));
1355 : :
1356 : : /*
1357 : : * If we have architectural seed generator, produce a seed and
1358 : : * add it to the pool. For the sake of paranoia don't let the
1359 : : * architectural seed generator dominate the input from the
1360 : : * interrupt noise.
1361 : : */
1362 : : if (arch_get_random_seed_long(&seed)) {
1363 : : __mix_pool_bytes(r, &seed, sizeof(seed));
1364 : : credit = 1;
1365 : : }
1366 : : spin_unlock(&r->lock);
1367 : :
1368 : 2038348 : fast_pool->count = 0;
1369 : :
1370 : : /* award one bit for the contents of the fast pool */
1371 : 2038348 : credit_entropy_bits(r, credit + 1);
1372 : : }
1373 : : EXPORT_SYMBOL_GPL(add_interrupt_randomness);
1374 : :
1375 : : #ifdef CONFIG_BLOCK
1376 : 0 : void add_disk_randomness(struct gendisk *disk)
1377 : : {
1378 [ # # # # ]: 0 : if (!disk || !disk->random)
1379 : 0 : return;
1380 : : /* first major is 1, so we get >= 0x200 here */
1381 : 0 : add_timer_randomness(disk->random, 0x100 + disk_devt(disk));
1382 : 0 : trace_add_disk_randomness(disk_devt(disk), ENTROPY_BITS(&input_pool));
1383 : : }
1384 : : EXPORT_SYMBOL_GPL(add_disk_randomness);
1385 : : #endif
1386 : :
1387 : : /*********************************************************************
1388 : : *
1389 : : * Entropy extraction routines
1390 : : *
1391 : : *********************************************************************/
1392 : :
1393 : : /*
1394 : : * This utility inline function is responsible for transferring entropy
1395 : : * from the primary pool to the secondary extraction pool. We make
1396 : : * sure we pull enough for a 'catastrophic reseed'.
1397 : : */
1398 : : static void _xfer_secondary_pool(struct entropy_store *r, size_t nbytes);
1399 : 2090 : static void xfer_secondary_pool(struct entropy_store *r, size_t nbytes)
1400 : : {
1401 [ - + # # ]: 2090 : if (!r->pull ||
1402 [ # # ]: 0 : r->entropy_count >= (nbytes << (ENTROPY_SHIFT + 3)) ||
1403 : 0 : r->entropy_count > r->poolinfo->poolfracbits)
1404 : 2090 : return;
1405 : :
1406 : 0 : _xfer_secondary_pool(r, nbytes);
1407 : : }
1408 : :
1409 : 1686 : static void _xfer_secondary_pool(struct entropy_store *r, size_t nbytes)
1410 : : {
1411 : : __u32 tmp[OUTPUT_POOL_WORDS];
1412 : :
1413 : 1686 : int bytes = nbytes;
1414 : :
1415 : : /* pull at least as much as a wakeup */
1416 : 1686 : bytes = max_t(int, bytes, random_read_wakeup_bits / 8);
1417 : : /* but never more than the buffer size */
1418 : 1686 : bytes = min_t(int, bytes, sizeof(tmp));
1419 : :
1420 : 5058 : trace_xfer_secondary_pool(r->name, bytes * 8, nbytes * 8,
1421 : 3372 : ENTROPY_BITS(r), ENTROPY_BITS(r->pull));
1422 : 1686 : bytes = extract_entropy(r->pull, tmp, bytes,
1423 : : random_read_wakeup_bits / 8, 0);
1424 : 1686 : mix_pool_bytes(r, tmp, bytes);
1425 : 1686 : credit_entropy_bits(r, bytes*8);
1426 : 1686 : }
1427 : :
1428 : : /*
1429 : : * Used as a workqueue function so that when the input pool is getting
1430 : : * full, we can "spill over" some entropy to the output pools. That
1431 : : * way the output pools can store some of the excess entropy instead
1432 : : * of letting it go to waste.
1433 : : */
1434 : 1686 : static void push_to_pool(struct work_struct *work)
1435 : : {
1436 : 1686 : struct entropy_store *r = container_of(work, struct entropy_store,
1437 : : push_work);
1438 [ - + ]: 1686 : BUG_ON(!r);
1439 : 1686 : _xfer_secondary_pool(r, random_read_wakeup_bits/8);
1440 : 3372 : trace_push_to_pool(r->name, r->entropy_count >> ENTROPY_SHIFT,
1441 : 1686 : r->pull->entropy_count >> ENTROPY_SHIFT);
1442 : 1686 : }
1443 : :
1444 : : /*
1445 : : * This function decides how many bytes to actually take from the
1446 : : * given pool, and also debits the entropy count accordingly.
1447 : : */
1448 : 2090 : static size_t account(struct entropy_store *r, size_t nbytes, int min,
1449 : : int reserved)
1450 : : {
1451 : : int entropy_count, orig, have_bytes;
1452 : : size_t ibytes, nfrac;
1453 : :
1454 [ - + ]: 2090 : BUG_ON(r->entropy_count > r->poolinfo->poolfracbits);
1455 : :
1456 : : /* Can we pull enough? */
1457 : : retry:
1458 : 2090 : entropy_count = orig = READ_ONCE(r->entropy_count);
1459 : : ibytes = nbytes;
1460 : : /* never pull more than available */
1461 : 2090 : have_bytes = entropy_count >> (ENTROPY_SHIFT + 3);
1462 : :
1463 [ - + ]: 2090 : if ((have_bytes -= reserved) < 0)
1464 : : have_bytes = 0;
1465 : 2090 : ibytes = min_t(size_t, ibytes, have_bytes);
1466 [ + + ]: 2090 : if (ibytes < min)
1467 : : ibytes = 0;
1468 : :
1469 [ - + ]: 2090 : if (unlikely(entropy_count < 0)) {
1470 : 0 : pr_warn("random: negative entropy count: pool %s count %d\n",
1471 : : r->name, entropy_count);
1472 : 0 : WARN_ON(1);
1473 : : entropy_count = 0;
1474 : : }
1475 : 2090 : nfrac = ibytes << (ENTROPY_SHIFT + 3);
1476 [ + + ]: 2090 : if ((size_t) entropy_count > nfrac)
1477 : 1830 : entropy_count -= nfrac;
1478 : : else
1479 : : entropy_count = 0;
1480 : :
1481 [ - + ]: 2090 : if (cmpxchg(&r->entropy_count, orig, entropy_count) != orig)
1482 : : goto retry;
1483 : :
1484 : 2090 : trace_debit_entropy(r->name, 8 * ibytes);
1485 [ + + + + ]: 4160 : if (ibytes &&
1486 : 2070 : (r->entropy_count >> ENTROPY_SHIFT) < random_write_wakeup_bits) {
1487 : 1616 : wake_up_interruptible(&random_write_wait);
1488 : 1616 : kill_fasync(&fasync, SIGIO, POLL_OUT);
1489 : : }
1490 : :
1491 : 2090 : return ibytes;
1492 : : }
1493 : :
1494 : : /*
1495 : : * This function does the actual extraction for extract_entropy and
1496 : : * extract_entropy_user.
1497 : : *
1498 : : * Note: we assume that .poolwords is a multiple of 16 words.
1499 : : */
1500 : 4494 : static void extract_buf(struct entropy_store *r, __u8 *out)
1501 : : {
1502 : : int i;
1503 : : union {
1504 : : __u32 w[5];
1505 : : unsigned long l[LONGS(20)];
1506 : : } hash;
1507 : : __u32 workspace[SHA_WORKSPACE_WORDS];
1508 : : unsigned long flags;
1509 : :
1510 : : /*
1511 : : * If we have an architectural hardware random number
1512 : : * generator, use it for SHA's initial vector
1513 : : */
1514 : 4494 : sha_init(hash.w);
1515 : : for (i = 0; i < LONGS(20); i++) {
1516 : : unsigned long v;
1517 : : if (!arch_get_random_long(&v))
1518 : : break;
1519 : : hash.l[i] = v;
1520 : : }
1521 : :
1522 : : /* Generate a hash across the pool, 16 words (512 bits) at a time */
1523 : 4494 : spin_lock_irqsave(&r->lock, flags);
1524 [ + + ]: 40446 : for (i = 0; i < r->poolinfo->poolwords; i += 16)
1525 : 35952 : sha_transform(hash.w, (__u8 *)(r->pool + i), workspace);
1526 : :
1527 : : /*
1528 : : * We mix the hash back into the pool to prevent backtracking
1529 : : * attacks (where the attacker knows the state of the pool
1530 : : * plus the current outputs, and attempts to find previous
1531 : : * ouputs), unless the hash function can be inverted. By
1532 : : * mixing at least a SHA1 worth of hash data back, we make
1533 : : * brute-forcing the feedback as hard as brute-forcing the
1534 : : * hash.
1535 : : */
1536 : 4494 : __mix_pool_bytes(r, hash.w, sizeof(hash.w));
1537 : : spin_unlock_irqrestore(&r->lock, flags);
1538 : :
1539 : : memzero_explicit(workspace, sizeof(workspace));
1540 : :
1541 : : /*
1542 : : * In case the hash function has some recognizable output
1543 : : * pattern, we fold it in half. Thus, we always feed back
1544 : : * twice as much data as we output.
1545 : : */
1546 : 4494 : hash.w[0] ^= hash.w[3];
1547 : 4494 : hash.w[1] ^= hash.w[4];
1548 : 8988 : hash.w[2] ^= rol32(hash.w[2], 16);
1549 : :
1550 : 4494 : memcpy(out, &hash, EXTRACT_SIZE);
1551 : : memzero_explicit(&hash, sizeof(hash));
1552 : 4494 : }
1553 : :
1554 : 2494 : static ssize_t _extract_entropy(struct entropy_store *r, void *buf,
1555 : : size_t nbytes, int fips)
1556 : : {
1557 : : ssize_t ret = 0, i;
1558 : : __u8 tmp[EXTRACT_SIZE];
1559 : : unsigned long flags;
1560 : :
1561 [ + + ]: 9482 : while (nbytes) {
1562 : 4494 : extract_buf(r, tmp);
1563 : :
1564 [ - + ]: 4494 : if (fips) {
1565 : 0 : spin_lock_irqsave(&r->lock, flags);
1566 [ # # ]: 0 : if (!memcmp(tmp, r->last_data, EXTRACT_SIZE))
1567 : 0 : panic("Hardware RNG duplicated output!\n");
1568 : 0 : memcpy(r->last_data, tmp, EXTRACT_SIZE);
1569 : : spin_unlock_irqrestore(&r->lock, flags);
1570 : : }
1571 : 4494 : i = min_t(int, nbytes, EXTRACT_SIZE);
1572 : 4494 : memcpy(buf, tmp, i);
1573 : 4494 : nbytes -= i;
1574 : 4494 : buf += i;
1575 : 4494 : ret += i;
1576 : : }
1577 : :
1578 : : /* Wipe data just returned from memory */
1579 : : memzero_explicit(tmp, sizeof(tmp));
1580 : :
1581 : 2494 : return ret;
1582 : : }
1583 : :
1584 : : /*
1585 : : * This function extracts randomness from the "entropy pool", and
1586 : : * returns it in a buffer.
1587 : : *
1588 : : * The min parameter specifies the minimum amount we can pull before
1589 : : * failing to avoid races that defeat catastrophic reseeding while the
1590 : : * reserved parameter indicates how much entropy we must leave in the
1591 : : * pool after each pull to avoid starving other readers.
1592 : : */
1593 : 2090 : static ssize_t extract_entropy(struct entropy_store *r, void *buf,
1594 : : size_t nbytes, int min, int reserved)
1595 : : {
1596 : : __u8 tmp[EXTRACT_SIZE];
1597 : : unsigned long flags;
1598 : :
1599 : : /* if last_data isn't primed, we need EXTRACT_SIZE extra bytes */
1600 : : if (fips_enabled) {
1601 : : spin_lock_irqsave(&r->lock, flags);
1602 : : if (!r->last_data_init) {
1603 : : r->last_data_init = 1;
1604 : : spin_unlock_irqrestore(&r->lock, flags);
1605 : : trace_extract_entropy(r->name, EXTRACT_SIZE,
1606 : : ENTROPY_BITS(r), _RET_IP_);
1607 : : xfer_secondary_pool(r, EXTRACT_SIZE);
1608 : : extract_buf(r, tmp);
1609 : : spin_lock_irqsave(&r->lock, flags);
1610 : : memcpy(r->last_data, tmp, EXTRACT_SIZE);
1611 : : }
1612 : : spin_unlock_irqrestore(&r->lock, flags);
1613 : : }
1614 : :
1615 : 2090 : trace_extract_entropy(r->name, nbytes, ENTROPY_BITS(r), _RET_IP_);
1616 : 2090 : xfer_secondary_pool(r, nbytes);
1617 : 2090 : nbytes = account(r, nbytes, min, reserved);
1618 : :
1619 : 2090 : return _extract_entropy(r, buf, nbytes, fips_enabled);
1620 : : }
1621 : :
1622 : : /*
1623 : : * This function extracts randomness from the "entropy pool", and
1624 : : * returns it in a userspace buffer.
1625 : : */
1626 : 0 : static ssize_t extract_entropy_user(struct entropy_store *r, void __user *buf,
1627 : : size_t nbytes)
1628 : : {
1629 : : ssize_t ret = 0, i;
1630 : : __u8 tmp[EXTRACT_SIZE];
1631 : : int large_request = (nbytes > 256);
1632 : :
1633 : 0 : trace_extract_entropy_user(r->name, nbytes, ENTROPY_BITS(r), _RET_IP_);
1634 [ # # # # ]: 0 : if (!r->initialized && r->pull) {
1635 : 0 : xfer_secondary_pool(r, ENTROPY_BITS(r->pull)/8);
1636 [ # # ]: 0 : if (!r->initialized)
1637 : : return 0;
1638 : : }
1639 : 0 : xfer_secondary_pool(r, nbytes);
1640 : 0 : nbytes = account(r, nbytes, 0, 0);
1641 : :
1642 [ # # ]: 0 : while (nbytes) {
1643 [ # # # # ]: 0 : if (large_request && need_resched()) {
1644 [ # # ]: 0 : if (signal_pending(current)) {
1645 [ # # ]: 0 : if (ret == 0)
1646 : : ret = -ERESTARTSYS;
1647 : : break;
1648 : : }
1649 : 0 : schedule();
1650 : : }
1651 : :
1652 : 0 : extract_buf(r, tmp);
1653 : 0 : i = min_t(int, nbytes, EXTRACT_SIZE);
1654 [ # # ]: 0 : if (copy_to_user(buf, tmp, i)) {
1655 : : ret = -EFAULT;
1656 : : break;
1657 : : }
1658 : :
1659 : 0 : nbytes -= i;
1660 : 0 : buf += i;
1661 : 0 : ret += i;
1662 : : }
1663 : :
1664 : : /* Wipe data just returned from memory */
1665 : : memzero_explicit(tmp, sizeof(tmp));
1666 : :
1667 : 0 : return ret;
1668 : : }
1669 : :
1670 : : #define warn_unseeded_randomness(previous) \
1671 : : _warn_unseeded_randomness(__func__, (void *) _RET_IP_, (previous))
1672 : :
1673 : 5879818 : static void _warn_unseeded_randomness(const char *func_name, void *caller,
1674 : : void **previous)
1675 : : {
1676 : : #ifdef CONFIG_WARN_ALL_UNSEEDED_RANDOM
1677 : : const bool print_once = false;
1678 : : #else
1679 : : static bool print_once __read_mostly;
1680 : : #endif
1681 : :
1682 [ + + + - ]: 5880222 : if (print_once ||
1683 [ + - ]: 808 : crng_ready() ||
1684 [ + - ]: 404 : (previous && (caller == READ_ONCE(*previous))))
1685 : 5879818 : return;
1686 : : WRITE_ONCE(*previous, caller);
1687 : : #ifndef CONFIG_WARN_ALL_UNSEEDED_RANDOM
1688 : 404 : print_once = true;
1689 : : #endif
1690 [ + - ]: 404 : if (__ratelimit(&unseeded_warning))
1691 : 404 : printk_deferred(KERN_NOTICE "random: %s called from %pS "
1692 : : "with crng_init=%d\n", func_name, caller,
1693 : : crng_init);
1694 : : }
1695 : :
1696 : : /*
1697 : : * This function is the exported kernel interface. It returns some
1698 : : * number of good random numbers, suitable for key generation, seeding
1699 : : * TCP sequence numbers, etc. It does not rely on the hardware random
1700 : : * number generator. For random bytes direct from the hardware RNG
1701 : : * (when available), use get_random_bytes_arch(). In order to ensure
1702 : : * that the randomness provided by this function is okay, the function
1703 : : * wait_for_random_bytes() should be called and return 0 at least once
1704 : : * at any point prior.
1705 : : */
1706 : 1045514 : static void _get_random_bytes(void *buf, int nbytes)
1707 : : {
1708 : : __u8 tmp[CHACHA_BLOCK_SIZE] __aligned(4);
1709 : :
1710 : 1045514 : trace_get_random_bytes(nbytes, _RET_IP_);
1711 : :
1712 [ - + ]: 2091048 : while (nbytes >= CHACHA_BLOCK_SIZE) {
1713 : : extract_crng(buf);
1714 : 0 : buf += CHACHA_BLOCK_SIZE;
1715 : 0 : nbytes -= CHACHA_BLOCK_SIZE;
1716 : : }
1717 : :
1718 [ + - ]: 1045524 : if (nbytes > 0) {
1719 : : extract_crng(tmp);
1720 : 1045530 : memcpy(buf, tmp, nbytes);
1721 : : crng_backtrack_protect(tmp, nbytes);
1722 : : } else
1723 : : crng_backtrack_protect(tmp, CHACHA_BLOCK_SIZE);
1724 : : memzero_explicit(tmp, sizeof(tmp));
1725 : 1045524 : }
1726 : :
1727 : 1045526 : void get_random_bytes(void *buf, int nbytes)
1728 : : {
1729 : : static void *previous;
1730 : :
1731 : 1045526 : warn_unseeded_randomness(&previous);
1732 : 1045526 : _get_random_bytes(buf, nbytes);
1733 : 1045520 : }
1734 : : EXPORT_SYMBOL(get_random_bytes);
1735 : :
1736 : :
1737 : : /*
1738 : : * Each time the timer fires, we expect that we got an unpredictable
1739 : : * jump in the cycle counter. Even if the timer is running on another
1740 : : * CPU, the timer activity will be touching the stack of the CPU that is
1741 : : * generating entropy..
1742 : : *
1743 : : * Note that we don't re-arm the timer in the timer itself - we are
1744 : : * happy to be scheduled away, since that just makes the load more
1745 : : * complex, but we do not want the timer to keep ticking unless the
1746 : : * entropy loop is running.
1747 : : *
1748 : : * So the re-arming always happens in the entropy loop itself.
1749 : : */
1750 : 0 : static void entropy_timer(struct timer_list *t)
1751 : : {
1752 : 0 : credit_entropy_bits(&input_pool, 1);
1753 : 0 : }
1754 : :
1755 : : /*
1756 : : * If we have an actual cycle counter, see if we can
1757 : : * generate enough entropy with timing noise
1758 : : */
1759 : 0 : static void try_to_generate_entropy(void)
1760 : : {
1761 : : struct {
1762 : : unsigned long now;
1763 : : struct timer_list timer;
1764 : : } stack;
1765 : :
1766 [ # # ]: 0 : stack.now = random_get_entropy();
1767 : :
1768 : : /* Slow counter - or none. Don't even bother */
1769 [ # # # # ]: 0 : if (stack.now == random_get_entropy())
1770 : 0 : return;
1771 : :
1772 : : timer_setup_on_stack(&stack.timer, entropy_timer, 0);
1773 [ # # ]: 0 : while (!crng_ready()) {
1774 [ # # ]: 0 : if (!timer_pending(&stack.timer))
1775 : 0 : mod_timer(&stack.timer, jiffies+1);
1776 : 0 : mix_pool_bytes(&input_pool, &stack.now, sizeof(stack.now));
1777 : 0 : schedule();
1778 [ # # ]: 0 : stack.now = random_get_entropy();
1779 : : }
1780 : :
1781 : 0 : del_timer_sync(&stack.timer);
1782 : : destroy_timer_on_stack(&stack.timer);
1783 : 0 : mix_pool_bytes(&input_pool, &stack.now, sizeof(stack.now));
1784 : : }
1785 : :
1786 : : /*
1787 : : * Wait for the urandom pool to be seeded and thus guaranteed to supply
1788 : : * cryptographically secure random numbers. This applies to: the /dev/urandom
1789 : : * device, the get_random_bytes function, and the get_random_{u32,u64,int,long}
1790 : : * family of functions. Using any of these functions without first calling
1791 : : * this function forfeits the guarantee of security.
1792 : : *
1793 : : * Returns: 0 if the urandom pool has been seeded.
1794 : : * -ERESTARTSYS if the function was interrupted by a signal.
1795 : : */
1796 : 0 : int wait_for_random_bytes(void)
1797 : : {
1798 [ # # ]: 0 : if (likely(crng_ready()))
1799 : : return 0;
1800 : :
1801 : : do {
1802 : : int ret;
1803 [ # # # # : 0 : ret = wait_event_interruptible_timeout(crng_init_wait, crng_ready(), HZ);
# # # # ]
1804 [ # # ]: 0 : if (ret)
1805 : 0 : return ret > 0 ? 0 : ret;
1806 : :
1807 : 0 : try_to_generate_entropy();
1808 [ # # ]: 0 : } while (!crng_ready());
1809 : :
1810 : : return 0;
1811 : : }
1812 : : EXPORT_SYMBOL(wait_for_random_bytes);
1813 : :
1814 : : /*
1815 : : * Returns whether or not the urandom pool has been seeded and thus guaranteed
1816 : : * to supply cryptographically secure random numbers. This applies to: the
1817 : : * /dev/urandom device, the get_random_bytes function, and the get_random_{u32,
1818 : : * ,u64,int,long} family of functions.
1819 : : *
1820 : : * Returns: true if the urandom pool has been seeded.
1821 : : * false if the urandom pool has not been seeded.
1822 : : */
1823 : 0 : bool rng_is_initialized(void)
1824 : : {
1825 : 0 : return crng_ready();
1826 : : }
1827 : : EXPORT_SYMBOL(rng_is_initialized);
1828 : :
1829 : : /*
1830 : : * Add a callback function that will be invoked when the nonblocking
1831 : : * pool is initialised.
1832 : : *
1833 : : * returns: 0 if callback is successfully added
1834 : : * -EALREADY if pool is already initialised (callback not called)
1835 : : * -ENOENT if module for callback is not alive
1836 : : */
1837 : 404 : int add_random_ready_callback(struct random_ready_callback *rdy)
1838 : : {
1839 : : struct module *owner;
1840 : : unsigned long flags;
1841 : : int err = -EALREADY;
1842 : :
1843 [ + - ]: 404 : if (crng_ready())
1844 : : return err;
1845 : :
1846 : 404 : owner = rdy->owner;
1847 [ + - ]: 404 : if (!try_module_get(owner))
1848 : : return -ENOENT;
1849 : :
1850 : 404 : spin_lock_irqsave(&random_ready_list_lock, flags);
1851 [ + - ]: 404 : if (crng_ready())
1852 : : goto out;
1853 : :
1854 : : owner = NULL;
1855 : :
1856 : 404 : list_add(&rdy->list, &random_ready_list);
1857 : : err = 0;
1858 : :
1859 : : out:
1860 : : spin_unlock_irqrestore(&random_ready_list_lock, flags);
1861 : :
1862 : 404 : module_put(owner);
1863 : :
1864 : 404 : return err;
1865 : : }
1866 : : EXPORT_SYMBOL(add_random_ready_callback);
1867 : :
1868 : : /*
1869 : : * Delete a previously registered readiness callback function.
1870 : : */
1871 : 0 : void del_random_ready_callback(struct random_ready_callback *rdy)
1872 : : {
1873 : : unsigned long flags;
1874 : : struct module *owner = NULL;
1875 : :
1876 : 0 : spin_lock_irqsave(&random_ready_list_lock, flags);
1877 [ # # ]: 0 : if (!list_empty(&rdy->list)) {
1878 : : list_del_init(&rdy->list);
1879 : 0 : owner = rdy->owner;
1880 : : }
1881 : : spin_unlock_irqrestore(&random_ready_list_lock, flags);
1882 : :
1883 : 0 : module_put(owner);
1884 : 0 : }
1885 : : EXPORT_SYMBOL(del_random_ready_callback);
1886 : :
1887 : : /*
1888 : : * This function will use the architecture-specific hardware random
1889 : : * number generator if it is available. The arch-specific hw RNG will
1890 : : * almost certainly be faster than what we can do in software, but it
1891 : : * is impossible to verify that it is implemented securely (as
1892 : : * opposed, to, say, the AES encryption of a sequence number using a
1893 : : * key known by the NSA). So it's useful if we need the speed, but
1894 : : * only if we're willing to trust the hardware manufacturer not to
1895 : : * have put in a back door.
1896 : : *
1897 : : * Return number of bytes filled in.
1898 : : */
1899 : 404 : int __must_check get_random_bytes_arch(void *buf, int nbytes)
1900 : : {
1901 : : int left = nbytes;
1902 : : char *p = buf;
1903 : :
1904 : 404 : trace_get_random_bytes_arch(left, _RET_IP_);
1905 : : while (left) {
1906 : : unsigned long v;
1907 : : int chunk = min_t(int, left, sizeof(unsigned long));
1908 : :
1909 : : if (!arch_get_random_long(&v))
1910 : : break;
1911 : :
1912 : : memcpy(p, &v, chunk);
1913 : : p += chunk;
1914 : : left -= chunk;
1915 : : }
1916 : :
1917 : 404 : return nbytes - left;
1918 : : }
1919 : : EXPORT_SYMBOL(get_random_bytes_arch);
1920 : :
1921 : : /*
1922 : : * init_std_data - initialize pool with system data
1923 : : *
1924 : : * @r: pool to initialize
1925 : : *
1926 : : * This function clears the pool's entropy count and mixes some system
1927 : : * data into the pool to prepare it for use. The pool is not cleared
1928 : : * as that can only decrease the entropy in the pool.
1929 : : */
1930 : 808 : static void __init init_std_data(struct entropy_store *r)
1931 : : {
1932 : : int i;
1933 : 808 : ktime_t now = ktime_get_real();
1934 : : unsigned long rv;
1935 : :
1936 : 808 : r->last_pulled = jiffies;
1937 : 808 : mix_pool_bytes(r, &now, sizeof(now));
1938 [ + + ]: 65448 : for (i = r->poolinfo->poolbytes; i > 0; i -= sizeof(rv)) {
1939 : : if (!arch_get_random_seed_long(&rv) &&
1940 : : !arch_get_random_long(&rv))
1941 [ - + ]: 64640 : rv = random_get_entropy();
1942 : 64640 : mix_pool_bytes(r, &rv, sizeof(rv));
1943 : : }
1944 : 808 : mix_pool_bytes(r, utsname(), sizeof(*(utsname())));
1945 : 808 : }
1946 : :
1947 : : /*
1948 : : * Note that setup_arch() may call add_device_randomness()
1949 : : * long before we get here. This allows seeding of the pools
1950 : : * with some platform dependent data very early in the boot
1951 : : * process. But it limits our options here. We must use
1952 : : * statically allocated structures that already have all
1953 : : * initializations complete at compile time. We should also
1954 : : * take care not to overwrite the precious per platform data
1955 : : * we were given.
1956 : : */
1957 : 404 : int __init rand_initialize(void)
1958 : : {
1959 : 404 : init_std_data(&input_pool);
1960 : 404 : init_std_data(&blocking_pool);
1961 : 404 : crng_initialize(&primary_crng);
1962 : 404 : crng_global_init_time = jiffies;
1963 [ - + ]: 404 : if (ratelimit_disable) {
1964 : 0 : urandom_warning.interval = 0;
1965 : 0 : unseeded_warning.interval = 0;
1966 : : }
1967 : 404 : return 0;
1968 : : }
1969 : :
1970 : : #ifdef CONFIG_BLOCK
1971 : 10100 : void rand_initialize_disk(struct gendisk *disk)
1972 : : {
1973 : : struct timer_rand_state *state;
1974 : :
1975 : : /*
1976 : : * If kzalloc returns null, we just won't use that entropy
1977 : : * source.
1978 : : */
1979 : 10100 : state = kzalloc(sizeof(struct timer_rand_state), GFP_KERNEL);
1980 [ + - ]: 10100 : if (state) {
1981 : 10100 : state->last_time = INITIAL_JIFFIES;
1982 : 10100 : disk->random = state;
1983 : : }
1984 : 10100 : }
1985 : : #endif
1986 : :
1987 : : static ssize_t
1988 : 0 : _random_read(int nonblock, char __user *buf, size_t nbytes)
1989 : : {
1990 : : ssize_t n;
1991 : :
1992 [ # # ]: 0 : if (nbytes == 0)
1993 : : return 0;
1994 : :
1995 : 0 : nbytes = min_t(size_t, nbytes, SEC_XFER_SIZE);
1996 : : while (1) {
1997 : 0 : n = extract_entropy_user(&blocking_pool, buf, nbytes);
1998 [ # # ]: 0 : if (n < 0)
1999 : 0 : return n;
2000 : 0 : trace_random_read(n*8, (nbytes-n)*8,
2001 : 0 : ENTROPY_BITS(&blocking_pool),
2002 : 0 : ENTROPY_BITS(&input_pool));
2003 [ # # ]: 0 : if (n > 0)
2004 : 0 : return n;
2005 : :
2006 : : /* Pool is (near) empty. Maybe wait and retry. */
2007 [ # # ]: 0 : if (nonblock)
2008 : : return -EAGAIN;
2009 : :
2010 [ # # # # : 0 : wait_event_interruptible(random_read_wait,
# # # # #
# ]
2011 : : blocking_pool.initialized &&
2012 : : (ENTROPY_BITS(&input_pool) >= random_read_wakeup_bits));
2013 [ # # ]: 0 : if (signal_pending(current))
2014 : : return -ERESTARTSYS;
2015 : : }
2016 : : }
2017 : :
2018 : : static ssize_t
2019 : 0 : random_read(struct file *file, char __user *buf, size_t nbytes, loff_t *ppos)
2020 : : {
2021 : 0 : return _random_read(file->f_flags & O_NONBLOCK, buf, nbytes);
2022 : : }
2023 : :
2024 : : static ssize_t
2025 : 1094518 : urandom_read(struct file *file, char __user *buf, size_t nbytes, loff_t *ppos)
2026 : : {
2027 : : unsigned long flags;
2028 : : static int maxwarn = 10;
2029 : : int ret;
2030 : :
2031 [ - + # # ]: 1094518 : if (!crng_ready() && maxwarn > 0) {
2032 : 0 : maxwarn--;
2033 [ # # ]: 0 : if (__ratelimit(&urandom_warning))
2034 : 0 : printk(KERN_NOTICE "random: %s: uninitialized "
2035 : : "urandom read (%zd bytes read)\n",
2036 : 0 : current->comm, nbytes);
2037 : 0 : spin_lock_irqsave(&primary_crng.lock, flags);
2038 : 0 : crng_init_cnt = 0;
2039 : : spin_unlock_irqrestore(&primary_crng.lock, flags);
2040 : : }
2041 : 1094518 : nbytes = min_t(size_t, nbytes, INT_MAX >> (ENTROPY_SHIFT + 3));
2042 : 1094518 : ret = extract_crng_user(buf, nbytes);
2043 : 1094358 : trace_urandom_read(8 * nbytes, 0, ENTROPY_BITS(&input_pool));
2044 : 1094490 : return ret;
2045 : : }
2046 : :
2047 : : static __poll_t
2048 : 1566118 : random_poll(struct file *file, poll_table * wait)
2049 : : {
2050 : : __poll_t mask;
2051 : :
2052 : : poll_wait(file, &random_read_wait, wait);
2053 : : poll_wait(file, &random_write_wait, wait);
2054 : : mask = 0;
2055 [ + - ]: 1566118 : if (ENTROPY_BITS(&input_pool) >= random_read_wakeup_bits)
2056 : : mask |= EPOLLIN | EPOLLRDNORM;
2057 [ - + ]: 1566118 : if (ENTROPY_BITS(&input_pool) < random_write_wakeup_bits)
2058 : 0 : mask |= EPOLLOUT | EPOLLWRNORM;
2059 : 1566118 : return mask;
2060 : : }
2061 : :
2062 : : static int
2063 : 4208 : write_pool(struct entropy_store *r, const char __user *buffer, size_t count)
2064 : : {
2065 : : size_t bytes;
2066 : : __u32 t, buf[16];
2067 : : const char __user *p = buffer;
2068 : :
2069 [ + + ]: 15452 : while (count > 0) {
2070 : : int b, i = 0;
2071 : :
2072 : 7036 : bytes = min(count, sizeof(buf));
2073 [ + - ]: 7036 : if (copy_from_user(&buf, p, bytes))
2074 : : return -EFAULT;
2075 : :
2076 : 7036 : for (b = bytes ; b > 0 ; b -= sizeof(__u32), i++) {
2077 : : if (!arch_get_random_int(&t))
2078 : : break;
2079 : : buf[i] ^= t;
2080 : : }
2081 : :
2082 : 7036 : count -= bytes;
2083 : 7036 : p += bytes;
2084 : :
2085 : 7036 : mix_pool_bytes(r, buf, bytes);
2086 : 7036 : cond_resched();
2087 : : }
2088 : :
2089 : : return 0;
2090 : : }
2091 : :
2092 : 808 : static ssize_t random_write(struct file *file, const char __user *buffer,
2093 : : size_t count, loff_t *ppos)
2094 : : {
2095 : : size_t ret;
2096 : :
2097 : 808 : ret = write_pool(&input_pool, buffer, count);
2098 [ + - ]: 808 : if (ret)
2099 : : return ret;
2100 : :
2101 : 808 : return (ssize_t)count;
2102 : : }
2103 : :
2104 : 6802 : static long random_ioctl(struct file *f, unsigned int cmd, unsigned long arg)
2105 : : {
2106 : : int size, ent_count;
2107 : 6802 : int __user *p = (int __user *)arg;
2108 : : int retval;
2109 : :
2110 [ + - + - : 6802 : switch (cmd) {
- + ]
2111 : : case RNDGETENTCNT:
2112 : : /* inherently racy, no point locking */
2113 : 3400 : ent_count = ENTROPY_BITS(&input_pool);
2114 [ + - ]: 3400 : if (put_user(ent_count, p))
2115 : : return -EFAULT;
2116 : 3400 : return 0;
2117 : : case RNDADDTOENTCNT:
2118 [ # # ]: 0 : if (!capable(CAP_SYS_ADMIN))
2119 : : return -EPERM;
2120 [ # # ]: 0 : if (get_user(ent_count, p))
2121 : : return -EFAULT;
2122 : 0 : return credit_entropy_bits_safe(&input_pool, ent_count);
2123 : : case RNDADDENTROPY:
2124 [ + - ]: 3400 : if (!capable(CAP_SYS_ADMIN))
2125 : : return -EPERM;
2126 [ + - ]: 3400 : if (get_user(ent_count, p++))
2127 : : return -EFAULT;
2128 [ + - ]: 3400 : if (ent_count < 0)
2129 : : return -EINVAL;
2130 [ + - ]: 3400 : if (get_user(size, p++))
2131 : : return -EFAULT;
2132 : 3400 : retval = write_pool(&input_pool, (const char __user *)p,
2133 : : size);
2134 [ + - ]: 3400 : if (retval < 0)
2135 : : return retval;
2136 : 3400 : return credit_entropy_bits_safe(&input_pool, ent_count);
2137 : : case RNDZAPENTCNT:
2138 : : case RNDCLEARPOOL:
2139 : : /*
2140 : : * Clear the entropy pool counters. We no longer clear
2141 : : * the entropy pool, as that's silly.
2142 : : */
2143 [ # # ]: 0 : if (!capable(CAP_SYS_ADMIN))
2144 : : return -EPERM;
2145 : 0 : input_pool.entropy_count = 0;
2146 : 0 : blocking_pool.entropy_count = 0;
2147 : 0 : return 0;
2148 : : case RNDRESEEDCRNG:
2149 [ # # ]: 0 : if (!capable(CAP_SYS_ADMIN))
2150 : : return -EPERM;
2151 [ # # ]: 0 : if (crng_init < 2)
2152 : : return -ENODATA;
2153 : 0 : crng_reseed(&primary_crng, NULL);
2154 : 0 : crng_global_init_time = jiffies - 1;
2155 : 0 : return 0;
2156 : : default:
2157 : : return -EINVAL;
2158 : : }
2159 : : }
2160 : :
2161 : 0 : static int random_fasync(int fd, struct file *filp, int on)
2162 : : {
2163 : 0 : return fasync_helper(fd, filp, on, &fasync);
2164 : : }
2165 : :
2166 : : const struct file_operations random_fops = {
2167 : : .read = random_read,
2168 : : .write = random_write,
2169 : : .poll = random_poll,
2170 : : .unlocked_ioctl = random_ioctl,
2171 : : .fasync = random_fasync,
2172 : : .llseek = noop_llseek,
2173 : : };
2174 : :
2175 : : const struct file_operations urandom_fops = {
2176 : : .read = urandom_read,
2177 : : .write = random_write,
2178 : : .unlocked_ioctl = random_ioctl,
2179 : : .fasync = random_fasync,
2180 : : .llseek = noop_llseek,
2181 : : };
2182 : :
2183 : 2189322 : SYSCALL_DEFINE3(getrandom, char __user *, buf, size_t, count,
2184 : : unsigned int, flags)
2185 : : {
2186 : : int ret;
2187 : :
2188 [ + + ]: 1094662 : if (flags & ~(GRND_NONBLOCK|GRND_RANDOM))
2189 : : return -EINVAL;
2190 : :
2191 [ - + ]: 1094596 : if (count > INT_MAX)
2192 : : count = INT_MAX;
2193 : :
2194 [ - + ]: 1094596 : if (flags & GRND_RANDOM)
2195 : 0 : return _random_read(flags & GRND_NONBLOCK, buf, count);
2196 : :
2197 [ + + ]: 1094596 : if (!crng_ready()) {
2198 [ - + ]: 11680 : if (flags & GRND_NONBLOCK)
2199 : : return -EAGAIN;
2200 : 0 : ret = wait_for_random_bytes();
2201 [ # # ]: 0 : if (unlikely(ret))
2202 : : return ret;
2203 : : }
2204 : 1082916 : return urandom_read(NULL, buf, count, NULL);
2205 : : }
2206 : :
2207 : : /********************************************************************
2208 : : *
2209 : : * Sysctl interface
2210 : : *
2211 : : ********************************************************************/
2212 : :
2213 : : #ifdef CONFIG_SYSCTL
2214 : :
2215 : : #include <linux/sysctl.h>
2216 : :
2217 : : static int min_read_thresh = 8, min_write_thresh;
2218 : : static int max_read_thresh = OUTPUT_POOL_WORDS * 32;
2219 : : static int max_write_thresh = INPUT_POOL_WORDS * 32;
2220 : : static int random_min_urandom_seed = 60;
2221 : : static char sysctl_bootid[16];
2222 : :
2223 : : /*
2224 : : * This function is used to return both the bootid UUID, and random
2225 : : * UUID. The difference is in whether table->data is NULL; if it is,
2226 : : * then a new UUID is generated and returned to the user.
2227 : : *
2228 : : * If the user accesses this via the proc interface, the UUID will be
2229 : : * returned as an ASCII string in the standard UUID format; if via the
2230 : : * sysctl system call, as 16 bytes of binary data.
2231 : : */
2232 : 12928 : static int proc_do_uuid(struct ctl_table *table, int write,
2233 : : void __user *buffer, size_t *lenp, loff_t *ppos)
2234 : : {
2235 : : struct ctl_table fake_table;
2236 : : unsigned char buf[64], tmp_uuid[16], *uuid;
2237 : :
2238 : 12928 : uuid = table->data;
2239 [ - + ]: 12928 : if (!uuid) {
2240 : : uuid = tmp_uuid;
2241 : 0 : generate_random_uuid(uuid);
2242 : : } else {
2243 : : static DEFINE_SPINLOCK(bootid_spinlock);
2244 : :
2245 : : spin_lock(&bootid_spinlock);
2246 [ + + ]: 12928 : if (!uuid[8])
2247 : 404 : generate_random_uuid(uuid);
2248 : : spin_unlock(&bootid_spinlock);
2249 : : }
2250 : :
2251 : 12928 : sprintf(buf, "%pU", uuid);
2252 : :
2253 : 12928 : fake_table.data = buf;
2254 : 12928 : fake_table.maxlen = sizeof(buf);
2255 : :
2256 : 12928 : return proc_dostring(&fake_table, write, buffer, lenp, ppos);
2257 : : }
2258 : :
2259 : : /*
2260 : : * Return entropy available scaled to integral bits
2261 : : */
2262 : 0 : static int proc_do_entropy(struct ctl_table *table, int write,
2263 : : void __user *buffer, size_t *lenp, loff_t *ppos)
2264 : : {
2265 : : struct ctl_table fake_table;
2266 : : int entropy_count;
2267 : :
2268 : 0 : entropy_count = *(int *)table->data >> ENTROPY_SHIFT;
2269 : :
2270 : 0 : fake_table.data = &entropy_count;
2271 : 0 : fake_table.maxlen = sizeof(entropy_count);
2272 : :
2273 : 0 : return proc_dointvec(&fake_table, write, buffer, lenp, ppos);
2274 : : }
2275 : :
2276 : : static int sysctl_poolsize = INPUT_POOL_WORDS * 32;
2277 : : extern struct ctl_table random_table[];
2278 : : struct ctl_table random_table[] = {
2279 : : {
2280 : : .procname = "poolsize",
2281 : : .data = &sysctl_poolsize,
2282 : : .maxlen = sizeof(int),
2283 : : .mode = 0444,
2284 : : .proc_handler = proc_dointvec,
2285 : : },
2286 : : {
2287 : : .procname = "entropy_avail",
2288 : : .maxlen = sizeof(int),
2289 : : .mode = 0444,
2290 : : .proc_handler = proc_do_entropy,
2291 : : .data = &input_pool.entropy_count,
2292 : : },
2293 : : {
2294 : : .procname = "read_wakeup_threshold",
2295 : : .data = &random_read_wakeup_bits,
2296 : : .maxlen = sizeof(int),
2297 : : .mode = 0644,
2298 : : .proc_handler = proc_dointvec_minmax,
2299 : : .extra1 = &min_read_thresh,
2300 : : .extra2 = &max_read_thresh,
2301 : : },
2302 : : {
2303 : : .procname = "write_wakeup_threshold",
2304 : : .data = &random_write_wakeup_bits,
2305 : : .maxlen = sizeof(int),
2306 : : .mode = 0644,
2307 : : .proc_handler = proc_dointvec_minmax,
2308 : : .extra1 = &min_write_thresh,
2309 : : .extra2 = &max_write_thresh,
2310 : : },
2311 : : {
2312 : : .procname = "urandom_min_reseed_secs",
2313 : : .data = &random_min_urandom_seed,
2314 : : .maxlen = sizeof(int),
2315 : : .mode = 0644,
2316 : : .proc_handler = proc_dointvec,
2317 : : },
2318 : : {
2319 : : .procname = "boot_id",
2320 : : .data = &sysctl_bootid,
2321 : : .maxlen = 16,
2322 : : .mode = 0444,
2323 : : .proc_handler = proc_do_uuid,
2324 : : },
2325 : : {
2326 : : .procname = "uuid",
2327 : : .maxlen = 16,
2328 : : .mode = 0444,
2329 : : .proc_handler = proc_do_uuid,
2330 : : },
2331 : : #ifdef ADD_INTERRUPT_BENCH
2332 : : {
2333 : : .procname = "add_interrupt_avg_cycles",
2334 : : .data = &avg_cycles,
2335 : : .maxlen = sizeof(avg_cycles),
2336 : : .mode = 0444,
2337 : : .proc_handler = proc_doulongvec_minmax,
2338 : : },
2339 : : {
2340 : : .procname = "add_interrupt_avg_deviation",
2341 : : .data = &avg_deviation,
2342 : : .maxlen = sizeof(avg_deviation),
2343 : : .mode = 0444,
2344 : : .proc_handler = proc_doulongvec_minmax,
2345 : : },
2346 : : #endif
2347 : : { }
2348 : : };
2349 : : #endif /* CONFIG_SYSCTL */
2350 : :
2351 : : struct batched_entropy {
2352 : : union {
2353 : : u64 entropy_u64[CHACHA_BLOCK_SIZE / sizeof(u64)];
2354 : : u32 entropy_u32[CHACHA_BLOCK_SIZE / sizeof(u32)];
2355 : : };
2356 : : unsigned int position;
2357 : : spinlock_t batch_lock;
2358 : : };
2359 : :
2360 : : /*
2361 : : * Get a random word for internal kernel use only. The quality of the random
2362 : : * number is good as /dev/urandom, but there is no backtrack protection, with
2363 : : * the goal of being quite fast and not depleting entropy. In order to ensure
2364 : : * that the randomness provided by this function is okay, the function
2365 : : * wait_for_random_bytes() should be called and return 0 at least once at any
2366 : : * point prior.
2367 : : */
2368 : : static DEFINE_PER_CPU(struct batched_entropy, batched_entropy_u64) = {
2369 : : .batch_lock = __SPIN_LOCK_UNLOCKED(batched_entropy_u64.lock),
2370 : : };
2371 : :
2372 : 0 : u64 get_random_u64(void)
2373 : : {
2374 : : u64 ret;
2375 : : unsigned long flags;
2376 : : struct batched_entropy *batch;
2377 : : static void *previous;
2378 : :
2379 : 0 : warn_unseeded_randomness(&previous);
2380 : :
2381 : 0 : batch = raw_cpu_ptr(&batched_entropy_u64);
2382 : 0 : spin_lock_irqsave(&batch->batch_lock, flags);
2383 [ # # ]: 0 : if (batch->position % ARRAY_SIZE(batch->entropy_u64) == 0) {
2384 : 0 : extract_crng((u8 *)batch->entropy_u64);
2385 : 0 : batch->position = 0;
2386 : : }
2387 : 0 : ret = batch->entropy_u64[batch->position++];
2388 : : spin_unlock_irqrestore(&batch->batch_lock, flags);
2389 : 0 : return ret;
2390 : : }
2391 : : EXPORT_SYMBOL(get_random_u64);
2392 : :
2393 : : static DEFINE_PER_CPU(struct batched_entropy, batched_entropy_u32) = {
2394 : : .batch_lock = __SPIN_LOCK_UNLOCKED(batched_entropy_u32.lock),
2395 : : };
2396 : 4834350 : u32 get_random_u32(void)
2397 : : {
2398 : : u32 ret;
2399 : : unsigned long flags;
2400 : : struct batched_entropy *batch;
2401 : : static void *previous;
2402 : :
2403 : 4834350 : warn_unseeded_randomness(&previous);
2404 : :
2405 : 9668696 : batch = raw_cpu_ptr(&batched_entropy_u32);
2406 : 4834348 : spin_lock_irqsave(&batch->batch_lock, flags);
2407 [ + + ]: 4834364 : if (batch->position % ARRAY_SIZE(batch->entropy_u32) == 0) {
2408 : 304308 : extract_crng((u8 *)batch->entropy_u32);
2409 : 304308 : batch->position = 0;
2410 : : }
2411 : 4834364 : ret = batch->entropy_u32[batch->position++];
2412 : : spin_unlock_irqrestore(&batch->batch_lock, flags);
2413 : 4834354 : return ret;
2414 : : }
2415 : : EXPORT_SYMBOL(get_random_u32);
2416 : :
2417 : : /* It's important to invalidate all potential batched entropy that might
2418 : : * be stored before the crng is initialized, which we can do lazily by
2419 : : * simply resetting the counter to zero so that it's re-extracted on the
2420 : : * next usage. */
2421 : 808 : static void invalidate_batched_entropy(void)
2422 : : {
2423 : : int cpu;
2424 : : unsigned long flags;
2425 : :
2426 [ + + ]: 4848 : for_each_possible_cpu (cpu) {
2427 : : struct batched_entropy *batched_entropy;
2428 : :
2429 : 3232 : batched_entropy = per_cpu_ptr(&batched_entropy_u32, cpu);
2430 : 3232 : spin_lock_irqsave(&batched_entropy->batch_lock, flags);
2431 : 3232 : batched_entropy->position = 0;
2432 : : spin_unlock(&batched_entropy->batch_lock);
2433 : :
2434 : 3232 : batched_entropy = per_cpu_ptr(&batched_entropy_u64, cpu);
2435 : : spin_lock(&batched_entropy->batch_lock);
2436 : 3232 : batched_entropy->position = 0;
2437 : : spin_unlock_irqrestore(&batched_entropy->batch_lock, flags);
2438 : : }
2439 : 808 : }
2440 : :
2441 : : /**
2442 : : * randomize_page - Generate a random, page aligned address
2443 : : * @start: The smallest acceptable address the caller will take.
2444 : : * @range: The size of the area, starting at @start, within which the
2445 : : * random address must fall.
2446 : : *
2447 : : * If @start + @range would overflow, @range is capped.
2448 : : *
2449 : : * NOTE: Historical use of randomize_range, which this replaces, presumed that
2450 : : * @start was already page aligned. We now align it regardless.
2451 : : *
2452 : : * Return: A page aligned address within [start, start + range). On error,
2453 : : * @start is returned.
2454 : : */
2455 : : unsigned long
2456 : 934988 : randomize_page(unsigned long start, unsigned long range)
2457 : : {
2458 [ - + ]: 934988 : if (!PAGE_ALIGNED(start)) {
2459 : 0 : range -= PAGE_ALIGN(start) - start;
2460 : : start = PAGE_ALIGN(start);
2461 : : }
2462 : :
2463 [ - + ]: 934988 : if (start > ULONG_MAX - range)
2464 : 0 : range = ULONG_MAX - start;
2465 : :
2466 : 934988 : range >>= PAGE_SHIFT;
2467 : :
2468 [ + + ]: 934988 : if (range == 0)
2469 : : return start;
2470 : :
2471 : 934996 : return start + (get_random_long() % range << PAGE_SHIFT);
2472 : : }
2473 : :
2474 : : /* Interface for in-kernel drivers of true hardware RNGs.
2475 : : * Those devices may produce endless random bits and will be throttled
2476 : : * when our pool is full.
2477 : : */
2478 : 0 : void add_hwgenerator_randomness(const char *buffer, size_t count,
2479 : : size_t entropy)
2480 : : {
2481 : : struct entropy_store *poolp = &input_pool;
2482 : :
2483 [ # # ]: 0 : if (unlikely(crng_init == 0)) {
2484 : 0 : crng_fast_load(buffer, count);
2485 : 0 : return;
2486 : : }
2487 : :
2488 : : /* Suspend writing if we're above the trickle threshold.
2489 : : * We'll be woken up again once below random_write_wakeup_thresh,
2490 : : * or when the calling thread is about to terminate.
2491 : : */
2492 [ # # # # : 0 : wait_event_interruptible(random_write_wait, kthread_should_stop() ||
# # # # #
# ]
2493 : : ENTROPY_BITS(&input_pool) <= random_write_wakeup_bits);
2494 : 0 : mix_pool_bytes(poolp, buffer, count);
2495 : 0 : credit_entropy_bits(poolp, entropy);
2496 : : }
2497 : : EXPORT_SYMBOL_GPL(add_hwgenerator_randomness);
2498 : :
2499 : : /* Handle random seed passed by bootloader.
2500 : : * If the seed is trustworthy, it would be regarded as hardware RNGs. Otherwise
2501 : : * it would be regarded as device data.
2502 : : * The decision is controlled by CONFIG_RANDOM_TRUST_BOOTLOADER.
2503 : : */
2504 : 0 : void add_bootloader_randomness(const void *buf, unsigned int size)
2505 : : {
2506 : : if (IS_ENABLED(CONFIG_RANDOM_TRUST_BOOTLOADER))
2507 : : add_hwgenerator_randomness(buf, size, size * 8);
2508 : : else
2509 : 0 : add_device_randomness(buf, size);
2510 : 0 : }
2511 : : EXPORT_SYMBOL_GPL(add_bootloader_randomness);
|
