Why complicated-looking passwords are not enough
We usually judge whether a password is strong by counting the capital letters, digits and symbols it contains. But a password like P@ssw0rd! is weak even though it follows those rules, because real attackers do not try passwords at random; they use dictionary attacks, leaked password lists and tools that model common letter-to-digit substitution patterns (a→@, o→0, s→$ and so on). To understand what really determines a password's resilience, you have to look at the concept of entropy.
What entropy is: character pool and length
Password entropy is a measure, in bits, of how many possible combinations a password could be one of. The calculation derives a "pool size" from the character types used in the password:
| Character type | Contribution to the pool |
|---|---|
| Lowercase (a-z) | +26 |
| Uppercase (A-Z) | +26 |
| Digit (0-9) | +10 |
| Symbol | +32 |
Entropy (in bits) is calculated with this formula: length × log2(pool size). On average, an attacker is assumed to need to try half of the possible combinations; the estimated cracking time is found by dividing half of the total number of combinations by the assumed guessing rate. This is not a purely theoretical formula; it is the same method used in the strength meters of password generator tools, and it shows how resilient a password is in measurable terms rather than "by the look of it".
How a brute-force attack works
A brute-force attack is a method that tries all possible combinations, in order or at random, until it finds the right password. The attacker does not know the password itself; they simply scan the character space and the possible length. The higher a password's entropy, the larger the combination space that has to be scanned, and the average number of attempts grows exponentially. But what really decides the outcome is how many combinations per second the attacker can try — and that is directly tied to the difference between online and offline attack scenarios described shortly.
Why length matters more than complexity
In the formula, length is in the multiplier position: every extra character increases the number of possible combinations exponentially. Adding another character type (adding symbols to lowercase letters, for example) increases the pool size, but its effect is not as large as length. For instance, in an 8-character password made up only of lowercase letters the pool size is 26 and the entropy comes to 8 × log2(26) ≈ 37.6 bits. In a password of the same length using all four character types, the pool size rises to 26+26+10+32=94 and the entropy becomes 8 × log2(94) ≈ 52.4 bits — adding symbols does of course help. But the entropy of a 20-character password made up only of lowercase letters is 20 × log2(26) ≈ 94 bits; far higher than the 8-character password using all four character types. That is why a long passphrase made of a few random words is usually stronger than a short password decorated with symbols — and easier to remember, too.
Why the attack scenario is decisive: online and offline
The same password can be cracked in very different amounts of time depending on where the attack takes place. On a rate-limited online login form the attacker is limited to roughly 1,000 attempts per second; the system may temporarily lock the account or delay the request after a few failed attempts. But once password hashes fall into an attacker's hands through a database leak, the attempts are made offline and that limitation disappears entirely: against an unprotected or fast hashing algorithm the common attack rate can reach around 1 billion attempts per second, and up to around 1 trillion attempts per second with large-scale dedicated hardware.
The difference between these three scenarios matters: it is not enough for a password to look resilient on an online form alone. The real threat model is the assumption that one day the password will be in an attacker's hands as a leaked hash and cracked offline.
The passphrase approach
A passphrase made of several random, unrelated words brings together both length and memorability. As the number of words grows the total combination space grows with it, and randomly chosen words — not a known sentence or a familiar expression — also stay resistant to dictionary-based attacks. The critical point is randomness: a predictable combination such as "SunSeaSandBeach" is much weaker than genuinely randomly chosen words.
Using a password manager makes it practical to apply both approaches at once: it stores a separate, long, completely randomly generated password for every account, while you only have to memorise a single strong passphrase that unlocks the password manager itself.
Is password entropy enough on its own?
Even a high-entropy password does not on its own mean complete security. A password can be compromised on the server side, stolen by malware that infects the user's device, or obtained directly through phishing; in none of those scenarios does the password's entropy offer any protection. Multi-factor authentication (MFA) should therefore be regarded as a separate layer of defence that complements a strong password: even if the password is stolen, the attacker also has to get past a second verification step. The entropy calculation only measures how resilient the password itself is against guessing; that is just one component of overall account security.
Common mistakes
- Using the same password on more than one site: a leak at one site puts every other account using that password at risk too.
- Relying on predictable letter-to-digit substitutions: substitutions such as a→@, i→1 and s→$ are already in the pattern lists attackers use and provide no real randomness.
- Thinking a short password with symbols is stronger than a long passphrase: length matters more than character variety.
- Ignoring the fact that online rate limiting no longer applies once an account has leaked as a hash: after a leak, the attack is carried out offline and far faster.
Judging a password's real resilience by eye is misleading; the entropy calculation and different attack rate scenarios give a concrete reference point. The tool below calculates the estimated entropy of the password you enter and the estimated cracking time under three different defence scenarios entirely in your browser, without sending it anywhere; the result is shown in whichever unit fits best — seconds, minutes, hours, days, years or centuries — and for very high entropy passwords it is summarised directly as "longer than centuries".