How is password strength measured?

By entropy in bits: log2(pool size) × length. An 8-character password from a 94-symbol pool has log2(94) × 8 ≈ 52.4 bits. Each extra character from the same pool adds the same number of bits, which is why length is the cheapest strength upgrade.

Does 'P@ssw0rd!' style complexity still matter?

Less than people think. Modern guidance (NIST SP 800-63B) emphasizes length, uniqueness and rate-limiting over forced symbol rules, because mandatory complexity pushes predictable patterns like Season+Year!123.

Home › Guides › Passwords

Password Strength Explained: Entropy & Crack Time

Q: Is 'P@ssw0rd!' a strong password?

No. Swapping letters for look-alike symbols (a→@, o→0) adds almost no real entropy because cracking tools try those substitutions first. 'P@ssw0rd!' is a dictionary word with cosmetic changes — a 4-word passphrase like 'copper-lantern-drift-mango' is far stronger and easier to remember.

Q: How long should a password be in 2026?

For everyday accounts, 14+ random characters or a 4-word passphrase (~50+ bits). For high-value accounts like banking and email, 16+ characters or a 5-word passphrase. Length matters more than exotic symbols once you pass ~12 characters.

Q: Why shouldn't I reuse passwords?

Credential-stuffing attacks take leaked username/password pairs from one breach and try them on hundreds of other sites automatically. A unique password per account limits any single breach to that one account. A password manager makes uniqueness practical.

Last updated: September 2026 · Independently QA-tested formulas

Quick answer: Password strength is entropy: bits = log2(pool size) × length. Bigger pool and more characters multiply. The password generator builds high-entropy passwords and shows the math, while the entropy calculator and crack-time tool break down any password's realistic resistance.

Most password advice is folklore — swap a for @, add a number, change it every 90 days. The actual math is simpler and more useful: strength is a bit count, and a few honest calculations show where real strength comes from.

The entropy formula (the only one you need)

bits = log2(alphabet size) × length

The alphabet is the set of characters a cracker must try. Common pools:

The entropy formula (the only one you need)
Pool	Size	Bits per character
Digits only (0–9)	10	3.32
Lowercase a–z	26	4.70
+ uppercase	52	5.70
+ digits (62)	62	5.95
Full keyboard (94)	94	6.55
3,000 common words	3,000	11.55

Worked examples

8 characters, full pool: 6.55 × 8 ≈ 52 bits
16 characters, lowercase only: 4.70 × 16 ≈ 75 bits — lowercase and long beats short and symbol-heavy.
4-word passphrase: 11.55 × 4 ≈ 46 bits; a 5th word pushes it near 58.
6-digit PIN: 3.32 × 6 ≈ 20 bits — fine for a phone screen lock with rate-limiting, useless for a website account.

Why length beats symbol swaps

Cracking tools try human patterns first: dictionary words, then leet-speak variants (a→@, s→$, o→0), then append years. P@ssw0rd! survives none of those filters. Meanwhile every extra random character multiplies the search space by the full pool size. A cracker facing 75 bits of lowercase does 2²³ ≈ 8 million times more work than one facing 52 bits of keyboard chaos.

Crack time — with the honest caveat

Offline attack speed depends on the hash: against fast hashes (unsalted MD5/SHA-1, still common in old leaks) consumer GPUs test billions of guesses per second; against properly salted slow hashes (bcrypt, Argon2) the same hardware manages thousands. That spread is why good sites store passwords slowly — the slow storage is a defense. Crack-time estimates are therefore a range, not a guarantee; treat any single number as one scenario.

Practical rules

Unique per site — credential stuffing reuses breached pairs everywhere, so one reused password burns many accounts.
Longer than clever — 16+ random chars or a 4–5 word passphrase.
Password manager — you only need to memorize one strong master passphrase.
2FA everywhere it matters — a second factor converts a leaked password from account takeover into a blocked login.
No forced 90-day rotation for rotation's sake — NIST guidance dropped it because predictable incrementing (Password1 → Password2) weakens passwords. Change on evidence of compromise.

Assumptions and limitations

Entropy math assumes truly random selection. Humans are biased (dates, names, keyboard walks) and add far fewer bits than the formula suggests.
Genuine randomness needs a CSPRNG — the generator tools use the browser's crypto.getRandomValues, not Math.random.
Crack-time numbers assume the attacker has the hash database. Online attacks are rate-limited far harder.

Related calculators

Worked example: Password Entropy Calculator at its default inputs

This is the answer Password Entropy Calculator gives before you touch anything — the defaults as shipped, computed live rather than copied from a sample.

Default inputs
Input	Default
Password Length	12
Character Pool Size (26 lower, 52 mixed case, 62 alphanumeric, 95 all ASCII)	62

Result: Entropy: 71.5 bits

The steps behind that answer

Formula: entropy = length × log₂(pool size)
Step 1: log₂(62) = 5.9542
Step 2: bits = 12 × 5.9542 = 71.5
Each extra character multiplies search space by the pool size — length beats complexity

Sensitivity: Password Length from half to one-and-a-half times

Hold every other field still and move only password length.

Sensitivity: Password Length from half to one-and-a-half times
Password Length	Result
6	Entropy: 35.7 bits
12	Entropy: 71.5 bits
18	Entropy: 107.2 bits

If the rows barely differ, password length is not your lever — change a different input. If they swing widely, get that number right before trusting the total.

Related guides

Length beats complexity

A password's strength comes from the number of guesses an attacker needs, and every added character multiplies that number. A long passphrase of ordinary words usually beats a short string of symbols that has to be written down.

Entropy estimates assume random selection. Human-chosen substitutions, like replacing o with zero, are already in every cracking dictionary and add far less than the formula suggests.

Reuse is the real risk

A single breach exposes every account that shares the password, and credential-stuffing attacks test leaked pairs automatically. Unique passwords per account matter more than any individual password's complexity.

A password manager makes unique passwords practical. The master password then becomes the one credential worth memorising carefully, and it should never be used anywhere else.

Two-factor and breach checks

A second factor defeats most credential-stuffing attacks regardless of password strength. An authenticator app or a hardware key is stronger than SMS, which can be intercepted or SIM-swapped.

Check your email against a breach notification service occasionally, and change any password that appears in one. Rotating every password on a schedule is less useful than reacting to actual exposure.

Frequently asked questions

Is 'P@ssw0rd!' a strong password?

No — dictionary word + cosmetic substitutions. Cracking tools try those variants early. A 4-word passphrase beats it at a fraction of the memorization cost.

How long should a password be in 2026?

14+ random characters or a 4-word passphrase for everyday accounts; 16+ or 5 words for banking and email.

Does complexity still matter?

Less than length and uniqueness. NIST SP 800-63B emphasizes length, screening against breached passwords and rate-limiting over symbol rules that create predictable patterns.

Why shouldn't I reuse passwords?

One breach plus credential stuffing equals many compromised accounts. A password manager makes uniqueness free.

Are passphrase words really random enough?

Only if chosen from a fixed wordlist with a random process (like diceware or a generator). Picking words you like collapses the entropy dramatically.

Estimates are illustrative math, not security guarantees. Follow your provider's current guidance for account recovery and 2FA.

Last updated November 2026