Random number generation is a process that yields numbers that cannot be reasonably predicted. The sequence of numbers should not be predictable, and it plays a significant role in applications that rely on the unpredictability of the random number sequence.

*"True"* Random Number generation processes can include anything from a simple coin flip, a dice roll, to cosmic radiation measurements, atmospheric pressure, lava lamps, and other physical means that depend on several naturally occurring physical aspects, which makes it quite difficult to predict on a computer.

Most modern computer operating systems attempt to provide a close "true" random number generator making use of measurements such as spinning hard disk latency to simulate a close alternative to "true" random number generators. Their implementation details make them more secure as well. For example, operating systems regularly reseed the the Random Number Generator to prevent potentially leaked internal state affecting the Random Number Generation in events of hibernation, or other events that memory could have been accessed bypassing kernel memory protection.

In real-life computer applications, operating systems and programming language runtime provide Random Number Generators (RNGs) that use various algorithms to generate random numbers, and make use of available physical randomness to increase the randomness of the generator. One of the fundamental drawbacks of these Pseudo Random Number Generators is that they depend on an initial "seed" value, and knowing the initial seed value and the algorithm is enough to predict the entire stream of random numbers, thereby making the use of a proper random number generator vital for any application.

## Random Number Generators in PHP

PHP provides several ways to generate random values: `rand`

, `mt_rand`

, `random_int`

, `random_bytes`

, `openssl_random_pseudo_bytes`

, etc., Some of them are Pseudorandom number generators, but they carry various properties that make them different from the other, and must be favored over the other.

Random number generators are used everywhere from simple computer games to PIN numbers to sensitive information encrypted with a randomly generated encryption key. Using appropriate random number generators is paramount in most of the applications to ensure that a malicious actor cannot determine the random number generated within the system.

All Pseudorandom generators inherently depend on a "seed" value that determines all the entire sequence of random numbers generated using the given algorithm. Computer games such as Minecraft build the entirety of the game world based on a single seed value. In order to build an identical game world, all it takes is just the initial seed.

Random Number Generators available in PHP vary a lot on how they are implemented, and how secure they are to be used in applications that rely on the randomness of the generator to be secure.

As of PHP 8.2, PHP provides following random number generators:

Function/Class | Availability | Notes |
---|---|---|

`rand` |
PHP 4 and later | Insecure, unsuitable for any security-related applications. Aliased to `mt_rand` since PHP 7.1 |

`mt_rand` |
PHP 4 and later | Uses Mersenne Twister. Received some bug fixes and improvements in PHP 7.1, but still inherently insecure. |

`lcg_value` |
PHP 4 and later | Returns a random float value in the inclusive range of 0 and 1. Not cryptographically secure. |

`random_int` |
PHP 7.0 and later | Recommended, as it is cryptographically secure |

`random_bytes` |
PHP 7.0 and later | Recommended, as it is cryptographically secure. If the system cannot generate cryptographically secure random numbers, it fails hard without falling back to insecure algorithms. |

`openssl_random_pseudo_bytes` |
OpenSSL and PHP 5.3 and later | Can be used to fetch cryptographically secure random numbers, but it is not guaranteed as the function may fallback to insecure algorithms. |

`Random\Engine\Mt19937` |
PHP 8.2 and later | An OOP interface for `mt_rand` . |

`Random\Engine\PcgOneseq128XslRr64` |
PHP 8.2 and later | Permuted congruential generator implementation. |

`Random\Engine\Xoshiro256StarStar` |
PHP 8.2 and later | Xoshiro PRNG implementation. |

## Measuring Randomness in PHP PRNGs

One of the easiest ways to measure the randomness of Random Number Generators is to visualize the yielded values to observe patterns.

Using PHP's GD extension, it is possible to plot an image by placing a single pixel on random X and Y coordinates. On a predetermined number of attempts, an image with mostly even pixel distribution indicates a random number generator that is close to a "true" RNG. RNGs that produce values purely based on a seed value (such as Mersenne Twister) should produce identical outputs if the seed remains the same.

```
// Name the testing function, which is used as the output image file name.
$test_name = 'random_int';
$size = 250;
$random_function = static function(int $max) {
return random_int(0, $max);
};
// Create an empty square image with a given $size.
$im = imagecreatetruecolor($size, $size);
$white = imagecolorallocate($im, 255, 255, 255);
$black = imagecolorallocate($im, 0, 0, 0);
// Fill the image in white
imagefill($im, 0, 0, $white);
$iterations = $size ** 2;
for ($i = 0; $i < $iterations; $i++) {
$x = $random_function($size);
$y = $random_function($size);
imagesetpixel($im, $x, $y, $black);
}
imagepng($im, $test_name . '.png', 0);
imagedestroy($im);
```

`random_int`

/ `random_bytes`

`random_int`

function is a CSPRNG (Cryptographically Secure Pseudo Random Number Generator) available since PHP 7.0. It throws an Exception if it could not yield a senescence of numbers with sufficient randomness, and does not fallback to any insecure RNG source.

Further, it is not possible to alter the seed values for this RNG, and is the recommended way to obtain random numbers and bytes in PHP, even for cryptographic operations.

```
$random_function = static function(int $max) {
return random_int(0, $max);
};
```

Using the snippet above to visualize the randomness, `random_int`

function produces an image similar to this:

New in PHP 8.2

In PHP 8.2, it is also possible to use`random_int`

and`random_bytes`

PRNGs with scoped and OOP API using`Random\Engine\Secure`

engine. There are more detailed examples available in PHP 8.2: New Random Extension - Usage examples

`mt_rand`

Function and `Random\Engine\Mt19937`

Engine

Mersenne Twister is a Pseudo Random Number Generator available in PHP. Its seed value is configurable, but PHP seeds it with a sufficiently random seed at start.

```
$random_function = static function(int $max) {
return mt_rand(0, $max);
};
```

One major difference between Mersenne Twister RNG and a hybrid/hardware approach is that the entire sequence of the random numbers depends on the seed. PHP's `mt_srand`

is used to seed the RNG. Mersenne Twister yields an identical random number sequence for the same seed.

This deterministic nature is useful when an application/game needs to generate values based on a single seed (such as Minecraft). However, Mersenne Twister a bad choice for applications that need to generate random numbers for cryptographic purposes because the internal state of the RNG can be derived by observing the sequences of random numbers the RNG yields.

To visualize this, the three following are generated using `mt_rand()`

function. Two of them use `$seed = 42`

, and the last one uses `$seed = 43`

:

```
mt_srand($seed);
$random_function = static function(int $max) {
return mt_rand(0, $max);
};
```

To better visualize the similarities and differences, the following images were generated using `imagefilledrectangle()`

function to draw filled rectangles instead of individual pixels. The color of the rectangle was also picked randomly.

`$seed = 42` |
`$seed = 42` |
`$seed = 43` |
---|---|---|

As long as the seed value is the same, the generated random number series remain the same. | As long as the seed value is the same, the generated random number series remain the same. | Changing the seed value even by one byte yields completely different series of random numbers. |

`rand`

Function

Since PHP 7.1, PHP's `rand`

function uses MT under the hood, the results are identical to the `mt_rand`

function. However, prior to PHP 7.0, the `rand`

function yielded a more predictable and repetitive stream of random numbers that made it quite far from a true random number generator.

```
$random_function = static function(int $max) {
return rand(0, $max);
};
```

Using `rand`

in PHP 7.1 and later is necessarily bad because it uses `mt_rand`

anyway. However, to make sure statically analyzers do not flag the use of `rand`

, consider moving to `random_int`

.

`lcg_value`

Function

`lcg_value()`

is a Combined linear congruential generator that returns a pseudo random number between 0 and 1. This function is also **not** considered a cryptographically secure pseudo random number generator.

```
$random_function = static function(int $max) {
return abs((int) (lcg_value() * $max));
};
```

`Random\Engine\PcgOneseq128XslRr64`

and `Random\Engine\Xoshiro256StarStar`

In PHP 8.2, the majority of the RNG functions are moved to a new extension called `random`

. It brings a new `\Random\Randomizer`

class, along with four RNG engines as PHP classes.

Two new PRNGs added with the new `random`

extension are `PcgOneseq128XslRr64`

, Permuted congruential generator implementation, and `Xoshiro256StarStar`

, a Xoshiro PRNG implementation. Both of them are similar to Mersenne Twister, in that they all only rely on the initial seed value, and can be used as a deterministic stream of numbers as long as the seed value remains the same.

PRNG | `$seed = 42` |
`$seed = 42` |
`$seed = 43` |
---|---|---|---|

Visualizing | As long as the seed value is the same, the generated random number series remain the same. | As long as the seed value is the same, the generated random number series remain the same. | Changing the seed value even by one byte yields completely different series of random numbers. |

`PcgOneseq128XslRr64` |
|||

`Xoshiro256StarStar` |

PHP offers several Random Number Generators, and the choice of the correct Random Number Generator is important, especially when it comes to applications on which the unpredictableness of the random number stream is important. Some of the RNGs, such as `rand()`

prior to PHP 7.1 are inherently insecure and predictable.

PHP 8.2 offers `Xoshiro256StarStar`

and `PcgOneseq128XslRr64`

as two additional RNGs in addition to existing Mersenne Twister (with an OOP API with `Mt19937`

).

Not all RNGs are suitable for Cryptographically Secure Pseudo Random Number Generators (CSPRNG). `openssl_random_pseudo_bytes`

function from the OpenSSL extension was a better choice prior to PHP 7.0, but even that was not ideal because it used to return `false`

if it was not possible to random numbers with sufficient entropy. This was later fixed in PHP 7.4 to throw an Exception on RNG failures.

RNGs such as Mersenne Twister, `Xoshiro256StarStar`

, and `PcgOneseq128XslRr64`

have use cases, but because they rely on a single seed value, using them for any application that require a CSPRNG is not recommended.

For all Random Number generation purposes, using

`random_int`

and`random_bytes`

functions is recommended because it fails with Exceptions (instead of silently defaulting insecure algorithms), and is supported in all PHP versions since PHP 7.0.

Applications that do not use the RNG for cryptographic use can use more faster implementations such as `Xoshiro256StarStar`

.