So just keep using RSA.

I am wondering that is there any way to improve to create primes . I mean there is no duplicate of public key left.

]]>Although I am bit late for this discussion, I do not understand why all this enornmous intellectual strain to figure out new PRNGs when a even a lousy hardware generator would give each bit its own piece of entropy ? It is true that hrng bits will be somewhat correlated and somewhat biased (without postprocessing which is not a good idea) but it is still infinitely better than a handfull of perfectly correlated bits produced deterministically by any prng.

It is sad that peolpe are spending so much time and research effort on futile topic especially for crypto purposes where speed and perfect de-biasness are of no importance.

[1] If "the random number used for your 'random' start point is weak..."

I take "weak" to mean here, that the number is to any significant extent predictable to an adversary. In such case, the resulting key is insecure, no matter how else the rest of the procedure is done. The initial "guess" must be unpredictable, or it's game over.

[2] "...it becomes increasingly likely that you will end up picking the same prime number than someone else"

Yes -- but all the same, very very very unlikely indeed. Typically, 1024 bit keys are based on randomly chosen 512 bit primes. The "narrow range" of 512 bit integers contains (if I did my calculation correctly) about 2 x 10^151 primes.

If (say) one trillion trillion (that is, 10^24) such keys were generated, the probability that there would be even a single duplicated factor among ALL of them, is less than 10^-100.

[3] "Everyone is using the exact same primality test, after all."

No. There are three well-known tests for pseudoprimality (that can tell whether a number if probably prime), and two practical tests for primality (that can prove a prime to be so), which might be used in real-world cryptosystems. Most of these tests have parameters that must be chosen by the designers, and so may exist in numerous variants. Also, two of the pseudoprime tests require "random" numbers, and so might never run the same way twice.

When RSA keys are based on pseudoprimality testing, there is a risk that a modulus factor will be composite, which of course results in an insecure key. The system designer can choose the test parameters to set the probability of this disaster to a level that is judged to be acceptable. However, aside from this risk, the test chosen doesn't affect the probability of duplicated factors.

]]>*Everyone is using the exact same primality test, after all*

Err no they are not...

In the not so distant past, asside from the "Brut Force" method, there was not a diffinitive test for primality in very large primes, just a probabilistic test, which had the advantage of being very quick.

Then three graduate level students in India came up with a diffinitive test, which whilst not quite as quick as the probabilistic method was "none to shabby".

There are also other ways of finding primes more quickly than sequential search from a random point.

One of which is based on the simple knowledge that the two numbers either side of multiplying the sequence of primes (including 2) has a better than average chance of being "twin primes" (2x3x5=30, 29/31). Also contrary to what is often said primes do have a fairly regular pattern because they effectivly "reflect" around these points and each sub-multiple down towards the next lowest point.

To see this think about each prime being the fundemental of a harmonic generator, each harmonic strikes out all it's harmonics from further consideration, this is the basis for the sieve method. Now write out all the numbers from 0 to 60 and underline those that are prime. Now examin the pattern either side of 30 notice any similarities around the point, how about 60-90, 90-120, etc?

Thus if you were lazy you could encode the ofsets from a suitably high reflection point and the first couple of hundred primes. Ask how long a prime the user wanted find the nearest reflection point and use the offsets to give you a much greater chance of finding two primes very quickly.

Oh these reflection point twin primes have one prime with the two Least Significant Bits being both 1, the other 01, which means that the result of multiplying them is 3 mod 4. However as waluable as this may appear to be I would not use them ;)

]]>To "generate" the prime number necessary for encryption, you start at a "random" point within a specific range, say, 200-digits numbers.

You then test the candidates for primality, *sequentially*.

If the range where you search for big prime numbers is too narrow (it is highly likely that everyone uses the same range), or the random number used for your "random" start point is weak, it becomes increasingly likely that you will end up picking the same prime number than someone else. Everyone is using the exact same primality test, after all.]]>

Amen to that.

]]>The world has changed! "Proprietary" used to refer to technology for which was secret, and/or for which some kind of license was required.

Apparently, the term has been redefined: "proprietary" is now any technology for which I need to pay more than $0.00, and/or requires that I move my bottom from my chair.

Bruce's "Practical Cryptography" can be got used from Amazon for less than $16.

I'm old enough to remember making trips to the library, in order to learn cool and useful stuff.

Sincerely,

A. Fossil

]]>Let's say I want to implement Fortuna - with some effort, I can get access to the book, one way or another.

Let's say I want to implement CSPRNG - probably I will skip Fortuna, because it's not publically available.

But now the interesting scenario - somebody else has implementation called "Fortuna", and I need to evaluate whether it works and has not been weakened somehow - intentionally or not. Seems I'm out of luck then...

Unfortunately most methods for removing a DC bias create a signal bias, or a "Tone" as it is called in the Audio Sigma Delta world.

Also the RNG should be super fast, because I need to throw away lots of results that fail some test of randomness (???) or Key strength / suitability.

"It makes no sense to use a true random entropy source to pick security parameters, such as RSA primes, with biased probabilities. Instead, use a true random entropy source to seed a cryptographically strong random number generator."

I agree fully with the logic of that -- if the generator is unbreakable, and there is no risk that seed might be otherwise compromised, then a seed should be usable indefinitely.

The objection to Method B is interesting, and for me a novel one. In a brute force (trial division) attack on an RSA modulus, it would be advantageous (if Method B were suspected) to first test "long primes" (those following longer gaps) before short primes.

I examined an interval of small (non-cryptographic) primes (the 50th million of primes), and found that about half the primes expected from Method B would come from the "longest" 20 percent of primes in the interval. Now, I don't know to what extent the distribution I saw applies to cryptographic-size primes, but if it did, I reckon a 2.5 times speed-up of the trial division attack, equivalent to a reduction of the modulus length by 3 bits.

Of course, noone has suggested that such a bias toward long primes might lead to any useful attack against a particular RSA modulus.

But could Method B bias account, to any extent, for the repetition of primes observed in the referenced research?

Suppose the distribution of prime gaps had such an extreme bias, that half of Method B primes came from only one millionth of the primes in the interval from which factors of an RSA modulus are drawn*. 1024-bit moduli are typically composed by finding primes whose representation requires 512 bits, of which there are about 2 x 10^151. The assumed severe "Method B Bias" would, accordingly, frequently draw primes from a population of, say, 10^145.

Applying the famous "birthday" approximation yields an estimate of more than 10^70 1024-bit RSA moduli that must be computed (under this extreme assumption of Method B bias) before the probability of a duplicated factor approaches 1/2 between any pair in this superastronomical population.

Those who suggest Method B as an algorithm for finding primes, sometimes also suggest setting a limit on the number of increment-and-test cycles before selection of a new pseudo-random odd. This is based on considerations of speed rather than security, because prime gaps are sometimes very large. However, applying this modification would reduce the Method B bias toward "long" primes.

_____________________________________________

*Formulae believed to well approximate both the density of primes, and the maximal gap between primes, suggest that the maximal gap is about ln(N) times the mean gap, where N is the upper bound the interval. For 1024-bit RSA moduli, this indicates a crude upper bound for Method B bias more like 100 than 1,000,000.

]]>Okay, let me elaborate. We are searching for a prime in a given interval. Method A is to generate random numbers repeatedly until the primality test passes. Method B is to generate one random number, then increment it repeatedly until the primality test passes. We assume the random number generator's output is uniformly distributed in the given interval.

With Method A, the probability of picking a particular prime is the same for every prime in the interval, namely the reciprocal of the number of primes in the interval.

With Method B, the probability of picking a particular prime is *not* the same for every prime in the interval. In this case, the probability of picking a prime p is the length of the gap between p and the previous prime, divided by the length of the whole interval. But because the gaps between successive primes are not all the same, Method B picks some primes with higher probability than others. This makes it slightly more likely that two runs of Method B will pick the same (higher-probability) prime, compared to Method A.

It makes no sense to use a true random entropy source to pick security parameters, such as RSA primes, with biased probabilities. Instead, use a true random entropy source to seed a cryptographically strong random number generator. Then use the generator with Method A to pick RSA primes. That way, you don't have to consume "valuable" entropy from the entropy source each time you generate a random number.

]]>"Since primes of the requisite size are (relatively) rare, there's a small chance that two runs of the software will hit the same prime -- even with a cryptographically strong random number generator seeded from a true random source."

I'm not confident that I follow the reasoning here -- is the idea that the increment-and-test algorithm increases the probability of repeating primes, versus generating a new pseudo-random bit sequence for each trial? It seems to me that the probability of repeated primes is not affected, but I'm interested in seeing any argument to the contrary. [Note: if the pseudo-random bit source is broken, the likelihood of repeated primes might well vary between these algorithms, depending on the nature of the defect.]

When I wrote an RSA key generator, I used the increment-and-test algorithm, on the premise that entropy is rare and valuable, and that numerous repeated draws from the entropy-pooling random generator would decrease the entropy of the resulting key.

By my estimate, generating a 2048-bit RSA modulus with a new pseudo-random candidate for each trial would consume on average of more than 350 kbits (versus 2 kbits for the increment-and-test approach). I suppose it boils down to how good one presumes the source to be. For me, that entropy is best at first and may diminish with repeated draws seems the more conservative assumption.

]]>*Boneheaded? Of course. But it could have happened that way*

Err no trust me on this I've seen it done that way many times, from a software developers reasoning it makes one whole load of sense for a couple of reasons.

Firstly because it's guaranteed to find a prime within a short period of time. And secondly because it "stays in chache" and is thus very fast.

It's also partly done that way because some people incrorrectly designed de-bias systems for post processing TRNG output to work that way.

This is because the reasoning is somewhat as follows,

1, All primes (except 2) are odd.

2, Therefore the LSBit of a prime is always 1.

3, Half the numbers from a TRNG are even.

4, Make TRNG output odd.

There are three basic ways to do step four,

1, Test if even and increment.

2, Just set the LSB.

3, Rotate TRNG "word" till LSB is set.

3, Shift left one bit and set LSB.

The nominaly correct way is the last way (usually no branch or attendent cach issues), but many programers do it the first way.

And the "Add 2 and retest as prime" also makes a whole load of sense if your plan is to fritz the key pair as it reduces your search space a great deal (see my post above).

As "entropy" is like "fine wine" it "takes time to mature" and is thus "an inordinatly expensive commodity". Another way you sometimes see is generate a whole stream of small TRNG numbers ( ie a word in size) then concatinate to make the large prime, if not a prime then swap bottom word with another new TRNG word or use a circular buffer and write over the bottom number and re-test.

Then there is "binary swap" or it's legion of variations, generate a large random number as above if no good then swap within the array of words in a binary (or other) pattern.

But... At the end of the day jprimes are a 'sparse data set' so ust generating more and more TRNG output is NOT guaranteed to ever finish or even get close... So pragmaticaly you do have to switch to incrementing something at some point.

As I described above it's a way I've used in the past to fritz PubKeys amongst other things (to demonstrate a point to managment about code review process). The only extra I used was to use a BBS random number generator as well (which conveniently hid the shorter PubKey used to encrypt the start point info).

]]>Here's another scenario: The software picks a random number, tests it for primality, and finds it isn't prime. But then -- rather than pick another random number, which might take a long time waiting for the entropy pool to replenish -- the software just repeatedly increments and tests the previous number until it hits a prime. Since primes of the requisite size are (relatively) rare, there's a small chance that two runs of the software will hit the same prime -- even with a cryptographically strong random number generator seeded from a true random source.

Boneheaded? Of course. But it *could* have happened that way.

But :

"containing RSA moduli, 0.27 million (4%) share their RSA modulus, often involving unrelated parties. Of 6.4 million distinct RSA moduli, 71052 (1.1%) occur more than once, some of them thousands of times.."

What the researchers seem to have found is the RNG leaking it's non-randomness .

ATM I see no reason not to assume that ALL RSA-keys are equally non-random .

I like Fortuna and I have implemented a C++ port of it for mobile devices. (On smartphones, entropy sources like the camera are very useful. Tons of entropy per single frame, even in viewfinder regime.)

Attacking the PRNG is very advantageous for adversaries, as it does not create any compatibility issues.

If you're not sure about your particular PRNG, I would suggest running the battery of NIST tests on the PRNG output from time to time. They are easy to implement, but they do take some CPU cycles.

]]>"However there is a catch, on certain systems and certain operating system types there is little or no uncertainty. This happens on many embbeded systems especially those that have a Real Time OS (RTOS) or use fixed low latency design for Real Time response (ie you want your foot going down on the break peddle in your car getting through the ABS system as rapidly as possible)."

That's basically what I see as the fundamental problem with cryptographically secure random number generation. Computers, by design, are usually pretty good at having predictable behavior. Entropy in computer systems often seems to boil down to measuring external things like user behavior (which is not always practical) or behavior determined by a sufficiently large number of factors that predicting the outcome is difficult.

One thing I think might be worth exploring is the idea of maximizing use of entropy in random number generators. Decades of crypto research have given us tools that transform relatively short values into long unpredictable outputs (stream ciphers, for example). Random number generators could potentially get a lot more cryptographically random output for each bit of true entropy input than they do right now. The end result would be an ability to be a lot more careful in entropy collection without an appreciable drop in random number generation speed.

]]>Perhaps RNGs were the target.

]]>*Fortuna has one big problem...*

Have a look at ,

http://th.informatik.uni-mannheim.de/people/lucks/papers/Ferguson/Fortuna.pdf

It's a PDF of a powerpoint presentaiton by Niels Ferguson going into the background of Fortuna's design and the things considered.

Although not giving you a full specification, it contains more than sufficient info for you to build your own version (and you could always go and buy the book ;)

Essentialy the working end of Fortuna is AES (or other block cipher) in counter mode. The initial seed value is the AESkey and value for the counter. It is updated by changing the counter or key and sometimes both. The update is done by K entropy pools where the pool used is based on 2^k, thus the current suggestion of K=32 should give a number of years (see Yarrow for an earlier idea). When either 1MByte of update or output is read from the generator the key value is updated. This is done by clocking the counter twice and using the two values to get the new key value.

The way the updating of the entropy pools is done is a little more complex. Have a look at,

http://rennes.ucc.ie/~robertmce/presentations/Fortuna_McEvoy.pdf

As far as I'm aware there is opensource code in atleast C++ or Python easily available that is sufficiently well written to be readily understandable.

On a more general note about randomness and it's uses have a look at,

http://www.iro.umontreal.ca/~lecuyer/

His papers are definatly worth a look through if you have the time.

]]>openssl s_client -connect google.com:443 < /dev/null | sha256

Using something like this--ideally using multiple servers--as input to an entropy pool may be useful for situations where an attacker cannot see all of the network traffic. Many systems generate keys when they boot the first time (e.g,. ssh); this is also the worst-case for available pool entropy...

Of course, proper hardware support is the only decent answer (VIA's Padlock or Intel's RdRand).

]]>]]>

The Wikipedia article does not count; or rather it counts as the best spec. Which is obviously deficient for proper implementation - there are various details to get right, various tradeoff to be made.

And it's not to useful to look at various implementations lying around - there is no way to understand what code is part of Fortuna and what is random hack.

So Bruce, if you really want to promote Fortuna, please make the spec public...

]]>http://en.wikipedia.org/wiki/RdRand

Patches are already in Linux to make (some) use of it.

]]>http://www.via.com.tw/en/initiatives/padlock/hardware.jsp]]>

In addition to the above, here's an online service for random number generation.

]]>1) recommended code for entropy generation on various systems would be exceptionally useful

and

2) even more useful would be recommendations on existing random number generators, such as

gpg --gen-random 2 (for a given version)

openssl rand (for a given version/platform)

Truecrypt's keyfile generator (for a given version/platform)

Microsoft .NET System.Security.Cryptography.RNGCryptoServiceProvider (for a given version/platform)

(hardware) Araneus Alea I hardware (possibly used in a reduced RF environment)

Users, unfortunately, can be told "Use a good random number generator" and "make sure the entropy pool is sufficient", but at the user level (even highly technical users), that's not very useful.

I think if you were installing an intentional back door, you'd have included the devices' ethernet addresses in the RNG seed. That would make the weakness invisible to this kind of examination, while still letting you brute force the low-entropy prime factors cheaply as needed.

I think this problem comes entirely down to assessing entropy correctly and waiting to generate RNG outputs till you have enough of it. I don't think Fortuna would help much--this is a place where what's needed is dumping every bit of entropy in your possession into the pool just before you generate your high-value keypair, not holding some back in hopes that you'll eventually reseed with enough entropy to get to a secure state. If your RNG isn't in a secure state once you generate your keypair, it probably doesn't matter whether you get into one later on.

]]>DSA is designed so it's perfectly okay to share the system parameters

(g,p,q) among many users, and also that there's no secrecy in these values. If any users of the same parameters get the same secret key x and public key y, that's a big problem, but it doesn't look like they saw any of that.

I'm not sure why this happened. One guess is that if you generate your own (g,p,q) randomly, that gives you enough time to get from a relatively predictable system state to a more unpredictable one.

My intuition here is like this: On a closed-off computer with no user interface and no physical hard drive and nothing going on in terms of network traffic, when you start up, your processor is in one of a fairly small number of possible states. Techniques for drawing entropy from the OS are ultimately just measuring this state, and so there's just not much entropy to be found.

Over time, I assume a certain amount of unpredictability sets in. If the device is plugged into a network, it may be processing some packets from time to time. There may be some other sources of unpredictability--for example, the device may have to manage its temperature by turning on/off a fan based on a thermostat, and that may affect the behavior of the system somehow.

If you're generating your DSA parameters first, at least using the technique for generating a provably ok set of parameters, there's a fair bit of processing going on. (You have to generate a 160-bit prime and a seed, then use that to generate a 1024-bit prime so that p%q==1.) My intuition is that during all this churning, there is enough time for the machine's state to get somewhat more unpredictable--by the end, it can be in a larger set of possible states. (For each SEED choice, we get a different number of iterations of the process, meaning a different set of possible machine states.)

So I have this mental picture that what we're really doing is:

RSA:

[small set of starting machine states]

Generate p

[slightly larger set]

Generate q

[slightly larger set]

DSA:

[small set of starting machine states]

Generate q and seed, and do lots of spinning and back-and-forth to get (g,p,q).

[much larger set of machine states]

Generate x and y=g^x mod p

I am not at all sure about this--I could be completely wrong. But this would explain something about that pattern we're seeing here. Though it's also quite possible that the DSA implementations are just better about getting fresh entropy, or that DSA implementations are done by higher end/more capable devices with more going on.

]]>*It pales, however, compared to the situation with RSA. Of 6.6 million distinct X.509 certificates and PGP keys (cf. [1]) containing RSA moduli, 0.27 million (4%) share their RSA modulus, often involving unrelated parties. Of 6.4 million distinct RSA moduli, 71052 (1.1%) occur more than once, some of them thousands of times.*.

Now as regular readers of this blog know "diceware" gets mentioned often when random number generation is discussed you can read the diceware authors take on this at,

http://diceware.blogspot.com/2012/02/was-whit-really-right.html

He thinks the research points to a possible signiture to "malware" fritzing the calls to the random number generator which Bruce has also mentioned.

Now this is far from a new idea Adam Young and Moti Yung proposed this and other ideas to fritz PQ pairs back last century under their ideas for "Cryptovirology",

http://www.cryptovirology.com/

Whilst I would not rule it out (I've done similar things myself as I've indicated in the past on this blog) it's more likely to be poor programing in some code library software engineers are using virtualy sight unseen.

Why do I think this, well Adam and Moti published information that showed how to easily hide your fritzing into the selection of one of the PQ primes that would be undetectable to detect with only the PQ pair or the resulting Pub/Pri keys.

Essentialy what you do is use the immense redundancy in the resulting PQ pair to hide a shortend (about 1/6th of total PubKey length) hidden RSA message for which you only have the PriKey, this message contains an offset number as to where one of the PQ primes was selected from. Thus you cut your search space down to a trivial number to find one of the primes (the other being genuinely random drops out).

Now as Bruce notes generating genuinely random numbers is at best a difficult problem (you first have to realise that there are no random numbers only random sequences and random is such a nebulous term you can only wave your arms around ;)

However the usual place to start looking is at what are quaintly called True Random Number Generators (TRNG's). The way they work is to take input from a physical world source (I'll leave quantum out of this simple explination). Now one the consiquences of physical world sources is their output is effectivly modelled as two or more signals combined (by addition, multiplication or both in one or more dimensions such as amplitude, time or sequence). One is in some way predictable and we call it "bias" and the other we cann't detect predictability and that's the one we want to use as our source of entropy.

Now seperating the bias from the desired unpredictable signal is even at the best of times wastefull and can appear as some kind of "voodoo ritual" method.

So many designers don't bother, they figure jusst putting it through a crypto or hash algorithm will solve the problem. It doesn't yo have no more entropy in the result than you had before, it just "looks" more random... The problem with this is you can get sequence correlation between two or more generator outputs, which can in some cases cause symptoms like those that have been found in those RSA Certs.

Now one of the problems that arises is the value of each bit of entropy. Depending on the source and how the bias is removed you could be getting only a very small percentage of the bits coming out of the source. The more complex the bias removal process the more bits you get but there is only so far you can go. Thus the designer has to make a trade off between CPU cycles and lines of code used to remove bias and the number of bits required.

Now back in the last century one or two people suggested a heretical idea of "entropy spreading", and it caught on. Unlike hashing the output which does not change the entropy the idea was to apply each bit of entropy to a pool of bits in such a way that it spread it's value across many of the bits in the pool and in some systems over time as well.

On further reflection you can come up with a different way to spread entropy, you take a stream cipher like RC4 or other reasonably efficient "pot stirrer" and apply each bit of entropy as it occurs to "jog the pot". Like throwing a stone in a pool the effect of the bit ripples out across the entire surface and folds back and mixes unpredictably with the other pot jogging bits. The advantage however is that the number of unpredictable bits you can get out of the stream cipher is considerably higher (look up unicity distance to see by how much).

A further thought on this is that of "non determanistic sampling" that is on many systems it is not possible for a piece of code to regularly sample the output of the stream cipher, therefor this adds further to the unpredictably of the generator output as you can use it as another pot jogger as well.

However there is a catch, on certain systems and certain operating system types there is little or no uncertainty. This happens on many embbeded systems especially those that have a Real Time OS (RTOS) or use fixed low latency design for Real Time response (ie you want your foot going down on the break peddle in your car getting through the ABS system as rapidly as possible).

Also no matter how fast your source of entropy is it still takes time to build up to a usefull number of bits, and rapidly sampling the entropy pool can rapidly bring down the effective level of entropy in the pool.

Thus one solution is to "block" a requesting process untill such time as sufficient entropy has built up. This can cause significant problems in that the process can be highly non linear and this in many systems is highly undesirable (imagine what would happen if the brake peddle signal got blocked?). And I've seen some designs where the blocked processes were also the ones adding entropy to the pool so dead lock could be just a breath away followed by total system lock up, not good on a PC but in an embedded system easily fatal.

Not knowing much of the above before you build a secure system that needs a suitably specified TRNG means that the chances are high that you can and in all probability will shoot yourself in the foot and some of your systems users in the head.

]]>Fortuna basically solved the problem of how to generate cryptographic pseudo random numbers from small amounts of entropy as far as I'm concerned (as long as the underlying crypto remains secure). Figuring out how to get good initial entropy still seems like an open problem.

]]>Mike

]]>Back as a student, I remember writing our own entropy source - getting the user to click on a series of pseudo-randomly-located boxes on screen. We hashed the exact timestamp, x and y position within the box and a random number from the existing PRNG together.

@Gweihir: the 'just wait' for more entropy is fine for some situations, but a busy server doing SSL could find it a bottleneck - particularly if an attacker knows that and opens a load of junk sessions to drain the entropy pool. I seem to recall entropy starvation becoming a performance bottleneck somewhere: on a headless server, entropy sources like keyboard and mouse movements don't apply - and of course network timing can be externally influenced, making it suspect.

]]>And even among crypto geeks who /know/ how to test (not me; I once learned the theory behind testing RNGs, but determing the output of Mersenne twister was better than a linear congruential was the farthest I ever went ), how many of them test more than one or two of the RNG reliant pieces of software they use?

Further, I'm convinced (and I doubt many here will disagree) this is a general problem with security related software; it's prone to extremely subtle bugs, which he vast majority of users, even most experts, are unlikely notice, which are nonetheless potential security problems.

But there is good news: This particular weakness is unlikely to be exploited; there are host of easier-to-exploit weaknesses out there.

Can anyone tel me why it is so?

]]>(Or home routers and appliances with debian baked into them?)

]]>What is surprising is that no security personnel at the device vendors thought about shouting about this at any point - entropy, and its consideration in security assessments, shouldn't be a black art.

]]>My guess is that the developers responsible are either incompetent and had no idea what they were doing (would not be a surprise) or decided to go for convenience instead of security (would not be a surprise either).

Side note: I know of cases where the CPU used in a device actually had a good true-RNG, but it was not used in key-generation or used wrongly due to developer incompetence. "Incompetence" here means they failed to read the half-page in the documentation that states that the bits delivered do not have 1 bit/bit of entropy but a lower value.

This is really not a technological problem.

]]>In computational science, RNGs are used to power Monte Carlo simulations along. For this application, "true" randomness is of course important, but so is repeatability. You need to be able to replicate a Monte Carlo simulation bit-for-bit, for debugging purposes and for the sake of scientific repeatability. So even though the numbers are pseudo-random, the seeds and sequence starts must be recorded, and the RNG had better make the same stream of numbers given those initialization values.

In security applications, repeatability is not only unnecessary, it's downright dangerous, as exemplified by the research above. RNGs for this class of applications should give some strong guarantee of non-repeatability, by gathering entropy from system electronic noise, keypress rates, etc. Which would be a terrible idea for scientific applications.

It's a subtle distinction, possibly lost on some security coders (and sadly also on some computational scientists). Selection of an RNG algorithm and/or initialization practice from the wrong application category can produce insecure code in one case, scientific malpractice in the other.

]]>Sadly, as usual, popular newspapers have reported it with too much hype -- one of them alerted readers that "now the bad guys can crack any key in minutes".

]]>