Password Generator — Strong Random Passwords

1. Where the randomness comes from

Every character, word and digit on this page is drawn from crypto.getRandomValues(), the browser's cryptographically secure random number generator. There is no Math.random() fallback anywhere in the code — if the secure generator is unavailable the tool refuses to produce a value rather than quietly producing a predictable one.

Two details matter more than the source. Indexes are chosen by rejection sampling rather than by % — taking a random byte modulo 62 makes the first few characters of the alphabet measurably more likely, and that bias is exactly the kind of thing a cracking rule exploits. And when a “one of every set” rule is in force, the guaranteed characters are placed by a Fisher–Yates shuffle over the same generator, so the symbol does not always land at the end where an attacker can assume it.

Nothing is generated on a server. There is no request to send, no history list to leak, no storage write and nothing in the URL. The value is written to the value of a read-only input rather than into the page as text, so it never appears in the document's markup and is not picked up by anything that serialises the DOM — an extension, a screen recorder or a crash report. The only copy is the one on your screen, and closing the tab is the whole of the clean-up.

2. Entropy is the number, length is the lever

Password strength is one calculation: bits = length × log2(pool size). The pool is how many characters could appear in each position, and every character you add multiplies the search space by that number again.

Character sets	Pool	Bits per character
Digits only	10	3.32
Lower + upper	52	5.70
Lower + upper + digits	62	5.95
Everything	86	6.43
Everything, look-alikes dropped	76	6.25

Notice how little the symbols buy: adding all 24 of them to letters and digits takes a character from 5.95 bits to 6.43, worth about half a bit each. Two more characters of length beat the entire symbol set. That is why the length slider is the first control on the panel and the character sets are underneath it.

Length	Letters + digits	Rating	With symbols
8	47.6 bits — 18 minutes	Reasonable	51.4 bits — 4.2 hours
10	59.5 bits — 49 days	Reasonable	64.3 bits — 3.5 years
12	71.5 bits — 511 years	Strong	77.1 bits — 26 thousand years
14	83.4 bits — 2 million years	Very strong	90.0 bits — 192 million years
16	95.3 bits — 8 billion years	Very strong	102.8 bits
20	119.1 bits	Very strong	128.5 bits — Overkill

The rating bands are fixed: under 28 bits Very weak, under 36 Weak, under 60 Reasonable, under 80 Strong, under 128 Very strong, 128 and over Overkill. The eight-character password with a symbol in it that so many login forms still specify is 4.2 hours of offline work — “Reasonable” is the most generous thing that can be said about it, and the default here is 20 characters for a reason.

To run that arithmetic on a password you already have rather than a new one, the password entropy checker takes a string and reports its bits, its band and its crack time. It shares this page's engine, so the two cannot disagree about what a string is worth — but it also carries a warning this page does not need: entropy is exact only for a value drawn at random, and a password you invented yourself will not reach the figure the formula gives it.

3. What “offline cracking time” assumes

The cracking figure is not a prediction. It is one explicit model, stated so you can disagree with it: 2^(bits − 1) ÷ 10^11 — half the keyspace on average, against 100 billion guesses per second. That is a well-funded attacker with modern GPUs working on a stolen database of fast, unsalted hashes, offline, with no rate limit and no one watching.

It is deliberately pessimistic, because the assumption you cannot control is how the site stored your password. Against a slow hash the same password looks completely different: a 12-character letters-and-digits password is 511 years at 10¹¹ guesses per second, but 5 billion years at the 10,000 per second a bcrypt or Argon2 hash allows. The figure shown is the floor, not the expectation.

Online attacks are a different game entirely. Guessing against a live login form means network round trips, rate limits and lockouts — a few guesses per second at best. Any password above about 40 bits is untouchable online. Entropy is insurance against the day the database leaks, which is the day you find out what the site's hashing choices were.

Years are a unit of comparison, not a promise “8 billion years” does not mean your account is safe until then. It means brute force is not the route in. Phishing, credential reuse, malware on the device and a password written into a support ticket all bypass the number completely, and none of them care how long it is. A password typed into a convincing copy of a login page is compromised at full strength, which is what the safe link checker is for.

4. Passphrases: eight bits a word

A passphrase's entropy is words × log2(list size). The word list here holds 256 short, common, unambiguous English words, deduplicated when it loads, which makes each word worth exactly 8 bits — the number on the panel is derived from the real list length, never hard-coded.

Eight bits a word is honest but modest, and it is smaller than the classic Diceware list of 7,776 words at 12.92 bits each. You need more words here to reach the same strength: ten words from this list is 80.0 bits, which is a shade past Diceware's six words at 77.5. The trade is deliberate — every word is short, unambiguous and typeable on a phone keyboard, and the entropy is stated plainly rather than assumed.

Words	Entropy	Rating	Offline cracking time
4	32.0 bits	Weak	instantly
6	48.0 bits	Reasonable	23 minutes
8	64.0 bits	Strong	2.9 years
10	80.0 bits	Very strong	192 thousand years
12	96.0 bits	Very strong	13 billion years

Four words is not a passphrase, whatever the cartoon says — on this list it is 32 bits and falls instantly. The slider starts at eight words, which is 64 bits and about 50 characters, and ten is the figure to reach for on anything that matters.

Two things do not help as much as people expect. Capitalising each word adds no entropy at all — attack rulesets have applied title case, leetspeak and common substitutions for twenty years, so it is a formatting preference, not a defence, and it is not counted. Adding a digit at the end adds log2(10) = 3.32 bits, which is counted honestly: eight words plus a digit is 67.3 bits, not 64 and not 70. Both options exist because password policies demand them, not because they make the phrase stronger.

5. PINs are protected by lockout, not by entropy

A PIN is drawn from a pool of ten, so a four-digit PIN is 13.3 bits and a six-digit PIN is 19.9. Every PIN length the panel offers reads “instantly” in the cracking tile, and that is not a bug in the estimate — 10,000 possibilities is not a search, it is a list.

Digits	Combinations	Entropy	Offline
4	10,000	13.3 bits	instantly
6	1,000,000	19.9 bits	instantly
8	100,000,000	26.6 bits	instantly
10	10,000,000,000	33.2 bits	instantly

What actually protects a PIN is the thing counting the attempts. A phone that wipes after ten wrong tries, a card that swallows itself after three, a door lock with a rate limit: those turn a million combinations into a real barrier, and at ten guesses per second even a six-digit PIN takes 14 hours. The entropy figure is shown anyway, because the honest reading of a PIN is “this is safe as long as someone is counting”. Where nothing counts the attempts, a PIN is the wrong control.

The value in picking one at random is narrower but real: it is not a birthday, not 1234, not 1111, and not in the top-twenty list that covers a startling share of real PINs. Random beats memorable when the memorable options are that predictable.

6. The options, and what each one costs

Every toggle on the password panel changes the pool, and the entropy figure follows immediately rather than being estimated afterwards:

Drop look-alikes removes I l 1 O 0 o and the punctuation ; : , . — ten characters, taking the full pool from 86 to 76. A 20-character password goes from 128.5 bits to 125.0. Worth it for anything that will be read aloud, retyped from a screen or dictated over a phone; pointless for anything going straight into a manager.
One of every set guarantees the mix a password policy asks for. It does not raise the entropy and the number does not move when you tick it: constraining the draw shrinks the keyspace very slightly rather than growing it, so the figure shown is never inflated to credit the rule. At sensible lengths the true cost is a fraction of a bit.
Characters to exclude shrinks the pool by whatever you bar — excluding { } [ ] takes 86 to 82. Characters that were never in the pool are ignored, so nothing is silently double-counted.

The symbol set is 24 characters — !@#$%^&*()-_=+[]{};:,.?/ — and what is missing is deliberate. No quotes, no backslash, no backtick, no pipe, no angle brackets: the characters that break shell commands, CSV imports, SQL literals and badly written login forms. A generated password you cannot paste into the system that demanded it is not a strong password, it is a support ticket.

Lengths are clamped to what is useful: 4 to 256 characters for a password, 3 to 32 digits for a PIN, 2 to 24 words for a passphrase. If a site caps you at 12 characters or forbids symbols, that is a limit on the site's storage design rather than advice about security — set the generator to the longest the form will take and let the entropy tile tell you what you actually got.

A unique password matters more than a strong one The most common way an account falls is not brute force, it is the same password arriving from another site's breach. Generate a different value for every login and keep them in a password manager or a locked note — a manager holding 40 random 20-character passwords is a far better position than one memorable 30-character phrase used everywhere. Paste it into the site, confirm the login works, then clear your clipboard: the clipboard is shared with every app on the device and is the one place a generated secret tends to linger.

7. Password Generator FAQs

How long should a password be?

16 characters or more from letters and digits, which is 95.3 bits of entropy and roughly 8 billion years of offline guessing at 100 billion attempts a second. 12 characters (71.5 bits) is the practical floor and 20 is the default here. Length beats complexity: two extra characters are worth more than adding the entire 24-symbol set.

Is this password generator actually random?

Yes. Every value comes from crypto.getRandomValues(), the browser’s cryptographically secure generator, and there is no Math.random() fallback — if the secure generator is missing, no value is produced. Indexes use rejection sampling rather than modulo, which would make the first characters of the alphabet slightly more likely, and guaranteed characters are placed by a Fisher–Yates shuffle so a symbol does not always land at the end.

How many words does a passphrase need?

Ten, on this list. The word list holds 256 words, so each word is worth exactly 8 bits: four words is 32 bits and falls instantly, six is 48 bits (23 minutes), eight is 64 bits (2.9 years) and ten is 80 bits (192 thousand years). A larger list such as Diceware’s 7,776 words gives 12.92 bits a word, which is why six Diceware words match ten from here.

Is a 6-digit PIN secure?

Not on its own — 1,000,000 combinations is 19.9 bits and falls instantly to an offline attack. A PIN is protected by whatever counts the attempts: a phone that wipes after ten tries, a card that blocks after three, a lock with a rate limit. At ten guesses a second a six-digit PIN takes about 14 hours. Where nothing limits the attempts, a PIN is the wrong control.

Does dropping look-alike characters weaken the password?

Slightly, and measurably. It removes I l 1 O 0 o along with the punctuation ; : , . — ten characters, so the full pool falls from 86 to 76 and a 20-character password from 128.5 bits to 125.0. That is a good trade for anything you will read aloud or retype from a screen, and pointless for anything going straight into a password manager.

Does capitalising words or adding a digit make it stronger?

Capitalising adds nothing — cracking rules have applied title case and letter substitutions for two decades, so it is a formatting preference and is not counted here. An appended digit adds log2(10) = 3.32 bits and is counted exactly: eight words plus a digit is 67.3 bits rather than 64. Both options exist for password policies that demand them.

What does the offline cracking time assume?

Half the keyspace on average against 100 billion guesses a second — 2^(bits − 1) ÷ 10^11. That models a well-funded attacker with modern GPUs working offline on a stolen database of fast, unsalted hashes. Against a slow hash such as bcrypt or Argon2 the same 12-character password moves from 511 years to about 5 billion. The figure is a floor, not a forecast.

Is the generated password sent anywhere or stored?

No. Generation happens in your browser, there is no request to a server, no history list, nothing written to storage and nothing in the URL. The value is written to a read-only input’s value rather than into the page as text, so it never appears in the document markup and is not captured by anything that serialises the DOM. Closing the tab is the entire clean-up.

Why does the strength meter stop at 128 bits?

Because 128 bits is the point where brute force stops being the attack. It matches the key length of AES-128, and the bands below it are Very weak under 28 bits, Weak under 36, Reasonable under 60, Strong under 80 and Very strong under 128. Anything at or beyond 128 is labelled Overkill, which is a comment on the arithmetic rather than a criticism of the password.

Which symbols does it use, and why not all of them?

A set of 24: !@#$%^&*()-_=+[]{};:,.?/ — with quotes, backslash, backtick, pipe and angle brackets deliberately left out because they break shell commands, CSV imports, SQL literals and poorly written login forms. Use the exclude box to bar anything else your system rejects; the pool and the entropy figure both shrink to match.

Should I use this instead of my password manager’s generator?

Either is fine — both draw from a secure generator and entropy is entropy. This page is useful when you want the bits, the pool size and the cracking estimate shown alongside the value, when you need a passphrase you can actually type on a phone, or when you want to generate something without a manager open. Store the result in the manager afterwards.