[1] http://www.theguardian.com/business/2009/may/18/digital-cont...
And I wouldn't put it past them to have an attack (at least theorectical) that exploits this
So if they write that there's a vulnerability after reading 2^80 bytes - that's great! We're secure. If they write that you must ensure to do something after 2^80 bytes - that's complete bullshit.
However, remember when attacks to 3DES, MD5 were only theoretical?
Also, you may not even need to read 2^80 bytes, there might be a (future) vulnerability that allows you to shortcut this.
If you can break reality, all bets are off though and trying to defend against attacks that break reality in the future are impossible.
Now, if someone found a lower limit based on exploiting some weakness in the random number generation, the analogy with 3DES and MD5 would make more sense.
But there seems to be smarter attacks (ref 21) https://en.wikipedia.org/wiki/Triple_DES#Security
My point is that even if today some sizes and lengths seem only of theoretical concern, tomorrow there might be a vulnerability, a new approach to the problem, or even natural technological evolution that might turn it into a practical attack (even when it seems impossible today)
Wait, what? dev/urandom is a DRBG seeded the same way dev/random is. This doesn't seem to make sense.
You're very unlikely to be continually reseeding your own DBRG with new entropy, so it will be less secure than /dev/urandom, which is.
Suspiciously bad advice, there, from what I can see.
But yes, that's not common. (more info: http://wiki.openssl.org/index.php/Random_Numbers)
(Except for saving the entropy pool between reboots, which can be useful, afaik.)
No. Doing random in userland is just wrong. If your program has access to /dev/urandom, use it. If not, use arc4random().
> “Random Number Generators: Introduction for Operating System Developers”
Or look how OpenBSD does it. (getentropy(), arc4random(), the subsystem)
> The entropy pool used by /dev/urandom must be saved between reboots.
OpenBSD does this, and more. The bootloader basically seeds the kernel with old entropy from before the reboot.
The excerpt below is from https://www.nsa.gov/ia/_files/factsheets/I43V_Slick_Sheets/S... (which in turn also references https://www.nsa.gov/ia/_files/factsheets/I43V_Slick_Sheets/S... )
Unix-like Platforms (e.g. Linux, Android, and Mac OS X):
Application developers should use the fread function to read random bytes from /dev/random for cryptographic RNG services. Because /dev/random is a blocking device, /dev/random may cause unacceptable delays, in which case application developers may prefer to implement a DRBG using /dev/random as a conditioned seed.
Application developers should use the “Random Number Generators: Introduction for Operating System Developers” guidance in developing this solution. If /dev/random still produces unacceptable delays, developers should use /dev/urandom which is a non-blocking device, but only with a number of additional assurances:
- The entropy pool used by /dev/urandom must be saved between reboots. - The Linux operating system must have estimated that the entropy pool contained the appropriate security strength entropy at some point before calling /dev/urandom. The current pool estimate can be read from /proc/sys/kernel/random/entropy_avail.
At most 2^80 bytes may be read from /dev/urandom before the developer must ensure that new entropy was added to the pool.