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 and What Actually Works

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:

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

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.