Edit: Passphrases vs Passwords: Why Diceware-…

Posts›Passphrases vs Passwords: Why Diceware-…

PublishedView Live →

Title

Slug

Preview: https://jwtsecretgenerator.com/blog/passphrase-vs-password-generator-guide

⚠ Changing the slug will break existing links to this post.

Description / Excerpt

162 / 180 characters

Content (Markdown)

# Passphrases vs Passwords: Why Diceware-Style Passphrases Are Easier to Remember and Harder to Crack

"Use a complex password with symbols and numbers" has been standard advice for decades, and it produces passwords like `Tr0ub4dor&3` — genuinely hard to remember, and, as it turns out, not even the strongest option available. A randomly generated multi-word passphrase like `correct horse battery staple` (the canonical xkcd example) can be both easier for a human to recall and harder for a computer to brute-force, if it's generated the right way. This guide explains why, and how to generate one properly.

## Where the "complex password" advice comes from — and where it falls short

The complexity rule (uppercase, lowercase, digit, symbol, minimum length) exists to increase entropy — the number of possible guesses an attacker has to try. More character types per position means more possible combinations. The problem is that humans respond to complexity requirements predictably: capitalize the first letter, add "1" or "!" at the end, substitute "a" for "@". Those patterns are well known to password-cracking tools, so a "complex" password that follows a predictable human pattern has far less real entropy than its character count suggests — cracking tools try these substitutions first, not last.

There's also the memorability problem: a password like `K9$mP2!vQx` is hard to memorize precisely because it's designed to look random, which pushes people toward reuse across sites or writing it down insecurely — both of which undermine the password more than weak entropy would.

## How a passphrase gets its strength

A passphrase built from randomly selected dictionary words takes a different approach to the same goal (entropy) via a different mechanism: instead of maximizing entropy per character, it maximizes entropy per *word*, and uses enough words to reach a comparable or greater total.

The classic method is **Diceware**: you have a word list (commonly ~7,776 words, chosen because that's 6⁵ — the number of outcomes from rolling five six-sided dice), and you select words by rolling dice (or, in a generator tool, using a CSPRNG) to pick an index into the list. Each word chosen this way contributes log₂(7776) ≈ 12.9 bits of entropy. A 6-word Diceware passphrase gives you roughly 6 × 12.9 ≈ 77 bits of entropy — comparable to or exceeding a reasonably long random password, while being made of ordinary words a human can actually chain into a mental image and recall.

The entropy math only holds if the words are selected **uniformly at random from a fixed list**, using an actual random process — not words you pick yourself. Human-chosen "random" words are not random; people gravitate toward common, short, related words (song lyrics, movie titles, personal associations), which collapses the effective entropy dramatically. This is the single most important rule: **you must not choose the words yourself.** Always use a proper random generator.

## Passphrase vs password: a direct comparison

| | Random password (e.g. 12 chars, mixed case + digits + symbols) | Diceware passphrase (6 random words) |
|---|---|---|
| Approx. entropy | ~78 bits (assuming true randomness across ~94 possible characters per position) | ~77 bits |
| Human-memorable? | Difficult — no semantic structure | Easier — can form a mental image/story |
| Resistant to pattern-based cracking? | Only if truly random per character (human-generated "complex" passwords often aren't) | Yes, as long as word selection is genuinely random |
| Typing on mobile | Awkward (symbol keyboard switching) | Easier (all lowercase letters and spaces) |
| Common site requirement friction | None (usually satisfies complexity rules) | Some older sites reject spaces or enforce symbol requirements |

The entropy numbers land in a similar range by design — the point isn't that passphrases are mathematically stronger in the abstract, it's that they achieve similar or better real-world entropy while being dramatically easier for a human to use correctly, which closes the gap between theoretical and *actual* security (a strong password nobody can remember often ends up written on a sticky note or reused everywhere, which is worse than a memorable-but-random passphrase used correctly).

## How to generate one correctly

The generation logic is simple, but it depends entirely on using a real CSPRNG to pick each word — the same principle as generating any cryptographic key.

**Node.js (using a word list array):**
```js
const crypto = require('crypto');

function randomWord(wordlist) {
  const index = crypto.randomInt(0, wordlist.length);
  return wordlist[index];
}

function generatePassphrase(wordlist, wordCount = 6, separator = '-') {
  return Array.from({ length: wordCount }, () => randomWord(wordlist)).join(separator);
}
```

**Python:**
```python
import secrets

def generate_passphrase(wordlist, word_count=6, separator="-"):
    return separator.join(secrets.choice(wordlist) for _ in range(word_count))
```

Note the use of `crypto.randomInt` / `secrets.choice` — both are CSPRNG-backed. Using `Math.random()` or `random.choice()` (the non-`secrets` version) would reintroduce exactly the predictability problem this whole approach exists to avoid.

If you'd rather not manage a word list yourself, our [Passphrase Generator](/tools/passphrase-generator) generates a Diceware-style passphrase client-side in your browser, with adjustable word count so you can dial in the entropy level you need.

## How many words do you need?

As a rough guide, using a ~7,776-word list:

- **4 words** (~51 bits) — acceptable for lower-stakes accounts, not recommended for anything sensitive.
- **6 words** (~77 bits) — a solid default for most personal accounts, comparable to a strong random password.
- **8 words** (~103 bits) — appropriate for high-value secrets (a password manager master password, disk encryption, cryptocurrency wallet).

For anything that's actually a cryptographic key rather than something a human types in — a JWT secret, an AES key, an API key — don't use a passphrase at all; generate raw random bytes directly, as covered in our [AES-256 key generation guide](/blog/aes-256-key-generation-guide) and [how to generate a JWT secret](/blog/how-to-generate-jwt-secret). Passphrases exist specifically to solve the "a human needs to remember this" problem; if nothing needs to remember it, skip the wordlist and generate maximum-entropy random bytes instead.

## FAQ

**Are passphrases accepted everywhere passwords are?**
Mostly, but some older systems have maximum length limits or reject spaces — check the target system's password policy before committing to a long passphrase, and have a separator-character fallback (hyphens instead of spaces) ready.

**Should I add numbers or symbols to a passphrase?**
It doesn't hurt, but it's not necessary if the word count already gives you sufficient entropy — the strength comes from the number of randomly selected words, not from bolting complexity requirements onto them. If a site forces symbol/digit inclusion, appending one random digit is enough; you don't need to scatter them throughout.

**Is `correct horse battery staple` itself a safe passphrase to use?**
No — it's famous precisely because it's an example, which means it's now in every password-cracking wordlist. Never use an example from an article (including this one) verbatim; always generate your own.

**How is this different from a mnemonic phrase for a crypto wallet (BIP-39)?**
Similar idea, different purpose and word list — BIP-39 seed phrases use a standardized 2,048-word list and encode actual key material with a checksum, not just a memorable secret. Don't substitute a generic Diceware passphrase for a wallet seed phrase or vice versa; use the tool designed for each purpose.

---

**Generate a secure passphrase now:** our free [Passphrase Generator](/tools/passphrase-generator) runs entirely in your browser.

*Related: [AES-256 key generation](/blog/aes-256-key-generation-guide) · [Password Hashing vs Encryption](/blog/password-hashing-vs-encryption)*

1218 words · ~7 min readMarkdown guide →

Tags (4/8)

passphrasepassword securityentropyauthentication

Author Name

Status

Cover Image URL (optional)

Danger Zone

Deleting this post sets its status to "deleted". It can be recovered via the API.