A signup form flashes a green bar and the word “Strong” the moment someone types:

Summer2026!

The strength meter isn’t lying, exactly. By its own math, that password scores well: a capital letter, lowercase letters, digits, a symbol.

But an attacker running a real cracking tool would try a password shaped exactly like that in the first few seconds — before it ever tries a genuinely random string of the same length.

The gap between what the meter reports and what actually resists an attacker comes down to one concept: entropy.

You’ll see it surface as numbers like:

• 40 bits of entropy
• 80 bits of entropy
• 128 bits of entropy

Is 80 good? Is 128 overkill? How does entropy connect to length? And why do security teams care about it so much?

Understanding entropy explains why Summer2026! can fall in seconds while a password that looks far less “complex” can outlast the lifetime of the universe.

What Is Password Entropy?

Password entropy measures unpredictability — specifically, how hard it would be for an attacker to guess a password.

Higher entropy means more possible combinations, less predictability, and greater resistance to guessing.

Lower entropy means fewer combinations, more predictability, and easier cracking.

It’s measured in bits. Each additional bit doubles the number of possible combinations.

Why Is It Called Entropy?

The term borrows from information theory, the same family of ideas behind RAG signal, noise, and entropy.

In that framework, entropy measures uncertainty: a fully predictable outcome has low entropy, a fully random one has high entropy. Passwords work the same way.

Take the signup form’s own suggestions of what to avoid:

password123

qwerty

letmein

Attackers already know these are common. Their real-world entropy is close to zero, no matter how they measure on paper.

Now compare with:

vK8#rP2!mZ4@tQ9

Far less predictable, far more combinations to search — meaningfully higher entropy.

How Password Entropy Is Calculated

The base formula:

Entropy = log₂(possible combinations)

Most calculators use:

Entropy = Length × log₂(Character Set Size)

This estimates how many possible passwords could exist given a length and an available character set.

Example: A Four-Digit PIN

A four-digit PIN ranges:

0000

through

9999

— 10,000 possible combinations.

log₂(10,000)

≈ 13.3 bits of entropy. That’s the security level behind a typical phone unlock PIN.

Example: Eight Lowercase Characters

Only lowercase letters, 26 characters, 8-character length:

26⁸

≈ 208 billion combinations.

8 × log₂(26)

≈ 37.6 bits.

Example: Sixteen Random Characters

Uppercase, lowercase, numbers, and symbols — a 94-character set, 16 characters long:

16 × log₂(94)

≈ 105 bits — dramatically stronger than the eight-character example, and the ballpark a password manager’s auto-generated password would land in.

Why Every Extra Bit Matters

Entropy grows exponentially — each extra bit doubles the search space.

Entropy	Possible Combinations
20 bits	1 million
30 bits	1 billion
40 bits	1 trillion
50 bits	1 quadrillion
60 bits	1 quintillion
80 bits	1.2 septillion
128 bits	340 undecillion

Small increases in entropy translate into enormous increases in real security.

The Problem With Entropy Calculators

Most entropy calculators assume passwords are chosen at random. Humans aren’t random — which is exactly why the signup form’s meter got fooled.

Summer2026!

scores well because it technically hits every character-class box — upper, lower, digit, symbol. But humans build passwords out of predictable patterns, and attackers know this cold.

Real-world cracking tools prioritise:

• Dictionary words
• Seasons
• Years
• Common substitutions
• Keyboard patterns

Actual security often lands well below what the calculated entropy implies.

The Difference Between Theoretical and Real Entropy

Theoretical Entropy

Assumes every character was chosen randomly, e.g.:

xR7#Lm2@Q9$KpW5!

Here the calculated entropy is a fair estimate of real difficulty.

Human-Generated Passwords

Summer2026!

The formula reports strong entropy. Actual predictability is much higher, because the underlying pattern — season, year, symbol — is one attackers already model for.

Why Password Length Matters So Much

Complexity requirements get most of the attention. Security teams increasingly focus on length instead.

Compare:

P@ssw0rd!

with:

correct horse battery staple

The second is longer, has far more possible combinations, and is genuinely easier to remember. Length usually adds more entropy than another special character ever will — which is exactly why the signup form’s “must contain a symbol” rule was solving the wrong problem.

Password Entropy and Passphrases

Passphrases behave differently from random character strings.

From a list of 7,776 words, four random words give:

7,776⁴

combinations →

4 × log₂(7776)

≈ 51.7 bits.

Five words → 64.6 bits. Six words → 77.5 bits.

Meaningful security, and genuinely memorable.

What Entropy Is Considered Secure?

No universal cutoff, but common guidelines:

Entropy	Security Level
Under 30 bits	Weak
30–50 bits	Moderate
50–70 bits	Strong
70–100 bits	Very Strong
100+ bits	Extremely Strong

Modern password managers routinely generate well past 100 bits — at which point the bottleneck stops being guessability and shifts to storage, authentication, and recovery design.

Online Attacks vs Offline Attacks

Entropy matters differently depending on how the attack happens.

Online Attacks

The attacker submits guesses directly through the login form — the exact form that flashed “Strong” earlier. Rate limits, account lockouts, and CAPTCHAs usually apply here, so even moderate entropy can hold up.

Offline Attacks

The attacker has stolen the password hashes and cracks them locally, with no rate limits and specialised hardware running billions of guesses per second. High entropy matters far more here — and most entropy discussions are really about resisting this scenario.

Does More Entropy Always Mean Better Security?

Generally, but only up to a point. 180 bits beats 120 bits — but both are already well past any realistic brute-force capability. Beyond that threshold, extra entropy buys little, and other controls start to matter more:

• Multi-factor authentication
• Password managers
• Account monitoring
• Breach detection
• Access controls

Why Password Managers Change Everything

Humans are bad at generating and remembering genuinely random passwords. A password manager removes that constraint entirely — instead of memorising something like:

vK8#rP2!mZ4@tQ9

for every account, the user remembers one master password, and the manager generates and stores a unique high-entropy password everywhere else. That alone would have made the signup form’s meter irrelevant.

Common Misconceptions About Entropy

Special characters automatically make passwords strong. Not necessarily — length and unpredictability matter more.

Complex passwords are always better. A long random passphrase can beat a short “complex” password.

Entropy measures real security perfectly. It estimates possible combinations; human behaviour often erodes actual security.

Entropy is only about length. Length helps a lot, but randomness matters equally — a long predictable password is still weak.

How Password Authentication Actually Works

Entropy is only half the picture. A well-built application never stores the actual password — it stores a cryptographic hash. On login, the entered password is hashed again and compared against the stored value.

User Password
        │
        ▼
Password Hashing
(Argon2id, bcrypt, scrypt)
        │
        ▼
Stored Password Hash
        │
        ▼
User Login
        │
        ▼
Hash Password Again
        │
        ▼
Compare Hashes
        │
        ▼
Authentication Success or Failure

If the database is stolen, an attacker gets hashes, not passwords. The system’s real security then rests on two things: how hard the passwords are to guess, and how resistant the hashing algorithm is to large-scale cracking.

Entropy handles the first problem; cryptographic storage and AES-style encryption decisions sit on a different part of the security boundary. Password hashing handles the second.

Further reading

• OWASP Password Storage Cheat Sheet: https://cheatsheetseries.owasp.org/cheatsheets/Password_Storage_Cheat_Sheet.html
• NIST SP 800-63B Digital Identity Guidelines: https://pages.nist.gov/800-63-4/sp800-63b.html

---

Password Hashing Is More Important Than Entropy

A high-entropy password offers little protection if it’s stored badly. Modern systems rely on password hashing algorithms deliberately built to be slow and computationally expensive.

Common algorithms:

• Argon2id – current OWASP Password Storage Cheat Sheet recommendation for new applications
• bcrypt – widely deployed, still considered secure when configured well
• scrypt – designed to demand memory and resist hardware acceleration
• PBKDF2 – common for compatibility with existing enterprise systems

Unlike general-purpose functions like SHA-256, these deliberately burn CPU time and memory, making large-scale offline cracking far more expensive.

A strong password and a strong hashing algorithm reinforce each other. Weak passwords stay vulnerable regardless of hashing quality — and a high-entropy password stored with a weak hashing method weakens the whole system.

Further reading

• OWASP Password Storage Cheat Sheet: https://cheatsheetseries.owasp.org/cheatsheets/Password_Storage_Cheat_Sheet.html
• RFC 9106 – Argon2 Memory-Hard Function: https://datatracker.ietf.org/doc/html/rfc9106

---

Modern Password Cracking Hardware

Entropy matters most after a database breach, when attackers can crack password hashes offline without tripping any lockout or rate limit.

Modern cracking rigs lean on parallel hardware — GPUs especially — to test enormous numbers of guesses per second. Rather than brute-forcing sequentially, attackers typically work through, in order:

• leaked password databases
• dictionary words
• common substitutions
• keyboard patterns
• predictable dates
• organisation-specific terminology

Only after exhausting those high-probability guesses does true brute force become practical — which is exactly why Summer2026! and a genuinely random string of the same length can have wildly different real-world resistance, even with similar theoretical entropy.

Human predictability usually matters more than mathematical possibility.

Further reading

• Hashcat Documentation: https://hashcat.net/hashcat/
• OWASP Password Storage Cheat Sheet: https://cheatsheetseries.owasp.org/cheatsheets/Password_Storage_Cheat_Sheet.html

---

Why NIST No Longer Recommends Complex Password Rules

Older policies forced uppercase, lowercase, numbers, symbols, and frequent forced resets. Research shows these rules mostly trained predictable behaviour — users responding with small, guessable tweaks:

• Summer2025!
• Summer2026!
• Password1!
• Password2!

Current NIST guidance shifts toward usability and genuine unpredictability instead. Modern recommendations include:

• allow long passwords and passphrases
• screen against known compromised or commonly used passwords
• skip mandatory periodic changes unless there’s evidence of compromise
• permit password managers and paste functionality
• encourage multi-factor authentication

That’s a direct fix for exactly what went wrong on the signup form earlier: reducing predictable human behaviour beats chasing theoretical complexity.

Further reading

• NIST SP 800-63B – Authentication and Lifecycle Management: https://pages.nist.gov/800-63-4/sp800-63b.html

---

Credential Stuffing Is Not Password Guessing

Plenty of account compromises involve no guessing at all. Attackers instead reuse credentials stolen from unrelated breaches — credential stuffing — one reason AI-assisted attackers can scale the search described in AI vs AI cybersecurity.

Automated tools test previously leaked username/password pairs across thousands of sites. It works because people reuse passwords.

This exposes a real limit of entropy: a password can be excellent on paper, but if it’s already leaked and reused elsewhere, no attacker needs to guess it at all.

Defending against this depends on:

• unique passwords per account
• password managers
• multi-factor authentication
• breached-password detection
• login anomaly monitoring

Entropy protects against guessing. Unique credentials protect against reuse. Both matter.

Further reading

• OWASP Credential Stuffing Prevention Cheat Sheet: https://cheatsheetseries.owasp.org/cheatsheets/Credential_Stuffing_Prevention_Cheat_Sheet.html
• Have I Been Pwned: https://haveibeenpwned.com/

---

Passkeys and Passwordless Authentication

Passwords remain the dominant login method, but adoption of passkeys, built on FIDO2 and WebAuthn, is growing.

Instead of a shared secret, passkeys use public-key cryptography: a private key stays on the user’s device, a public key registers with the service, and login verifies a cryptographic signature rather than comparing a password at all.

That approach means:

• no shared secret transmitted during login
• strong resistance to phishing
• protection against credential stuffing
• nothing to remember or reuse

Passkeys don’t make entropy irrelevant — many systems will keep supporting passwords for years — but they represent a shift toward eliminating password-related risk rather than just demanding stronger passwords from users on forms like the one that opened this article.

Further reading

• FIDO Alliance – Passkeys: https://fidoalliance.org/passkeys/
• WebAuthn Level 3 Specification: https://www.w3.org/TR/webauthn-3/

---

Modern Password Security Tools

Strong password security takes more than a high-entropy password.

Tool	Primary Purpose
Password Managers	Generate and store unique, high-entropy passwords for every account.
Password Strength Estimators (zxcvbn)	Catch predictable patterns simple entropy math misses.
Have I Been Pwned	Checks whether an email or password has appeared in known breaches.
Authenticator Applications	Generate TOTP codes for multi-factor authentication.
Passkeys	Replace shared passwords with phishing-resistant public-key authentication.

Each addresses a different weakness. Entropy measures password unpredictability — not whether the system around it is observable, rate-limited, or safely recoverable.

Password managers improve randomness. Strength estimators catch human predictability that basic entropy calculators — like the one on that signup form — miss entirely. Multi-factor authentication limits the blast radius of a stolen password. Passkeys cut dependence on passwords altogether.

Together, they beat relying on complexity rules alone by a wide margin.

Official resources

• Bitwarden: https://bitwarden.com/
• KeePassXC: https://keepassxc.org/
• Dropbox zxcvbn: https://github.com/dropbox/zxcvbn
• Have I Been Pwned: https://haveibeenpwned.com/
• FIDO Alliance Passkeys: https://fidoalliance.org/passkeys/

---

Frequently Asked Questions

What is password entropy?

A mathematical measure of how unpredictable a password is — an estimate of how many combinations an attacker would need to search during a brute-force attack. Higher entropy generally means a harder-to-guess password.

Is password entropy the same as password strength?

Not entirely. Entropy measures theoretical unpredictability; real-world strength also depends on human behaviour, reuse, hashing quality, and whether the password has already leaked.

What is a good level of password entropy?

No universal threshold, but 50–70 bits is generally considered strong for most applications, and password managers commonly generate well past 100 bits.

Why is password hashing important?

It protects stored passwords if the authentication database is compromised. Algorithms like Argon2id, bcrypt, and scrypt make offline cracking dramatically harder than a fast general-purpose hash would.

What is credential stuffing?

An attack using usernames and passwords stolen from other breaches to break into accounts elsewhere — it works because people reuse passwords across sites.

Are passphrases better than complex passwords?

Often — a long, randomly generated passphrase can offer more entropy while staying easier to remember than a short password stuffed with symbol substitutions.

Do passkeys replace passwords?

Increasingly, for supported services, using public-key cryptography instead of a shared secret. Many systems still support traditional passwords, so understanding entropy remains relevant for the foreseeable future.

What is the best way to improve password security?

Use a password manager, generate unique high-entropy passwords per account, enable multi-factor authentication, and avoid reusing passwords across services.

Conclusion

Password entropy measures how unpredictable a password is, and how hard it would be to guess through brute force.

Higher entropy means more combinations and more resistance to cracking — every additional bit doubles the possibilities an attacker has to consider.

But as that green “Strong” meter proved, entropy is only part of the picture. Human-generated passwords carry predictable patterns that quietly undercut real security, even when a calculator scores them well.

The most reliable fix doesn’t depend on getting the entropy math right by hand: use a password manager, generate genuinely long random passwords, enable multi-factor authentication, and skip the memorable patterns entirely. That combination protects far more than chasing any single entropy number ever will.