News for hackers. Stuff that matters.
Re:Android RNG Weakness Renders Bitcoin Wallets Insecure by cperciva on Sunday August 11, 2013 @02:52PM (#6195782)
you should use your OS's CSPRNG (here, /dev/random) to the exclusion of any other RNG

Bad advice. Use your OS's CSPRNG to get a seed, but work with your own PRNG (say, HMAC_DRBG) internally. Going to the OS every time you want a few bits is both very slow and makes it far easier for local attackers to see when you're using entropy.

Re:Android RNG Weakness Renders Bitcoin Wallets Insecure by tptacek on Sunday August 11, 2013 @03:19PM (#6195896)
Strongest possible disagree. For instance, the Debian OpenSSL bug was an entirely unforced error stemming from applications that chose to use Debian OpenSSL's terrible CSPRNG on top of the OS's CSPRNG. The local attacker scenario you're talking about is a theoretical risk when there are attackers running code in the same OS as your CSPRNG; a far more likely concrete flaw is, for instance, a SecureRandom implementation that allows developers to specify insecure seed values.

I'll go to bat on this disagreement. Don't use application-layer CSPRNGs. Use the one the OS provides, to the exclusion of alternatives.

Re:Android RNG Weakness Renders Bitcoin Wallets Insecure by cperciva on Sunday August 11, 2013 @11:11PM (#6197454)
Strongest possible disagree.

Ok, we disagree. It wouldn't be the first time. ;-)

the Debian OpenSSL bug was an entirely unforced error stemming from applications that chose to use Debian OpenSSL's terrible CSPRNG on top of the OS's CSPRNG

I think the biggest problem was that OpenSSL used OpenSSL's CSPRNG after Debian broke it. Having applications all open+read+close /dev/random is not going to prevent that.

a far more likely concrete flaw is, for instance, a SecureRandom implementation that allows developers to specify insecure seed values.

A SecureRandom implementation should not allow the application to provide seed values except as additional input. It should always seed itself from the operating system entropy source, with no option to disable that.

Aside from the issue of performance (which can be severe) and the timing information leakage to local spies, there's a very practical reason to avoid developers read from /dev/random:

  int fd;

  fd = open("/dev/random", O_RDONLY);
  read(fd, buf, buflen);
  close(fd);
I've seen this on a number of occasions, and it works perfectly fine... until your server gets busy, the kernel entropy pool runs down, and /dev/random returns a short read. At that point, all hell breaks loose. To me, this scenario alone is enough to tell developers to use a library's automatically seeded CSPRNG instead of reading from the kernel.
Re:Android RNG Weakness Renders Bitcoin Wallets Insecure by tptacek on Sunday August 11, 2013 @11:44PM (#6197548)
Linux random/urandom is supposed to prevent short-reads for exactly this reason. You raise an interesting point, but I'm not persuaded that the risk of quietly failing to read from the random device is greater than the risks of adopting an entire new CSPRNG to sit on top of the OS's CSPRNG.
Re:Android RNG Weakness Renders Bitcoin Wallets Insecure by cperciva on Monday August 12, 2013 @01:06AM (#6197741)
Linux random/urandom is supposed to prevent short-reads for exactly this reason.

Oh great, yet another way that Linux developers are going to write broken code because they think the whole unix world behaves like Linux...

Re:Android RNG Weakness Renders Bitcoin Wallets Insecure by tptacek on Monday August 12, 2013 @10:54AM (#6199518)
So then what you should do is write a "libpcap for randomness" that uses the best-practices method of getting randomness from the OS CSPRNG. On Linux it'll be just a couple lines; on BSD it'll be a few more lines for the "atomicio" equivalent read, and on WINAPI it'd set up and call CryptGenRandom.

There's value in having a uniform interface to all the different OS CSPRNGs.

What I'm saying isn't valuable is duplicative effort to build additional CSPRNG logic in the app layer. As we keep seeing, these app-layer CSPRNGs are additional single points of failure; they don't add defensive depth.

Re:Android RNG Weakness Renders Bitcoin Wallets Insecure by tedunangst on Monday August 12, 2013 @12:22PM (#6200018)
How is OpenSSL RAND_bytes not that uniform interface?
Re:Android RNG Weakness Renders Bitcoin Wallets Insecure by tptacek on Monday August 12, 2013 @12:35PM (#6200110)
OpenSSL provides its own CSPRNG. When that CSPRNG breaks, as it has in the past, no amount of careful validation of the OS CSPRNG helps you. The OpenSSL CSPRNG is thus a second single point of failure.
Re:Android RNG Weakness Renders Bitcoin Wallets Insecure by fulafel on Monday August 12, 2013 @07:45AM (#6198683)
The random/urandom devices do originate from Linux, other implementations should be careful about not making incompatible changes.
Re:Android RNG Weakness Renders Bitcoin Wallets Insecure by marshray on Sunday August 11, 2013 @03:53PM (#6196071)
The Debian OpenSSL bug was a result of Debian patching OpenSSL's RNG to make it utterly broken. Unless you're going to claim Debian couldn't have patched an equivalent bug into the kernel, you can't generalize this as support for the claim that kernel RNGs are inherently superior to library RNGs.
Re:Android RNG Weakness Renders Bitcoin Wallets Insecure by tptacek on Sunday August 11, 2013 @04:34PM (#6196223)
I'm saying the error was unforced because the effort the OpenSSL CSPRNG went through was duplicative.
Re:Android RNG Weakness Renders Bitcoin Wallets Insecure by marshray on Sunday August 11, 2013 @05:16PM (#6196367)
So your position is that Debian didn't go far enough?

They should have disabled OpenSSL's CSPRNG entirely and redirected its internal calls to perform IO operations on /dev/[u]random?

Re:Android RNG Weakness Renders Bitcoin Wallets Insecure by tptacek on Sunday August 11, 2013 @07:13PM (#6196734)
Modulo the fact that Debian shouldn't be mucking with the inner workings of packages in the first place, sure; stubbing out OpenSSL's CSPRNG with calls to the OS CSPRNG seems like a reasonable plan. It is, by the way, part of the NaCL design too.
Re:Android RNG Weakness Renders Bitcoin Wallets Insecure by marshray on Sunday August 11, 2013 @10:17PM (#6197317)
Last I heard, there were still some "security oriented" OSes using RC4 for their /dev/random.
Re:Android RNG Weakness Renders Bitcoin Wallets Insecure by tptacek on Sunday August 11, 2013 @11:26PM (#6197507)
arc4random predates modern OS CSPRNGs.
Re:Android RNG Weakness Renders Bitcoin Wallets Insecure by marshray on Sunday August 11, 2013 @11:49PM (#6197565)
So does OpenSSL. I think it's just not reasonable to expect a widely-portable crypto primitive and protocol library to judge the quality of the host /dev/[u]random and delegate to it. Of course, they seed from the host device and try to estimate the entropy it provides.

Even that OS with the biased /dev/[u]random using RC4 because it was fast would keep a separate RC4 state in each process' libc to avoid the overhead of kernel calls.

Re:Android RNG Weakness Renders Bitcoin Wallets Insecure by tptacek on Sunday August 11, 2013 @11:54PM (#6197575)
So then, you think NaCL's design decision to rely on /dev/urandom was a mistake?
Re:Android RNG Weakness Renders Bitcoin Wallets Insecure by marshray on Monday August 12, 2013 @12:15AM (#6197633)
I think if NaCL ever gets popular that design decision will bite somebody, somewhere, on some OS.

Our crypto libraries need to provide their own belt to wear with the OS-provided suspenders. Yes, I know about potential fork() bugs, but our modern VM-crazed deployments introduce that possibility at kernel level too. We need our good crypto implementers shipping good lightweight CSPRNGs, rather than the kernel developers who try to compensate with 6000 bit entropy pools.

Re:Android RNG Weakness Renders Bitcoin Wallets Insecure by tptacek on Monday August 12, 2013 @12:22AM (#6197649)
If some OS screws up urandom so much that it bites someone, it'll bite a huge number of different apps, and not just the ones that use NaCL. Like it or not, urandom has to work; all sorts of things depend on it. The urandom ship has sailed.

Meanwhile, better to have just one codebase to review, rather than 100 crappy ones, like the SecureRandom from Harmony.

Re:Android RNG Weakness Renders Bitcoin Wallets Insecure by marshray on Monday August 12, 2013 @12:37AM (#6197682)
OK, so NaCL will not be guilty and they will be in good company.

I'm sure these principles of minimal redundancy will be of great comfort to those users who get their private keys exposed.

Do you see the paradox here? Find me these developers who are undoubtedly competent to implement their own CSPRNG, but prefer not to. These are the folks I want implementing the CSPRNG that will be generating my keys, rather than kernel developers who find entropy pools exciting.

Re:Android RNG Weakness Renders Bitcoin Wallets Insecure by tptacek on Monday August 12, 2013 @12:41AM (#6197688)
You see my point, right? A lot of your security already depends on urandom working. Everyone knows this, and a lot of effort has gone into validating the kernel random driver (there have been some pretty good systems security papers on it). Given that you already depend on urandom, all a new CSPRNG gets most developers is a second single point of failure.
Re:Android RNG Weakness Renders Bitcoin Wallets Insecure by marshray on Monday August 12, 2013 @12:56AM (#6197720)
I get your point and I agree it's at least not a wrong way to look at it. But you say "the kernel random driver" as if there were only one for a crypto app developer to worry about.

We have already seen a huge number of bad keys generated. Is it that obvious at this point that kernel (and embedded system) developers are so much better at this than OpenSSL?

Is it possible that you just tend to look at more broken library and app crypto code during the course of your work? If you worked primarily with broken kernel crypto code, would you perhaps prefer (for your own use) a CSPRNG in a library written by your favorite experts?

Re:Android RNG Weakness Renders Bitcoin Wallets Insecure by tptacek on Monday August 12, 2013 @12:38PM (#6200132)
It is true that we see a lot of broken randomness code, and it is also true that we pay a lot of attention to failures of different CSPRNGs, but my point of view on this is also influenced by things like the design paper Daniel Bernstein wrote for Nacl.
Re:Android RNG Weakness Renders Bitcoin Wallets Insecure by marshray on Monday August 12, 2013 @04:19PM (#6201502)
I'll wager your team has reviewed more crypto code, and more recently, than DJB.

Meh, this conversation needed to be over

      do random_beverage(); while (self->is_conscious());
Re:Android RNG Weakness Renders Bitcoin Wallets Insecure by tptacek on Monday August 12, 2013 @06:24PM (#6202576)
Tell you what: I will ask DJB tonight and see what he says.
Re:Android RNG Weakness Renders Bitcoin Wallets Insecure by tedunangst on Sunday August 11, 2013 @05:40PM (#6196429)
This seems the complete opposite of your usual advice to use a library. You want every app developer to memorize the intricacies of which of random or urandom or srandom they should use on which OS and whether they need to worry about blocking or short reads and whether the entropy returned is good, or really good, or just good enough? You don't think people are going to dick that up? I'd trust the OpenSSL devs to figure this mess out before John Q. Random developer. Any day.
Re:Android RNG Weakness Renders Bitcoin Wallets Insecure by tptacek on Sunday August 11, 2013 @07:12PM (#6196727)
The OS already provides a library for securely generating random numbers. On Unix, that library is called "the random driver". Its interface is file-descriptor based.

You'd rather not be in a position to care about cryptographic randomness regardless. So, by all means, use high-level crypto libraries. But those libraries should also be using the random driver, instead of trying to bolt their own CSPRNG on top of it (or, god forbid, trying to avoid the random driver altogether).