Why Composition Rules Don't Strengthen Passwords

Forcing uppercase, digits, and symbols pushes users toward predictable patterns like Password1!. NIST now prohibits mandating composition rules. Here is why they backfired.

ZERO UPLOAD · ALL LOCAL
  1. Type or paste a password into the input field — strength updates instantly as you type.
  2. Check the entropy bits and strength tier in the meter below the input.
  3. Review the crack time table to see how long each attack scenario would take against your password.
  4. Read the feedback panel for specific suggestions if zxcvbn detected patterns or weaknesses.
  5. Use the eye icon to unmask the password if you need to review what you typed.

Type or paste a password to analyse its strength.

Length
Character pool
Entropy
Pattern
Attack Scenarios GPU times assume raw brute-force of a stolen hash. Online times use pattern-aware estimation against a live service.
GPU — Fast Hash (NTLM, MD5) Est. crack time
RTX 4070 Ti Super 155 GH/s · 16 GB GDDR6X
RTX 5070 175 GH/s · 12 GB GDDR7
RTX 4090 300 GH/s · 24 GB GDDR6X
RTX 5090 410 GH/s · 32 GB GDDR7
GPU — Slow Hash (bcrypt cost 12 / Argon2id) Est. crack time
RTX 4070 Ti Super 740 H/s * · 16 GB GDDR6X
RTX 5070 670 H/s * · 12 GB GDDR7
RTX 4090 1,440 H/s * · 24 GB GDDR6X
RTX 5090 2,380 H/s * · 32 GB GDDR7
Online Attack Est. crack time
Throttled 100 guesses/hour — rate-limited login service
Unthrottled 10 guesses/second — no rate limiting

* bcrypt and Argon2id are deliberately slow password hashes, so their crack times depend entirely on the cost factor a site configures. These rates assume bcrypt at cost factor 12, a conservative legacy setting. OWASP's current guidance prefers Argon2id for new systems and lists bcrypt as a legacy fallback with a work factor of 10 or more. Published hashcat v6.2.6 benchmarks measure bcrypt at cost factor 5 (RTX 4090 at 184 kH/s, RTX 5090 at 305 kH/s); each step up the cost factor doubles the work, so cost 12 runs 128 times slower than the benchmark default. The RTX 4090 and RTX 5090 figures divide those benchmarks by 128, while the RTX 4070 Ti Super and RTX 5070 figures are scaled from their SM and core counts. Sources: hashcat RTX 4090, hashcat RTX 5090, and the OWASP Password Storage Cheat Sheet.

Why Composition Rules Don't Strengthen Passwords

'Password1!' satisfies almost every composition rule a website can throw at it, and that is precisely the problem. Composition requirements, mandating an uppercase letter, a digit, and a symbol, were designed to force unpredictability into every password. Instead, they trained an entire generation of users toward the same narrow set of workarounds: capitalize the first letter, append a digit, tack a symbol onto the end. Consequently, the passwords composition rules approve of are often more predictable, not less, than a password chosen without any rule at all. NIST's current guidance reflects this directly, prohibiting verifiers from mandating composition rules for exactly this reason.1 This page explains the psychology behind why composition rules backfire, walks through the entropy math that exposes the gap, and covers what genuinely reduces guessability in their place.

How composition rules create predictable passwords

Told to include a capital letter, most people capitalize the first character, since that is the position where capitalization already feels natural from years of writing sentences. Told to include a digit and a symbol, most people append them at the end, often as a short, memorable sequence like '1!' or '123'. Password cracking tools like zxcvbn check for exactly these patterns first, because they are so widespread that testing them costs almost nothing before falling back to broader brute force, and anyone who has watched a cracking tool rank a 'compliant' password below a longer, simpler one has seen the proxy fail in real time, which is precisely why satisfying a composition checklist says almost nothing about whether a password will hold up under attack.2

XKCD's widely referenced 2011 comic illustrated this with 'Tr0ub4dor&3', a password that satisfies every composition rule yet follows the exact substitution pattern, letter-for-number swaps plus an appended symbol, that cracking dictionaries are specifically built to test before falling back to broader search strategies.3 A composition-compliant password is not automatically an unpredictable one. The comic drove the point home by showing how the substitutions humans make under rule pressure are so consistent across users that attackers can predict them exhaustively with almost no extra search cost beyond the base dictionary pass.

Even the specific substitutions people reach for are predictable across languages and demographics: '@' for 'a', '0' for 'o', '3' for 'e', and '1' or '!' for 'i' show up so consistently in breach data that cracking wordlists apply them as a standard mutation pass against every dictionary word before moving on to anything more exhaustive.2

The entropy math composition rules get wrong

A sixteen-character password using only lowercase letters carries roughly 75.2 bits of entropy under the Shannon formula. An eight-character password that satisfies a full composition rule, upper, lower, digit, and symbol, drawing from the complete 95-character pool, carries only about 52.6 bits, some 23 bits less despite technically following every rule imposed on it. Composition rules optimize for a proxy, character-class variety, that correlates weakly with what actually matters: the size of the keyspace an attacker must search.4

Where the proxy breaks down completely

Because composition rules apply to short passwords just as readily as long ones, they let an eight-character password through as 'strong' while providing no mechanism to push users toward the length that would actually matter more. A person satisfying the rule with the shortest possible compliant password gets a worse outcome than someone ignoring the rule entirely and typing sixteen plain lowercase characters instead.

What entropy actually measures here

Entropy measures the size of the search space an attacker must navigate, not whether a character set is diverse. A password that uses only lowercase letters but is long enough still presents more possible combinations than a short, rule-compliant alternative using the full ASCII set, because entropy is additive across character positions under assumed-random selection. Multiplying the pool size by the length gives the total keyspace, which is why an eight-character password drawn from ninety-five symbols can still lose to a sixteen-character password drawn from twenty-six.4

The practical lesson is that any entropy calculation stopping at character-class variety misses the larger keyspace that length alone provides, because each additional character multiplies the search space whether or not the character set is more diverse. That is why the tools that rate password strength today prioritize total entropy over rule compliance, and it is why the most effective password policy is to demand length and then let users choose characters freely without enforcing a composition checklist.

What actually reduces guessability

NIST's current guidance replaces composition mandates with two more direct controls: a length requirement, fifteen characters for standalone passwords, and mandatory blocklist screening against known breached and commonly used passwords at the moment a password is created.15 Both target the actual failure modes composition rules missed, insufficient length and reuse of already-compromised credentials, rather than a proxy metric that predictable substitution patterns can satisfy without any real gain in unpredictability.

For your own passwords, the practical replacement for composition rules is straightforward: favor length over complexity, let a generator produce genuinely random characters rather than typing a rule-compliant pattern by hand, and check new passwords against a breach database before reusing anything close to a previous one. None of this requires memorizing more rules yourself; a password manager's generator already defaults to the full character pool and a comfortable length, and you can score a rule-compliant password's real randomness against that same baseline to see exactly how far short a checklist-satisfying password actually falls.

Why blocklist screening beats composition rules at the source

CapyToolkit applies this reasoning by scoring the actual effective randomness of passwords instead of counting character classes. A password that satisfies every composition rule but appears in a breach list will score poorly under that approach, while a long, randomly generated value from a password manager will score well even if it contains no uppercase letters or symbols at all. Auditing an existing policy against these two controls, rather than against a checklist of required character classes, is the fastest way to tell whether it reflects current thinking.

When to use this

Reference this page when a service still enforces old-style composition requirements and you want to understand why following them does not guarantee a strong password, or when you are designing a signup form and deciding whether to keep composition rules your organization inherited from an older policy.

Examples

A signup form still requires 1 uppercase, 1 digit, and 1 symbol

Satisfy the rule with a long, randomly generated password rather than a short hand-typed one; the rule does not reward the length that matters most, so you have to supply it yourself.

Auditing an internal password policy for a redesign

Replace mandatory character-class requirements with a 15-character minimum and blocklist screening against breached-password data, matching current NIST guidance.

Sources
  1. 1.

    NIST, "Authenticators," SP 800-63-4, pages.nist.gov, accessed July 2026. https://pages.nist.gov/800-63-4/sp800-63b/authenticators/

  2. 2.

    Dropbox, "zxcvbn README," github.com, accessed June 2026. https://github.com/dropbox/zxcvbn/blob/master/README.md

  3. 3.

    Randall Munroe, "Password Strength," xkcd.com, comic #936, accessed July 2026. https://xkcd.com/936/

  4. 4.

    Wikipedia, "Entropy (information theory)," en.wikipedia.org, accessed July 2026. https://en.wikipedia.org/wiki/Entropy_(information_theory)

  5. 5.

    NIST, "Strength of Memorized Secrets (Appendix A)," SP 800-63B, github.com/usnistgov, accessed July 2026. https://github.com/usnistgov/800-63-3/blob/nist-pages/sp800-63b/appA_memorized.md

FAQ