Password Entropy Math, Brute-Force Feasibility, and Generating High-Security Credentials

What is Password Entropy and How is it Measured?#

Password entropy is a measurement of the unpredictability and randomness of a secret string, derived from Claude Shannon’s foundational work on Information Theory. It quantifies how many binary guesses (bits) an automated attacker would need to systematically test every possible permutation in the worst-case scenario.

Each additional bit of entropy doubles the total number of attempts required to exhaust the keyspace ($2^H$). A password with 60 bits of entropy requires $2^{60}$ (~1.15 quintillion) guesses to guarantee a brute-force match.

The Mathematical Entropy Formula: H = L × log2(R)#

The entropy $H$ of a randomly generated string is calculated using the pool size $R$ (number of possible characters) and the string length $L$:

Formula: H = L × log2(R)

Where:
- H = Entropy in bits
- L = Length of the password
- R = Size of the character pool (keyspace per character)

Common Character Pool Sizes (R):
- Numbers only (0-9):                R = 10 (log2(10) ≈ 3.32 bits/char)
- Lowercase letters (a-z):           R = 26 (log2(26) ≈ 4.70 bits/char)
- Upper + Lowercase (a-z, A-Z):      R = 52 (log2(52) ≈ 5.70 bits/char)
- Alphanumeric (a-z, A-Z, 0-9):      R = 62 (log2(62) ≈ 5.95 bits/char)
- Full Printable ASCII (with symbols): R = 94 (log2(94) ≈ 6.55 bits/char)

Modern GPU Cracking Speeds and Brute-Force Feasibility#

Modern offline password cracking rigs utilizing dedicated GPU arrays (such as eight NVIDIA RTX 4090 GPUs) can execute over 200 billion NTLM or MD5 hash evaluations per second.

Why Length Trumps Complexity: Passwords vs Passphrases#

National Institute of Standards and Technology (NIST) Special Publication 800-63B officially discourages legacy composition rules (e.g., mandating at least one uppercase letter, one digit, and one special character).

When forced to include special symbols, humans predictably replace letters with obvious substitutions (e.g., "@" for "a", "!" at the end), which automated cracking tools anticipate via mask attacks. Increasing the length of a passphrase composed of 4 to 6 genuinely random dictionary words yields higher entropy while remaining easy for human users to remember.

Cryptographically Secure Randomness (CSPRNG) in the Browser#

When generating passwords or cryptographic keys in client-side software, developers must never use `Math.random()`. JavaScript’s `Math.random()` utilizes a pseudo-random number generator (PRNG) like Xoroshiro128+, which is deterministic and predictable.

Always use the Web Crypto API’s `crypto.getRandomValues()`, which interfaces with kernel-level hardware entropy sources (such as thermal noise and interrupt timings).

// ❌ Insecure: Math.random() is predictable
function insecureRandomChar(pool) {
  return pool[Math.floor(Math.random() * pool.length)];
}

// ✅ Cryptographically Secure: Web Crypto API (CSPRNG)
function secureRandomPassword(length = 16) {
  const charset = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789!@#$%^&*()-_=+";
  const randomBytes = new Uint32Array(length);
  window.crypto.getRandomValues(randomBytes);
  
  return Array.from(randomBytes)
    .map((val) => charset[val % charset.length])
    .join('');
}

Frequently Asked Questions about Password Security#

Key security questions answered:

• What is the minimum recommended password entropy? Security standards recommend at least 64 bits of entropy for everyday web accounts and 80+ bits for master passwords and cryptographic root keys.
• Are online password generators safe? Only if they generate keys 100% locally in your browser without transmitting generated strings over the network.
• How can I generate cryptographic hashes locally? You can use Softnag’s Hash Generator to calculate SHA-256 and HMAC hashes in your browser with complete privacy.