Generate a Diceware Passphrase — Free EFF Wordlist Generator

Why Passphrases Beat Passwords: Entropy and the Passphrase Generator Advantage

A traditional complex credential like P@ssw0rd! feels secure but is often predictable in structure. A diceware passphrase composed of six random words is both longer and far more unpredictable — delivering superior password security without the memorability penalty. The reason lies in entropy: the measure of how unpredictable your credential is to a brute-force attacker.

Entropy is a measure of the uncertainty or randomness of a system. The concept is a difficult one to grasp fully and is confusing, even to experts. Strictly speaking, any given passphrase has an entropy of zero because it is already chosen. It is the method you use to randomly select your passphrase that has entropy. Entropy tells how hard it will be to guess the passphrase itself even if an attacker knows the method you used to select it.

A classic analogy: a single coin toss — heads or tails — has one bit of entropy. Every additional bit doubles the number of possibilities an attacker must search.

Measuring Entropy and Randomness in Your Diceware Passphrase

Calculating informational strength for a passphrase is straightforward. Each word chosen from the 7,776-entry index contributes:

$$\text{bits per word} = \log_2(7776) \approx 12.92$$

In JavaScript, this is expressed as:

Math.log2(7776); // ≈ 12.92 bits/word

A symbol drawn from a 36-symbol pool adds:

Math.log2(36); // ≈ 5.16 bits/symbol

For comparison, a random letter from a 26-character alphabet contributes approximately 10 bits/letter, and a symbol from a 36-character set contributes roughly 5.16 bits per character. The total unpredictability for a passphrase of N words is simply:

$$\text{Total entropy} = N \times 12.92 \text{ bits}$$

The overall search space — the number of possible combinations — grows exponentially with word count:

(7776^WordsInPhrase)

So for five words: \(7776^5 = 28,430,288,029,929,701,376\) — nearly 28 quintillion possible phrases. This is the source of strong account security: even a professional adversary cannot enumerate that space in any practical timeframe. The selection method's unpredictability is what makes dice-generated passphrases so powerful: it is not the words themselves but the truly random selection process that creates attack resistance.

Crack Time vs. Passphrase Length: Brute-Force Attack Estimates

To understand why passphrase length matters so much, consider how long an exhaustive brute-force search of 50% keyspace would take at various attacker speeds. On average, a brute-force attacker needs to try half of all possible combinations before finding yours. A small cluster of GPUs can achieve approximately 350 billion hashes per second (hashes/second). A nation-state actor may operate at quadrillions per second. The table below shows estimated crack time at each word count, assuming a professional adversary performing GPU cracking at 350 billion guesses per second:

A six-word passphrase at 350 billion attempts per second would require approximately 10,000 years for an exhaustive brute-force — far beyond the reach of even a well-funded attacker. At a hypothetical quadrillion attempts per second, eight or more words still exhausts multiple human lifespans before covering 50% keyspace. This is why the standard recommendation is a minimum of six words, considered safe for high-protection applications including full-disk encryption and long-term cryptographic keys. Security research consistently supports this threshold.

Worked Passphrase Examples and Entropy Comparison

Here are three concrete passphrase examples to ground the math in reality.

Example 1 — A 6-word passphrase with dice roll mappings:

• Roll: 45231 → panoramic
• Roll: 34215 → nectar
• Roll: 42431 → precut
• Roll: 52413 → smith
• Roll: 12341 → banana
• Roll: 21345 → handclap

Result: panoramic nectar precut smith banana handclap — 77.52 bits of informational strength (6 × 12.92). This generated result is both memorable and cryptographically formidable.

Example 2 — Single complex credential vs. 5-word passphrase:

A complex 8-character credential using uppercase, lowercase, digits, and symbols (94 possible characters) has a search space of:

$$94^8 = 6{,}095{,}689{,}385{,}410{,}816 \approx 6 \times 10^{15}$$

A five-word passphrase has a search space of:

$$7776^5 = 28{,}430{,}288{,}029{,}929{,}701{,}376 \approx 2.84 \times 10^{19}$$

The five-word passphrase is roughly 4,600 times larger in coverage — and dramatically easier to remember. Credential strength is not just about character complexity but the size of the space an attacker must search.

Example 3 — Crack time worked example using the table:

Suppose your attacker speed is 350 billion attempts per second (a realistic GPU cracking rig). A 6-word passphrase has a combined search space of approximately \(7776^6 \approx 2.21 \times 10^{23}\). To cover 50% of that space:

$$\text{Time} = \frac{2.21 \times 10^{23} \div 2}{3.5 \times 10^{11}} \approx 3.16 \times 10^{11} \text{ seconds} \approx 10{,}000 \text{ years}$$

Even if an attacker could get lucky on the first try (an extraordinarily unlikely outcome), on average they would need to work through half the search space — which at current GPU cracking speeds takes millennia. That is the power of passphrase length.

Security, Privacy, and How This Diceware Passphrase Generator Operates

Online protection depends not just on passphrase strength but on the trustworthiness of the tool generating it. This application is designed from the ground up for information integrity and data confidentiality: it runs entirely in your local browser as static files — there is no server side processing, no database, and no network connection required after the initial page load. No data leaves your browser — not your passphrase size, your die rolls, or the output itself. This reflects sound cryptography practice and is a core principle of this tool's design.

How the Secure Random Number Generator Works

The generator relies on window.crypto.getRandomValues(), the JavaScript CSPRNG built into all modern browsers. This is not a pseudo-random number generator seeded by time — it is a cryptographically strong value generator that draws from the browser's secure entropy pool, including hardware sources. Many cryptographic library authors now use this same API as their primary source of unpredictability. Here is what the call looks like in practice:

window.crypto.getRandomValues(new Uint32Array(1));

This returns high-quality random bytes suitable for passphrase generation. The browser's value generator is also used to simulate die rolls and emulate a dice roll sequence, producing digits from 1 to 6 for each of the five positions. You can inspect the open source code in the GitHub repository to verify this behavior yourself — all HTML, JavaScript, and CSS assets are versioned with no external dependencies (zero dependencies). The tool is served over an HTTPS connection with HSTS enforced, preventing any man-in-the-middle attack on the code from a non-TLS connection. For offline use, once you load the page you can disable your network connection and the application continues to function from the local browser cache.

Safe Usage: Special Character Options and Operational Security

Even the most cryptographically sound passphrase can be compromised through poor operational habits. Here are the key practices for using this tool most safely:

• Generate passphrases only on a machine you own and control — no public machines or shared devices.
• Ensure no one can shoulder surf your screen while the passphrase is displayed.
• Always access the tool over a verified HTTPS connection — HSTS prevents downgrade attacks.
• Once generated, write it down on paper immediately and store somewhere safe, away from digital exposure.
• Close your browser window as soon as you are done — this removes the displayed result from memory.
• For the highest-protection applications (guarding long-term encryption keys, VT accounts, or disk encryption), use actual dice and perform the diceware lookup manually using a printed reference — this is the official Diceware FAQ recommendation and eliminates any software risk.
• Use the new special button to append a symbol (based on 2 rolls) if your site or service requires one — this adds roughly 5.16 bits of additional unpredictability to your passphrase.
• Use a minimum passphrase size of six words; length directly determines resistance against any brute-force search.

For most users — including those with high online safety needs such as protecting passphrases for credential management, authentication tokens, or encryption keys — the browser-based generator is safe and practical. The value generation is identical in quality to rolling dice from the attacker's perspective: the source of unpredictability is cryptographically equivalent. For nation-state-level adversaries, however, the Diceware FAQ recommends using actual dice to roll 5 values and look them up manually — and this generator supports that workflow through its manual entry and lookup features. Whether you use two die rolls for a symbol or five for a word, the tool accommodates both flows: two rolls generate a symbol from a pool of 36 characters, while five rolls select a word from the full 7,776-entry index. This tool was built with cybersecurity and user confidentiality in mind, is available as an open source project in a versioned GitHub repository, and carries no third-party tracking or analytics. What you generate stays yours alone.