Cryptographically secure pseudorandom number generator

From Wikipedia, the free encyclopedia

You have new messages (last change).
Portal:Cryptography
 Cryptography Portal

A cryptographically secure pseudo-random number generator (CSPRNG) is a pseudo-random number generator (PRNG) with properties that make it suitable for use in cryptography.

Many aspects of cryptography require random numbers, for example:

The "quality" of the randomness required for these applications varies. For example creating a nonce in some protocols needs only uniqueness. On the other hand, generation of a master key requires a higher quality, such as more entropy. And in the case of one-time pads, the information-theoretic guarantee of perfect secrecy only holds if the key material is obtained from a true random source with high entropy.

Ideally, the generation of random numbers in CSPRNGs uses entropy obtained from a high quality source, which might be a hardware random number generator or perhaps unpredictable system processes — though unexpected correlations have been found in several such ostensibly independent processes. From an information theoretic point of view, the amount of randomness, the entropy that can be generated is equal to the entropy provided by the system. But sometimes, in practical situations, more random numbers are needed than there is entropy available. Also the processes to extract randomness from a running system are slow in actual practice. In such instances, a CSPRNG can sometimes be used. A CSPRNG can "stretch" the available entropy over more bits.

When all the entropy we have is available before algorithm execution begins, we really have a stream cipher. However some crypto system designs allow for the addition of entropy during execution, in which case it is not a stream cipher equivalent and cannot be used as one. Stream cipher and CSPRNG design is thus closely related.

Contents

[edit] Requirements

The requirements of an ordinary PRNG are also satisfied by a cryptographically secure PRNG, but the reverse is not true. CSPRNG requirements fall into two groups: first, that their statistical properties are good (passing statistical randomness tests); and secondly, that they hold up well under serious attack, even when part of their initial or running state becomes available to an attacker.

  • Every CSPRNG should satisfy the "next-bit test". The next-bit test is as follows: Given the first k bits of a random sequence, there is no polynomial-time algorithm that can predict the (k+1)th bit with probability of success higher than 50%. Andrew Yao proved in 1982 that a generator passing the next-bit test will pass all other polynomial-time statistical tests for randomness.
  • Every CSPRNG should withstand 'state compromise extensions'. In the event that part or all of its state has been revealed (or guessed correctly), it should be impossible to reconstruct the stream of random numbers prior to the revelation. Additionally, if there is an entropy input while running, it should be infeasible to use knowledge of the input's state to predict future conditions of the CSPRNG state.
Example: If the CSPRNG under consideration produces output by computing some function of the next digit of π, it may well be random, as π appears to be a random sequence. However, this does not satisfy the next-bit test, and thus is not cryptographically secure. There exist algorithms that will predict the next bit; examples include looking up digits or computing them ad hoc.

Most PRNGs are not suitable for use as CSPRNGs and will fail on both counts. First, while most PRNGs outputs appear random to assorted statistical tests, they do not resist determined reverse engineering. Specialized statistical tests may be found specially tuned to such a PRNG that shows the random numbers not to be truly random. Second, for most PRNGs, when their state has been revealed, all future random numbers can be predicted.

CSPRNGs are designed explicitly to resist this type of cryptanalysis.

[edit] Some background

Santha and Vazirani proved that several bit streams with weak randomness can be combined to produce a higher-quality quasi-random bit stream.[1] Even earlier, John von Neumann proved that a simple algorithm can remove a considerable amount of the bias in any bit stream[2] which should be applied to each bit stream before using any variation of the Santha-Vazirani design. The field is termed entropy extraction and is the subject of active research (e.g., N Nisan, S Safra, R Shaltiel, A Ta-Shma, C Umans, D Zuckerman).

[edit] Designs

In the discussion below, CSPRNG designs are divided into three classes: 1) those based on block ciphers, 2) those based upon 'hard' mathematical problems, and 3) special-purpose designs.

[edit] Designs based on cryptographic primitives

  • A secure block cipher can be converted into a CSPRNG by running it in counter mode. This is done by choosing a random key and encrypting a zero, then encrypting a 1, then encrypting a 2, etc. The counter can also be started at an arbitrary number other than zero. Obviously, the period will be 2n for an n-bit block cipher; equally obviously, the initial values (ie, key and "plaintext") must not become known to an attacker lest, however good this CSPRNG construction might be otherwise, all security be lost.
  • A cryptographically secure hash of a counter might also act as a good CSPRNG in some cases. In this case, it is necessary that the initial value of this counter is random and secret. If the counter is a bignum, then the CSPRNG could have an infinite period. However, there has been little study of these algorithms for use in this manner, and at least some authors warn against this use (Young and Yung, Malicious Cryptography, Wiley, 2004, sect 3.2).
  • Most stream ciphers work by generating a pseudorandom stream of bits that are combined (almost always XORed) with the plaintext; this stream can sometimes be used as a good CSPRNG (though not always: see RC4 cipher).

One design in this class is included in the ANSI X9.17 standard (Financial Institution Key Management (wholesale)), and has been adopted as a FIPS standard as well. It works as follows:

  • input: Date/time information D (in the maximum resolution available), a 64 bit random seed s, and a DES EDE key k.
  • compute: I = DES_k (D)
  • output: Each time a random number is required, output x=DES_k(I xor s), and update the seed s to DES_k(x xor I)

It has been suggested that this algorithm would be improved by using AES instead of DES (Young and Yung, op cit, sect 3.5.1)

[edit] Number theoretic designs

  • Blum Blum Shub has a strong, though conditional, security proof, based on the difficulty of integer factorization. However, implementations are slow compared to some other designs.

[edit] Special designs

There are a number of practical PRNGs that have been designed to be cryptographically secure, including

[edit] Standards

Several CSPRNGs have been standardized. For example,

  • FIPS 186-2
  • NIST SP 800-90: Hash_DRBG, HMAC_DRBG, CTR_DRBG and Dual_EC_DRBG.
  • ANSI X9.17-1985 Appendix C
  • ANSI X9.31-1998 Appendix A.2.4
  • ANSI X9.62-1998 Annex A.4, obsoleted by ANSI X9.62-2005, Annex D (HMAC_DRBG)

A good reference is maintained by NIST.

There are also standards for statistical testing of new CSPRNG designs:

Wikibooks
Wikibooks has more about this subject:

[edit] External links

Retrieved from "http://en.wikipedia.org../../../c/r/y/Cryptographically_secure_pseudorandom_number_generator.html"
In other languages