News for hackers. Stuff that matters.
Re:/dev/random – a new approach by tptacek on Sunday April 24, 2016 @06:31PM (#11561668)
This proposed design comprehensively ratifies Linux's nonsensical legacy random/urandom division; for instance, it maintains a "512 bit emergency entropy level" in case urandom becomes "stressed". It appears to be motivated principally by concerns about the quality of entropy being fed continually into the LRNG --- which is a nonproblem.

This is silly.

There are three problems a kernel CSPRNG needs to address:

1. It needs to seed itself reliably and not provide output when it's not securely seeded.

2. It needs to re-key itself regularly to provide forward secrecy and recovery from attacks.

3. It needs to be performant enough to be used in applications to the exclusion of all other RNGs.

That's it. Once problem (1) is addressed, there is never again for the uptime of the system a concern about the quality or "level" of entropy in the LRNG. DRBGs like this document proposes are effectively stream ciphers (in fact: Salsa20, the new hotness in bulk cipher designs, is essentially a hash DRBG --- and, in the BSDs, a [crappy] stream cipher was the RNG). "Entropy" keys the cipher. The idea that you can "run low" on entropy is the same as the idea that you can "run low" on key. No.

Kernel CSPRNGs do need continually updated entropy pools. But not because their original entropy is depleted! Rather: you want your RNG to be updated so that its "key" changes regularly, so that if your system is compromised transiently, you'll recover.

And, of course, the division between /dev/random and /dev/urandom sabotages goal (3) --- arguably the most important goal. Almost every time you've read about some crypto randomness catastrophe --- from Debian commenting out their RNG and reducing SSH key space to 16 bits, to Bitcoin wallets coughing up private keys by repeating nonces --- you've been reading about userspace RNG failures. People use userspace RNGs because they think the kernel RNG is too slow. And they think the kernel RNG is too slow because they use /dev/random, which obstinately refuses to provide output when --- wait, I'm not dignifying /dev/random: it refuses to provide output at random.

Re:/dev/random – a new approach by sillysaurus3 on Sunday April 24, 2016 @07:46PM (#11561862)
A kernel CSPRNG needs to:

1. Seed itself reliably.

2. Do nothing unless seeded.

3. Re-seed itself regularly, for forward secrecy.

4. Have good performance.

How difficult is #1? It's as simple as gathering 128 bits of entropy. If you have 128 bits, you an expand them into an infinite sequence of random numbers, securely, forever.

I think this is the essence of your comment. The topic is important, so it's worth being clear.

Re:/dev/random – a new approach by xorcist on Monday April 25, 2016 @03:56AM (#11562999)
It used to be a real problem in virtual environments. That's why they all have special drivers for randomness now.
Re:/dev/random – a new approach by Natanael_L on Monday April 25, 2016 @06:00AM (#11563322)
Yup, mass cloning a VM is really bad if you rely on stream ciphers for communication over the Internet and you do not instantly reseed. Suddenly you'll have tons of identical keystreams otherwise, making plaintext recovery trivial.

Your VM host simply must instantly inject unique entropy into each VM guest instantly on creation, duplication and start. Otherwise you're breaking your own security.

Re:/dev/random – a new approach by xorcist on Monday April 25, 2016 @06:59AM (#11563468)
It also makes #2 above hard in practice. You simply don't know when to block. That's one of the reasons Linux developers are, shall we say, conservative with regards to the entropy pool.

On a recent Linux environment those problems are solved however. Use proper random drivers for your virtualized environment and use getrandom() in your application.

Re:/dev/random – a new approach by infogulch on Monday April 25, 2016 @10:43AM (#11564474)
Could the host set a 'dirty entropy' flag whenever it creates/duplicates/starts a new VM? The VM could then watch for this flag and reseed when it notices.
Re:/dev/random – a new approach by Natanael_L on Monday April 25, 2016 @11:27AM (#11564826)
The solution in use now is that the guest OS asks the VM host for entropy using its VM guest specific kernel drivers, to seed the CSPRNG of the guest. If you have it do that on every guest RNG request you'll get the same desired effect without adding more communication.

When you duplicate any VM guest, all sensitive key material should be replaced instantly (preferably never copied to begin with, the host should generate and inject fresh key material).

Refilling the entropy pool alone isn't enough when reuse-insecure ciphers like stream ciphers are actively used, for the reasons stated above. Some ciphers are more tolerant of reuse (see AES-GCM vs AES-GCM-SIV).

Re:/dev/random – a new approach by kang on Monday April 25, 2016 @12:27AM (#11562520)
> If you have 128 bits, you an expand them into an infinite sequence of random numbers, securely, forever.

How? And why 128 only?

Re:/dev/random – a new approach by jcranmer on Monday April 25, 2016 @02:17AM (#11562736)
Think of a CSPRNG as encrypting a simple incrementing counter with, say, AES using a random key (this is in fact one of the ways you can build a CSPRNG). A CSPRNG function that's not weak is basically equivalent in strength that has n bits of entropy is then basically equivalent to a cipher with that many bits of key.

The acceptable safe maximum length isn't quite infinite, it's basically 2^64 rounds (not necessarily bits or bytes) for 128 bits of entropy. But that's basically arbitrarily long in practice as anyone cares.

Re:/dev/random – a new approach by benkuykendall on Monday April 25, 2016 @01:55AM (#11562676)
A psuedorandom generator G(x) can expand n random bits to n+1 psuedorandom bits that still "look random" to any efficient program that sees them. The existence of such a G that is efficiently computable is hard to prove (at least as hard as P!=NP) but there are many reasonable functions we theorize to have this property.

So with original entropy x, evaluate G(x) => x', c. Output the random bits c and repeat with x = x'. The sequence of c is psuedorandom.

k=128 is the key length of the generator. We define an efficient program to be one that runs in some time polynomial in k. How big of a k you need is based on how powerful computers are at present.

Re:/dev/random – a new approach by aortega on Monday April 25, 2016 @03:06AM (#11562859)
128 bits is widely considered a "big enough number" that a exhaustive search even on the fastest computers today will require an unthinkable amount of resources (time and power). It's the threshold for "secure" algorithms.
Re:/dev/random – a new approach by JdeBP on Thursday April 28, 2016 @06:29AM (#11587699)
"unthinkable" is not really the right word. "impracticable", perhaps.
Re:/dev/random – a new approach by oconnor663 on Monday April 25, 2016 @06:38PM (#11567957)
One way to think about producing random bits is to just imagine encrypting a large file full of zeros. If you use a good cipher, the result should look totally random. (And if it's not totally random, you have a bad cipher.)

So then the question becomes, what's the largest file you can encrypt with a single key? And the answer is any file you want. There's practically no size limit when you're encrypting files.

128 bits is usually the minimum recommended key size, not because of anything to do with the amount of randomness you can produce, but because you always have worry about an attacker guessing your key by brute force. Brute forcing a key is the same as just trying all possible keys to find one that works. (If there's another way to brute force the key, again you have a bad cipher.) We can estimate how big a key needs to be by looking at the fastest computers that exist: https://en.wikipedia.org/wiki/Supercomputer The fastest computer in the world does something like 2^55 operations per second. There are 2^25 seconds in a year, so if we generously assume that checking a key is just one operation, then a supercomputer like that could check about 2^80 keys per year. 128 is just the first nice power of 2 that's much larger than 80.

Re:/dev/random – a new approach by tptacek on Tuesday April 26, 2016 @04:36PM (#11575416)
There technically is a size limit --- and, for some constructions (like GCM), the size limit is potentially meaningful. But it's (a) enormous and (b) irrelevant, because the LRNG rekeys itself regularly. You can't extract random bytes from /dev/urandom fast enough to beat rekeying.
Re:/dev/random – a new approach by stingraycharles on Monday April 25, 2016 @02:21AM (#11562745)
The same way as any other cryptographic algorithm does that, e.g. RSA.
Re:/dev/random – a new approach by wolf550e on Monday April 25, 2016 @11:17AM (#11564746)
RSA is not used to encrypt large messages. Symmetric ciphers are used for this. With classic RSA, the secret key for the symmetric cipher is encrypted using RSA.

Often (e.g. in the Signal protocol), a short secret key is extended using a HKDF (RFC 5869) to create enough bits for a symmetric key and an IV or a nonce (and a MAC key if needed).

So for randomness, take 128 bits, use HKDF to extend to 192 bits, use 128 bits of output as AES-128 key, use next 64 bits of output as nonce, use 64 bits counter, produce AES-128(key, nonce||counter) for every value of counter until it overflows as randomness. 2^64 of 2^4 byte blocks is 2^68 bytes of randomness - enough for most purposes. An Intel chip will produce it at 1GB/sec per core.

Re:/dev/random – a new approach by merb on Monday April 25, 2016 @07:13AM (#11563504)
The question is more how to make 'Have good performance' and 'good crypto'. It's mostly a tradeoff.
Re:/dev/random – a new approach by Xylakant on Monday April 25, 2016 @07:41AM (#11563593)
"Good performance" needs to be on par or better with any userspace RNG. It's great if it's better but as long as there's an implementation that is on par with userspace there's no reason to write userspace RNGs at least from the performance perspective.

Though there will still be people doing it for various reasons, one of them "because we can".

Re:/dev/random – a new approach by haberman on Sunday April 24, 2016 @07:33PM (#11561831)
Is there a difference between re-seeding and re-keying?

I think of this analogy: you re-key/re-seed periodically not because the originally lock gets weaker, but in case someone stole your key without you knowing. Accurate?

Re:/dev/random – a new approach by tptacek on Sunday April 24, 2016 @07:37PM (#11561842)
Pretty much yes.
Re:/dev/random – a new approach by aidenn0 on Sunday April 24, 2016 @07:49PM (#11561869)
Has anybody made a set of patches to give linux the BSD behavior (block until seeded, then never block again)? I run into issues with /dev/random regularly and while I can patch every single application, that feels like playing whack-a-mole compared to patching the kernel.
Re:/dev/random – a new approach by ryuuchin on Sunday April 24, 2016 @10:51PM (#11562331)
The solution (currently sans kernel patching) is to just seed /dev/urandom yourself at system startup to avoid the issue of it not being seeded. Don't most distro's do this anyway?

After that it's just down to using /dev/urandom[1] or the getrandom syscall (which is the same as using /dev/urandom). Also the getrandom syscall actually has the behavior you're talking about.

[1] http://sockpuppet.org/blog/2014/02/25/safely-generate-random...

Re:/dev/random – a new approach by aidenn0 on Monday April 25, 2016 @01:54PM (#11565970)
The point is that I run one kernel but dozens of applications; I feel like I'm playing application whack-a-mole trying to patch the applications, when I could just patch the kernel.
Re:/dev/random – a new approach by marvy on Monday April 25, 2016 @07:29PM (#11568224)
It seems that you're just complaining that some applications read from /dev/random, but you wish they would read from /dev/urandom. If I understand you correctly, then it seems there exists a simple solution. (Disclaimer: I don't use Linux, or any other Unix. I may not know what I'm talking about.)

  mv /dev/random /dev/badrandom
  ln -s /dev/random /dev/urandom # is this the right syntax?
Or something like that?
Re:/dev/random – a new approach by ryuuchin on Monday April 25, 2016 @10:09PM (#11568943)
I'm not sure it's that simple. Someone mentioned a solution somewhere in this thread relating to if you're using udev. It still won't give you the block until seeded behavior but my post gave the solution to that (seed it yourself at system start (which most distro's may already do)). It should be possible to give /dev/random the same behavior as /dev/urandom I just haven't really looked into it.
Re:/dev/random – a new approach by dadrian on Sunday April 24, 2016 @10:40PM (#11562316)
The getrandom() system call does this. See http://man7.org/linux/man-pages/man2/getrandom.2.html
Re:/dev/random – a new approach by rwmj on Monday April 25, 2016 @05:15AM (#11563198)
Re:/dev/random – a new approach by nshepperd on Sunday April 24, 2016 @08:43PM (#11561985)
If you're using udev, you can configure it to make /dev/random a symlink to /dev/urandom (eg. [1]). Sadly that doesn't give you the "block until seeded" behaviour though, and I don't know of any kernel patch doing that yet.

1. http://superuser.com/questions/309840/how-can-i-point-dev-ra...

Re:/dev/random – a new approach by Natanael_L on Monday April 25, 2016 @05:54AM (#11563308)
You could make a script that prevents /dev/urandom from being made available until /r/random stops blocking, to then also simultaneously create that symlink.

Edit: on boot, first prevent access to /dev/urandom, then symlink it to /dev/random. Then as soon as /dev/random stops blocking, reverse the direction of the symlink. Same improved security, much simpler to use.

Re:/dev/random – a new approach by indolering on Monday April 25, 2016 @03:13PM (#11566544)
This would also quiet a lot of the noise around the entropy estimation blocking in `/dev/random`. I mean, if basically everyone [1] agrees that you should just use `/dev/urandom/` because blocking on entropy estimation is misguided, then why not copy the behavior of every other Unix?

[1]: http://www.2uo.de/myths-about-urandom/

Re:/dev/random – a new approach by raverbashing on Monday April 25, 2016 @05:00AM (#11563149)
Thinking out loud here:

1 - try to read from /dev/random.

2 - While 1 has not succeeded, wait and try again

3 - Once it has succeeded, read from /dev/urandom on next reads

Re:/dev/random – a new approach by loup-vaillant on Monday April 25, 2016 @05:45AM (#11563278)
I've heard that reading from /dev/random tends to "steal" entropy from /dev/urandom or something. I'm not sure. But if you only use urandom, you're safe. Here, from a quick search: http://sockpuppet.org/blog/2014/02/25/safely-generate-random... http://www.2uo.de/myths-about-urandom/
Re:/dev/random – a new approach by raverbashing on Monday April 25, 2016 @05:58AM (#11563315)
Then you came to a different conclusion than me, because the text say a lot of times to use urandom

There's no stealing with entropy. And once random returns a read the RNG is seeded, period.

Re:/dev/random – a new approach by loup-vaillant on Monday April 25, 2016 @06:42AM (#11563430)
My memories are foggy, unreliable, and out of date. I did say I was not sure…
Re:/dev/random – a new approach by Tomte on Sunday April 24, 2016 @08:51PM (#11562006)
Not to /dev/urandom, AFAIK. But at least they have the new getrandom syscall.
Re:/dev/random – a new approach by mindslight on Sunday April 24, 2016 @08:38PM (#11561971)
Practically yes. But as cryptosystem security is based on teasing out differences with respect to various oracles, bounding the security of every piece of cryptographic software to the kernel PRNG algorithm gives me the willies. The only saving grace is that the specific algorithm can be changed out with no worries of backwards incompatibility.

I agree the current implementation makes this distinction worthless, but it doesn't have to be. The biggest hurdle is that true entropy is scarce, and thus must be strictly partitioned between users.

A hardware RNG would solve this, but RDRAND not so much. I feel that if consumer hardware is being subverted by TLAs, the RNG would be the most likely avenue of attack. We may even eventually see partitioning of secure systems into deterministic/functional and non-deterministic parts, with the non-deterministic tape being saved for auditing.

Re:/dev/random – a new approach by tptacek on Sunday April 24, 2016 @08:46PM (#11561994)
Neither of your first two paragraphs are correct. I don't have an opinion about the last.

First: while I don't know what you mean by "teasing out differences with respect to various oracles", the fact that you have a kernel CSPRNG that your system relies on means that diversity in CSPRNGs is a bad thing. Simply: alternatives to the LRNG lead to multiple single points of failure.

Entropy is not "scarce". In fact, it's infinite and renewable. To generate a practically unbounded number of random bytes from just 16 bytes of starting state entropy, just use those 16 bytes as an AES key, and use it to encrypt an incrementing counter.

Re:/dev/random – a new approach by mindslight on Monday April 25, 2016 @12:31PM (#11565380)
I think my point is better made as such:

urandom only implements computational security, whereas random makes an attempt at information theoretic security (albeit an extremely poor one). Computational security is so practically useful that the difference between the two seems moot, but there still is a valid distinction.

Re:/dev/random – a new approach by tptacek on Monday April 25, 2016 @01:56PM (#11565985)
In the context of /dev/random, "information-theoretically secure" means "equivalent to a one-time pad". Anyone can look at the design of the LRNG and see that it's not that. So, no.
Re:/dev/random – a new approach by mindslight on Monday April 25, 2016 @02:40PM (#11566303)
Software engineering has a strong distinction between abstract model and concrete implementation, yes? The properties of the interface of /dev/random indicate an attempt at being information-theoretically secure. I've repeatedly disclaimed that I'm well aware the implementation falls well short of such.

To me, XOR using /dev/random should be usable for a true OTP [0] whereas XOR using /dev/urandom has the security of the effective stream cipher.

[0] (malleability disclaimer, lest you think I'm arguing for the practicalities of "OTP" or something)

Re:/dev/random – a new approach by mindslight on Sunday April 24, 2016 @08:57PM (#11562025)
A break of SHA1 (ie SHA1 preimage oracle) breaks u/random. This is less secure than something that is broken if SHA1 and SHA2 are broken. But since there are no known full breaks of either, this is "merely" hypothetical.

We can define our measure of entropy such that the output of AES (/SHA1) qualifies, or such that it does not. The way it is used in the random/urandom distinction, it's clearly not meant to include PRNG output.

Re:/dev/random – a new approach by tptacek on Sunday April 24, 2016 @09:49PM (#11562192)
random and urandom use the same cryptographic components, so if a break in SHA1 breaks urandom, it breaks /dev/random too.
Re:/dev/random – a new approach by mindslight on Sunday April 24, 2016 @09:58PM (#11562217)
Yes. As I said, the current implementation fails to live up to the distinction.

They should be completely partitioned pools, and collected entropy that goes out random should never be mixed into the urandom pool. Of course it's likely random still wants whitening, likely resulting in the use of a computationally-secure algorithm.

Practically since it's anyone's guess what the random clients expect, it's probably the right thing to `ln -f urandom random`. Bona fide hardware sources can come up with their own device/daemon to administer and/or stir into the kernel P/RNG. I'm just pointing out that there is a worthwhile distinction they were trying for, despite the engineering pitfalls of trying to make it available!

Re:/dev/random – a new approach by tptacek on Monday April 25, 2016 @01:56PM (#11565989)
I have no idea what you're trying to accomplished by these "partitioned pools". Sorry, you've lost me.
Re:/dev/random – a new approach by tmd83 on Monday April 25, 2016 @04:08AM (#11563024)
'Entropy doesn't get depleted' seems to be something that I have read in many places yet the Linux kernel dev doesn't seem to focus too much on that. Any reason for them missing the point?

It seems you would want to slowly change/update the entropy pool to protect against compromise. So can there be a worst-case situation (if you don't block - for the different reason) that your entropy pool is not updating fast enough to recover from compromise. Or the pool update requires so little entropy (compared to what linux is doing with kind of refilling it) that its almost impossible for that to matter?

Re:/dev/random – a new approach by Tomte on Monday April 25, 2016 @04:15AM (#11563038)
Ted T'so showed up here on HN in one of these discussions and derided any criticism as "ivory tower" and "academic".

OTOH, Kroah-Hartmann and Torvalds seemed to approve of my essay ("Myths about /dev/urandom"), so maybe not all hope is lost.

Still, let's not lose perspective here: the Linux random subsystem certainly has its flaws, but it is secure for all practical purposes. Just not convenient.

Re:/dev/random – a new approach by IgorPartola on Monday April 25, 2016 @09:34AM (#11564044)
Any insight as to why Linux is continuing to insist on taking the approach it has thus far?
Re:/dev/random – a new approach by thaumasiotes on Sunday April 24, 2016 @07:19PM (#11561803)
> wait, I'm not dignifying /dev/random: it refuses to provide output at random

Why would this be a problem? Read one byte from /dev/random, and observe one of 257 possible values chosen at random. :D

Re:/dev/random – a new approach by eru on Sunday April 24, 2016 @08:10PM (#11561922)
You'd have to correct for the biases. Not only in probability, but subsequent calls are also not independent.
Re:/dev/random – a new approach by thaumasiotes on Sunday April 24, 2016 @09:38PM (#11562148)
Sure, I realize that. (Although "subsequent calls are not independent" means it's not actually refusing to respond "at random".) I'm just pointing out in a facetious, emoticon-marked manner that "it behaves randomly" is kind of an odd insult to level against a source of randomness.
Re:/dev/random – a new approach by lomnakkus on Monday April 25, 2016 @01:47AM (#11562649)
I think the point is that it should behave predictably (but of course give you random data). Behavior is a "larger" concept than just what kind of data you get from a thing.
Re:/dev/random – a new approach by kzrdude on Monday April 25, 2016 @06:21AM (#11563380)
You can quite predictably drain dev/random and make it not respond randomly. in the 257-valued joke's terms, you can force it to always emit the blocking behavior.
Re:/dev/random – a new approach by 4ad on Monday April 25, 2016 @06:02AM (#11563328)
Why are you posting this here instead of the Linux mailing list?
Re:/dev/random – a new approach by incompatible on Sunday April 24, 2016 @07:51PM (#11561870)
Interesting. Would the re-keying process require a source of fresh entropy, if it's to be non-deterministic?
Re:/dev/random – a new approach by tptacek on Sunday April 24, 2016 @07:56PM (#11561881)
No. Modern CSPRNGs based on DRBGs are relying on fundamental crypto building blocks like block ciphers and hashes. A single bit difference between the previous state and the new state after the addition of any entropy whatsoever completely scrambles the RNG state. Obviously, you're getting many more bits than one out of your regular updates from the entropy collection subsystem.
Re:/dev/random – a new approach by kevhito on Sunday April 24, 2016 @08:40PM (#11561980)
Well, maybe? If the purpose re-keying is to recover from a transient compromise, then a single bit isn't really sufficient, is it? If the attacker has completely recovered the old seed, they can recover the entire rng stream up to the point where the reseeding happens. The attacker would notice the new output doesn't match, and at that point can't the attacker simply (brute force) try mixing in a 0 or 1 bit to see which one matches the new output of the rng? Even a few bits wouldn't protect against a brute force simulation of the reseeding. It seems like re-seeding a few bits at a time is in fact worse than storing up, say, 128 bits of new entropy then reseeding all 128 bits at the same time. With small incremental reseeding, the attacker can brute force each small reseeding if they can observe the rng outputs.

Or is there something I'm not seeing about how reseeding works?

Re:/dev/random – a new approach by tomsmeding on Monday April 25, 2016 @02:43AM (#11562800)
That's one of the things that's mentioned in the paper: don't seed one bit at the time. Moral of this discussion (not of the paper) is that you should regularly reseed, but only when you can completely replace the seed with entropy, and don't worry about making users wait for randomness because it makes you look interesting.
Re:/dev/random – a new approach by tptacek on Sunday April 24, 2016 @08:47PM (#11561995)
I knew someone was going to say this. In fact, the last sentence of my comment was added in an edit after this rebuttal occurred to me. Yeah. Dunno. Definitely don't slowly permute your CSPRNG state one bit at a time.
Re:/dev/random – a new approach by aortega on Monday April 25, 2016 @03:02AM (#11562845)
>Kernel CSPRNGs do need continually updated entropy pools. But not because their original entropy is depleted! Rather: you want your RNG to be updated so that its "key" changes regularly, so that if your system is compromised transiently, you'll recover.

It's very unlikely that a compromise will be temporary. This situation "transient compromise" will never happen. Moreover, once a system is compromised, by definition you cannot trust it until replacing it from a known-good source or backup, at which point, you just start the CSRNG with new entropy.

No system should need or even attempt to recover from a transient compromise, you are just causing a false feeling of security.

Re:/dev/random – a new approach by ibotty on Monday April 25, 2016 @03:23AM (#11562893)
You don't necessarily know your rng is being attacked.

Rekeying frequently makes passive attacks way harder, so it makes sense to rekey as a often as you can.

Re:/dev/random – a new approach by aortega on Monday April 25, 2016 @05:59PM (#11567716)
What would be, for example, a passive attack against a CS-RNG?
Re:/dev/random – a new approach by Natanael_L on Tuesday April 26, 2016 @07:59AM (#11571061)
Sidechannel leaks against mobile devices.
Re:/dev/random – a new approach by indolering on Monday April 25, 2016 @03:28PM (#11566673)
How do you feel about his use of all interrupts?
Re:/dev/random – a new approach by ianmiers on Sunday April 24, 2016 @06:45PM (#11561712)
Linux RNGs: where refusing to XOR in additional hardware randomness into the output stream is not just a defensible opinion, but the dominant one.
Re:/dev/random – a new approach by ryuuchin on Sunday April 24, 2016 @10:43PM (#11562321)
Except they do use rdrand if supported. When the random function is called it does a SHA transform. The SHA state gets initialized with rdrand and then the kernel pool is mixed in. This avoids the theoretical issues with xoring rdrand directly into the output.

You should generally avoid xor when it comes to untrusted output such as rdrand since it could theoretically control what gets generated and as such could cancel out whatever you're xoring it with (or at least this is the claim AFAIK). It's better to mix it using some other method, e.g. hash or cipher[1].

[1] https://boringssl.googlesource.com/boringssl/+/master/crypto...

Re:/dev/random – a new approach by Natanael_L on Sunday April 24, 2016 @08:28PM (#11561951)
Refusing to XOR it in is sensible. That RNG hardware might know too much about your existing entropy pool (either malicious bias or design flaws). Rejecting to mix it in cryptographically is however dumb.