Cryptographically secure pseudorandom number generator

Short description: Type of functions designed for being unsolvable by root-finding algorithms

A cryptographically secure pseudorandom number generator (CSPRNG) or cryptographic pseudorandom number generator (CPRNG) is a pseudorandom number generator (PRNG) with properties that make it suitable for use in cryptography. It is also referred to as a cryptographic random number generator (CRNG).

## Contents

* 1 Background
* 2 Requirements
* 3 Definitions
* 4 Entropy extraction
* 5 Designs
* 5.1 Designs based on cryptographic primitives
* 5.2 Number-theoretic designs
* 5.3 Practical schemes
* 6 Standards
* 7 Security flaws
* 7.1 NSA kleptographic backdoor in the Dual_EC_DRBG PRNG
* 7.2 DUHK attack
* 7.3 Japanese PURPLE cipher machine
* 8 References
* 9 External links

## Background

Most cryptographic applications require random numbers, for example:

* key generation
* initialization vectors
* nonces
* salts in certain signature schemes, including ECDSA and RSASSA-PSS
* token generation

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, the 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 comes from a true random source with high entropy, and thus just any kind of pseudorandom number generator is insufficient.

Ideally, the generation of random numbers in CSPRNGs uses entropy obtained from a high-quality source, generally the operating system's randomness API. However, 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, numbers are needed with more randomness than the available entropy can provide. 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.

## 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:

1. They pass statistical randomness tests:
* Every CSPRNG should satisfy the next-bit test. That is, 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 non-negligibly better than 50%.[1]
* Andrew Yao proved in 1982 that a generator passing the next-bit test will pass all other polynomial-time statistical tests for randomness. In other words, no polynomial-time algorithm would be able to distinguish the output of the RNG from true randomness.[2]
* Instead of polynomial-time complexity, another metric considered in practice is the absolute number of operations required for a distinguisher to tell the output from true randomness. From the number of operations one can also define a security level (bits of security) for a particular CSPRNG against distinguishing attacks.[3][4]
2. They hold up well under serious attack, even when part of their initial or running state becomes available to an attacker:[5]
* Every CSPRNG should withstand "state compromise extension attacks".[5]: 4 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.
* For instance, if the PRNG under consideration produces output by computing bits of pi in sequence, starting from some unknown point in the binary expansion, it may well satisfy the next-bit test and thus be statistically random, as pi is conjectured to be a normal number. However, this algorithm is not cryptographically secure; an attacker who determines which bit of pi is currently in use (i.e. the state of the algorithm) will be able to calculate all preceding bits as well.

Most PRNGs are not suitable for use as CSPRNGs and will fail on both counts:

1. 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. At the same time, because CSPRNGs are designed to resist all statistical tests (and are believed to be secure on this front until such a test has been found), a CSPRNG can replace any true random number generator in any non-cryptographic application as well.
2. For most PRNGs, when their state has been revealed, all past random numbers can be retrodicted, allowing an attacker to read all past messages, as well as future ones. CSPRNGs are designed explicitly to resist this type of cryptanalysis.

## Definitions

In the asymptotic setting, a family of deterministic polynomial time computable functions Gk:{0,1}k->{0,1}p(k) for some polynomial p, is a pseudorandom number generator (PRNG, or PRG in some references), if it stretches the length of its input (p(k)>k for any k), and if its output is computationally indistinguishable from true randomness, i.e. for any probabilistic polynomial time algorithm A, which outputs 1 or 0 as a distinguisher,

|Prx<-{0,1}k[A(G(x))=1]−Prr<-{0,1}p(k)[A(r)=1]|<μ(k)

for some negligible function μ.[6] (The notation x<-X means that x is chosen uniformly at random from the set X.)

There is an equivalent characterization: For any function family Gk:{0,1}k->{0,1}p(k), G is a PRNG if and only if the next output bit of G cannot be predicted by a polynomial time algorithm.[7]

A forward-secure PRNG with block length t(k) is a PRNG Gk:{0,1}k->{0,1}k×{0,1}t(k), where the input string si with length k is the current state at period i, and the output (si+1, yi) consists of the next state si+1 and the pseudorandom output block yi of period i, that withstands state compromise extensions in the following sense. If the initial state s1 is chosen uniformly at random from {0,1}k, then for any i, the sequence (y1,y2,…,yi,si+1) must be computationally indistinguishable from (r1,r2,…,ri,si+1), in which the ri are chosen uniformly at random from {0,1}t(k).[8]

Any PRNG G:{0,1}k->{0,1}p(k) can be turned into a forward secure PRNG with block length p(k)−k by splitting its output into the next state and the actual output. This is done by setting G(s)=G0(s)‖G1(s), in which |G0(s)|=|s|=k and |G1(s)|=p(k)−k; then G is a forward secure PRNG with G0 as the next state and G1 as the pseudorandom output block of the current period.

## Entropy extraction

Main article: Randomness extractor

Santha and Vazirani proved that several bit streams with weak randomness can be combined to produce a higher-quality, quasi-random bit stream.[9] Even earlier, John von Neumann suggested a simple algorithm that can remove a considerable amount of the bias in any bit stream.[10]

## Designs

CSPRNG designs are divided into two classes:

1. Designs based on cryptographic primitives such as ciphers and cryptographic hashes
2. Designs based on mathematical problems thought to be hard

### Designs based on cryptographic primitives

* A secure block cipher can be converted into a CSPRNG by running it in counter mode using, for example, a special construct that the NIST in SP 800-90A calls CTR DRBG. CTR_DBRG typically uses Advanced Encryption Standard (AES).
* AES-CTR_DRBG is often used as a random number generator in systems that use AES encryption.[11][12]
* The NIST CTR_DRBG scheme erases the key after the requested randomness is output by running additional cycles. This is wasteful from a performance perspective, but does not immediately cause issues with forward secrecy. However, realizing the performance implications, the NIST recommends an "extended AES-CTR-DRBG interface" for its Post-Quantum Cryptography Project submissions. This interface allows multiple sets of randomness to be generated without intervening erasure, only erasing when the user explicitly signals the end of requests. As a result, the key could remain in memory for an extended time if the "extended interface" is misused. Newer "fast-key-erasure" RNGs erase the key with randomness as soon as randomness is requested.[13]
* A stream cipher can be converted into a CSPRNG. This has been done with RC4, ISAAC, and ChaCha20, to name a few.
* A cryptographically secure hash might also be a base of a good CSPRNG, using, for example, a construct that NIST calls Hash DRBG.
* An HMAC primitive can be used as a base of a CSPRNG, for example, as part of the construct that NIST calls HMAC DRBG.

### Number-theoretic designs

* The Blum Blum Shub algorithm has a security proof based on the difficulty of the quadratic residuosity problem. Since the only known way to solve that problem is to factor the modulus, it is generally regarded that the difficulty of integer factorization provides a conditional security proof for the Blum Blum Shub algorithm. However the algorithm is very inefficient and therefore impractical unless extreme security is needed.
* The Blum–Micali algorithm has a security proof based on the difficulty of the discrete logarithm problem but is also very inefficient.
* Daniel Brown of Certicom wrote a 2006 security proof for Dual EC DRBG, based on the assumed hardness of the Decisional Diffie–Hellman assumption, the x-logarithm problem, and the truncated point problem. The 2006 proof explicitly assumes a lower outlen (amount of bits provided per iteration) than in the Dual_EC_DRBG standard, and that the P and Q in the Dual_EC_DRBG standard (which were revealed in 2013 to be probably backdoored by NSA) are replaced with non-backdoored values.

### Practical schemes

"Practical" CSPRNG schemes not only include an CSPRNG algorithm, but also a way to initialize ("seed") it while keeping the seed secret. A number of such schemes have been defined, including:

* Implementations of /dev/random in Unix-like systems.
* Yarrow, which attempts to evaluate the entropic quality of its seeding inputs, and uses SHA-1 and 3DES internally. Yarrow was used in macOS and other Apple OS' up until about December 2019, after which it switched to Fortuna.
* Fortuna, the successor to Yarrow, which does not attempt to evaluate the entropic quality of its inputs; it uses SHA-256 and "any good block cipher". Fortuna is used in FreeBSD. Apple changed to Fortuna for most or all Apple OSs beginning around Dec. 2019.
* The Linux kernel CSPRNG, which uses ChaCha20 to generate data,[14] and BLAKE2s to ingest entropy.[15]
* arc4random, a CSPRNG in Unix-like systems that seeds from /dev/random. It originally is based on RC4, but all main implementations now use ChaCha20.[16][17][18]
* CryptGenRandom, part of Microsoft's CryptoAPI, offered on Windows. Different versions of Windows use different implementations.
* ANSI X9.17 standard (Financial Institution Key Management (wholesale)), which has been adopted as a FIPS standard as well. It takes as input a TDEA (keying option 2) key bundle k and (the initial value of) a 64-bit random seed s.[19] Each time a random number is required, it executes the following steps:

1. Obtain the current date/time D to the maximum resolution possible.
2. Compute a temporary value t = TDEAk(D).
3. Compute the random value x = TDEAk(s ⊕ t), where ⊕ denotes bitwise exclusive or.
4. Update the seed s = TDEAk(x ⊕ t).

Obviously, the technique is easily generalized to any block cipher; AES has been suggested.[20] If the key k is leaked, the entire X9.17 stream can be predicted; this weakness is cited as a reason for creating Yarrow.[21]

All these above-mentioned schemes, save for X9.17, also mix the state of a CSPRNG with an additional source of entropy. They are therefore not "pure" pseudorandom number generators, in the sense that the output is not completely determined by their initial state. This addition aims to prevent attacks even if the initial state is compromised.[lower-alpha 1]

## Standards

Several CSPRNGs have been standardized. For example:

* FIPS 186-4[23]
* NIST SP 800-90A

This withdrawn standard has four PRNGs. Two of them are uncontroversial and proven: CSPRNGs named Hash_DRBG[24] and HMAC_DRBG.[25]

The third PRNG in this standard, CTR DRBG, is based on a block cipher running in counter mode. It has an uncontroversial design but has been proven to be weaker in terms of distinguishing attack, than the security level of the underlying block cipher when the number of bits output from this PRNG is greater than two to the power of the underlying block cipher's block size in bits.[26]

When the maximum number of bits output from this PRNG is equal to the 2blocksize, the resulting output delivers the mathematically expected security level that the key size would be expected to generate, but the output is shown to not be indistinguishable from a true random number generator.[26] When the maximum number of bits output from this PRNG is less than it, the expected security level is delivered and the output appears to be indistinguishable from a true random number generator.[26]

It is noted in the next revision that the claimed security strength for CTR_DRBG depends on limiting the total number of generate requests and the bits provided per generate request.

The fourth and final PRNG in this standard is named Dual EC DRBG. It has been shown to not be cryptographically secure and is believed to have a kleptographic NSA backdoor.[27]

* NIST SP 800-90A Rev.1

This is essentially NIST SP 800-90A with Dual_EC_DRBG removed, and is the withdrawn standard's replacement.

* 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.[28]

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

* A Statistical Test Suite for Random and Pseudorandom Number Generators, NIST Special Publication 800-22.[29]

## Security flaws

### NSA kleptographic backdoor in the Dual_EC_DRBG PRNG

The Guardian and The New York Times reported in 2013 that the National Security Agency (NSA) inserted a backdoor into a pseudorandom number generator (PRNG) of NIST SP 800-90A, which allows the NSA to readily decrypt material that was encrypted with the aid of Dual EC DRBG. Both papers reported[30][31] that, as independent security experts long suspected,[32] the NSA had been introducing weaknesses into CSPRNG standard 800-90; this being confirmed for the first time by one of the top-secret documents leaked to The Guardian by Edward Snowden. The NSA worked covertly to get its own version of the NIST draft security standard approved for worldwide use in 2006. The leaked document states that "eventually, NSA became the sole editor". In spite of the known potential for a kleptographic backdoor and other known significant deficiencies with Dual_EC_DRBG, several companies such as RSA Security continued using Dual_EC_DRBG until the backdoor was confirmed in 2013.[33] RSA Security received a $10 million payment from the NSA to do so.[34]

### DUHK attack

On October 23, 2017, Shaanan Cohney, Matthew Green, and Nadia Heninger, cryptographers at the University of Pennsylvania and Johns Hopkins University, released details of the DUHK (Don't Use Hard-coded Keys) attack on WPA2 where hardware vendors use a hardcoded seed key for the ANSI X9.31 RNG algorithm, stating "an attacker can brute-force encrypted data to discover the rest of the encryption parameters and deduce the master encryption key used to encrypt web sessions or virtual private network (VPN) connections."[35][36]

### Japanese PURPLE cipher machine

During World War II, Japan used a cipher machine for diplomatic communications; the United States was able to crack it and read its messages, mostly because the "key values" used were insufficiently random.[37]

## References

1. ↑ The use of entropy-mixing after CSPRNG initialization has been question by Daniel J. Bernstein.[22]

1. ↑ Katz, Jonathan; Lindell, Yehuda (2008). Introduction to Modern Cryptography. CRC press. p. 70. ISBN 978-1584885511. https://archive.org/details/Introduction_to_Modern_Cryptography.
2. ↑ Andrew Chi-Chih Yao. Theory and applications of trapdoor functions . In Proceedings of the 23rd IEEE Symposium on Foundations of Computer Science, 1982.
3. ↑ Stankovski, Paul (2010). "Greedy Distinguishers and Nonrandomness Detectors". Progress in Cryptology - INDOCRYPT 2010. Lecture Notes in Computer Science. 6498. pp. 210–226. doi:10.1007/978-3-642-17401-8_16. ISBN 978-3-642-17400-1. https://lup.lub.lu.se/record/1747288.
4. ↑ Aumasson, Jean-Philippe (veorq) (Nov 12, 2015). "Comment on: change Siphash to use one of the faster variants of the algorithm (Siphash13, Highwayhash) · Issue #29754 · rust-lang/rust" (in en). https://github.com/rust-lang/rust/issues/29754#issuecomment-156073946. "SipHash designer here, haven't changed my opinion about SipHash-1-3 :-) [...] There's a "distinguisher" on 4 rounds[...], or in simplest terms a statistical bias that shows up given a specific difference pattern in the input of the 4-round sequence. But you can't inject that pattern in SipHash-1-3 because you don't control all the state. And even if you could inject that pattern the bias wouldn't be exploitable anyway."
5. ↑ 5.0 5.1 Kelsey, John; Schneier, Bruce; Wagner, David; Hall, Chris (1998). "Cryptanalytic Attacks on Pseudorandom Number Generators". Fast Software Encryption. Berlin, Heidelberg: Springer Berlin Heidelberg. doi:10.1007/3-540-69710-1_12. ISBN 978-3-540-64265-7. https://www.schneier.com/wp-content/uploads/2017/10/paper-prngs.pdf. Retrieved 2023-09-11.
6. ↑ Goldreich, Oded (2001), Foundations of cryptography I: Basic Tools, Cambridge: Cambridge University Press, ISBN 978-0-511-54689-1 , def 3.3.1.
7. ↑ Goldreich, Oded (2001), Foundations of cryptography I: Basic Tools, Cambridge: Cambridge University Press, ISBN 978-0-511-54689-1 , Theorem 3.3.7.
8. ↑ Dodis, Yevgeniy, Lecture 5 Notes of Introduction to Cryptography, http://cs.nyu.edu/courses/fall08/G22.3210-001/lect/lecture5.pdf, retrieved 3 January 2016 , def 4.
9. ↑ Miklos Santha, Umesh V. Vazirani (1984-10-24). "Generating quasi-random sequences from slightly-random sources". University of California. pp. 434–440. ISBN 0-8186-0591-X. http://www.cs.berkeley.edu/~vazirani/pubs/quasi.pdf. Retrieved 2006-11-29.
10. ↑ John von Neumann (1963-03-01). "Various techniques for use in connection with random digits". The Collected Works of John von Neumann. Pergamon Press. pp. 768–770. ISBN 0-08-009566-6.
11. ↑ Kleidermacher, David; Kleidermacher, Mike (2012). Embedded Systems Security: Practical Methods for Safe and Secure Software and Systems Development. Elsevier. p. 256. ISBN 9780123868862. https://books.google.com/books?id=E9hBXN-HK1cC.
12. ↑ Cox, George; Dike, Charles; Johnston, DJ (2011). "Intel's Digital Random Number Generator (DRNG)". http://www.hotchips.org/wp-content/uploads/hc_archives/hc23/HC23.18.2-security/HC23.18.210-Random-Numbers-Cox-Intel-e.pdf.
13. ↑ Bernstein, Daniel J.. "2017.07.23: Fast-key-erasure random-number generators: An effort to clean up several messes simultaneously. #rng #forwardsecrecy #urandom #cascade #hmac #rekeying #proofs". https://blog.cr.yp.to/20170723-random.html.
14. ↑ "Github commit of random.c". Github. July 2, 2016. https://github.com/torvalds/linux/blob/e192be9d9a30555aae2ca1dc3aad37cba484cd4a/drivers/char/random.c.
15. ↑ "Linux 5.17 Random Number Generator Seeing Speed-Ups, Switching From SHA1 To BLAKE2s - Phoronix". https://www.phoronix.com/news/Linux-5.17-RNG.
16. ↑ "CVS log of arc4random.c". CVS. October 1, 2013. http://cvsweb.openbsd.org/cgi-bin/cvsweb/src/lib/libc/crypt/arc4random.c?rev=1.25&content-type=text/x-cvsweb-markup.
17. ↑ "CVS log of arc4random.c". CVS. November 16, 2014. http://cvsweb.netbsd.org/bsdweb.cgi/src/lib/libc/gen/arc4random.c?rev=1.26&content-type=text/x-cvsweb-markup&only_with_tag=MAIN.
18. ↑ "FreeBSD 12.0-RELEASE Release Notes: Runtime Libraries and API". 5 March 2019. https://www.freebsd.org/releases/12.0R/relnotes.html#userland-libraries.
19. ↑ Menezes, Alfred; van Oorschot, Paul; Vanstone, Scott (1996). "Chapter 5: Pseudorandom Bits and Sequences". Handbook of Applied Cryptography. CRC Press. http://www.cacr.math.uwaterloo.ca/hac/about/chap5.pdf. Retrieved 2009-06-05.
20. ↑ Young, Adam; Yung, Moti (2004-02-01). Malicious Cryptography: Exposing Cryptovirology. John Wiley & Sons. sect 3.5.1. ISBN 978-0-7645-4975-5. http://eu.wiley.com/WileyCDA/WileyTitle/productCd-0764549758.html. Retrieved 2010-06-16.
21. ↑ Kelsey, John; Schneier, Bruce; Ferguson, Niels (August 1999). "Yarrow-160: Notes on the Design and Analysis of the Yarrow Cryptographic Pseudorandom Number Generator". Sixth Annual Workshop on Selected Areas in Cryptography. Lecture Notes in Computer Science. 1758. pp. 13–33. doi:10.1007/3-540-46513-8_2. ISBN 978-3-540-67185-5. https://www.schneier.com/wp-content/uploads/2016/02/paper-yarrow.pdf. Retrieved 2024-03-20.
22. ↑ Daniel J. Bernstein (2014-02-05). "cr.yp.to: 2014.02.05: Entropy Attacks!". http://blog.cr.yp.to/20140205-entropy.html. "Is there any serious argument that adding new entropy all the time is a good thing? The Linux /dev/urandom manual page claims that without new entropy the user is "theoretically vulnerable to a cryptographic attack", but (as I've mentioned in various venues) this is a ludicrous argument"
23. ↑ "FIPS 186-4". http://nvlpubs.nist.gov/nistpubs/FIPS/NIST.FIPS.186-4.pdf.
24. ↑ Kan, Wilson (September 4, 2007). "Analysis of Underlying Assumptions in NIST DRBGs". https://eprint.iacr.org/2007/345.pdf.
25. ↑ Ye, Katherine Qinru (April 2016). "The Notorious PRG: Formal verification of the HMAC-DRBG pseudorandom number generator". https://www.cs.cmu.edu/~kqy/resources/thesis.pdf.
26. ↑ 26.0 26.1 26.2 Campagna, Matthew J. (November 1, 2006). "Security Bounds for the NIST Codebook-based Deterministic Random Bit Generator". http://eprint.iacr.org/2006/379.pdf.
27. ↑ Perlroth, Nicole (September 10, 2013). "Government Announces Steps to Restore Confidence on Encryption Standards". The New York Times. http://bits.blogs.nytimes.com/2013/09/10/government-announces-steps-to-restore-confidence-on-encryption-standards/.
28. ↑ Computer Security Division, Information Technology Laboratory (24 May 2016). "Random Number" (in EN-US). http://csrc.nist.gov/groups/ST/toolkit/random_number.html.
29. ↑ Rukhin, Andrew; Soto, Juan; Nechvatal, James; Smid, Miles; Barker, Elaine; Leigh, Stefan; Levenson, Mark; Vangel, Mark et al. (April 30, 2010). "A Statistical Test Suite for Random and Pseudorandom Number Generators for Cryptographic Applications". NIST. doi:10.6028/NIST.SP.800-22r1a. https://csrc.nist.gov/publications/detail/sp/800-22/rev-1a/final. Retrieved May 23, 2023.
30. ↑ Borger, James; Greenwald, Glenn (6 September 2013). "Revealed: how US and UK spy agencies defeat internet privacy and security". The Guardian. https://www.theguardian.com/world/2013/sep/05/nsa-gchq-encryption-codes-security.
31. ↑ Perlroth, Nicole (5 September 2013). "N.S.A. Able to Foil Basic Safeguards of Privacy on Web". The New York Times. https://www.nytimes.com/2013/09/06/us/nsa-foils-much-internet-encryption.html?pagewanted=all&_r=0.
32. ↑ Schneier, Bruce (15 November 2007). "Did NSA Put a Secret Backdoor in New Encryption Standard?". Wired. https://www.wired.com/politics/security/commentary/securitymatters/2007/11/securitymatters_1115. Retrieved 7 September 2013.
33. ↑ Green, Matthew (20 September 2013). "RSA warns developers not to use RSA products". http://blog.cryptographyengineering.com/2013/09/rsa-warns-developers-against-its-own.html.
34. ↑ Menn, Joseph (20 December 2013). "Exclusive: Secret contract tied NSA and security industry pioneer". Reuters. https://www.reuters.com/article/us-usa-security-rsa-idUSBRE9BJ1C220131220.
35. ↑ "Practical state recovery attacks against legacy RNG implementations". https://duhkattack.com/paper.pdf.
36. ↑ "DUHK Crypto Attack Recovers Encryption Keys, Exposes VPN Connections". 25 October 2017. https://it.slashdot.org/story/17/10/25/0047224/duhk-crypto-attack-recovers-encryption-keys-exposes-vpn-connections.
37. ↑ Balciunas, Marijus (2004-03-18). "Japan's Purple Machine". DePaul University. http://ovid.cs.depaul.edu/Classes/CS233-W04/Papers/PurpleMagic.pdf.

## External links

| The Wikibook Cryptography has a page on the topic of: Random number generation

|

* RFC 4086, Randomness Requirements for Security
* Java "entropy pool" for cryptographically secure unpredictable random numbers.
* Java standard class providing a cryptographically strong pseudo-random number generator (PRNG).
* Cryptographically Secure Random number on Windows without using CryptoAPI
* Conjectured Security of the ANSI-NIST Elliptic Curve RNG, Daniel R. L. Brown, IACR ePrint 2006/117.
* A Security Analysis of the NIST SP 800-90 Elliptic Curve Random Number Generator, Daniel R. L. Brown and Kristian Gjosteen, IACR ePrint 2007/048. To appear in CRYPTO 2007.
* Cryptanalysis of the Dual Elliptic Curve Pseudorandom Generator, Berry Schoenmakers and Andrey Sidorenko, IACR ePrint 2006/190.
* Efficient Pseudorandom Generators Based on the DDH Assumption, Reza Rezaeian Farashahi and Berry Schoenmakers and Andrey Sidorenko, IACR ePrint 2006/321.
* Analysis of the Linux Random Number Generator, Zvi Gutterman and Benny Pinkas and Tzachy Reinman.
* NIST Statistical Test Suite documentation and software download.

* v
* t
* e

Cryptography

* History of cryptography
* Cryptanalysis
* Outline of cryptography

* Symmetric-key algorithm
* Block cipher
* Stream cipher
* Public-key cryptography
* Cryptographic hash function
* Message authentication code
* Random numbers
* Steganography

* Category

0.00

(0 votes)

Original source: https://en.wikipedia.org/wiki/Cryptographically secure pseudorandom number generator. Read more

|

Retrieved from "https://handwiki.org/wiki/index.php?title=Cryptographically_secure_pseudorandom_number_generator&oldid=4298573"
*[v]: View this template
*[t]: Discuss this template
*[e]: Edit this template