Page History

Pseudorandom number generators use mathematical algorithms to produce a sequence of numbers with good statistical properties, but the numbers produced are not genuinely random.

The C Standard function Standard rand() (available in stdlib.h) does not have good random number properties function, exposed through the C++ standard library through <cstdlib> as std::rand(), makes no guarantees as to the quality of the random sequence produced. The numbers generated by some implementations of std:rand() have have a comparatively short cycle, and the numbers can be predictable. Applications that have strong pseudorandom number requirements must use a generator that is known to be sufficient for their needs.

Noncompliant Code Example

The following noncompliant code generates an ID with a numeric part produced by calling the rand() function. The IDs produced are predictable and have limited randomness. Further, depending on the value of RAND_MAX, the resulting value has modulo bias.

Code Block

bgColor	#FFCCCC
lang	cpp

enum#include <cstdlib>
#include <string>
 
void f() {len
 = 12};
char id[len];  /* id will hold  std::string id("ID"); // Holds the ID, starting with 
                * the characters "ID" followed
 by a 
                * random integer */
int r;
int num;
/* ... */
r = rand();  /* generate a random integer */
num = snprintf(id, len, "ID%-d", r);  /* generate the ID */
/* ... */

Compliant Solution (POSIX)

 // by a random integer in the range [0-10000].
  id += std::to_string(std::rand() % 10000);
  // ...
}

Compliant Solution

The C++ Standard Library provides mechanisms for fine-grained control over pseudorandom number generation. It breaks number generation down into two parts: one part is the algorithm responsible for providing random values (the engine), and the other is responsible for distribution of the random values via a density function (the distribution). The distribution object is not strictly required, but works to ensure that values are properly distributed within a given range, instead of improperly distributed due to bias issues. This compliant solution uses the Mersenne Twister algorithm as the engine for generating random values, and a uniform distribution to negate the modulo bias from the noncompliant code example:In this compliant solution, a better pseudorandom number generator is the random() function. While the low-dozen bits generated by rand() go through a cyclical pattern, all the bits generated by random() are usable.

Code Block

bgColor	#ccccff
lang	cpp

enum#include <random>
#include <string>
 
void f() {len
 = 12};
char id[len];  /* id will hold  std::string id("ID"); // Holds the ID, starting with 
                * the characters "ID" followed by a 
                * random integer */
int r;
int num;
/* ... */
time_t now = time(NULL);
if (now == (time_t) -1) {
  /* handle error */
}
srandom(now);  /* seed the PRNG with the current time */
/* ... */
r = random();  /* generate  by a random integer */
num = snprintf(id, len, "ID%-d", r);  /* generatein the ID */
/* ... */

The rand48 family of functions provides another alternative for pseudorandom numbers.

Although not specified by POSIX, arc4random() is an option on systems that support it. The arc4random(3) manual page says that

arc4random() fits into a middle ground not covered by other subsystems such as the strong, slow, and resource expensive random devices described in random(4) versus the fast but poor quality interfaces described in rand(3), random(3), and drand48(3).

To achieve the best random numbers possible, an implementation-specific function must be used. When unpredictability matters and speed is not an issue, such as in the creation of strong cryptographic keys, a true entropy source such as /dev/random or a hardware device capable of generating random numbers should be used. Note that the /dev/random device can block for a long time if there are not enough events going on to generate sufficient entropy.

Compliant Solution (Windows)

In the compliant solution, on Windows platforms, the CryptGenRandom() function can be used to generate cryptographically strong random numbers. It is important to note that the exact details of the implementation are unknown, and it is unknown what source of entropy the CryptGenRandom() uses. The Microsoft Developer Network CryptGenRandom() reference [MSDN 2010] says,

If an application has access to a good random source, it can fill the pbBuffer buffer with some random data before calling CryptGenRandom(). The CSP [cryptographic service provider] then uses this data to further randomize its internal seed. It is acceptable to omit the step of initializing the pbBuffer buffer before calling CryptGenRandom().

Code Block

bgColor	#ccccff
lang	cpp

#include<Wincrypt.h>

HCRYPTPROV hCryptProv;
union {
    BYTE bs[sizeof(long int)];
    long int li;
} rand_buf;

if (!CryptGenRandom(hCryptProv, sizeof(rand_buf), &rand_buf) {
    /* Handle error */
} else {
    printf("Random number: %ld\n", rand_buf.li);range [0-10000].
  std::uniform_int_distribution<int> distribution(0, 10000);
  std::mt19937 engine;
  id += std::to_string(distribution(engine));
  // ...
}