Can 777-characters long passphrase be considered too short?

Question

Is Rumkin.com's password tool a reliable tool for password strength checking?

I am asking because:

1. I am getting confusing suggestions:

   (the password in this example is 777 characters long)

2. D. W.'s comment to Jeff Atwood's answer claims that Rumpkin's estimates are apparently bogus.

3. Adam Katz's answer to my other question claims that password complexity detection tools are all wrong. So that would include Rumpkin's, try zxcvbn (that I've been using so far) and many / all others.

Please, note that this is not a broad question on whether all password strength checkers are unreliable. This has been addressed many times. But rather specifically about Rumkin.com's password tool. I want to learn whether this tool's suggestion system is flawed or if (in any scenario) a 777-character password may be considered not long enough (and therefore whether any system can or rather should suggest making it even longer)?

Answer 1

Looking at the code of the site (which is not included in the linked github) it shows that the suggestion of making the passphrase longer is simply displayed always. From password-module.js (slightly beautified):

{
    key: "viewSuggestions",
    value: function() {
        var t = [m("li", "Make the passphrase longer.")],
            r = this.strengthScore.charsets;
        return r.lower     || t.push(m("li", "Add lowercase letters.")),
             r.upper       || t.push(m("li", "Add uppercase letters.")), 
             r.number      || t.push(m("li", "Add numbers.")), 
             r.punctuation || t.push(m("li", "Add punctuation.")), 
             r.symbol      || t.push(m("li", "Add symbols, such as ones used for math.")), 
             t
    }
}

As can be seen - "Make the passphrase longer." is always included and all the others depending on the input.

Is Rumkin.com's password tool a reliable tool for password strength checking?

Your main point seem to be the strange suggestion that even a very long password should be made longer. As shown, this is not a suggestion you can rely on. It is not an actual harmful suggestion though. But after some sufficient complexity and length is reached, this recommendation adds no real value and instead causes confusion.

Answer 2

If it's claiming that the way to improve the strength of a 777 character passphrase is to "make it longer", then it's nonsense.

A 777 character passphrase isn't necessarily very secure (for example, if it's just the letter a 777 times or if it's in a public dictionary or wordlist) - but in both of those cases the recommendation of "make it longer" is wrong.

All of these "entropy" calculators are pretty dodgy, because they tend to make bad assumptions about how attackers are actually cracking passwords. For example, the one you linked says that "password" provides 35 bits of entropy, when it's one of the most commonly used password out there and right at the start of pretty much every wordlist.

Answer 3

Your question looks like XY problem. Why do you use this tool at all?

1. High entropy of passwords is very important only if no "resource hungry" password hashing is used. For instance, if you use Argon2 in such way that hashing takes 1 second, then one CPU/GPU core can try only 86 400 (60 x 60 x 24) passwords per day or 31 536 000 passwords in a year. A million of such cores can brute-force 31 536 000 000 000 passwords in a year, means a 45 bit password, which approximately corresponds to a random password of length 10, consisting of lower case English letters. Rental of 1 000 000 cores for one year is very expensive. Means, for users with "cheap" secrets even a 10 letter password can be secure in a system with such hashing.

2. rumkin.com uses pretty old assumption about login security. Many web sites and applications lock users for some time (minutes, hours) after a few failed login attempts. That's why even short simple passwords may be sufficient to prevent brute-forcing. Many web sites and applications use also 2FA which makes logins despite short simple passwords even more secure. That's why forcing users to use longer and more complex passwords does not necessarily increases security essentially.

In case you need password for some application that uses no "resource hungry" password hashing: rumkin.com does not take into account the generator used to generate passwords for particular user. For the password "aabbbababa" it shows 46 bits entropy. But if we know that the generator uses just letters "a" and "b" to generate any password, then the entropy is just 10 bits.

Besides, talking about a password as "too short" or "long enough" makes not much sense. The most important question is, what entropy the password has. Depending on generator used, a shorter password can have much more entropy than a longer one. E.g. a password of length 3 created from randomly selected English letters has higher entropy than a password of length 10 created from randomly selected letters "a" and "b".

Answer 4

Yes, there are situations where a 777-character password might be considered too short^*. This would be the case if the password had a very low entropy. Entropy is a measure of how much information is contained in a sequence of symbols. While a completely uniform random 777-character password would be unbreakable, you could easily have an insecure password if it is low-entropy.

What is important is not password length on its own, but password entropy. Although increasing the length often increases entropy, the solution is not necessarily to keep increasing length. There are two relevant types of entropy here: Shannon entropy and min-entropy. Shannon entropy is the amount of information required to describe a sequence. However, if you want to measure how unpredictable a sequence is, you use min-entropy. According to an answer on Cryptography:

Say you have an algorithm which produces 8 digit numeric password. If the number 00000000 occurs 50% of the time, and the remaining 10⁸-1 passwords occur with equal probability, then the Shannon entropy would be about 14.3 bits, but the min-entropy is precisely 1, which is -log₂(0.5).

So you can absolutely have a long password that has many characters but is still insecure. While increasing the length may improve security, if your generation process cannot even generate a secure password that is hundreds of characters long, you need a better generation process.

_{* It would actually be too weak, not necessarily too short. A 32 character password is much shorter, but if it is random and has a high entropy, it would be much, much stronger than a 777-character password with low entropy.}