Why word-based passphrases beat random character strings
The classic advice — mix uppercase, lowercase, digits, and symbols into an 8-character password — produces something that's simultaneously hard to remember and, these days, not actually all that hard to crack, because 8 characters is a small search space even with a big alphabet. The Diceware method, popularized by the XKCD comic showing "correct horse battery staple", takes a different approach: string together several genuinely random common words. Because each word is drawn from a list of thousands of options, a handful of words produces a search space that dwarfs an 8-character password, while remaining something a human can actually memorize and type.
The two places Diceware generators go wrong
The idea is simple, but implementations quietly fail in two specific ways worth understanding before you trust one with your passphrase.
1. Using the wrong random source
Math.random() is not cryptographically secure. It's a fast pseudo-random generator designed for things like animations and games, not security-sensitive selection. Passphrase generation needs a cryptographically secure pseudo-random number generator (CSPRNG) — in a browser, that's crypto.getRandomValues(). Any tool generating "secure" passphrases with plain Math.random() undermines the entire premise before the math even starts.
2. Modulo bias from naive range mapping
Even using a proper CSPRNG, there's a subtler bug: naively mapping a random byte or integer onto a word list index using the modulo operator (randomByte % listSize) introduces a small but real statistical bias whenever the list size doesn't evenly divide the random source's range — some words end up very slightly more likely to be picked than others. The fix is rejection sampling: draw enough random bits to cover the list size, and if the drawn value falls in the "leftover" biased region, discard it and draw again. This guarantees a perfectly uniform distribution across every word in the list, at the cost of occasionally needing a second draw.
How entropy is actually calculated
Entropy, in bits, measures how large the total search space is: specifically, log2(number of possible outcomes). For a passphrase of N words drawn uniformly from a list of size L, the entropy is N × log2(L) bits, because each word choice is an independent random event. A word list of exactly 4,096 words is convenient because log2(4096) = 12 exactly — so a 6-word passphrase from such a list carries exactly 72 bits of entropy, a number you can verify by hand, not a marketing figure pulled from nowhere. A real Diceware tool should compute and display this number live, based on the actual list size and word count you chose — not show a fixed "Strong!" label regardless of your settings.
What "not the official EFF list" means, honestly
The original, numbered Diceware word list (and the EFF's popular alternative version) are specific, published, community-vetted lists designed for use with physical dice rolls. A tool that uses its own curated word list — assembled and filtered by other means — is following the same method (uniform random selection from a fixed list, entropy calculated the same way) without being that specific list. A trustworthy tool says so plainly rather than implying an official pedigree it doesn't have.
Practical tips for using a generated passphrase
Five to six words is a reasonable range for most personal accounts; go higher for anything protecting genuinely high-value data. Adding a random 2-digit number can satisfy sites that insist on "must contain a number" without meaningfully weakening the passphrase. Whatever separator you choose (hyphen, space, or none) doesn't materially affect entropy — the word selection is where the security lives.
Bottom line
A trustworthy passphrase generator needs three things working correctly together: a real CSPRNG instead of Math.random, proper rejection sampling to eliminate modulo bias, and an entropy figure calculated live from your actual settings rather than a made-up strength meter. Get all three right and "random word passphrase" stops being a cute idea and becomes genuinely defensible math.
Frequently Asked Questions
Yes — Diceware-Style Passphrase Generator creates random multi-word passphrases using crypto.getRandomValues with proper rejection sampling, drawn from a curated ~4,096-word list.
It exclusively uses crypto.getRandomValues, the browser's cryptographically secure random source, with rejection sampling to eliminate modulo bias — Math.random is never used for word or number selection.
Entropy is calculated live as word_count × log2(wordlist_size), using the actual size of the embedded word list and the number of words you selected — it is a real, verifiable calculation, not a fixed or made-up strength label.
No, and the tool says so directly — it uses its own curated ~4,096-word list assembled from a standard dictionary, following the same random-selection method as official Diceware lists rather than reproducing one specific published list.
It's a one-time $4.99 purchase — no subscription, no account required, and it works fully offline once opened.