The Mathematics of Password Strength

Password strength is a number. Claude Shannon formalized this in 1948 as information entropy, measured in bits. Each bit doubles the number of possible combinations an attacker must try. A password drawn randomly from 76 characters (uppercase, lowercase, digits, and 14 symbols) carries approximately 6.25 bits of entropy per character. A 16-character password therefore contains roughly 100 bits of entropy: 2¹⁰⁰ possible combinations, a number with 31 digits.

The practical consequence is exponential. A 20-character password from this generator contains approximately 125 bits of entropy, meaning an attacker would need to try roughly 10³⁷ combinations to guarantee finding it. At one trillion guesses per second, the expected search time exceeds the current age of the universe by a factor of billions. Length is the dominant variable. Adding four characters does more for security than switching from alphabetic to alphanumeric.

Length Wins Exponentially

Adding one character to a random password multiplies the search space by 76. Adding four characters multiplies it by 76⁴, which is roughly 33 million. This exponential scaling is why length matters far more than clever substitutions. Replacing "a" with "@" in a human-chosen password adds virtually zero entropy because attackers already include that substitution in their dictionaries. Adding four truly random characters adds 25 bits of entropy. Twenty-five bits means the attacker needs 33 million times longer to search the space.

The 2024 NIST Special Publication 800-63B recommends prioritizing password length over complexity rules. The research behind this guideline found that complexity requirements (one uppercase, one digit, one symbol) produce predictable patterns: Password1! satisfies every rule while appearing in millions of breached credential databases. A purely random 16-character string satisfies no human pattern because it has none to satisfy. This generator guarantees all four character classes for every password, then shuffles the positions with the same cryptographic random source so no position is predictable.

The Cryptographic Source

Every character in your password originates from crypto.getRandomValues(), the Web Cryptography API specified by the W3C. This function draws entropy from hardware-level sources in your device: thermal noise, electrical timing jitter, and other physical processes rooted in quantum uncertainty. The output passes rigorous statistical test suites including NIST SP 800-22 and TestU01.

The guarantee runs deeper than the algorithm. This is the same entropy source that generates the session keys protecting your online banking, the ephemeral keys in every HTTPS connection, and the initialization vectors in encrypted messaging. Browser vendors audit this implementation relentlessly because a weakness here would compromise every secure connection on the web. Your password inherits that entire chain of assurance.

The Human Factor

Researchers at Carnegie Mellon analyzed millions of real-world passwords from breach databases and found a striking pattern. Human-chosen passwords cluster heavily around a few thousand common structures: names followed by years, dictionary words with predictable substitutions, keyboard walks like qwerty123. These patterns reduce effective entropy to 20-40 bits regardless of nominal length, because attackers build dictionaries from exactly these patterns.

A machine-generated password eliminates the human factor entirely. Every character position draws independently from the full character pool with uniform probability. There is no pattern to exploit, no dictionary to consult, no psychological tendency to predict. The only attack remaining is exhaustive search across the entire keyspace, and the mathematics of exponential growth make that search infeasible for any reasonable password length.

Brute-Force Arithmetic

The strength analysis panel above displays real-time crack estimates at three attack speeds. The online attack scenario (1,000 guesses per second) represents a rate-limited web service. The fast hardware scenario (10 billion per second) represents an optimized GPU cluster cracking offline hashes. The nation-state scenario (1 trillion per second) represents a theoretical maximum with dedicated infrastructure. At 100 bits of entropy, even the nation-state scenario requires approximately 4 × 10¹⁸ years. The sun will exhaust its hydrogen fuel in about 5 billion years. Your password outlasts the solar system.

In the Classroom

Password entropy provides an accessible gateway to information theory. Have students visit /password/8 and note the entropy, then visit /password/16 and observe that the entropy exactly doubles. Each added character contributes a fixed number of bits. This linear relationship between length and entropy produces an exponential relationship between length and security, a concept students can verify by comparing the crack time estimates at different lengths.

For a deeper exercise, compare dice83 passwords with diceware passphrases. A six-word passphrase carries about 77 bits of entropy. A 12-character random password carries about 75 bits. Both achieve similar security through entirely different mechanisms: the passphrase uses a large pool (7,776 words) with few selections; the password uses a smaller pool (76 characters) with more selections. The tradeoff is memorability versus raw strength, and understanding that tradeoff teaches students how entropy actually works. The tool runs entirely in the browser, requires no accounts, and stores no student data.

Private by Architecture

Every password generated on this page exists only inside your browser. The server delivers the HTML, CSS, and JavaScript that compose the tool. Your device executes the generation. At no point does any password, partial password, or password-related data travel over any network connection. The only persistent record of a password is wherever you choose to paste it after copying.

Sharing the tool URL is inherently safe. Sending someone the link /password/20 gives them the same generator with the same configuration. Their browser creates entirely independent passwords from its own entropy source. The URL carries the tool specification. Your device carries the secret.