random: use computational hash for entropy extraction, and related fixes
Subsystems (3)
Jason A. Donenfeld
maintainerv2 cover random: use computational hash for entropy extraction, and related fixes
The bulk of the motivation for this and description of crypto vulnerabilities is in the first patch of this series. The following two patches then fix up entropy accounting for the new model. The last patch fixes a minor code safety issue.
This v2 improves some documentation comments and unifies these patches into one patchset.
Jason A. Donenfeld (4):
random: use computational hash for entropy extraction
random: simplify entropy debiting
random: use linear min-entropy accumulation crediting
random: make credit_entropy_bits() always safe
drivers/char/random.c | 490 ++++++---------------------------- include/trace/events/random.h | 30 +-- 2 files changed, 87 insertions(+), 433 deletions(-)
Signature · 1 line
2.35.0
Jason A. Donenfeld
maintainerPATCH v2 1/4 random: use computational hash for entropy extraction
The current 4096-bit LFSR used for entropy collection had a few desirable attributes for the context in which it was created. For example, the state was huge, which meant that /dev/random would be able to output quite a bit of accumulated entropy before blocking. It was also, in its time, quite fast at accumulating entropy byte-by-byte, which matters given the varying contexts in which mix_pool_bytes() is called. And its diffusion was relatively high, which meant that changes would ripple across several words of state rather quickly.
However, it also suffers from a few security vulnerabilities. In particular, inputs learned by an attacker can be undone, but more over, if the state of the pool leaks, its contents can be controlled and entirely zeroed out. I've demonstrated this attack with this SMT2 script, <https://xn--4db.cc/5o9xO8pb>, which Boolector/CaDiCal solves in a matter of seconds on a single core of my laptop, resulting in little proof of concept C demonstrators such as <https://xn--4db.cc/jCkvvIaH/c>.
For basically all recent formal models of RNGs, these attacks represent a significant cryptographic flaw. But how does this manifest practically? If an attacker has access to the system to such a degree that he can learn the internal state of the RNG, arguably there are other lower hanging vulnerabilities -- side-channel, infoleak, or otherwise -- that might have higher priority. On the other hand, seed files are frequently used on systems that have a hard time generating much entropy on their own, and these seed files, being files, often leak or are duplicated and distributed accidentally, or are even seeded over the Internet intentionally, where their contents might be recorded or tampered with. Seen this way, an otherwise quasi-implausible vulnerability is a bit more practical than initially thought.
Another aspect of the current mix_pool_bytes() function is that, while its performance was arguably competitive for the time in which it was created, it's no longer considered so. This patch improves performance
significantly: on a high-end CPU, an i7-11850H, it improves performance of mix_pool_bytes() by 225%, and on a low-end CPU, a Cortex-A7, it improves performance by 103%.
This commit replaces the LFSR of mix_pool_bytes() with a straight- forward cryptographic hash function, BLAKE2s, which is already in use for pool extraction. Universal hashing with a secret seed was considered too, something along the lines of <https://eprint.iacr.org/2013/338>,
but the requirement for a secret seed makes for a chicken & egg problem. Instead we go with a formally proven scheme using a computational hash function, described in sections 5.1, 6.4, and B.1.8 of
<https://eprint.iacr.org/2019/198>.
BLAKE2s outputs 256 bits, which should give us an appropriate amount of min-entropy accumulation, and a wide enough margin of collision resistance against active attacks. mix_pool_bytes() becomes a simple call to blake2s_update(), for accumulation, while the extraction step becomes a blake2s_final() to generate a seed, with which we can then do a HKDF-like or BLAKE2X-like expansion, the first part of which we fold back as an init key for subsequent blake2s_update()s, and the rest we produce to the caller. This then is provided to our CRNG like usual. In that expansion step, we make opportunistic use of 32 bytes of RDRAND output, just as before. We also always reseed the crng with 32 bytes, unconditionally, or not at all, rather than sometimes with 16 as before, as we don't win anything by limiting beyond the 16 byte threshold.
Going for a hash function as an entropy collector is a conservative, proven approach. The result of all this is a much simpler and much less bespoke construction than what's there now, which not only plugs a vulnerability but also improves performance considerably.
--- drivers/char/random.c | 304 ++++++++---------------------------------- 1 file changed, 55 insertions(+), 249 deletions(-)
drivers/char/random.c +55 -249
@@ -42,61 +42,6 @@*/ /* -* (now, with legal B.S. out of the way.....) -* -* This routine gathers environmental noise from device drivers, etc., -* and returns good random numbers, suitable for cryptographic use. -* Besides the obvious cryptographic uses, these numbers are also good -* for seeding TCP sequence numbers, and other places where it is -* desirable to have numbers which are not only random, but hard to -* predict by an attacker. -* -* Theory of operation -* =================== -* -* Computers are very predictable devices. Hence it is extremely hard -* to produce truly random numbers on a computer --- as opposed to -* pseudo-random numbers, which can easily generated by using a -* algorithm. Unfortunately, it is very easy for attackers to guess -* the sequence of pseudo-random number generators, and for some -* applications this is not acceptable. So instead, we must try to -* gather "environmental noise" from the computer's environment, which -* must be hard for outside attackers to observe, and use that to -* generate random numbers. In a Unix environment, this is best done -* from inside the kernel. -* -* Sources of randomness from the environment include inter-keyboard -* timings, inter-interrupt timings from some interrupts, and other -* events which are both (a) non-deterministic and (b) hard for an -* outside observer to measure. Randomness from these sources are -* added to an "entropy pool", which is mixed using a CRC-like function. -* This is not cryptographically strong, but it is adequate assuming -* the randomness is not chosen maliciously, and it is fast enough that -* the overhead of doing it on every interrupt is very reasonable. -* As random bytes are mixed into the entropy pool, the routines keep -* an *estimate* of how many bits of randomness have been stored into -* the random number generator's internal state. -* -* When random bytes are desired, they are obtained by taking the BLAKE2s -* hash of the contents of the "entropy pool". The BLAKE2s hash avoids -* exposing the internal state of the entropy pool. It is believed to -* be computationally infeasible to derive any useful information -* about the input of BLAKE2s from its output. Even if it is possible to -* analyze BLAKE2s in some clever way, as long as the amount of data -* returned from the generator is less than the inherent entropy in -* the pool, the output data is totally unpredictable. For this -* reason, the routine decreases its internal estimate of how many -* bits of "true randomness" are contained in the entropy pool as it -* outputs random numbers. -* -* If this estimate goes to zero, the routine can still generate -* random numbers; however, an attacker may (at least in theory) be -* able to infer the future output of the generator from prior -* outputs. This requires successful cryptanalysis of BLAKE2s, which is -* not believed to be feasible, but there is a remote possibility. -* Nonetheless, these numbers should be useful for the vast majority -* of purposes. -* * Exported interfaces ---- output * =============================== *
@@ -298,23 +243,6 @@* * mknod /dev/random c 1 8 * mknod /dev/urandom c 1 9 -* -* Acknowledgements: -* ================= -* -* Ideas for constructing this random number generator were derived -* from Pretty Good Privacy's random number generator, and from private -* discussions with Phil Karn. Colin Plumb provided a faster random -* number generator, which speed up the mixing function of the entropy -* pool, taken from PGPfone. Dale Worley has also contributed many -* useful ideas and suggestions to improve this driver. -* -* Any flaws in the design are solely my responsibility, and should -* not be attributed to the Phil, Colin, or any of authors of PGP. -* -* Further background information on this topic may be obtained from -* RFC 1750, "Randomness Recommendations for Security", by Donald -* Eastlake, Steve Crocker, and Jeff Schiller. */ #define pr_fmt (fmt) KBUILD_MODNAME ": " fmt
@@ -358,79 +286,15 @@/* #define ADD_INTERRUPT_BENCH */ -/* -* If the entropy count falls under this number of bits, then we -* should wake up processes which are selecting or polling on write -* access to /dev/random. -*/ -static int random_write_wakeup_bits =28 * (1 <<5 ); - -/* -* Originally, we used a primitive polynomial of degree .poolwords -* over GF(2). The taps for various sizes are defined below. They -* were chosen to be evenly spaced except for the last tap, which is 1 -* to get the twisting happening as fast as possible. -* -* For the purposes of better mixing, we use the CRC-32 polynomial as -* well to make a (modified) twisted Generalized Feedback Shift -* Register. (See M. Matsumoto & Y. Kurita, 1992. Twisted GFSR -* generators. ACM Transactions on Modeling and Computer Simulation -* 2(3):179-194. Also see M. Matsumoto & Y. Kurita, 1994. Twisted -* GFSR generators II. ACM Transactions on Modeling and Computer -* Simulation 4:254-266) -* -* Thanks to Colin Plumb for suggesting this. -* -* The mixing operation is much less sensitive than the output hash, -* where we use BLAKE2s. All that we want of mixing operation is that -* it be a good non-cryptographic hash; i.e. it not produce collisions -* when fed "random" data of the sort we expect to see. As long as -* the pool state differs for different inputs, we have preserved the -* input entropy and done a good job. The fact that an intelligent -* attacker can construct inputs that will produce controlled -* alterations to the pool's state is not important because we don't -* consider such inputs to contribute any randomness. The only -* property we need with respect to them is that the attacker can't -* increase his/her knowledge of the pool's state. Since all -* additions are reversible (knowing the final state and the input, -* you can reconstruct the initial state), if an attacker has any -* uncertainty about the initial state, he/she can only shuffle that -* uncertainty about, but never cause any collisions (which would -* decrease the uncertainty). -* -* Our mixing functions were analyzed by Lacharme, Roeck, Strubel, and -* Videau in their paper, "The Linux Pseudorandom Number Generator -* Revisited" (see: http://eprint.iacr.org/2012/251.pdf). In their -* paper, they point out that we are not using a true Twisted GFSR, -* since Matsumoto & Kurita used a trinomial feedback polynomial (that -* is, with only three taps, instead of the six that we are using). -* As a result, the resulting polynomial is neither primitive nor -* irreducible, and hence does not have a maximal period over -* GF(2**32). They suggest a slight change to the generator -* polynomial which improves the resulting TGFSR polynomial to be -* irreducible, which we have made here. -*/ enum poolinfo { -POOL_WORDS =128 , -POOL_WORDMASK =POOL_WORDS -1 , -POOL_BYTES =POOL_WORDS *sizeof (u32), -POOL_BITS =POOL_BYTES *8 , +POOL_BITS =BLAKE2S_HASH_SIZE *8 ,POOL_BITSHIFT =ilog2 (POOL_BITS ),/* To allow fractional bits to be tracked, the entropy_count field is * denominated in units of 1/8th bits. */ POOL_ENTROPY_SHIFT =3 ,#define POOL_ENTROPY_BITS() (input_pool.entropy_count >> POOL_ENTROPY_SHIFT) - POOL_FRACBITS = POOL_BITS << POOL_ENTROPY_SHIFT, - -/* x^128 + x^104 + x^76 + x^51 +x^25 + x + 1 */ -POOL_TAP1 =104 , -POOL_TAP2 =76 , -POOL_TAP3 =51 , -POOL_TAP4 =25 , -POOL_TAP5 =1 , - -EXTRACT_SIZE =BLAKE2S_HASH_SIZE /2 + POOL_FRACBITS = POOL_BITS << POOL_ENTROPY_SHIFT };/*
@@ -438,6 +302,12 @@ enum poolinfo {*/ static DECLARE_WAIT_QUEUE_HEAD (random_write_wait);static struct fasync_struct *fasync; +/* +* If the entropy count falls under this number of bits, then we +* should wake up processes which are selecting or polling on write +* access to /dev/random. +*/ +static int random_write_wakeup_bits =POOL_BITS *3 /4 ;static DEFINE_SPINLOCK (random_ready_list_lock);static LIST_HEAD (random_ready_list);
@@ -493,73 +363,31 @@ MODULE_PARM_DESC(ratelimit_disable, "Disable random ratelimit suppression");* **********************************************************************/ -static u32 input_pool_data[POOL_WORDS] __latent_entropy; -static struct { +struct blake2s_state hash;spinlock_t lock; -u16 add_ptr; -u16 input_rotate;int entropy_count; } input_pool = { + .hash.h = {BLAKE2S_IV0 ^ (0x01010000 |BLAKE2S_HASH_SIZE ), +BLAKE2S_IV1 ,BLAKE2S_IV2 ,BLAKE2S_IV3 ,BLAKE2S_IV4 , +BLAKE2S_IV5 ,BLAKE2S_IV6 ,BLAKE2S_IV7 }, + .hash.outlen =BLAKE2S_HASH_SIZE , .lock =__SPIN_LOCK_UNLOCKED (input_pool.lock), }; -static ssize_t extract_entropy (void *buf,size_t nbytes,int min); -static ssize_t _extract_entropy (void *buf,size_t nbytes); +static bool extract_entropy (void *buf,size_t nbytes,int min); +static void _extract_entropy (void *buf,size_t nbytes);static void crng_reseed (struct crng_state *crng,bool use_input_pool); -static const u32 twist_table[8 ] = { -0x00000000 ,0x3b6e20c8 ,0x76dc4190 ,0x4db26158 , -0xedb88320 ,0xd6d6a3e8 ,0x9b64c2b0 ,0xa00ae278 }; -/* * This function adds bytes into the entropy "pool". It does not * update the entropy estimate. The caller should call * credit_entropy_bits if this is appropriate. -* -* The pool is stirred with a primitive polynomial of the appropriate -* degree, and then twisted. We twist by three bits at a time because -* it's cheap to do so and helps slightly in the expected case where -* the entropy is concentrated in the low-order bits. */ static void _mix_pool_bytes (const void *in,int nbytes) { -unsigned long i; -int input_rotate; -const u8 *bytes = in; -u32 w; - - input_rotate = input_pool.input_rotate; - i = input_pool.add_ptr; - -/* mix one byte at a time to simplify size handling and churn faster */ -while (nbytes--) { - w =rol32 (*bytes++, input_rotate); - i = (i -1 ) &POOL_WORDMASK ; - -/* XOR in the various taps */ - w ^= input_pool_data[i]; - w ^= input_pool_data[(i +POOL_TAP1 ) &POOL_WORDMASK ]; - w ^= input_pool_data[(i +POOL_TAP2 ) &POOL_WORDMASK ]; - w ^= input_pool_data[(i +POOL_TAP3 ) &POOL_WORDMASK ]; - w ^= input_pool_data[(i +POOL_TAP4 ) &POOL_WORDMASK ]; - w ^= input_pool_data[(i +POOL_TAP5 ) &POOL_WORDMASK ]; - -/* Mix the result back in with a twist */ - input_pool_data[i] = (w >>3 ) ^ twist_table[w &7 ]; - -/* -* Normally, we add 7 bits of rotation to the pool. -* At the beginning of the pool, add an extra 7 bits -* rotation, so that successive passes spread the -* input bits across the pool evenly. -*/ - input_rotate = (input_rotate + (i ?7 :14 )) &31 ; - } - - input_pool.input_rotate = input_rotate; - input_pool.add_ptr = i; +blake2s_update (&input_pool.hash, in, nbytes); }static void __mix_pool_bytes (const void *in,int nbytes)
@@ -953,15 +781,14 @@ static int crng_slow_load(const u8 *cp, size_t len)static void crng_reseed (struct crng_state *crng,bool use_input_pool) {unsigned long flags; -int i, num; +int i;union {u8 block[CHACHA_BLOCK_SIZE ];u32 key[8 ]; } buf;if (use_input_pool) { - num =extract_entropy (&buf,32 ,16 ); -if (num ==0 ) +if (!extract_entropy (&buf,32 ,16 ))return ; }else {_extract_crng (&primary_crng, buf.block);
@@ -1329,74 +1156,48 @@ static size_t account(size_t nbytes, int min) }/* -* This function does the actual extraction for extract_entropy. -* -* Note: we assume that .poolwords is a multiple of 16 words. +* This is an HKDF-like construction for using the hashed collected entropy +* as a PRF key, that's then expanded block-by-block. */ -static void extract_buf (u8 *out) +static void _extract_entropy (void *buf,size_t nbytes) { -struct blake2s_state state__aligned(__alignof__(unsigned long)) ; -u8 hash[BLAKE2S_HASH_SIZE ]; -unsigned long *salt;unsigned long flags; - -blake2s_init (&state,sizeof (hash)); - -/* -* If we have an architectural hardware random number -* generator, use it for BLAKE2's salt & personal fields. -*/ -for (salt = (unsigned long *)&state.h[4 ]; - salt < (unsigned long *)&state.h[8 ]; ++salt) { -unsigned long v; -if (!arch_get_random_long (&v)) -break ; - *salt ^= v; +u8 seed[BLAKE2S_HASH_SIZE ], next_key[BLAKE2S_HASH_SIZE ]; +struct { +unsigned long rdrand[32 /sizeof (long )]; +size_t counter; + } block; +size_t i; + +for (i =0 ; i <ARRAY_SIZE (block.rdrand); ++i) { +if (!arch_get_random_long (&block.rdrand[i])) + block.rdrand[i] =random_get_entropy (); } -/* Generate a hash across the pool */ spin_lock_irqsave (&input_pool.lock, flags); -blake2s_update (&state, (const u8 *)input_pool_data,POOL_BYTES ); -blake2s_final (&state, hash);/* final zeros out state */ -/* -* We mix the hash back into the pool to prevent backtracking -* attacks (where the attacker knows the state of the pool -* plus the current outputs, and attempts to find previous -* outputs), unless the hash function can be inverted. By -* mixing at least a hash worth of hash data back, we make -* brute-forcing the feedback as hard as brute-forcing the -* hash. -*/ -__mix_pool_bytes (hash,sizeof (hash)); -spin_unlock_irqrestore (&input_pool.lock, flags); +/* seed = HASHPRF(last_key, entropy_input) */ +blake2s_final (&input_pool.hash, seed); -/* Note that EXTRACT_SIZE is half of hash size here, because above -* we've dumped the full length back into mixer. By reducing the -* amount that we emit, we retain a level of forward secrecy. -*/ -memcpy (out, hash,EXTRACT_SIZE ); -memzero_explicit (hash,sizeof (hash)); -} +/* next_key = HASHPRF(key, RDRAND || 0) */ + block.counter =0 ; +blake2s (next_key, (u8 *)&block, seed,sizeof (next_key),sizeof (block),sizeof (seed)); +blake2s_init_key (&input_pool.hash,BLAKE2S_HASH_SIZE , next_key,sizeof (next_key)); -static ssize_t _extract_entropy (void *buf,size_t nbytes) -{ -ssize_t ret =0 , i; -u8 tmp[EXTRACT_SIZE ]; +spin_unlock_irqrestore (&input_pool.lock, flags); +memzero_explicit (next_key,sizeof (next_key));while (nbytes) { -extract_buf (tmp); - i =min_t (int, nbytes,EXTRACT_SIZE ); -memcpy (buf, tmp, i); + i =min_t (size_t, nbytes,BLAKE2S_HASH_SIZE ); +/* output = HASHPRF(key, RDRAND || ++counter) */ + ++block.counter; +blake2s (buf, (u8 *)&block, seed, i,sizeof (block),sizeof (seed)); nbytes -= i; buf += i; - ret += i; } -/* Wipe data just returned from memory */ -memzero_explicit (tmp,sizeof (tmp)); - -return ret; +memzero_explicit (seed,sizeof (seed)); +memzero_explicit (&block,sizeof (block)); }/*
@@ -1404,13 +1205,18 @@ static ssize_t _extract_entropy(void *buf, size_t nbytes)* returns it in a buffer. * * The min parameter specifies the minimum amount we can pull before -* failing to avoid races that defeat catastrophic reseeding. +* failing to avoid races that defeat catastrophic reseeding. If we +* have less than min entropy available, we return false and buf is +* not filled. */ -static ssize_t extract_entropy (void *buf,size_t nbytes,int min) +static bool extract_entropy (void *buf,size_t nbytes,int min) {trace_extract_entropy (nbytes,POOL_ENTROPY_BITS (), _RET_IP_); - nbytes =account (nbytes, min); -return _extract_entropy (buf, nbytes); +if (account (nbytes, min)) { +_extract_entropy (buf, nbytes); +return true; + } +return false; }#define warn_unseeded_randomness (previous) \
@@ -1674,7 +1480,7 @@ static void __init init_std_data(void)unsigned long rv;mix_pool_bytes (&now,sizeof (now)); -for (i =POOL_BYTES ; i >0 ; i -=sizeof (rv)) { +for (i =BLAKE2S_BLOCK_SIZE ; i >0 ; i -=sizeof (rv)) {if (!arch_get_random_seed_long (&rv) && !arch_get_random_long (&rv)) rv =random_get_entropy ();
Signature · 1 line
2.35.0
Re: [PATCH v2 1/4] random: use computational hash for entropy extraction
Am Fri, Feb 04, 2022 at 02:53:22PM +0100 schrieb Jason A. Donenfeld:
Quoted 46 lines
The current 4096-bit LFSR used for entropy collection had a few desirable attributes for the context in which it was created. For example, the state was huge, which meant that
/dev/randomwould be able to output quite a bit of accumulated entropy before blocking. It was also, in its time, quite fast at accumulating entropy byte-by-byte, which matters given the varying contexts in whichmix_pool_bytes()is called. And its diffusion was relatively high, which meant that changes would ripple across several words of state rather quickly.However, it also suffers from a few security vulnerabilities. In particular, inputs learned by an attacker can be undone, but more over, if the state of the pool leaks, its contents can be controlled and entirely zeroed out. I've demonstrated this attack with this SMT2 script, <https://xn--4db.cc/5o9xO8pb>, which Boolector/CaDiCal solves in a matter of seconds on a single core of my laptop, resulting in little proof of concept C demonstrators such as <https://xn--4db.cc/jCkvvIaH/c>.
For basically all recent formal models of RNGs, these attacks represent a significant cryptographic flaw. But how does this manifest practically? If an attacker has access to the system to such a degree that he can learn the internal state of the RNG, arguably there are other lower hanging vulnerabilities -- side-channel, infoleak, or otherwise -- that might have higher priority. On the other hand, seed files are frequently used on systems that have a hard time generating much entropy on their own, and these seed files, being files, often leak or are duplicated and distributed accidentally, or are even seeded over the Internet intentionally, where their contents might be recorded or tampered with. Seen this way, an otherwise quasi-implausible vulnerability is a bit more practical than initially thought.
Another aspect of the current
mix_pool_bytes()function is that, while its performance was arguably competitive for the time in which it was created, it's no longer considered so. This patch improves performance
significantly: on a high-end CPU, an i7-11850H, it improves performance ofmix_pool_bytes()by 225%, and on a low-end CPU, a Cortex-A7, it improves performance by 103%.This commit replaces the LFSR of
mix_pool_bytes()with a straight- forward cryptographic hash function, BLAKE2s, which is already in use for pool extraction. Universal hashing with a secret seed was considered too, something along the lines of <https://eprint.iacr.org/2013/338>,
but the requirement for a secret seed makes for a chicken & egg problem. Instead we go with a formally proven scheme using a computational hash function, described in sections 5.1, 6.4, and B.1.8 of
<https://eprint.iacr.org/2019/198>.
Quoted 9 lines
BLAKE2s outputs 256 bits, which should give us an appropriate amount of min-entropy accumulation, and a wide enough margin of collision resistance against active attacks.
mix_pool_bytes()becomes a simple call toblake2s_update(), for accumulation, while the extraction step becomes ablake2s_final()to generate a seed, with which we can then do a HKDF-like or BLAKE2X-like expansion, the first part of which we fold back as an init key for subsequent blake2s_update()s, and the rest we produce to the caller. This then is provided to our CRNG like usual. In that expansion step, we make opportunistic use of 32 bytes of RDRAND
Why are we only using RDRAND here, and not RDSEED?
Thanks,
Dominik
Jason A. Donenfeld
maintainerRe: [PATCH v2 1/4] random: use computational hash for entropy extraction
Quoted 1 line · Dominik Brodowski
Why are we only using RDRAND here, and not RDSEED?
Simply because that's what was already used here; I didn't revisit the old decision. It seems like any changes there should be made in a separate patch with its own justification. If you think there's good rationale, free to send that.
Part of why these changes are so gradual is because much of random.c isn't my code originally. Were it mine, I'd presumably know all my various rationales and be able to rapidly think within them and reevaluate. But because that's not the case, I find that I'm spending a lot of time trying to reconstruct the original rationales of its authors. IOW, rather than saying, "I don't get this, must be bad," I'm trying to do a little bit of archeology to at least make sure I know what I'm disagreeing with, if I even disagree at all. That's time consuming in part, but also is part of doing things evolutionarily.
With regards to RDRAND vs RDSEED, just off the top of my head -- I'm writing this email on my phone -- I think extract_entropy/extract_buf used to be used as part of /dev/random's blocking stream, which ostensibly could mean more frequent calls, once every 10 bytes IIRC. Nowadays it's only called once every 5 minutes (per numa node), so maybe RDSEED could make sense? Or maybe there are other reasons to unearth, or none at all. We'll have to look and see.
Jason
Jason A. Donenfeld
maintainerRe: [PATCH v2 1/4] random: use computational hash for entropy extraction
Quoted 1 line · Jason A. Donenfeld
Nowadays it's only called once every 5 minutes (per numa
Period, not per node.
Jason A. Donenfeld
maintainerRe: [PATCH v2 1/4] random: use computational hash for entropy extraction
Hey Dominik,
I just noticed that we use RDSEED in crng_reseed(). I would think we could remove that and stick to having RDSEED used in extract entropy as you suggested. I'm now pretty sure the older decision boiled down to the 10 bytes vs 5 minutes thing, as discussed before. So please feel free to send a patch doing just this.
Jason
Jason A. Donenfeld
maintainerPATCH v2 2/4 random: simplify entropy debiting
In reply to Jason A. DonenfeldOur pool is 256 bits, and we only ever use all of it or don't use it at all, which is decided by whether or not it has 128 bits in it. So we can drastically simplify the accounting and cmpxchg loop to do exactly this. While we're at it, we move the minimum bit size into a constant so it can be shared between the two places where it matters.
The reason we want any of this is for the case in which an attacker has compromised the current state, and then bruteforces small amounts of entropy added to it. By demanding a particular minimum amount of entropy be present before reseeding, we make that bruteforcing difficult.
Note that this rationale no longer includes anything about /dev/random blocking at the right moment, since /dev/random no longer blocks (except for at ~boot), but rather uses the crng. In a former life, /dev/random was different and therefore required a more nuanced account(), but this is no longer.
Behaviorally, nothing changes here. This is just a simplification of the code.
--- drivers/char/random.c | 91 ++++++++--------------------------- include/trace/events/random.h | 30 +++--------- 2 files changed, 27 insertions(+), 94 deletions(-)
drivers/char/random.c +21 -70
@@ -289,12 +289,14 @@enum poolinfo {POOL_BITS =BLAKE2S_HASH_SIZE *8 ,POOL_BITSHIFT =ilog2 (POOL_BITS ), +POOL_MIN_BITS =POOL_BITS /2 ,/* To allow fractional bits to be tracked, the entropy_count field is * denominated in units of 1/8th bits. */ POOL_ENTROPY_SHIFT =3 ,#define POOL_ENTROPY_BITS() (input_pool.entropy_count >> POOL_ENTROPY_SHIFT) - POOL_FRACBITS = POOL_BITS << POOL_ENTROPY_SHIFT + POOL_FRACBITS = POOL_BITS << POOL_ENTROPY_SHIFT, +POOL_MIN_FRACBITS =POOL_MIN_BITS <<POOL_ENTROPY_SHIFT };/*
@@ -375,8 +377,7 @@ static struct { .lock = __SPIN_LOCK_UNLOCKED(input_pool.lock), }; -static bool extract_entropy (void *buf,size_t nbytes,int min); -static void _extract_entropy (void *buf,size_t nbytes); +static void extract_entropy (void *buf,size_t nbytes);static void crng_reseed (struct crng_state *crng,bool use_input_pool);
@@ -467,7 +468,7 @@ static void process_random_ready_list(void)*/ static void credit_entropy_bits (int nbits) { -int entropy_count, entropy_bits, orig; +int entropy_count, orig;int nfrac = nbits <<POOL_ENTROPY_SHIFT ;/* Ensure that the multiplication can avoid being 64 bits wide. */
@@ -527,8 +528,7 @@ static void credit_entropy_bits(int nbits)trace_credit_entropy_bits (nbits, entropy_count >>POOL_ENTROPY_SHIFT , _RET_IP_); - entropy_bits = entropy_count >>POOL_ENTROPY_SHIFT ; -if (crng_init <2 && entropy_bits >=128 ) +if (crng_init <2 && entropy_count >=POOL_MIN_FRACBITS )crng_reseed (&primary_crng, true); }
@@ -618,7 +618,7 @@ static void crng_initialize_secondary(struct crng_state *crng)static void __init crng_initialize_primary (void ) { -_extract_entropy (&primary_crng.state[4 ],sizeof (u32) *12 ); +extract_entropy (&primary_crng.state[4 ],sizeof (u32) *12 );if (crng_init_try_arch_early () && trust_cpu && crng_init <2 ) {invalidate_batched_entropy ();numa_crng_init ();
@@ -788,8 +788,17 @@ static void crng_reseed(struct crng_state *crng, bool use_input_pool) } buf;if (use_input_pool) { -if (!extract_entropy (&buf,32 ,16 )) -return ; +int entropy_count; +do { + entropy_count =READ_ONCE (input_pool.entropy_count); +if (entropy_count <POOL_MIN_FRACBITS ) +return ; + }while (cmpxchg (&input_pool.entropy_count, entropy_count,0 ) != entropy_count); +extract_entropy (buf.key,sizeof (buf.key)); +if (random_write_wakeup_bits) { +wake_up_interruptible (&random_write_wait); +kill_fasync (&fasync,SIGIO ,POLL_OUT ); + } }else {_extract_crng (&primary_crng, buf.block); _crng_backtrack_protect(&primary_crng, buf.block,
@@ -1114,52 +1123,11 @@ EXPORT_SYMBOL_GPL(add_disk_randomness);* *********************************************************************/ -/* -* This function decides how many bytes to actually take from the -* given pool, and also debits the entropy count accordingly. -*/ -static size_t account (size_t nbytes,int min) -{ -int entropy_count, orig; -size_t ibytes, nfrac; - -BUG_ON (input_pool.entropy_count >POOL_FRACBITS ); - -/* Can we pull enough? */ -retry: - entropy_count = orig =READ_ONCE (input_pool.entropy_count); -if (WARN_ON (entropy_count <0 )) { -pr_warn ("negative entropy count: count %d\n" , entropy_count); - entropy_count =0 ; - } - -/* never pull more than available */ - ibytes =min_t (size_t, nbytes, entropy_count >> (POOL_ENTROPY_SHIFT +3 )); -if (ibytes < min) - ibytes =0 ; - nfrac = ibytes << (POOL_ENTROPY_SHIFT +3 ); -if ((size_t )entropy_count > nfrac) - entropy_count -= nfrac; -else - entropy_count =0 ; - -if (cmpxchg (&input_pool.entropy_count, orig, entropy_count) != orig) - goto retry; - -trace_debit_entropy (8 * ibytes); -if (ibytes &&POOL_ENTROPY_BITS () < random_write_wakeup_bits) { -wake_up_interruptible (&random_write_wait); -kill_fasync (&fasync,SIGIO ,POLL_OUT ); - } - -return ibytes; -} -/* * This is an HKDF-like construction for using the hashed collected entropy * as a PRF key, that's then expanded block-by-block. */ -static void _extract_entropy (void *buf,size_t nbytes) +static void extract_entropy (void *buf,size_t nbytes) {unsigned long flags;u8 seed[BLAKE2S_HASH_SIZE ], next_key[BLAKE2S_HASH_SIZE ];
@@ -1169,6 +1137,8 @@ static void _extract_entropy(void *buf, size_t nbytes) } block;size_t i; +trace_extract_entropy (nbytes,POOL_ENTROPY_BITS ()); +for (i =0 ; i <ARRAY_SIZE (block.rdrand); ++i) {if (!arch_get_random_long (&block.rdrand[i])) block.rdrand[i] =random_get_entropy ();
@@ -1200,25 +1170,6 @@ static void _extract_entropy(void *buf, size_t nbytes)memzero_explicit (&block,sizeof (block)); } -/* -* This function extracts randomness from the "entropy pool", and -* returns it in a buffer. -* -* The min parameter specifies the minimum amount we can pull before -* failing to avoid races that defeat catastrophic reseeding. If we -* have less than min entropy available, we return false and buf is -* not filled. -*/ -static bool extract_entropy (void *buf,size_t nbytes,int min) -{ -trace_extract_entropy (nbytes,POOL_ENTROPY_BITS (), _RET_IP_); -if (account (nbytes, min)) { -_extract_entropy (buf, nbytes); -return true; - } -return false; -} -#define warn_unseeded_randomness (previous) \ _warn_unseeded_randomness(__func__, (void *)_RET_IP_, (previous))
include/trace/events/random.h +6 -24
@@ -79,22 +79,6 @@ TRACE_EVENT(credit_entropy_bits, __entry->bits, __entry->entropy_count, (void *)__entry->IP) ); -TRACE_EVENT (debit_entropy, - TP_PROTO(int debit_bits), - -TP_ARGS ( debit_bits), - -TP_STRUCT__entry ( -__field ( int, debit_bits ) - ), - -TP_fast_assign ( - __entry->debit_bits = debit_bits; - ), - -TP_printk ("input pool: debit_bits %d" , __entry->debit_bits) -); - TRACE_EVENT(add_input_randomness, TP_PROTO(int input_bits),
@@ -161,31 +145,29 @@ DEFINE_EVENT(random__get_random_bytes, get_random_bytes_arch, );DECLARE_EVENT_CLASS (random__extract_entropy, - TP_PROTO(int nbytes, int entropy_count, unsigned long IP), + TP_PROTO(int nbytes, int entropy_count), -TP_ARGS (nbytes, entropy_count,IP ), +TP_ARGS (nbytes, entropy_count),TP_STRUCT__entry ( __field( int, nbytes )__field ( int, entropy_count ) - __field(unsigned long, IP ) ),TP_fast_assign ( __entry->nbytes = nbytes; __entry->entropy_count = entropy_count; - __entry->IP = IP; ), -TP_printk ("input pool: nbytes %d entropy_count %d caller %pS" , - __entry->nbytes, __entry->entropy_count, (void *)__entry->IP) +TP_printk ("input pool: nbytes %d entropy_count %d" , + __entry->nbytes, __entry->entropy_count) );DEFINE_EVENT (random__extract_entropy, extract_entropy, - TP_PROTO(int nbytes, int entropy_count, unsigned long IP), + TP_PROTO(int nbytes, int entropy_count), -TP_ARGS (nbytes, entropy_count,IP ) +TP_ARGS (nbytes, entropy_count) ); TRACE_EVENT(urandom_read,
Signature · 1 line
2.35.0
Re: [PATCH v2 2/4] random: simplify entropy debiting
Am Fri, Feb 04, 2022 at 02:53:23PM +0100 schrieb Jason A. Donenfeld:
Quoted 2 lines
Our pool is 256 bits, and we only ever use all of it or don't use it at all, which is decided by whether or not it has 128 bits in it. So we can
"has at least"
Quoted 15 lines
drastically simplify the accounting and cmpxchg loop to do exactly this. While we're at it, we move the minimum bit size into a constant so it can be shared between the two places where it matters.
The reason we want any of this is for the case in which an attacker has compromised the current state, and then bruteforces small amounts of entropy added to it. By demanding a particular minimum amount of entropy be present before reseeding, we make that bruteforcing difficult.
Note that this rationale no longer includes anything about
/dev/randomblocking at the right moment, since/dev/randomno longer blocks (except for at ~boot), but rather uses the crng. In a former life,/dev/randomwas different and therefore required a more nuancedaccount(), but this is no longer.
Quoted 7 lines
Behaviorally, nothing changes here. This is just a simplification of the code.
Cc Theodore Ts'o <[email protected]>Cc Dominik Brodowski <[email protected]>Cc Greg Kroah-Hartman <[email protected]>Signed-off-by Jason A. Donenfeld <[email protected]>
Thanks,
Dominik
Jason A. Donenfeld
maintainerPATCH v2 3/4 random: use linear min-entropy accumulation crediting
In reply to Jason A. Donenfeld30e37ec516ae ("random: account for entropy loss due to overwrites") assumed that adding new entropy to the LFSR pool probabilistically cancelled out old entropy there, so entropy was credited asymptotically, approximating Shannon entropy of independent sources (rather than a stronger min-entropy notion) using 1/8th fractional bits and replacing a constant 2-2/√𝑒 term (~0.786938) with 3/4 (0.75) to slightly underestimate it. This wasn't superb, but it was perhaps better than nothing, so that's what was done. Which entropy specifically was being cancelled out and how much precisely each time is hard to tell, though as I showed with the attack code in my previous commit, a motivated adversary with sufficient information can actually cancel out everything.
Since we're no longer using an LFSR for entropy accumulation, this probabilistic cancellation is no longer relevant. Rather, we're now using a computational hash function as the accumulator and we've switched to working in the random oracle model, from which we can now revisit the question of min-entropy accumulation, which is done in detail in <https://eprint.iacr.org/2019/198>.
Consider a long input bit string that is built by concatenating various smaller independent input bit strings. Each one of these inputs has a designated min-entropy, which is what we're passing to credit_entropy_bits(h). When we pass the concatenation of these to a random oracle, it means that an adversary trying to receive back the same reply as us would need to become certain about each part of the concatenated bit string we passed in, which means becoming certain about all of those h values. That means we can estimate the accumulation by simply adding up the h values in calls to credit_entropy_bits(h); there's no probabilistic cancellation at play like there was said to be for the LFSR. Incidentally, this is also what other entropy accumulators based on computational hash functions do as well.
So this commit replaces credit_entropy_bits(h) with essentially total = min(POOL_BITS, total + h), done with a cmpxchg loop as before.
What if we're wrong and the above is nonsense? It's not, but let's assume we don't want the actual _behavior_ of the code to change much. Currently that behavior is not extracting from the input pool until it has 128 bits of entropy in it. With the old algorithm, we'd hit that magic 128 number after roughly 256 calls to credit_entropy_bits(1). So, we can retain more or less the old behavior by waiting to extract from the input pool until it hits 256 bits of entropy using the new code. For people concerned about this change, it means that there's not that much practical behavioral change. And for folks actually trying to model the behavior rigorously, it means that we have an even higher margin against attacks.
--- drivers/char/random.c | 112 +++++++----------------------------------- 1 file changed, 19 insertions(+), 93 deletions(-)
drivers/char/random.c +19 -93
@@ -286,17 +286,9 @@/* #define ADD_INTERRUPT_BENCH */ -enum poolinfo { +enum {POOL_BITS =BLAKE2S_HASH_SIZE *8 , -POOL_BITSHIFT =ilog2 (POOL_BITS ), -POOL_MIN_BITS =POOL_BITS /2 , - -/* To allow fractional bits to be tracked, the entropy_count field is -* denominated in units of 1/8th bits. */ -POOL_ENTROPY_SHIFT =3 , -#define POOL_ENTROPY_BITS() (input_pool.entropy_count >> POOL_ENTROPY_SHIFT) - POOL_FRACBITS = POOL_BITS << POOL_ENTROPY_SHIFT, -POOL_MIN_FRACBITS =POOL_MIN_BITS <<POOL_ENTROPY_SHIFT +POOL_MIN_BITS =POOL_BITS /* No point in settling for less. */ };/*
@@ -469,66 +461,18 @@ static void process_random_ready_list(void)static void credit_entropy_bits (int nbits) {int entropy_count, orig; -int nfrac = nbits <<POOL_ENTROPY_SHIFT ; - -/* Ensure that the multiplication can avoid being 64 bits wide. */ -BUILD_BUG_ON (2 * (POOL_ENTROPY_SHIFT +POOL_BITSHIFT ) >31 );if (!nbits)return ; -retry: - entropy_count = orig =READ_ONCE (input_pool.entropy_count); -if (nfrac <0 ) { -/* Debit */ - entropy_count += nfrac; - }else { -/* -* Credit: we have to account for the possibility of -* overwriting already present entropy. Even in the -* ideal case of pure Shannon entropy, new contributions -* approach the full value asymptotically: -* -* entropy <- entropy + (pool_size - entropy) * -* (1 - exp(-add_entropy/pool_size)) -* -* For add_entropy <= pool_size/2 then -* (1 - exp(-add_entropy/pool_size)) >= -* (add_entropy/pool_size)*0.7869... -* so we can approximate the exponential with -* 3/4*add_entropy/pool_size and still be on the -* safe side by adding at most pool_size/2 at a time. -* -* The use of pool_size-2 in the while statement is to -* prevent rounding artifacts from making the loop -* arbitrarily long; this limits the loop to log2(pool_size)*2 -* turns no matter how large nbits is. -*/ -int pnfrac = nfrac; -const int s =POOL_BITSHIFT +POOL_ENTROPY_SHIFT +2 ; -/* The +2 corresponds to the /4 in the denominator */ - -do { -unsigned int anfrac =min (pnfrac,POOL_FRACBITS /2 ); -unsigned int add = - ((POOL_FRACBITS - entropy_count) * anfrac *3 ) >> s; - - entropy_count += add; - pnfrac -= anfrac; - }while (unlikely (entropy_count <POOL_FRACBITS -2 && pnfrac)); - } - -if (WARN_ON (entropy_count <0 )) { -pr_warn ("negative entropy/overflow: count %d\n" , entropy_count); - entropy_count =0 ; - }else if (entropy_count >POOL_FRACBITS ) - entropy_count =POOL_FRACBITS ; -if (cmpxchg (&input_pool.entropy_count, orig, entropy_count) != orig) - goto retry; +do { + entropy_count = orig =READ_ONCE (input_pool.entropy_count); + entropy_count =min (POOL_BITS , entropy_count + nbits); + }while (cmpxchg (&input_pool.entropy_count, orig, entropy_count) != orig); -trace_credit_entropy_bits (nbits, entropy_count >>POOL_ENTROPY_SHIFT , _RET_IP_); +trace_credit_entropy_bits (nbits, entropy_count, _RET_IP_); -if (crng_init <2 && entropy_count >=POOL_MIN_FRACBITS ) +if (crng_init <2 && entropy_count >=POOL_MIN_BITS )crng_reseed (&primary_crng, true); }
@@ -791,7 +735,7 @@ static void crng_reseed(struct crng_state *crng, bool use_input_pool)int entropy_count;do { entropy_count =READ_ONCE (input_pool.entropy_count); -if (entropy_count <POOL_MIN_FRACBITS ) +if (entropy_count <POOL_MIN_BITS )return ; }while (cmpxchg (&input_pool.entropy_count, entropy_count,0 ) != entropy_count);extract_entropy (buf.key,sizeof (buf.key));
@@ -1014,7 +958,7 @@ void add_input_randomness(unsigned int type, unsigned int code, last_value = value;add_timer_randomness (&input_timer_state, (type <<4 ) ^ code ^ (code >>4 ) ^ value); -trace_add_input_randomness (POOL_ENTROPY_BITS ()); +trace_add_input_randomness (input_pool.entropy_count); }EXPORT_SYMBOL_GPL (add_input_randomness);
@@ -1112,7 +1056,7 @@ void add_disk_randomness(struct gendisk *disk)return ;/* first major is 1, so we get >= 0x200 here */ add_timer_randomness (disk->random,0x100 +disk_devt (disk)); - trace_add_disk_randomness(disk_devt(disk), POOL_ENTROPY_BITS()); + trace_add_disk_randomness(disk_devt(disk), input_pool.entropy_count); }EXPORT_SYMBOL_GPL (add_disk_randomness);#endif
@@ -1137,7 +1081,7 @@ static void extract_entropy(void *buf, size_t nbytes) } block;size_t i; -trace_extract_entropy (nbytes,POOL_ENTROPY_BITS ()); +trace_extract_entropy (nbytes, input_pool.entropy_count);for (i =0 ; i <ARRAY_SIZE (block.rdrand); ++i) {if (!arch_get_random_long (&block.rdrand[i]))
@@ -1486,9 +1430,9 @@ static ssize_t urandom_read_nowarn(struct file *file, char __user *buf, {int ret; - nbytes =min_t (size_t, nbytes,INT_MAX >> (POOL_ENTROPY_SHIFT +3 )); + nbytes =min_t (size_t, nbytes,INT_MAX >>6 ); ret =extract_crng_user (buf, nbytes); -trace_urandom_read (8 * nbytes,0 ,POOL_ENTROPY_BITS ()); +trace_urandom_read (8 * nbytes,0 , input_pool.entropy_count);return ret; }
@@ -1527,7 +1471,7 @@ static __poll_t random_poll(struct file *file, poll_table *wait) mask =0 ;if (crng_ready ()) mask |=EPOLLIN |EPOLLRDNORM ; -if (POOL_ENTROPY_BITS () < random_write_wakeup_bits) +if (input_pool.entropy_count < random_write_wakeup_bits) mask |=EPOLLOUT |EPOLLWRNORM ;return mask; }
@@ -1582,8 +1526,7 @@ static long random_ioctl(struct file *f, unsigned int cmd, unsigned long arg)switch (cmd) {case RNDGETENTCNT :/* inherently racy, no point locking */ - ent_count =POOL_ENTROPY_BITS (); -if (put_user (ent_count, p)) +if (put_user (input_pool.entropy_count, p))return -EFAULT ;return 0 ;case RNDADDTOENTCNT :
@@ -1734,23 +1677,6 @@ static int proc_do_uuid(struct ctl_table *table, int write, void *buffer,return proc_dostring (&fake_table, write, buffer, lenp, ppos); } -/* -* Return entropy available scaled to integral bits -*/ -static int proc_do_entropy (struct ctl_table *table,int write,void *buffer, -size_t *lenp,loff_t *ppos) -{ -struct ctl_table fake_table; -int entropy_count; - - entropy_count = *(int *)table->data >>POOL_ENTROPY_SHIFT ; - - fake_table.data = &entropy_count; - fake_table.maxlen =sizeof (entropy_count); - -return proc_dointvec (&fake_table, write, buffer, lenp, ppos); -} -static int sysctl_poolsize =POOL_BITS ;extern struct ctl_table random_table[];struct ctl_table random_table[] = {
@@ -1763,10 +1689,10 @@ struct ctl_table random_table[] = { }, { .procname = "entropy_avail", + .data = &input_pool.entropy_count, .maxlen = sizeof(int), .mode = 0444, - .proc_handler = proc_do_entropy, - .data = &input_pool.entropy_count, + .proc_handler = proc_dointvec, }, { .procname = "write_wakeup_threshold",
@@ -1962,7 +1888,7 @@ void add_hwgenerator_randomness(const char *buffer, size_t count,*/ wait_event_interruptible_timeout (random_write_wait, !system_wq ||kthread_should_stop () || -POOL_ENTROPY_BITS () <= random_write_wakeup_bits, + input_pool.entropy_count <= random_write_wakeup_bits,CRNG_RESEED_INTERVAL );mix_pool_bytes (buffer, count);credit_entropy_bits (entropy);
Signature · 1 line
2.35.0
Re: [PATCH v2 3/4] random: use linear min-entropy accumulation crediting
Quoted 11 lines · Jason A. Donenfeld
What if we're wrong and the above is nonsense? It's not, but let's assume we don't want the actual _behavior_ of the code to change much. Currently that behavior is not extracting from the input pool until it has 128 bits of entropy in it. With the old algorithm, we'd hit that magic 128 number after roughly 256 calls to
credit_entropy_bits(1). So, we can retain more or less the old behavior by waiting to extract from the input pool until it hits 256 bits of entropy using the new code. For people concerned about this change, it means that there's not that much practical behavioral change. And for folks actually trying to model the behavior rigorously, it means that we have an even higher margin against attacks.
I tested this, and it actually was 205 calls prior to patch 1 in this series, and 267 calls after patch 1. That's in contrast to 256 calls after this patch. Not a big difference, but this is going to result in ~25% more single-bit calls being needed compared to the old version. It's unclear whether you're arguing that's basically the same, or whether you thought it was a smaller difference.
drivers/char/random.c line 292
Quoted 13 lines
drivers/char/random.c +2
-9+enum {POOL_BITS =BLAKE2S_HASH_SIZE *8 , -POOL_BITSHIFT =ilog2 (POOL_BITS ), -POOL_MIN_BITS =POOL_BITS /2 , - -/* To allow fractional bits to be tracked, the entropy_count field is -* denominated in units of 1/8th bits. */ -POOL_ENTROPY_SHIFT =3 , -#define POOL_ENTROPY_BITS() (input_pool.entropy_count >> POOL_ENTROPY_SHIFT) -POOL_FRACBITS =POOL_BITS <<POOL_ENTROPY_SHIFT , - POOL_MIN_FRACBITS = POOL_MIN_BITS << POOL_ENTROPY_SHIFT +POOL_MIN_BITS =POOL_BITS /* No point in settling for less. */ };
Doesn't the default value of random_write_wakeup_bits need to be increased to this value? Otherwise, the pool can get stuck with entropy_count greater than or equal to random_write_wakeup_bits (192) but less than POOL_MIN_BITS (256).
In fact, the only correct value of random_write_wakeup_bits will be 256, i.e. the entire pool. Perhaps it should no longer be configurable via /proc/sys? Note that there's also an off-by one bug that will need to be fixed:add_hwgenerator_randomness() checks entropy_count <= random_write_wakeup_bits rather than entropy_count < random_write_wakeup_bits as random_poll() does.
Also: given all these considerations, perhaps the increase in POOL_MIN_BITS is best done in a separate patch?
drivers/char/random.c static void process_random_ready_list(void) · line 471
Quoted 4 lines
drivers/char/random.c +4
-0+do { + entropy_count = orig =READ_ONCE (input_pool.entropy_count); + entropy_count =min (POOL_BITS , entropy_count + nbits); + }while (cmpxchg (&input_pool.entropy_count, orig, entropy_count) != orig);
This can be simplified slightly:
do {
orig = READ_ONCE(input_pool.entropy_count);
entropy_count = min(POOL_BITS, orig + nbits);
} while (cmpxchg(&input_pool.entropy_count, orig, entropy_count) != orig);- Eric
Jason A. Donenfeld
maintainerRe: [PATCH v2 3/4] random: use linear min-entropy accumulation crediting
Hi Eric,
Quoted 5 lines · Eric Biggers
I tested this, and it actually was 205 calls prior to patch 1 in this series, and 267 calls after patch 1. That's in contrast to 256 calls after this patch. Not a big difference, but this is going to result in ~25% more single-bit calls being needed compared to the old version. It's unclear whether you're arguing that's basically the same, or whether you thought it was a smaller difference.
My argument is that we're not _decreasing_ the security in any substantive way with this change.
Quoted 3 lines
Doesn't the default value of
random_write_wakeup_bitsneed to be increased to this value? Otherwise, the pool can get stuck withentropy_countgreater than or equal torandom_write_wakeup_bits(192) but less thanPOOL_MIN_BITS(256).
Good catch, thanks.
Quoted 2 lines
In fact, the only correct value of
random_write_wakeup_bitswill be 256, i.e. the entire pool. Perhaps it should no longer be configurable via/proc/sys?
I think so, yea. I'll change up in an add-on commit.
Quoted 3 lines
Note that there's also an off-by one bug that will need to be fixed:
add_hwgenerator_randomness()checksentropy_count<=random_write_wakeup_bitsrather thanentropy_count<random_write_wakeup_bitsasrandom_poll()does.
Thanks.
Quoted 11 lines
drivers/char/random.c static void process_random_ready_list(void) · line 471
Quoted 4 lines
drivers/char/random.c +4
-0+do { + entropy_count = orig =READ_ONCE (input_pool.entropy_count); + entropy_count =min (POOL_BITS , entropy_count + nbits); + }while (cmpxchg (&input_pool.entropy_count, orig, entropy_count) != orig);This can be simplified slightly:
do { orig = READ_ONCE(input_pool.entropy_count); entropy_count = min(POOL_BITS, orig + nbits); } while (cmpxchg(&input_pool.entropy_count, orig, entropy_count) != orig);
That looks nicer indeed. Will do.
Thanks for your comments.
Jason
Jason A. Donenfeld
maintainerPATCH v2 4/4 random: make credit_entropy_bits() always safe
In reply to Jason A. DonenfeldThis is called from various hwgenerator drivers, so rather than having one "safe" version for userspace and one "unsafe" version for the kernel, just make everything safe; the checks are cheap and sensible to have anyway.
--- drivers/char/random.c | 29 +++++++++-------------------- 1 file changed, 9 insertions(+), 20 deletions(-)
drivers/char/random.c +9 -20
@@ -453,18 +453,15 @@ static void process_random_ready_list(void)spin_unlock_irqrestore (&random_ready_list_lock, flags); } -/* -* Credit (or debit) the entropy store with n bits of entropy. -* Use credit_entropy_bits_safe() if the value comes from userspace -* or otherwise should be checked for extreme values. -*/ static void credit_entropy_bits (int nbits) {int entropy_count, orig; -if (!nbits) +if (nbits <=0 )return ; + nbits =min (nbits,POOL_BITS ); + do { entropy_count = orig = READ_ONCE(input_pool.entropy_count); entropy_count = min(POOL_BITS, entropy_count + nbits);
@@ -476,18 +473,6 @@ static void credit_entropy_bits(int nbits)crng_reseed (&primary_crng, true); } -static int credit_entropy_bits_safe (int nbits) -{ -if (nbits <0 ) -return -EINVAL ; - -/* Cap the value to avoid overflows */ - nbits =min (nbits,POOL_BITS ); - -credit_entropy_bits (nbits); -return 0 ; -} -/********************************************************************* * * CRNG using CHACHA20
@@ -1534,7 +1519,10 @@ static long random_ioctl(struct file *f, unsigned int cmd, unsigned long arg)return -EPERM ;if (get_user (ent_count, p))return -EFAULT ; -return credit_entropy_bits_safe (ent_count); +if (ent_count <0 ) +return -EINVAL ; +credit_entropy_bits (ent_count); +return 0 ;case RNDADDENTROPY :if (!capable (CAP_SYS_ADMIN ))return -EPERM ;
@@ -1547,7 +1535,8 @@ static long random_ioctl(struct file *f, unsigned int cmd, unsigned long arg) retval =write_pool ((const char __user *)p, size);if (retval <0 )return retval; -return credit_entropy_bits_safe (ent_count); +credit_entropy_bits (ent_count); +return 0 ;case RNDZAPENTCNT :case RNDCLEARPOOL :/*
Signature · 1 line
2.35.0
Re: [PATCH v2 4/4] random: make credit_entropy_bits() always safe
Am Fri, Feb 04, 2022 at 02:53:25PM +0100 schrieb Jason A. Donenfeld:
Quoted 8 lines
This is called from various hwgenerator drivers, so rather than having one "safe" version for userspace and one "unsafe" version for the kernel, just make everything safe; the checks are cheap and sensible to have anyway.
Cc Dominik Brodowski <[email protected]>Reported-by Sultan Alsawaf <[email protected]>Signed-off-by Jason A. Donenfeld <[email protected]>
Thanks,
Dominik