Creating Good Passwords

What Makes a Good Password?

Good passwords are hard for hackers to guess. They have three properties:

Good Passwords Are Random

Good Passwords Are Long

Even if passwords are random, they must be long, or else hackers might accidentally guess them.

Good Passwords Contain Lots of Entropy

Entropy is a measure of randomness. The more entropy a password has, the more difficult it is for hackers to guess it. Entropy is usually measured in bits — the same bits that computers use, each of which is 0 or 1. One bit of entropy contains the same amount of randomness as a single coin flip. N bits of entropy contain the same amount of randomness as N coin flips.

Information Entropy

Algorithmic Entropy

How Both Kinds of Entropy Fit into Password Generation

Password Strength and Quantum Computers

Entropy Sources

Flipping Coins

Rolling Dice

Poker and Bridge Cards

Alphabets

Passwords are sequences of random symbols. Therefore, you have to decide which set of symbols — which alphabet — you'll use. Each symbol contributes log₂ N bits of entropy, where N is the size of the alphabet and log₂ is the base-2 logarithm function, if you choose each symbol independently and randomly.

Here are some alphabets and the number of bits of entropy each of their symbols contributes:

Unless otherwise specified, tables in future sections list how many bits of entropy each symbol contributes if each symbol is chosen independently and randomly. Entropy decreases if some symbols aren't chosen independently or randomly.

Decimal Digits

There are 10 decimal digits (hence the name "decimal"):

0 1 2 3 4 5 6 7 8 9

Entropy

Assuming you generate each digit independently and randomly:

^*: Highly secure against classical computers
^†: Highly secure against quantum computers

Generating with Ten-Sided Dice

Ten-sided dice are the easiest way to generate random decimal digits. Throw multiple dice at the same time to generate them faster. Ten-sided dice are cheap and easy to find online and in board game stores.

Generating with Six-Sided Dice

Suppose you throw two 6-sided dice, one red and one black. Use this table to figure out which decimal digit each throw generates:

If the black die shows a 6, throw the dice again.

Probability of generating a digit: 5/6

Generating with Coins

The slowest way to generate decimal digits is with a coin. Flip a coin five times. Use this to figure out which decimal digit the five flips generate ('H' is heads, 't' is tails):

If the first four flips are heads, ignore them and flip five times again.

You're essentially creating a five-digit binary number (where tails represents 0 and heads represents 1), converting it to decimal, and keeping the units digit.

Probability of generating a digit: 15/16

Generating with Poker Cards

You can also generate random digits with poker cards. Take a 52-card deck and remove the face cards and jokers, but keep the aces and 10's. There should be 40 cards left.

Shuffle the cards and draw them one at a time. Keep the first card of each suit you encounter and discard the rest. Stop once you keep one card of each suit. The ranks of the four cards you keep correspond to decimal digits:

Reshuffle the cards after generating digits. If you don't, subsequent draws will make some digits more probable than others, reducing the password's entropy.

Example: Suppose you shuffle and draw the following cards:

You'd keep the four cards with yellow borders (the ace of spades, 3 of clubs, 5 of diamonds, and 3 of hearts) and generate the digits 1, 3, 5, and 3. Then you'd reshuffle the entire deck and repeat until you get all the digits you need.

Hexadecimal

Hexadecimal is commonly used in computer programming. It combines the decimal digits with the first 6 letters of the English alphabet, providing 16 symbols:

0 1 2 3 4 5 6 7 8 9 a b c d e f

Entropy

Assuming you generate each symbol independently and randomly:

^*: Highly secure against classical computers
^†: Highly secure against quantum computers

Generating with Coins

Flip a coin four times. Convert the four flips into a hexadecimal symbol with this table ('H' is heads, 't' is tails):

Lowercase English Alphabet

There are 26 letters in the English alphabet:

a b c d e f g h i j k l m n o p q r s t u v w x y z

Entropy

Assuming you generate each letter independently and randomly:

^*: Highly secure against classical computers
^†: Highly secure against quantum computers

Generating with Six-Sided Dice

Suppose you throw two 6-sided dice, one red and one black. Use this table to figure out which English letter each throw generates:

'-' means that you should roll the dice again.

Probability of generating a letter: 11/18

Generating with Coins

The slowest way to generate English letters is with a coin. Flip a coin five times. Use this to figure out which letter the five flips generate ('H' is heads, 't' is tails):

'-' means that you should ignore the result and flip five times again.

Probability of generating a letter: 13/16

Generating with Poker Cards

You can also generate random letters with poker cards. Shuffle a deck and flip the top card. Ignore its suit. The card's color and rank correspond to a letter:

Reshuffle the cards after generating a letter. If you don't, subsequent draws will make some letters more probable than others, reducing the password's entropy.

Another technique is to divide the 52 cards into two decks, each containing a red suit and a black suit (so 26 cards per deck), and to shuffle and draw from each deck separately. This might be faster than using a single deck.

Lowercase English Alphabet Plus Decimal Digits

Combining lowercase English letters and decimal digits gives 36 symbols.

Entropy

Assuming you generate each symbol independently and randomly:

^*: Highly secure against classical computers
^†: Highly secure against quantum computers

Generating with Six-Sided Dice

Generating symbols with two 6-sided dice is easy. Suppose one is red and the other is black:

Full English Alphabet

Combining uppercase (majuscule) and lowercase (miniscule) English letters gives 52 symbols.

Entropy

Assuming you generate each letter independently and randomly:

^*: Highly secure against classical computers
^†: Highly secure against quantum computers

Generating with Poker Cards

You can generate random English letters with poker cards. Shuffle a deck and flip the top card. Its suit and rank correspond to a letter:

Card	Symbol	Card	Symbol	Card	Symbol	Card	Symbol
A	a	A	A	A	n	A	N
2	b	2	B	2	o	2	O
3	c	3	C	3	p	3	P
4	d	4	D	4	q	4	Q
5	e	5	E	5	r	5	R
6	f	6	F	6	s	6	S
7	g	7	G	7	t	7	T
8	h	8	H	8	u	8	U
9	i	9	I	9	v	9	V
10	j	10	J	10	w	10	W
J	k	J	K	J	x	J	X
Q	l	Q	L	Q	y	Q	Y
K	m	K	M	K	z	K	Z

You can, of course, arrange the suits in any order you please in the above diagram.

Base64 Alphabet

Entropy

Assuming you generate each symbol independently and randomly:

^*: Highly secure against classical computers
^†: Highly secure against quantum computers

Generating with Eight-Sided Dice

The easiest to generate Base64 symbols is with two 8-sided dice. Suppose one is red and the other is black:

Generating with Coins

The slowest way to generate Base64 symbols is with a coin. Flip a coin six times. Convert the first three flips and the last three flips into two numbers using this table ('H' is heads, 't' is tails):

Then convert those two numbers to Base64 as follows:

List of 1,296 Common Words

This "alphabet" is a set of 1,296 common English words (or words of any human language). Each word is counted as a symbol. Any list of words will do as long as there are no duplicates.

Passwords constructed from common words are easier to remember than long strings of random letters and numbers. They're also longer and thus slightly harder for hackers to guess.

Entropy

Assuming you generate each word independently and randomly:

^*: Highly secure against classical computers
^†: Highly secure against quantum computers

Generating with Six-Sided Dice

Number each word in base six. The first word is 1111, the second is 1112, the sixth is 1116, the seventh is 1121, the eigth is 1122, and the last (1,296th) word is 6666.

To randomly pick a word, roll four 6-sided dice. Pick the word with the resulting number. For example, if your dice show "2545", pick word 2545.

List of 7,776 Common Words

This "alphabet" is a set of 7,776 common English words (or words of any human language). Each word is counted as a symbol. Any list of words will do as long as there are no duplicates.

Passwords constructed from common words are easier to remember than long strings of random letters and numbers. They're also longer and thus slightly harder for hackers to guess.

Entropy

Assuming you generate each word independently and randomly:

^*: Highly secure against classical computers
^†: Highly secure against quantum computers

Generating with Six-Sided Dice

Number each word in base six. The first word is 11111, the second is 11112, the sixth is 11116, the seventh is 11121, the is eigth 11122, and the last (7,776th) word is 66666.

To randomly pick a word, roll five 6-sided dice. Pick the word with the resulting number. For example, if your dice show "32545", pick word 32545.

Alternative Password Generation Schemes

These ways to generate passwords have less entropy than the systems outlined in earlier sections because the resulting passwords' symbols aren't generated independently.

Generate English Letters with Poker Cards Shuffled Once

Thoroughly shuffle a deck of 52 cards (excluding jokers). Draw cards one at a time. Each card's suit and rank correspond to an English letter, which can be lowercase (miniscule) or uppercase (majuscule):

Card	Symbol	Card	Symbol	Card	Symbol	Card	Symbol
A	a	A	A	A	n	A	N
2	b	2	B	2	o	2	O
3	c	3	C	3	p	3	P
4	d	4	D	4	q	4	Q
5	e	5	E	5	r	5	R
6	f	6	F	6	s	6	S
7	g	7	G	7	t	7	T
8	h	8	H	8	u	8	U
9	i	9	I	9	v	9	V
10	j	10	J	10	w	10	W
J	k	J	K	J	x	J	X
Q	l	Q	L	Q	y	Q	Y
K	m	K	M	K	z	K	Z

The password's randomness (entropy) will be less than if you were to shuffle the entire deck every time you draw a card, but you'll only have to randomize the deck once.

Here's how much entropy your password will have based on this scheme:

^*: Highly secure against classical computers
^†: Secure against quantum computers
^‡: Highly secure against quantum computers

How Many Passwords Should I Create?

Ideally, each of your accounts would have a different password. That way a hacker who breaks into one account or service you use can only access that account with the stolen password.

But most of us have at least a dozen accounts; some have several dozen. That's a lot of passwords to remember!

Some people compromise by distinguishing between critical, sensitive, and throwaway accounts and services. They give each critical account or service its own highly-secure password, each moderately sensitive account its own moderately-secure password, and all throwaway accounts the same moderately-secure password. What "sensitive", "moderately sensitive", and "throwaway" mean are up to the user. This is the solution I use.

Other people create a few highly-secure password prefixes. For each account, they combine one of the prefixes with a memorable (not necessarily random) suffix to get a password. This makes it much easier to remember one's passwords, but if an attacker can guess that you're using this scheme, he'll have a much easier time breaking into your other accounts after learning one of your passwords.

The Mathematics of Password Generation

Fortunately, password generation doesn't rely on complicated mathematics. You can calculate a system's entropy using grade school and middle school math.

Information Entropy

The amount of entropy each symbol contributes to a password (if chosen randomly and independently) is

where "log₂" is logarithm base 2 and N is the size of the password's alphabet.

Why is this so? Imagine how you could randomly pick one symbol out of an alphabet of N symbols. One very general way to do so is to assign each symbol a number from 0 to N-1. For example, if your alphabet is the lowercase English letters (N=26), you could do this:

Then you could flip a coin multiple times, convert the flips into a binary number (1's and 0's), convert the binary number to a base ten number (our everyday counting system), and pick the letter associated with that number. For example, if you were to use the table above and flip tails, heads, heads, tails, and tails, you'd convert the five flips into the binary number "01100", which is "12" in base ten, which corresponds to the digit "m" in the table. If the generated number isn't assigned to any symbols in your alphabet, keep generating numbers until you pick a symbol. It's easy to see that this scheme makes choosing each symbol equally likely.

Assuming you only have to generate one binary number to pick a symbol, how many times would you have to flip a coin to pick a symbol? (In other words, how many digits would the binary number have to have?) The answer is the symbol's contribution to the password's entropy. Remember, a coin flip has 1 bit of entropy. If it takes 5 coin flips to randomly pick a symbol out of an alphabet, the symbol's entropy contribution is 5 bits. Therefore, given that

which states that it takes x coin flips to randomly pick one of N symbols,

x is each symbol's entropy.

Note that x will be fractional unless N is a power of 2. There are 26 lowercase English letters, so each letter contributes

bits if chosen independently and randomly.

Another way to measure a password generation system's entropy is to look at how many different passwords it can generate. Assuming the system can generate M different passwords and each one is equally likely (that is, each password is chosen independently and randomly), ask, "How many coin flips would it take to randomly select one of the M passwords?" The answer is the system's information entropy in bits. If there are M possibilities, the password generator's entropy is

The Rule of Product

The mathematical foundations of password systems and password strength come from combinatorics, the study of arrangements. It rests on a few simple counting principles. One that's particularly important for passwords is the rule of product.

Suppose you can choose one of A things followed by one of B things. How many combinations of one A thing and one B thing are there?

For example, if A is the letters {X, Y} and B is the numbers {1, 2, 3, 4}, then there are two choices for A and four for B. The AB combinations are:

X1 X2 X3 X4
Y1 Y2 Y3 Y4

There are eight combinations. Notice that this is the size of A times the size of B: 2 x 4.

This observation generalizes to all sets A and B:

The total number of combinations of one A thing followed by one B thing is |A| x |B|.

Here "|A|" means "the number of things in A" or "the size of A".

What if you choose one from each of three sets A, B, and C? The total number of combinations is |A| x |B| x |C|. Why does this work? If we define a fourth set D as the set of combinations of one B thing followed by one C thing, then D has |B| x |C| things. Now, how many combinations of one A thing and one D thing are there? The answer is:

|A| x |D| = |A| x (|B| x |C|)
	  = |A| x  |B| x |C|

To see how this applies to password generation, suppose you make the lowercase English letters your password alphabet. Let's call this alphabet A. The alphabet has 26 letters, so |A| = 26. If you were to generate a single-letter password, there would only be 26 possible passwords. But if you randomly choose two letters, there would be

|A| x |A| = 26 x 26 = 26² = 676 possible passwords

The possibilities grow exponentially as you add more letters:

So if you randomly and independently choose n letters, there would be |A|ⁿ possible passwords.

Permutations

Suppose you have a set of things. We'll call the set A. Each thing in A is unique. How many arrangements of those A things are there? In other words, if you had to arrange everything in A into a line, how many possible lines would there be?