mt_rand() is not secure for cryptographic purposes because it uses the Mersenne Twister algorithm, which produces predictable output, may be poorly seeded, and is not designed for security. 2. For secure random number generation, use random_int() instead, as it draws from the operating system’s cryptographically secure pseudorandom number generator (CSPRNG) and is resistant to prediction and timing attacks. 3. Avoid common mistakes such as assuming all random functions are equivalent, mishandling ranges in random_int(), or combining secure and insecure functions like random_int() and mt_rand(), which undermines security. 4. For PHP versions earlier than 7.0, install the paragonie/random_compat library via Composer to use random_int() and random_bytes() securely. 5. mt_rand() remains acceptable only for non-security-sensitive tasks such as shuffling quiz questions, generating UI IDs, or game mechanics where unpredictability is not critical. 6. Always use cryptographically secure functions like random_int() when dealing with authentication tokens, session keys, password resets, or any user-facing secrets to ensure robust security.

Generating random numbers in PHP has evolved significantly over the years — especially when it comes to security. If you're still using mt_rand() for sensitive operations like generating tokens, passwords, or session keys, it's time to upgrade. Here's why and how to move from mt_rand() to random_int() for cryptographically secure number generation.

Why mt_rand() Isn’t Secure

mt_rand() uses the Mersenne Twister algorithm, which is great for simulations, games, or shuffling data — but not secure for cryptography.

• Predictable output: Given enough outputs, an attacker can reverse-engineer the internal state and predict future values.
• Not seeded properly by default: Especially in older PHP versions, seeding could be weak or based on predictable values like timestamps.
• Not designed for security: It’s a pseudo-random number generator (PRNG) meant for performance, not unpredictability.

Example: If you use mt_rand(1, 1000000) to generate a password reset token, an attacker might brute-force or predict possible values over time.

Use random_int() for Security-Critical Code

PHP 7 introduced random_int(), part of the random extension (built into PHP 7.0 ), which generates cryptographically secure random integers.

$secureRandomNumber = random_int(1, 1000000);

This function:

• Pulls randomness from the OS-level CSPRNG (like /dev/urandom on Linux or CryptGenRandom on Windows).
• Is resistant to prediction and timing attacks.
• Blocks only if the system’s entropy pool is empty (very rare on modern systems).

? Use random_int() when you need unpredictable numbers:

• CSRF tokens
• Password reset keys
• Session identifiers (though PHP handles this internally)
• Any user-facing secret

Common Mistakes and Pitfalls

Even with random_int(), developers can slip up:

• Assuming all random functions are equal
  Don’t fall into the trap of replacing rand() with mt_rand() and calling it "fixed." Only random_int(), random_bytes(), or libraries like paragonie/random_compat are secure.

• Improper range handling
  random_int($min, $max) must have valid bounds. Avoid negative ranges or $min > $max.

• Trying to "improve" randomness
  Don’t do things like:

  // ? Don't do this
  $num = random_int(1, 100) * mt_rand(1, 10);

  Mixing secure and insecure sources weakens the result.

Backward Compatibility: PHP < 7.0

If you're stuck on PHP 5.x, use the paragonie/random_compat library:

composer require paragonie/random_compat

Now you can safely use:

$secureNumber = random_int(1, 100);
$bytes = random_bytes(16);

It polyfills random_int() and random_bytes() using secure sources, even on older PHP versions.

When Is mt_rand() Still Okay?

There are still valid uses for mt_rand() — just not where security matters:

• Shuffling a list of quiz questions
• Generating non-sensitive IDs for UI elements
• Game mechanics where fairness ≠ security

But when in doubt, use random_int().

Basically, if it touches user authentication, access control, or secrets — go cryptographically secure. The switch from mt_rand() to random_int() is simple, safe, and future-proof.

The above is the detailed content of From `mt_rand` to `random_int`: Generating Cryptographically Secure Numbers. For more information, please follow other related articles on the PHP Chinese website!