3 ms·
It's worth noting that the password entropy should be estimated relative to the attacker's uncertainty about the password. An attacker, even a brute force atta
by schoen 12y ago
It's worth noting that the password entropy should be estimated relative to the attacker's uncertainty about the password. An attacker, even a brute force attacker, is implicitly assigning a probability distribution or at least a probability ranking to candidate passwords: the attacker can choose what order to guess them in and isn't constrained to use "the shortlex ordering of all strings" as the search strategy.
One response to this is to use Kerckhoffs's principle
https://en.wikipedia.org/wiki/Kerckhoffs%27s_principle https://en.wikipedia.org/wiki/Kerckhoffs%27s_principle
and say that to estimate the entropy of a password, we should assume that the attacker can guess the "system" or method that we used to generate it, but doesn't know the true physical randomness that went into it. (If we seed a random number generator with the time, the attacker can know that fact and try every possible seed value as part of the attack.)
Another response is to say that the attacker doesn't inherently know the system but that the attacker's reasonable attempts to guess it still need to be part of the entropy calculation, because a prudent attacker would have some model of plausible and likely password generation methods that would inform the order in which the attacker tries guesses. So if the attacker decides "next, I'll try all sequences of three English words", you just have to figure out at what point the attacker is going to try that rule as part of the guessing process, and that lets you figure out when the attacker will succeed, which in this case is still incredibly much sooner than trying all strings in shortlex order.
I think the former method, the assumption that the adversary knows which password generation system you're going to use, is safer, for basically the reasons that proponents of Kerckhoffs's rule have given. Here it's that if we don't truly know how much uncertainty the adversary has about our method for generating passwords, it would be safest to assume the uncertainty is zero, and that all the strength comes from the randomness we fed into the system. By that measure the strength of your passwords is exactly n log₂(|d|) when you use n words randomly, independently, and uniformly selected from a dictionary d (maybe assuming that the passwords you create that way don't overlap with passwords that could have been produced by some other simpler rule that a realistic adversary would have regarded as worth testing sooner).