Password strength calculators often display a number called entropy.

You might see messages such as:

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

For many people, these numbers are confusing.

Is 80 good?

Is 128 overkill?

How does entropy relate to password length?

And why do security professionals care about it so much?

Understanding password entropy helps explain why some passwords can be cracked almost instantly while others would take longer than the age of the universe.

What Is Password Entropy?

Password entropy is a measurement of unpredictability.

In simple terms, entropy estimates how difficult it would be for an attacker to guess a password.

Higher entropy means:

• More possible password combinations
• Less predictability
• Greater resistance to guessing attacks

Lower entropy means:

• Fewer possible combinations
• More predictability
• Easier password cracking

Entropy is typically measured in bits.

Each additional bit doubles the number of possible password combinations.

Why Is It Called Entropy?

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

In information theory, entropy measures uncertainty.

A completely predictable outcome has low entropy.

A completely random outcome has high entropy.

Passwords follow the same principle.

Consider these examples:

password123

qwerty

letmein

These passwords are highly predictable.

Attackers know people use them frequently.

Their practical entropy is extremely low.

Now compare them with:

vK8#rP2!mZ4@tQ9

This password is far less predictable.

An attacker has many more possible combinations to consider.

Its entropy is much higher.

How Password Entropy Is Calculated

The basic entropy formula is:

Entropy = log₂(possible combinations)

Most password entropy calculations use:

Entropy = Length × log₂(Character Set Size)

The calculation estimates how many possible passwords could exist given the length and available character choices.

Example: Four-Digit PIN

A four-digit PIN can contain:

0000

through

9999

This creates:

10,000

possible combinations.

Entropy becomes:

log₂(10,000)

Approximately:

13.3 bits

A four-digit PIN has about 13 bits of entropy.

Example: Eight Lowercase Characters

Suppose a password contains only lowercase letters.

Available characters:

26

Password length:

8

Possible combinations:

26⁸

Approximately:

208 billion

Entropy:

8 × log₂(26)

Approximately:

37.6 bits

Example: Sixteen Random Characters

Suppose a password uses:

• Uppercase letters
• Lowercase letters
• Numbers
• Symbols

Total character set:

94

Password length:

16

Entropy:

16 × log₂(94)

Approximately:

105 bits

This is dramatically stronger than the previous example.

Why Every Extra Bit Matters

Entropy grows exponentially.

Each additional 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

This is why small increases in entropy can have enormous security impacts.

The Problem With Entropy Calculators

Many entropy calculators assume passwords are completely random.

Humans are not random.

Consider:

Summer2026!

A calculator may assign a relatively high entropy score because the password contains:

• Uppercase letters
• Lowercase letters
• Numbers
• Symbols

However, humans frequently create passwords using predictable patterns.

Attackers know this.

Real-world cracking tools prioritize:

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

As a result, actual security may be much lower than the calculated entropy suggests.

The Difference Between Theoretical and Real Entropy

This distinction is important.

Theoretical Entropy

Assumes every character was chosen randomly.

Example:

xR7#Lm2@Q9$KpW5!

Theoretical entropy is usually accurate here.

Human-Generated Passwords

Example:

Summer2026!

The calculation may suggest strong entropy.

Actual predictability is much higher.

This reduces real-world security.

Why Password Length Matters So Much

Many people focus on complexity requirements.

Security professionals increasingly focus on length.

Compare:

P@ssw0rd!

with:

correct horse battery staple

The second password contains more characters and far more possible combinations despite being easier to remember.

Length often contributes more entropy than adding special characters.

This is one reason passphrases have become increasingly popular.

Password Entropy and Passphrases

Passphrases work differently from random character strings.

Consider a list of:

7,776 words

Choosing four random words creates:

7,776⁴

possible combinations.

Entropy:

4 × log₂(7776)

Approximately:

51.7 bits

Using five random words:

64.6 bits

Using six random words:

77.5 bits

This provides substantial security while remaining easier to remember.

What Entropy Is Considered Secure?

There is no universal threshold, but common guidelines are:

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 often generate passwords with well over 100 bits of entropy, which is why the bottleneck often moves from guessing resistance to storage, authentication, and recovery design.

Online Attacks vs Offline Attacks

Entropy matters differently depending on the attack type.

Online Attacks

The attacker submits login attempts directly.

Systems usually enforce:

• Rate limits
• Account lockouts
• CAPTCHA challenges

Even moderate entropy may provide sufficient protection.

Offline Attacks

An attacker obtains password hashes and attempts cracking locally.

No rate limits exist.

Attackers can perform billions of guesses per second using specialised hardware.

High entropy becomes far more important.

Most password entropy discussions focus on resisting offline attacks.

Does More Entropy Always Mean Better Security?

Generally yes, but only up to a point.

A password with:

180 bits

of entropy is stronger than one with:

120 bits

However, both are already beyond practical brute-force capabilities.

At some point, additional entropy provides little practical benefit.

Other security measures become more important.

These include:

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

Why Password Managers Change Everything

Humans struggle to create and remember truly random passwords.

Password managers remove this limitation.

Instead of remembering:

vK8#rP2!mZ4@tQ9

for dozens of websites, users only need to remember one master password.

The manager can generate high-entropy passwords automatically.

This dramatically improves security across all accounts.

Common Misconceptions About Entropy

Special Characters Automatically Make Passwords Strong

Not necessarily.

Length and unpredictability matter more than symbols alone.

Complex Passwords Are Always Better

A longer random passphrase may provide greater security than a short complex password.

Entropy Measures Real Security Perfectly

Entropy estimates possible combinations.

Human behaviour often reduces actual security.

Entropy Is Only About Length

Length helps significantly, but randomness is equally important.

Predictable long passwords can still be weak.

How Password Authentication Actually Works

Password entropy is only one part of the authentication process.

When you create an account, a well-designed application should never store your actual password.

Instead, it stores a cryptographic hash of the password. During login, the password you enter is hashed again using the same algorithm, and the resulting hash is compared with the stored value.

A typical authentication workflow looks like this:

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

This approach means that even if an attacker steals the authentication database, they should only obtain password hashes rather than the original passwords.

The security of the system then depends on two factors:

• how difficult the passwords are to guess
• how resistant the hashing algorithm is to large-scale cracking attempts

Password entropy addresses the first problem; cryptographic storage and AES-style encryption decisions address different parts of the security boundary.

Password hashing addresses 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 provides little protection if it is stored insecurely.

Modern authentication systems rely on specialised password hashing algorithms that are intentionally slow and computationally expensive.

Common algorithms include:

• Argon2id – the current recommendation from the OWASP Password Storage Cheat Sheet for new applications
• bcrypt – widely deployed and still considered secure when configured appropriately
• scrypt – designed to increase memory requirements and resist hardware acceleration
• PBKDF2 – commonly used for compatibility with existing enterprise systems

Unlike general-purpose hash functions such as SHA-256, these algorithms deliberately consume CPU time and memory.

That makes large-scale offline password cracking significantly more expensive.

A strong password and a strong hashing algorithm work together.

Weak passwords remain vulnerable regardless of the hashing algorithm.

Likewise, storing high-entropy passwords with an outdated or inappropriate hashing method weakens the security of the entire authentication 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

Password entropy becomes particularly important after a database breach.

If attackers obtain password hashes, they can attempt to recover passwords offline without triggering account lockouts or rate limiting.

Modern password cracking tools use highly parallel hardware, including GPUs, to evaluate enormous numbers of password guesses every second.

Rather than trying every possible combination sequentially, attackers typically prioritise:

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

Only after exhausting these high-probability guesses do brute-force attacks become practical.

This explains why two passwords with similar theoretical entropy can have dramatically different real-world resistance to cracking.

Human predictability often 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 password policies often required users to include uppercase letters, lowercase letters, numbers and symbols while forcing password changes every few months.

Research has shown that these rules frequently encouraged predictable behaviour.

Users responded by making small, easily guessed modifications such as:

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

Current guidance from the U.S. National Institute of Standards and Technology (NIST) places greater emphasis on usability and unpredictability.

Modern recommendations include:

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

These recommendations improve practical security by reducing predictable human behaviour rather than simply increasing 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

Many successful account compromises involve no password guessing at all.

Instead, attackers use credentials stolen from previous data breaches.

This technique is known as credential stuffing, and it is one reason AI-assisted attackers can scale the search space described in AI vs AI cybersecurity.

Rather than attempting to crack a password, attackers automatically test previously leaked username and password combinations across thousands of websites.

The attack succeeds because many people reuse the same password across multiple accounts.

This highlights an important limitation of entropy.

A password may have excellent entropy.

If it has already been exposed in another breach and reused elsewhere, attackers no longer need to guess it.

Preventing credential stuffing depends on:

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

Entropy protects against guessing.

Unique credentials protect against reuse.

Both are essential.

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 most common authentication method, but many organisations are beginning to adopt passkeys based on the FIDO2 and WebAuthn standards.

Unlike passwords, passkeys use public-key cryptography.

A private key remains securely stored on the user’s device, while the corresponding public key is registered with the service.

During authentication, the server verifies a cryptographic signature rather than comparing a password.

This approach offers several advantages:

• no shared secret is transmitted during login
• resistance to phishing attacks
• protection against credential stuffing
• no passwords to remember or reuse

Passkeys do not make password entropy irrelevant.

Many systems will continue supporting passwords for years to come.

However, they demonstrate how modern authentication increasingly focuses on eliminating password-related risks rather than simply encouraging stronger passwords.

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 depends on more than creating a high-entropy password.

Several widely adopted tools help reduce human error while improving overall account security.

Tool	Primary Purpose
Password Managers	Generate and store unique, high-entropy passwords for every account.
Password Strength Estimators (zxcvbn)	Identify predictable patterns that simple entropy calculations may overlook.
Have I Been Pwned	Allows users to check whether an email address or password has appeared in known data breaches.
Authenticator Applications	Generate time-based one-time passwords (TOTP) for multi-factor authentication.
Passkeys	Replace shared passwords with phishing-resistant public-key authentication.

These tools address different aspects of authentication.

Entropy measures password unpredictability, not whether the authentication system around it is observable, rate-limited, or safely recoverable.

Password managers improve randomness.

Strength estimators evaluate human predictability.

Multi-factor authentication limits the impact of stolen passwords.

Passkeys reduce dependence on passwords altogether.

Together, they provide substantially stronger protection than relying on password complexity rules alone.

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?

Password entropy is a mathematical measure of how unpredictable a password is. It estimates the number of possible combinations an attacker would need to search during a brute-force attack. Higher entropy generally means a password is more difficult to guess.

Is password entropy the same as password strength?

Not entirely.

Entropy measures theoretical unpredictability, while real-world password strength also depends on human behaviour, password reuse, hashing algorithms and whether the password has appeared in previous data breaches.

What is a good level of password entropy?

There is no universal threshold, but passwords with around 50–70 bits of entropy are generally considered strong for many applications, while password managers commonly generate passwords exceeding 100 bits of entropy.

Why is password hashing important?

Password hashing protects stored passwords if an authentication database is compromised. Modern algorithms such as Argon2id, bcrypt and scrypt make offline password cracking significantly more difficult than using fast cryptographic hash functions.

What is credential stuffing?

Credential stuffing is an attack that uses usernames and passwords stolen from previous breaches to access accounts on other services. It succeeds because many people reuse passwords across multiple websites.

Are passphrases better than complex passwords?

Often, yes.

A long, randomly generated passphrase can provide more entropy while remaining easier to remember than a short password containing multiple symbols and character substitutions.

Do passkeys replace passwords?

Passkeys are increasingly replacing passwords for supported services by using public-key cryptography instead of shared secrets. However, many systems continue to support traditional passwords, making good password hygiene and understanding entropy important for the foreseeable future.

What is the best way to improve password security?

For most users, the strongest approach is to use a password manager, generate unique high-entropy passwords for every account, enable multi-factor authentication and avoid reusing passwords across different services.

Conclusion

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

Higher entropy means more possible combinations and greater resistance to password cracking. Every additional bit doubles the number of possibilities an attacker must consider.

While entropy provides a useful way to compare password strength, it is only part of the picture. Human-generated passwords often contain predictable patterns that reduce real-world security, even when calculators assign high scores.

For most users, the best approach is simple: use a password manager, generate long random passwords, enable multi-factor authentication, and avoid relying on memorable patterns. Those practices provide far more protection than chasing a specific entropy number alone.