Page History

...

The C Standard function rand() (available in stdlib.h) does not have good random number properties. The numbers generated by rand() have a comparatively short cycle, and the numbers may be predictable.

To achieve the best random numbers possible, an implementation-specific function must be used. When unpredictability really matters and speed is not an issue, such as in the creation of strong cryptographic keys, use a true entropy source such as /dev/random or a hardware device capable of generating random numbers. The /dev/random device may block for a long time if there are not enough events going on to generate sufficient entropy. From the Linux urandom(4) manual page:

A read from the /dev/urandom device will not block waiting for more entropy. As a result, if there is not sufficient entropy in the entropy pool, the returned values are theoretically vulnerable to a cryptographic attack on the algorithms used by the driver. Knowledge of how to do this is not available in the current non-classified literature, but it is theoretically possible that such an attack may exist. If this is a concern in your application, use /dev/random instead.

In many cases, however, it will be acceptable to simply use a pseudorandom number generator from a cryptographic library (such as the Mersenne Twister) and seed it with data read from /dev/random.

Non-Compliant Code Example

The following code generates an ID with a numeric part produced by calling the rand() function. The IDs produced are predictable and have limited randomness.

enum {len = 12};
char id[len];  /* id will hold 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 */
/* ... */

Non-Compliant Code Example

A better pseudorandom number generator is the random() function.

...

However, the instance of the random() function in this example uses time(0) as a seed. With a trivial seed like time(0), the results from random() are also predictable.

Compliant Solution (

...

POSIX)

When unpredictability really matters and speed is not an issue, use a true entropy source such as /dev/random or a hardware device capable of generating random numbers. The /dev/random device may block for a long time if there are not enough events going on to generate sufficient entropy. From the Linux urandom(4) manual page:

A read from the /dev/urandom device will not block waiting for more entropy. As a result, if there is not sufficient entropy in the entropy pool, the returned values are theoretically vulnerable to a cryptographic attack on the algorithms used by the driver. Knowledge of how to do this is not available in the current non-classified literature, but it is theoretically possible that such an attack may exist. If this is a concern in your application, use /dev/random instead.

In most cases, however, it will be acceptable to simply use a pseudorandom number generator from a cryptographic library (such as the Mersenne Twister) and seed it with data read from /dev/random.

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

long int li;
FILE* fd;

if(!(fd = fopen("/dev/random", "r")) {
   /* Handle error condition */
}

if(fread(&li, sizeof(li), 1, fd) != sizeof(li)) {
   /* Handle error condition */
}

fclose(fd);

printf("Random number: %ld\n", li);

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

Although not specified by POSIX, arc4random() is an Another option on systems that support it is arc4random(). From the arc4random(3) manual page:

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).

Compliant Solution (Windows)

On Windows platforms, the CryptGenRandom() function may be used to generate cryptographically strong random numbers. It is important to note, however, that the exact details of the implementation are unknown, and it is undetermined as to what source of entropy the CryptGenRandom() uses. From the Microsoft Developer Network CryptGenRandom() reference:

...

#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);
}

Risk Assessment

Using the rand() function leads to possibly predictable random numbers.

Related Vulnerabilities

Search for vulnerabilities resulting from the violation of this rule on the CERT website.

References

\[[ISO/IEC 9899-1999|AA. C References#ISO/IEC 9899-1999]\] Section 7.20.2.1, "The rand function"

...