← Back to all guides

What Actually Makes a Password Hard to Crack (It's Not the Exclamation Point)

Published October 20, 2026

Length and unpredictability beat clever substitutions every time — here's how to generate a genuinely strong password, check it against real cracking assumptions, and understand what a password hash actually protects.

Most password rules are theater. "At least one uppercase letter, one number, one symbol" feels rigorous, but it trains people to turn password into P@ssw0rd!, which is not meaningfully harder to guess — it's one of the first substitutions any cracking tool tries. If you've ever wondered why your IT department's password policy produces passwords you can barely remember but that still show up in breach databases, this is why: the rule optimizes for the appearance of complexity, not for actual resistance to cracking.

The real story is simpler and more mathematical than "mix it up." It comes down to two things: how long the password is, and how unpredictable it is to something that isn't a human trying to guess it by hand.

Why length beats cleverness

Password strength against brute-force guessing is fundamentally about entropy — roughly, how many possible passwords a cracking tool would have to try before it's likely to hit yours. Entropy scales with two things: the size of the character set you're drawing from, and the number of characters you use.

Here's the part that surprises people: adding length multiplies the search space exponentially, while adding a "required symbol" to an otherwise-short password barely moves the needle. An 8-character password using lowercase, uppercase, digits, and symbols has roughly 94^8 possible combinations — about 6 quadrillion. That sounds like a lot until you remember that modern offline cracking rigs (the kind used against a stolen database of hashes, not a live login form) can try billions of guesses per second against weakly-hashed passwords. Six quadrillion at a few billion guesses a second is hours to days, not centuries.

Compare that to a 20-character passphrase like correct-horse-battery-staple-42 — lowercase letters, hyphens, and a couple of digits, nothing exotic. Even restricting the character set, the sheer length pushes the combination count into the trillions of trillions. It's also something a human can actually memorize, because it's built from words and a pattern, not a random jumble. This is the core insight behind the famous XKCD "correct horse battery staple" argument, and it still holds up: four or five random, unrelated words strung together will usually outlast an 8-character "complex" password, while being dramatically easier to type and remember.

None of this means symbols and numbers are useless — a longer password that also uses a large character set is stronger than one that doesn't. The point is that length is doing most of the work, and if you have to trade one for the other, length wins.

Step 1: Generate something genuinely random

The best way to get a strong password isn't to think one up — the moment a human invents a password, it stops being random, because human-generated "randomness" leans on patterns (keyboard walks like qwerty123, birth years, pet names, leetspeak substitutions) that cracking dictionaries are specifically built around. Attackers don't start with blind brute force; they start with lists of real breached passwords and common patterns, because that's where the easy wins are.

Use Password Generator to produce something with no human fingerprints on it. Set it to a meaningful length — 16 characters is a reasonable floor for anything important, 20+ for something like a password manager master password — and include the full character set (lowercase, uppercase, digits, symbols) unless the site you're registering on has an unusually restrictive policy. Because the generator runs entirely in your browser, the password it produces is never transmitted anywhere or logged on a server; it exists only on your screen until you copy it.

If you need something memorable and strong — say, a master password you'll type by hand regularly rather than paste from a manager — lean toward the passphrase approach: several unrelated words, plus a separator and a number or two. Length first, complexity second.

Step 2: Check it against realistic cracking assumptions

Once you have a candidate password, run it through Password Strength Checker. A good strength checker isn't just counting character types — it's estimating actual crack time under different attack scenarios (an online attack throttled by login rate limits, versus an offline attack against a stolen hash database with no throttling at all), and checking whether the password or its components show up in known breach patterns.

This step matters even for generator output, for one practical reason: it catches cases where a website's own rules force you to shorten or simplify what the generator gave you. If a signup form caps passwords at 12 characters or disallows certain symbols, you want to re-check the resulting password rather than assume it's still as strong as the original 20-character version you generated.

Pay attention to what the checker tells you about why a password is weak, not just the pass/fail verdict. "Too short" means add length. "Common pattern detected" means the structure — not just the specific characters — needs to change, because pattern-matching is exactly what breach-trained cracking dictionaries are good at.

A practical aside: what a password hash actually is

This is worth understanding even if you never touch a line of backend code, because it explains why "the company got breached" doesn't automatically mean "your actual password is now public" — and also why it sometimes effectively does.

No reasonably-built service stores your actual password. Instead, when you set a password, the service runs it through a one-way hash function and stores only the output — the hash. A hash function takes an input of any length and produces a fixed-length string of characters, and critically, it's designed to be practically impossible to reverse: you can't take the hash and recover the original password from it directly. When you log in later, the service hashes whatever you just typed and compares that new hash against the stored one. If they match, you typed the right password — the service never needed to store or even look at your actual password to verify this.

This is why a company can truthfully say "we don't know your password" while still being able to log you in. It's also why, when a breach happens and a database of password hashes leaks, the attacker's job isn't "read the passwords off the screen" — it's "guess candidate passwords, hash each one, and see which hashes match." That's exactly the brute-force process described above, run offline against the stolen hash list instead of against a live login form. A long, random password is dramatically more resistant to this because the attacker has to actually search that enormous combination space — there's no shortcut from having the hash alone, assuming the hash function itself is sound.

You can see this mechanic directly with Hash Generator. Type in a sample password and generate, say, a SHA-256 hash of it — you'll get a 64-character string that looks nothing like the input and gives no hint about its length, character set, or content. Try it again with a password that differs by a single character and notice the output is completely different, not just "slightly different" — that's a deliberate property of good hash functions called the avalanche effect, and it's part of why hashes can't be reverse-engineered by inspection. This is purely for testing and learning how the mechanism works; it's not how you'd protect a production login system, which needs a slow, purpose-built password hashing algorithm (bcrypt, scrypt, or Argon2) rather than a fast general-purpose hash like SHA-256 — fast hashes are actually a liability for passwords specifically, because "fast to compute" also means "fast to brute-force." That nuance is a whole topic on its own, but it's worth knowing that not all hashing is equal, even though all of it is one-way.

Putting it together

  1. Generate a long, fully random password or passphrase with Password Generator — favor length over cleverness, 16+ characters as a floor.
  2. Verify it with Password Strength Checker, especially if a site's rules forced you to shorten or alter it.
  3. If you're curious how the "we don't store your password" claim actually works, experiment with Hash Generator on a few sample strings and watch how unpredictably the output changes with tiny input changes.
  4. Use a unique password per site — strength doesn't help you if one breached, reused password unlocks everything else.

Everything above runs client-side in your browser: nothing you generate, check, or hash is sent to a server or logged anywhere, which is exactly the property you want when the whole point of the exercise is keeping a secret secret.

← Back to all guides