Passphrases vs Passwords: Why Four Random Words Beat Random Characters

The Password Usability Trap

Security policies that mandate "at least 8 characters with uppercase, lowercase, number, and symbol" produce predictable patterns: Password1!, Welcome@2024, Company#123. These satisfy the rules but are trivially guessable.

Meanwhile, four random dictionary words — correct-horse-battery-staple — are both more secure and easier to remember. Here's the math.

Understanding Entropy

Password strength is measured in bits of entropy — the base-2 logarithm of the number of possible combinations.

Entropy = log₂(alphabet_size ^ length)

Six Diceware words have more entropy than a 12-character mixed-character password, and are dramatically easier to remember.

The Diceware Method

Diceware is the gold standard for passphrase generation. It uses physical dice (or a CSPRNG) to index into a published word list:

1. Roll five dice to get a 5-digit number like 34512
2. Look up 34512 in the Diceware list → horse
3. Repeat for each word
4. Combine: horse blanket fiddle mirror stone lemon

The security comes from the randomness of the selection, not the words themselves. An attacker knows you used Diceware — they still have 7,776^6 ≈ 2.2 × 10²³ combinations to try.

Why Random Matters — Not "Memorable"

The critical mistake: choosing words that "go together" (sunny beach vacation) instead of random ones.

# ❌ NOT a passphrase (predictable theme)
sunny beach vacation trip

# ✅ Correct passphrase (random words)
furnace pebble yacht democracy

If you choose words that make a story, you've reduced the search space to "phrases that make sense" — far smaller than the full word list raised to the power of the number of words.

Entropy in Code

// Using Web Crypto API (browser) or crypto module (Node.js)
async function generatePassphrase(wordCount = 5) {
  const wordList = await fetch("/wordlist.txt").then(r => r.text())
  const words = wordList.split("\n").filter(Boolean)

  const indices = new Uint32Array(wordCount)
  crypto.getRandomValues(indices)

  return Array.from(indices)
    .map(i => words[i % words.length])
    .join("-")
}

// Never use Math.random() for security
// Math.random() is NOT cryptographically secure
const bad = Math.random()   // ❌
const good = crypto.getRandomValues(new Uint32Array(1))[0]  // ✅

NIST Guidelines (SP 800-63B)

NIST's 2017 password guidelines (updated 2024) recommend:

• Minimum 8 characters (15 recommended)
• Support up to 64 characters — do not impose maximums that prevent passphrases
• Do not require complexity rules (uppercase/symbols/numbers requirements)
• Check against breached password lists (HaveIBeenPwned API)
• Allow all printable Unicode characters
• Do not expire passwords unless there is evidence of compromise

When to Use Passphrases vs Random Strings

Generate a secure random passphrase instantly with HeoLab's Passphrase Generator — uses the Web Crypto API for true randomness.

Conclusion

Four random Diceware words provide ~50 bits of entropy — roughly equivalent to a 9-character random mixed-character password — but are far more memorable. Six words (~77 bits) is effectively uncrackable with any foreseeable computing power. Drop the complexity rules, embrace passphrases, and teach your users that length is the real security property.