How to Create a Strong Password (and Why Length Beats Complexity)

For years the rule was a short password sprinkled with symbols: P@ssw0rd!. That advice was mostly wrong, and the organization that originally pushed composition rules has since walked them back. The factor that actually decides whether your password survives an attack is not how weird it looks but how much entropy it carries — and entropy is driven far more by length than by punctuation. This guide shows the math, then explains what modern guidance (NIST SP 800-63B) tells you to do instead, and why the answer depends on how you are actually being attacked.

Entropy, with the actual arithmetic

Password strength is measured in bits of entropy. Each bit doubles the number of guesses an attacker must make, so 52 bits is not "a bit more" than 51 — it is twice as much work. For a randomly generated password the formula is:

entropy (bits) = length × log2(alphabet size)

Run the numbers on the "complex" 8-character password everyone was told to use. Drawing 8 characters randomly from the full set of 95 printable ASCII symbols gives:

8 × log2(95) ≈ 8 × 6.57 ≈ 52 bits

Now compare a passphrase. Diceware picks words at random from a list of 7776, so each word contributes log2(7776) ≈ 12.9 bits regardless of how long or common the word is:

• A 4-word Diceware passphrase ≈ 4 × 12.9 ≈ 51.6 bits — already matching that gnarly 8-character symbol soup, and far easier to type and remember.
• A 5-word passphrase ≈ 5 × 12.9 ≈ 64.5 bits — that one extra word multiplies the number of possible passphrases by 7776, the full size of the word list.

That is the whole argument for length in one line: adding a character to the alphabet nudges log2(alphabet) up slightly, but adding length multiplies. A longer passphrase of ordinary words out-resists a short P@ss1! every time.

Why human "complex" passwords are weaker than they look

Here is the catch buried in that formula: it only holds when characters are chosen at random. Human-chosen passwords are not random, so their real entropy is a fraction of what the alphabet size implies. People follow the same handful of patterns — a capital letter first, the digits and a symbol crammed at the end, dictionary words with predictable a→@ and o→0 swaps. Cracking tools encode exactly these patterns and try them first.

So P@ssw0rd! has nowhere near the ~59 bits its length-and-alphabet would suggest. It is a single dictionary word with the most-guessed substitutions and the most-guessed decoration positions — a target that falls in the opening moments of any real attack. The nominal entropy formula is an upper bound you only reach by removing yourself from the choice and letting a generator pick.

The threat model changes everything: offline vs online

"How strong is strong enough?" has no single answer because there are two completely different attacks, separated by many orders of magnitude.

• Online guessing hits the live login form. It is rate-limited and lockout-protected: an attacker gets a handful of tries before being throttled or blocked. Against this, even a modest password that is not on the common-password lists holds up, because nobody is making millions of attempts.
• Offline cracking happens after a database is stolen. If the site stored passwords with a fast hash (MD5, SHA-256), an attacker runs billions of guesses per second against the stolen dump on a GPU, with no rate limit at all. This is the game that high-entropy passwords are really defending against.

Notice the two levers are not both yours. Whether the offline attack is cheap depends on how the site stored your password — a site using a slow, salted hash like bcrypt or Argon2id (see hashing vs encryption) collapses those billions-per-second into a few thousand, changing what "strong enough" even means. You cannot control that, which is exactly why length and uniqueness — the parts you do control — matter: a unique high-entropy password limits the blast radius to the one site that leaked it.

What NIST 800-63B actually recommends now

Modern guidance made a sharp turn away from the rules most sites still enforce. NIST's Digital Identity Guidelines (SP 800-63B) now say:

• Drop mandatory composition rules. Forcing an upper, a lower, a digit, and a symbol does not help — it just channels users into the predictable patterns above.
• Stop forcing periodic rotation. Mandatory "change your password every 90 days" backfires: users pick predictable increments (Password1 → Password2). Rotate only on evidence of compromise.
• Favor length and allow it. Accept passwords of at least 64 characters, and accept all printable characters including spaces — so long passphrases are permitted rather than blocked by a misguided max-length or character filter.
• Screen against breach lists. Check new passwords against known-compromised-password corpora and reject matches. This does far more real-world good than any symbol requirement.

If a site still forces you to add a symbol and rotate every quarter, it is following advice its own authors retired.

A practical recipe

1. Length first. A 4–5 word random passphrase or 16+ random characters clears the bar for anything that matters.
2. Truly random, not personal. MyDogRex2020 is a passphrase in form only; a pet name and a year are guessable. Entropy comes from random selection, not from the words being words.
3. Unique per site. Reuse is the number-one cause of account takeover — one breach becomes every account via credential stuffing.
4. Use a password manager. No human should invent and recall dozens of unique 16+ character secrets. Let the manager generate and store them; you memorize one strong master passphrase and protect it well.
5. Add a second factor. Even a perfect password benefits from 2FA, which defeats a stolen-password replay outright.

The browser-based Password Generator creates long random passwords and passphrases with adjustable length and character sets, entirely on your device, so the generated value never leaves your machine.

Mistakes that quietly weaken your passwords

• Reusing passwords across sites — the fuel for credential-stuffing attacks
• Basing them on personal info — names, birthdays, pets, sports teams
• Tiny increments like Summer2024 → Summer2025
• Predictable substitutions — @ for a, 0 for o
• Keyboard walks like qwerty or 1qaz2wsx

Generate strong passwords and keys

These tools run entirely in your browser, so generated values never leave your device:

Conclusion

A strong password is a long, random, unique one — and the entropy math shows why: a 5-word random passphrase (~64 bits) beats a tortured 8-character P@ss1! because length multiplies while symbols barely add. Human-chosen "complexity" collapses to predictable patterns, so let a generator do the choosing. Follow the current guidance — length over composition rules, screening over forced rotation — lean on a password manager for uniqueness, and add a second factor. Those habits defeat the overwhelming majority of real-world attacks, online and offline.