|About this Passwords Page|
If weak passwords (passphrases) are used, they will be easily discovered by trying every possible character combination in reasonable time through brute-force attacks. This method is very fast for short and/or non-random passwords.
This chapter discusses:
- How to calculate entropy for both pre-quantum and post-quantum strength;
- Estimating the brute force time for passwords of different length;
- Key-stretching measures which help to make password length manageable in a post-quantum world; and
- Principles for stronger passwords.
Generating Unbreakable Passwords
To generate strong passwords that are both easy to remember and have an easily calculatable large entropy, it is advised to use the Diceware package. Instead of generating a random sequence containing alphanumerical and special characters, Diceware selects a sequence of words equiprobably from a list containing several thousand that have been curated for their memorability, length and profanity.
Passwords that are long enough should be safe for millions or billions of years, even if the list chosen is known to the attacker. This relies on the fact that the time taken to try all possible combinations would be infeasibly large, even for a well-equipped adversary.  
Diceware Password Strength
When determining appropriate password length, ideally it should have at least as much entropy as the bit length of the symmetric key that is derived from it.  As will be explained later, one can deviate from this rule to have a shorter password while still having a realistically strong protection level. The entropy type referred to throughout this page is Shannon Entropy. The concept of Min-entropy measures the worst case lower bound of passphrase entropy in case of diceware generating words that have semantic meaning as a sentence or short passphrases whose character length can be easily brute-forced. This in practice is extremely unlikely and is detectable by the user and in the latter case a recommended number of words is advised to mitigate this risk.
Entropy per word is calculated by dividing log of number of words in list by log 2. List lengths vary.
log (7776) / log (2) = 12.92 bits
log (6800) / log (2) = 12.73 bits
Total password entropy is:
number of words * entropy per word
There are 32 special characters on a standard U.S. keyboard:
log (32) / log (2) = 5 bits per character
Alternatively, an alphanumeric string using lower/uppercase will have 62 characters in the set:
log (62) / log (2) = 5.95 bits per character
The relationship between entropy and the length of the diceware password is outlined below.
Table: Diceware Password Strength 
|Word Total||Bits of Entropy||Estimated Brute-force Time (Classical Computing) ||Future-proof Safety ||Post-quantum Secure |
|Eight||~103||~15 x age Universe||Yes||No|
|Nine||~116||~119,441 x age Universe||Yes||No|
|Ten||~129||~928,773,415 x age Universe||Yes||No|
|Fifteen||~194||~26,405,295,715,806,668,059,525,829,264 x age Universe||Yes||Yes|
|Twenty||~259||~750,710,162,715,852,378,145,230,792,130,183,941,981,164,925,924 x age Universe||Yes||Yes|
Calculating Brute-force Time
Moore's Law predicts the doubling of number of on-die transistors every 24 months (two years). Other estimates by the industry put that at 18 months. It is expected that Moore's Law ends by 2025 because of physical constraints of silicon.
1 trillion guesses in 2013 = 240 operations.
Lower bound - Doubling every 24 months 2013-2025:
Upper bound - Every 18 months 2013-2025:
To gauge strength against adversary capabilities, an example 80-bit password versus an adversary capable of 1 trillion or (240 guesses per second):
2(80-40) = 240 seconds
Classical vs Quantum Computing
Classical Computing Attack
- 7-word diceware passphrases are recommended, yielding ~90 bits of entropy against classical computing attacks. 
- 10-word diceware passphrases provide 128 bits of entropy.
Quantum Computing Attack
- Grover’s quantum search algorithm halves the key search space, so all entropy values in the table above are halved on quantum computers. For example, the cost of searching for the right 2128 passphrase drops to (very) roughly ~264. 
- A 20-word passphrase with 2256 bit entropy today, yields 128-bit post-quantum protection.
- Quantum computers do not impact the entropy provided by key-stretching algorithms. See below. 
Depending on how it is implemented, key-stretching introduces a major speed-bump for brute-forcing as it forces an adversary to undergo extra steps compared to processing vanilla, symmetric, master encryption keys. They allow passwords to be shorter while adding a certain entropy security margin. Note this does not help if bad passwords are chosen.
Passwords for LUKS FDE are secured using a key-stretching implementation known as a Password-Based Key Derivation Function (PBKDF). The older HMAC-SHA* algorithm is less effective against parallelization by GPUs and ASICs -- the same weaknesses suffered by Bitcoin against dedicated mining hardware.
Argon2id is the winner of the Password Hashing Competition and the state-of-the-art hashing algorithm of choice when protecting encryption keys. Its memory-hard properties introduce a large penalty for brute-search on general computers and even more so on GPUs and ASICs.
This is how to calculate entropy for Argon2id. An example  using arbitrary parameters is below:
- 1 GiB RAM, 50 iterations and 4 threads
- m=1GiB, t=50, p=4
The "20" comes from the exponent of 2 that gives the number of kibibytes that is used in 1 GiB RAM (220 = 1,048,576 kibibytes in this case). The number of 1 KiB block operations is most important. For 4 GiB, the exponent becomes "22" (222 = 4,194,304 kibibytes).
General Computers "Lower Bound"
20 + (log (50) / log(2)) = ~26 bits
GPUs and ASICs "Upper Bound"
20 + (20 - (log (8*4) / log (2))) + (log (50) / log (2)) = ~41 bits
Subtracting the parallelism (8x within a block and 4x thread-level p=4), because for this sort of attack the parallelism reduces the duration for which the memory has to be occupied.
Then, I think t=50 is excessive. It isn't even the equivalent of a one word longer passphrase, but it takes more time than typing a word would. Perhaps you should consider t=3. That will be only "4 bits" less, giving you something like 22 to 40 bits (depending on attack hardware) of stretching relative to BLAKE2b. --SolarDesigner (OpenWall lead and cryptographer who participated in the Password Hashing Competition)
Migrating LUKS FDE to Argon2id
These steps migrate systems which are currently encrypted with LUKS first from a LUKS1 to LUKS2 header, then shift to Argon2id. Removable media migration should be straightforward, however the main running system will require extra pre-boot steps because an open encrypted volume cannot be modified.  Take precautions such as backing up your data and make a copy of the required steps since they will be inaccessible during part of the process.
Argon2id Entropy Estimates
For LUKS FDE where memorization is a burden (assuming EFF list and 26 bit Argon2id lower bound):
- [post-quantum] 10 words + Argon2id = ~90 bits
- [post-quantum] 11 words + Argon2id = ~97 bits
- [post-quantum] 12 words + Argon2id = ~103 bits
For LUKS FDE where memorization is a burden (assuming EFF list and 24 bit Argon2id lower bound for faster logins [configured by 4 GiB, 3 iterations, 4 threads]):
- [post-quantum] 10 words + Argon2id = ~88 bits
- [post-quantum] 11 words + Argon2id = ~95 bits
- [post-quantum] 12 words + Argon2id = ~102 bits
In summary, 12 words is the safest compromise, giving a comfortable security margin at mild cognitive expense.
For any other encrypted media/container that does not implement Argon2id or where memory is not a problem because you can safely store the password on your encrypted computer:
- [post-quantum] 20 words = 128 bits
head /dev/random | tr -dc A-Za-z0-9 | head -c 43 ; echo ''
makepasswd --chars 43
The "diceware" package is available in Debian. To generate a 12-word password from the EFF's list, run:
Follow this additional advice for Diceware passwords: 
- Diceware passwords should have spaces between each word, otherwise the strength of the password is materially weakened. For example, a six-word passphrase without spaces “stray clam my aloof micro judo” has the same strength as a five-word passphrase “stray clammy aloof micro judo” with spaces.
- Only change passwords if a compromise is suspected.
- Random character capitalization is not recommended. Although it adds 1 bit per character, it requires regular pressing of the shift key - slowing down typing and increasing the number of keystrokes. Instead, it is better to just make the password longer if additional entropy is required.
Principles for Stronger Passwords
The last time I sat down to work out the statistics from known password lists the initial letter of a password/phrase had less than 4bits of entropy which rapidly dropped to less than 1.5bits by the seventh character, and dropping to a little over 1bit after ten characters. ... The simple fact is computers are now faster and more adept at password cracking than humans can think up memorable ways to remember strings of information that to humans look random..." --Clive Robinson
Users should read Wikipedia: Weak Passwords to learn about better practices for generating strong passwords and to determine if current passwords are weak. (w). The general principles for stronger passwords are outlined below. 
Table: Stronger Password Principles
|Content and Length||
- One trillion guesses per second.
- Safe until at least the year 2050.
- Assuming Grover's algorithm halves the number of iterations required to brute-force a key. This means doubling the length of symmetric keys to protect against future (hypothetical) quantum attacks.
- See: https://bugs.debian.org/896968 for details.
- The reason is the outcome of a dice roll is influenced by the physics of gravity, air resistance, torque applied, surface friction, the initial position of the die and other factors. High-friction surfaces are recommended, since dice tend to bounce more times in a chaotic fashion.
- Also see: EFF Dice-Generated Passphrases and EFF's Long Wordlist (.txt).
- https://security.stackexchange.com/questions/6095/xkcd-936-short-complex-password-or-long-dictionary-passphrase Second reply.