Why Math.random() Isn’t Secure and How to Use crypto.getRandomValues() for True Randomness

When we need a random number, most people reach for Math.random(), which returns a floating‑point number between 0 and 1 with a single line of code.

However, this function has a fatal flaw: it produces pseudo‑random numbers.

Math.random() ’s “original sin”: it is predictable

Math.random()

generates numbers that are not truly random but pseudo‑random.

Pseudo‑random numbers are produced by a deterministic algorithm that starts from a seed; knowing the seed lets you predict all subsequent values.

Early browsers often used a simple timestamp as the seed, making prediction easy. Modern browsers improve seed generation, but the core mechanism of Math.random() has not changed, and the ECMAScript specification does not require it to be cryptographically secure.

Safer alternative: crypto.getRandomValues()

The window.crypto API provides cryptographic operations, and crypto.getRandomValues() is a CSPRNG (cryptographically secure pseudo‑random number generator).

Unlike Math.random(), its design goal is to provide cryptographic‑level security.

How does it achieve “true randomness”?

It draws high‑quality entropy from the operating system, such as precise mouse movements, keyboard timing, hardware noise, and network packet arrival times.

Exact timing and trajectory of mouse movements

Timing of keyboard input

Micro‑noise from hardware devices

Arrival times of network packets

The OS mixes these events into an entropy pool, and crypto.getRandomValues() extracts randomness from that pool, making its output statistically unpredictable.

How to use crypto.getRandomValues()

It works differently from Math.random(). Instead of returning a number directly, it fills a typed array such as Uint8Array or Uint32Array.

Basic usage:

// Create an array of 10 bytes
const randomBytes = new Uint8Array(10);
// Fill it with cryptographically secure random values
crypto.getRandomValues(randomBytes);
console.log(randomBytes); // e.g., Uint8Array(10) [185, 20, 248, 119, ...]

We can wrap this in a helper function that returns a floating‑point number between 0 and 1.

Alternative to Math.random() : generate a 32‑bit unsigned integer and scale it.

Function for a secure random integer within a range (common use):

function secureRandomInt(min, max) {
  const range = max - min + 1;
  // Create a sufficiently large random number to reduce modulo bias
  const randomValue = new Uint32Array(1);
  crypto.getRandomValues(randomValue);
  return min + (randomValue[0] % range);
}
console.log(secureRandomInt(1, 6));  // simulate a secure dice
console.log(secureRandomInt(1000, 9999)); // generate a secure 4‑digit code

Math.random()

is suitable for non‑security‑critical scenarios such as particle effects, random visual patterns, or games where the seed is shared to reproduce the same level.

When true randomness is required, choose crypto.getRandomValues(), which is supported by all modern browsers except IE.