Password Entropy and How Strength Checkers Evaluate Credentials

For years, sign-up forms enforced rigid composition checklists: "Must be at least 8 characters and include 1 uppercase letter, 1 lowercase letter, 1 digit, and 1 special symbol." The result was predictable across millions of accounts—people typed a common dictionary word, capitalized the first letter, added the current year, and put an exclamation mark on the end, producing passwords like Summer2026! or Welcome1!.

Those strings pass every naive regex composition rule while offering very little real protection against modern password-cracking tools. To understand what actually makes a credential resilient—and how a thoughtful strength evaluator scores an input—we need to look at information entropy and human pattern predictability.

The Math of Password Entropy (in Bits)

When every character in a password is chosen independently and uniformly at random from a character pool of size R, the total number of possible passwords of length L is R^L. In information theory, entropy E is measured in bits using the base-2 logarithm of that search space:

E = L * log2(R)

Each additional bit of entropy doubles the number of guesses an attacker must make on average. Consider standard ASCII character pools:

• Digits only (0–9, pool size 10): log2(10) ≈ 3.32 bits per character. A random 6-digit PIN has only ~19.9 bits of entropy (1,000,000 total combinations).
• Lowercase letters (a–z, pool size 26): log2(26) ≈ 4.70 bits per character.
• Mixed-case alphanumeric (a–z, A–Z, 0–9, pool size 62): log2(62) ≈ 5.95 bits per character.
• Full printable pool with symbols (pool size ~90+): log2(90) ≈ 6.49 bits per character.

Notice what happens in the formula E = L * log2(R): length L is the linear multiplier, whereas expanding the character pool R grows slowly inside a logarithm! Look at a concrete comparison:

8 random characters from pool 90:   8  × 6.49 =  51.9 bits
16 random lowercase letters (a-z):  16 × 4.70 =  75.2 bits
20 random alphanumeric+symbols:     20 × 6.49 = 129.8 bits

A 16-character random lowercase string has over 23 more bits of entropy—more than eight million times as many combinations—than an 8-character string using uppercase, lowercase, digits, and symbols!

Why Naive Pool Math Overestimates Human Passwords

The formula E = L * log2(R) holds true only when a cryptographically secure random generator picked every character. Humans do not pick characters uniformly at random.

Real offline cracking tools (such as Hashcat and John the Ripper) do not start at aaaaaaaa and increment blindly through zzzzzzzz. Instead, they execute prioritized attack modes in order:

1. Breached password lists: Testing millions of previously leaked credentials verbatim.
2. Dictionary + rule mutations: Taking English words, names, sports teams, and keyboard walks, then applying automated rules—capitalizing the first letter, appending 123, !, or four-digit years (1990–2029), and applying leetspeak substitutions (p@ssw0rd, 3 for e, 0 for o).
3. Keyboard adjacency & repeats: Sequences like qwertyuiop, asdfghjkl, 1qaz2wsx, or aaaaaa.
4. Combinator & mask attacks: Pairing two short words together or targeting masks like ?u?l?l?l?l?l?d?d?s (one uppercase, five lowercase, two digits, one symbol).

Because attackers model these exact habits, a good strength evaluator cannot just count character classes. When you test a synthetic sample in the Password Strength Checker, it inspects length, character variety, repeated runs, sequential runs (abcd, 1234), keyboard patterns, and common dictionary roots so predictable patterns receive an honest warning rather than an inflated score.

Online Throttled Attacks vs. Offline Hash Cracking

When interpreting crack-time estimates in a strength checker, keep in mind there are two very different threat scenarios:

• Online attacks: An attacker submits login attempts against a live web server. If the server enforces rate limiting, account lockouts, or multi-factor authentication (MFA), the attacker might only manage a few guesses per minute.
• Offline attacks: An attacker obtains password hashes from a database backup or breach and tests guesses locally on GPU hardware with zero network latency. Against a weak unsalted hash, a GPU rig can test billions of candidates per second; even against a strong salted Argon2id or bcrypt hash (which slows guesses down to thousands per second), passwords under 45–50 bits of real entropy remain vulnerable over days or weeks.

Aiming for at least 75–80+ bits of genuine random entropy (for example, a 14–16+ character random password stored in a password manager, or a 5–6 word randomly rolled Diceware passphrase) keeps credentials safe against offline cracking scenarios.

Modern NIST SP 800-63B Guidance for Developers

If you are building authentication for a web application, NIST Digital Identity Guidelines (SP 800-63B) and OWASP Authentication Cheat Sheets recommend moving away from frustrating legacy rules:

• Prioritize minimum length (at least 8 characters minimum, and ideally encourage 12–15+ characters) while allowing long passphrases up to at least 64 characters.
• Do not block paste functionality on password inputs! Blocking Ctrl+V / Cmd+V discourages password managers and pushes users back toward short, memorable passwords.
• Allow all printable ASCII characters and spaces without silently truncating passwords.
• Screen new passwords against known breached credential lists (or k-anonymity range checks) rather than forcing arbitrary symbol rules or mandatory 90-day password rotation (unless a compromise is suspected).

Generating Credentials with crypto.getRandomValues

Never use Math.random() in JavaScript to generate passwords, reset tokens, or session IDs—Math.random() is a non-cryptographic pseudo-random number generator whose internal state can be reconstructed from observed outputs.

Modern browsers expose the Web Crypto CSPRNG via window.crypto.getRandomValues():

function generateSecurePassword(length, charset) {
  const randomValues = new Uint32Array(length);
  window.crypto.getRandomValues(randomValues);
  let output = '';
  for (let i = 0; i < length; i++) {
    output += charset[randomValues[i] % charset.length];
  }
  return output;
}

That client-side Web Crypto approach powers the Password Generator, letting you create long, unpredictable credentials right inside your browser tab without any network call. And when experimenting with the Password Strength Checker, always test synthetic examples that resemble a structure you are curious about—never paste your live banking, email, or production passwords into any web page.