Demystifying Password Entropy: Why Length Beats Complexity Against Modern GPU Cracking

01. The Mathematics of Password Entropy

Information security evaluates password strength not by human intuition, but through Claude Shannon's concept of information entropy. Entropy measures the unpredictable uncertainty inherent in a generated secret, quantified in discrete bits.

For an unbiased random string drawn with uniform probability from a known alphabet of symbols, password entropy is governed by the standard combinatorial formula:

Consider the mathematics when comparing character pool expansion against length expansion:

Notice the exponential divergence. Expanding the character set from 26 letters to 94 symbols on an 8-character password yields only an additional 14.8 bits of entropy. Adding eight characters to an alphanumeric string adds over 42 bits of entropy, expanding the search keyspace by a factor of over seven trillion.

02. Modern GPU Hash Cracking Economics

Understanding entropy requires analyzing the attacker's physical hardware capabilities. Offline password cracking is an embarrassingly parallel computational task ideally suited to modern Graphics Processing Units (GPUs).

A standard enterprise password-cracking rig equipped with eight NVIDIA GeForce RTX 4090 GPUs running Hashcat achieves staggering raw throughput:

While modern slow hashing functions (such as Argon2id, scrypt, and bcrypt) introduce intentional memory hardness and iteration delays, databases leaked in historical breaches frequently contain unsalted MD5, SHA-1, or NTLM hashes. Length provides raw mathematical resistance regardless of backend hashing deficiencies.

03. The Inherent Flaws of `Math.random()`

Many developer utilities generate passwords using naive JavaScript patterns:

const chars = "abcdefghijklmnopqrstuvwxyz0123456789";
let password = "";
for (let i = 0; i < 16; i++) {
    password += chars[Math.floor(Math.random() * chars.length)]; // Insecure
}

In V8 and modern browser engines, Math.random() implements the Xoroshiro128+ pseudo-random number generator (PRNG). This algorithm is engineered for execution speed and statistical distribution in games or simulations, not cryptographic security.

Xoroshiro128+ maintains an internal state of only two 64-bit unsigned integers. By observing a small sequence of outputs (typically 2 to 5 consecutive floating-point numbers), an automated solver can reverse-engineer the internal state variables using basic Z3 theorem provers. Once the state is recovered, every past and future "random" output is completely deterministic and predictable.

04. Cryptographic Randomness via Web Cryptography API

Secure password generation requires a Cryptographically Secure Pseudo-Random Number Generator (CSPRNG). In the browser environment, this is provided natively by the Web Cryptography API: window.crypto.getRandomValues().

function generateSecurePassword(length = 20) {
    const charset = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!@#$%^&*";
    const randomValues = new Uint32Array(length);
    window.crypto.getRandomValues(randomValues);

    let result = "";
    for (let i = 0; i < length; i++) {
        result += charset[randomValues[i] % charset.length];
    }
    return result;
}

Unlike userspace math functions, crypto.getRandomValues interfaces with operating system kernel entropy pools:

• Linux / Android: Pulls from the kernel CSPRNG via getrandom() or /dev/urandom.
• Windows: Calls BCryptGenRandom leveraging TPM chip jitter and interrupt timings.
• macOS / iOS: Interfaces with arc4random_buf backed by Apple's CoreCrypto hardware engine.

By harvesting true physical environmental noise (thermal sensor variations, keyboard interrupt intervals, network packet micro-delays), the generated values satisfy both next-bit unpredictability and forward secrecy.