What Is a Mnemonic Password? 3 Examples Dissected With Real Entropy Numbers

The classic XKCD comic – the one where “correct horse battery staple” beats “Tr0ub4dor&3” on both memorability and strength – has been shared around the internet so many times that it’s a security meme at this point. It’s a great illustration: a passphrase built from ordinary words can be harder to crack than a short string of random-looking characters.

But here’s what most people miss about that comic. “Correct horse battery staple” wasn’t invented by a human trying to be clever. It was generated by randomly selecting words from a large dictionary – a technique called Diceware. That random selection is the source of its strength.

A lot of people take the wrong lesson from that comic. They think, Okay, I’ll just make up my own phrase and substitute a few letters with numbers and symbols. That’s a mnemonic password. And it’s not the same thing at all.

I’ve been digging into these patterns recently, running real examples through different entropy calculators, and the gap between what people think their mnemonic passwords are worth and what they’re worth is kind of shocking. Let me show you exactly what I found.

What is a mnemonic password? (And why it’s not the same as a random passphrase)

A mnemonic password is something you invent yourself – a memorable phrase, a song lyric, a sentence that means something to you, often with character substitutions thrown in to make it look more complex. You take something like “My dog likes bones” and turn it into MyD0gL1kesB0nes!. You swapped some letters for numbers, added a capital letter, threw a symbol on the end. Feels clever?

A random passphrase like “correct horse battery staple” uses words chosen by a random process – dice rolls, a cryptographically secure random generator, something that has no human bias. That means its entropy is predictable. A four-word Diceware phrase gives you about 50–52 bits of entropy, and you can calculate that exactly because you know the generation method.

A mnemonic password? You made it up. That’s the weakness.

Entropy is measured in bits – it’s basically the “surprise factor” for an attacker trying to guess your password. More bits means more guesses required, which means more time. The formula is straightforward: entropy equals length times the base-2 logarithm of the character set size, where L is the length and R is the number of possible characters. On a standard US keyboard, you’ve got 26 lowercase letters, 26 uppercase letters, 10 numbers, and 32 special symbols – 94 total if you use all types.

That formula only works if every character is chosen randomly from the full set. When a human picks the characters, they don’t pick randomly. They pick patterns.

There’s a fundamental rule in cryptography called Kerckhoffs’s principle: you should assume the attacker knows your method. If you used a pattern, they’ll try that pattern. And your “clever” substitution trick? Attackers saw it coming.

Red flag: A human-picked password with substitutions follows predictable patterns. Attackers pre-compute leetspeak variants (0 for o, 1 for i, 3 for e) and test them first. Your “clever” trick is in their dictionary.

Example 1: MyD0gL1kesB0nes! – a simple mnemonic dissected

Let me show you one I’ve been looking at. MyD0gL1kesB0nes! – 13 characters, mixed case, numbers, a symbol on the end. If you plug this into a simple entropy calculator that assumes every character is randomly chosen from the full 94-character set, you get a number that looks respectable.

The problem is that’s not how this password was generated.

Let’s break it down piece by piece. My – capital M, common start. D0g – the letter o replaced with a zero. L1kes – the letter i replaced with a one.

B0nes – another o replaced with a zero. ! – a common ending symbol. This is a sentence with a leetspeak substitution layer on top.

An attacker who knows what they’re doing doesn’t try every possible 13-character combination. They grab a dictionary of English words. They add leetspeak substitutions – 0 for o, 1 for i, 3 for e, 4 for a, that whole set. They add pet names, because “dog” is a pet reference. And suddenly the search space collapses.

Look at what happened with a similar pattern: HelpFidoSaveTony33!. Proton’s entropy calculator claimed 117 bits for that one. KeePassXC, which checks against a dictionary, said 52 bits. That’s a gap of 65 bits. Same password, different assessment, because one tool assumed random generation and the other assumed human generation — which naturally leads to the question: what are some good passwords to remember?

MyD0gL1kesB0nes! follows the same pattern. That dictionary-aware estimate in the 50-bit range is the realistic one.

To put that in perspective, researchers have demonstrated brute-force speeds of 350 billion guesses per second. An 8-character mixed-case plus numbers password takes about 3 years at that speed, which highlights the easy passwords to remember 8 characters challenge of balancing memorability with entropy. A 50-bit password is in the territory where cracking hardware starts to become a threat.

Example 2: Ilove2EatPizza! – a longer mnemonic with common words

Okay, so maybe you’re thinking, “Fine, but what if I make it longer?” That’s the instinct. If 13 characters isn’t enough, 15 characters will fix it, right?

Here’s where it gets interesting. Ilove2EatPizza! is 15 characters – two more than the first example. It uses English words, a predictable substitution (2 for “to”), and another sentence structure. On paper, the raw length suggests more entropy.

But an attacker using a bigram-based model – one that looks at two-character sequences, n-grams, the way words fit together in English – can crack this faster than the length suggests. The phrase “I love to eat pizza” is not a random string of characters. It’s a high-frequency English sentence with a trivial substitution. The structure is predictable.

The hammer for this point is P[rmDrds,r. This string looks random at first glance. Under a random 95-printable-character model, it scores 65.7 bits – not amazing, but not terrible. But if you generated it by shifting your fingers one key to the right on a QWERTY keyboard?

Under that model, it’s 16 bits. Same string. Different strength.

This is the insight. Entropy is not a property of the password itself. It’s a property of how you generated it. If an attacker knows your method – and Kerckhoffs’s principle says you should assume they do – the entropy collapses to whatever that method allows.

Ilove2EatPizza! is longer than MyD0gL1kesB0nes!, but under a realistic model that accounts for English phrases and basic substitutions, it’s still in the weak zone. The length helps, but not as much as you’d think.

Example 3: A high-entropy mnemonic using unrelated words (ClocksPuzzleJazzBroom)

Alright, so what if you do it right? What does the best possible mnemonic look like?

You need unrelated words from different domains. No “I love my dog” narrative. No song lyrics. No phrases that an English bigram model would predict. You need words that don’t follow each other.

Something like ClocksPuzzleJazzBroom. Four nouns from unrelated categories. No sentence structure. No predictable sequence.

You can throw in some random casing – ClocksPuzzleJazzBroom already has capital letters at the start of each word, which helps a little. Add a substituted digit and a symbol, and you’ve got something like Cl0cksPuzzl3JazzBr00m!.

Under a dictionary model where each word contributes roughly 11 bits, four words give you about 44 bits. The substitutions and casing add a bit more, but you’re still looking at maybe 50 bits total. Even the best mnemonic construction with unrelated words and random casing stays below the 75-bit threshold.

And that threshold matters. 75 bits is the minimum for a strong password. 100+ bits is the secure target. 75–80 bits is enough to resist known brute-force attacks. A well-constructed mnemonic might get you to 60–65 bits on a good day. It’s better than MyD0gL1kesB0nes!, but it’s not in the strong zone.

Consider the Bankruptcies example. Proton’s calculator claimed 68 bits for that single word. KeePassXC said 16 bits. A single dictionary word, even a long one, is worthless against a dictionary attack. Your four-word mnemonic is better, but it’s still not good enough for your bank account.

The hidden weakness: entropy depends on the attacker’s model

Entropy isn’t a number attached to a password like its height or its weight. It’s a number that depends on what the attacker assumes about how you generated it.

P[rmDrds,r under a random model: 65.7 bits. Same string under a shifted-keyboard model: 16 bits. The difference isn’t in the string. It’s in the assumption.

This applies to every mnemonic password. If the attacker knows you used a phrase, the entropy collapses. If they know you used leetspeak substitutions, they can enumerate those substitutions. If they know you used a keyboard pattern, they can check those patterns. Kerckhoffs’s principle isn’t theoretical paranoia – it’s a direct statement about how real-world attackers operate.

The HelpFidoSaveTony33! discrepancy – 117 bits from Proton, 52 bits from KeePassXC – isn’t a bug in the calculator. It’s a demonstration of two models making two assumptions. The KeePassXC number is more realistic because it accounts for dictionary words. The Bankruptcies gap – 68 vs 16 bits – is more dramatic because it’s a single dictionary word.

At 350 billion guesses per second, a 50-bit password doesn’t last long. The speed of modern cracking hardware makes every bit of entropy matter. Each additional bit doubles the attacker’s work, but each pattern you introduce can halve it just as easily.

When to use a mnemonic password vs. a password manager

So after all that, when is a mnemonic password okay to use?

NIST’s current guidelines are sensible on this. They recommend a minimum of 8 characters, allow up to 64, skip arbitrary complexity rules, use blocklists to prevent common passwords, and only force a change when there’s a suspected breach. They’re prioritizing memorability over arbitrary complexity, which is the right call for real-world usability.

For low-risk accounts – newsletters, forums, accounts where a breach would be annoying but not catastrophic – a well-constructed mnemonic can work. If you build it from at least 20 characters using unrelated words with random casing and avoid personal information (pet names, birthdays, street names – attackers scrape that from social media), you’re in a reasonable zone. It’s not strong by the 75-bit standard, but it’s strong enough for a forum account.

Bottom line: A mnemonic password built from four unrelated words tops out around 50-60 bits. That’s fine for a forum account, but your email or bank needs 75+ bits. Use a password manager for anything that matters.

For security-critical accounts – banking, email, anything with personal data or financial access – you need a password manager. Full stop. Password managers generate and store high-entropy passwords that exceed the 75-bit threshold. Something like kmXz2=zs[m%7?y4A at 105 bits is what a strong password looks like.

A 15-character password using all character types would take 56 trillion years to crack at current speeds. Apple’s default 18-character password buys you about 2 quadrillion years.

Tools like Proton Pass, Apple Passwords, and 1Password all generate these automatically. KeePassXC has one of the best entropy calculators because it checks against dictionaries. They solve the memorability problem by handling the storage themselves. You only need to remember one master password or use biometric unlock.

The tradeoff you need to know

Here’s where we land. MyD0gL1kesB0nes! looks clever but collapses to around 52 bits. Ilove2EatPizza! is longer but still weak against bigram-based attacks. Even the best mnemonic construction with unrelated words and random casing stays below the 75-bit threshold that security-critical accounts demand.

Entropy isn’t about what your password looks like. It’s about how you generated it. Human brains are terrible at randomness. Attackers know this. They build their tools to exploit it.

For low-risk accounts, a 20+ character mnemonic made from unrelated words with random casing is fine. For everything that matters – your email, your bank, your primary account – use a password manager. It’s not about being lazy. It’s about understanding that the math doesn’t work in your favor when you try to outthink the attacker with a phrase. The math works when you let randomness do its job.

People Also Ask