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

I am asking because:

  1. I am getting confusing suggestions:

    password is very strong; suggest making the passphrase longer (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)?

  • 4
    A 778 character password has more entropy than a 777 password right? Even if all the characters have the same value.
    – Jodrell
    Commented Dec 19, 2022 at 9:38
  • 4
    Rumpkin's estimates aren't (necessarily) "bogus". Automated password strength estimations should just be taken with a massive grain of salt, because it's impossible to account for every way someone can make a bad password (and thus every way someone can try to crack it). My main criticism of the password strength estimator, at face value, would be that it doesn't have giant bright flashing text (metaphorically speaking) pointing out the above.
    – NotThatGuy
    Commented Dec 19, 2022 at 13:14
  • 15
    @Jodrell A single password does not have any entropy whatsoever. A method to generate a password has entropy. See security.stackexchange.com/a/265409/90896
    – jcaron
    Commented Dec 19, 2022 at 14:40
  • @jcaron that should be obvious and, is when you think about it, good link. Then, if we all coalesce on generating passwords with the same algorithm we actually make passwords easier to guess.
    – Jodrell
    Commented Dec 19, 2022 at 14:55
  • 7
    It's hard to see the point of this tool. No security-conscious person should ever use a service that asks them to provide their actual or potential password for a different authentication domain. On the other hand, few people who are not security-conscious are likely to have much interest in a password-strength calculator. Commented Dec 19, 2022 at 17:06

4 Answers 4


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.")), 

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.

  • It would be nice if you could post the non-minified code. Even though you've indented it, it's still hard to read.
    – Barmar
    Commented Dec 19, 2022 at 15:58
  • 12
    @Barmar: I have only the minified code, so I only reformatted it for better readability. For me it is pretty clear, what the code does but maybe I'm used to read very compact code. Commented Dec 19, 2022 at 16:04
  • @Barmar You can interpret each instance of x || y in the return statement as if (!x) {y;}, then finally we do return t;.
    – Jivan Pal
    Commented Dec 21, 2022 at 0:11
  • @Barmar: not sure if this helps, but the possibly unusual feature here is the use of the comma. In javascript, an expression separated by commas evaluates left-to-right and returns the rightmost term. So here if each of the character sets in r gives true, the corresponding t.push statement executes due to the or and it pushes the right message into t. At the end, t (with the corresponding messages) is returned. Commented Dec 21, 2022 at 14:10
  • @MartinArgerami I know how to interpret it, that doesn't make it easy to read. 1-letter variables don't help, either, I haven't had to deal withthat since I first used BASIC 40+ years ago.
    – Barmar
    Commented Dec 21, 2022 at 14:30

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.

  • 4
    I want to see a dictionary that contains words that are 777 characters long! :-)
    – gerrit
    Commented Dec 19, 2022 at 7:48
  • 5
    @gerrit apparently there's a chemical names that's 189,819 characters long, and another that's 1,909 characters. But more realistically, there's a 255 character "word" in the rockyou wordlist, and it's not uncommon for (badly) scraped wordlists to end up with long strings of HTML in them. If you're wondering, the one in rockyou is "panda255555555[...]5"
    – Gh0stFish
    Commented Dec 19, 2022 at 10:47
  • 5
    I wish I could upvote this a second time just for the last paragraph. Entropy calculations that don’t factor in context are borderline useless for this type of thing, but many people consistently seem to forget this. Commented Dec 19, 2022 at 15:08
  • I'm gonna be honest, even if it's just the letter a 777 times that's probably pretty strong in practice because almost nobody is going to try 777 character long passwords at all. Exception: any system that truncates the password
    – Murphy
    Commented Dec 21, 2022 at 14:09
  • Well making it longer would improve the strength of a 777 character password. Even if you had 778 as rather than 777 as, it's still slightly harder to guess Commented Dec 21, 2022 at 16:09

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".

  • Locking an account after a few failed attacks does nothing to protect against password spraying attacks, where a few common passwords are tried against many usernames. It only protects against targeted attacks, where many passwords are tried against one username.
    – Mark
    Commented Dec 21, 2022 at 0:32
  • You mention locking the account after a few failed tries. That doesn't protect against spraying, so even a "short simple password" needs to be strong enough to resist it.
    – Mark
    Commented Dec 21, 2022 at 3:27
  • @Mark: This is a very good point. If there are 1 000 000 users and passwords are locked after 5 failed attempts, password spraying is equivalent to trying 5 x 1 000 000 = 5 000 000 passwords before being locked. This should be taken into account when we are estimating password resistance to brute-forcing.
    – mentallurg
    Commented Dec 21, 2022 at 8:42

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 108-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 -log2(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.

  • 10
    If a generation process produces passwords 777 characters long with too little entropy, the right change is not likely to be generating even longer passwords. Commented Dec 18, 2022 at 23:55
  • @user2357112 True, but that is a situation where a longer password may be more secure, technically. I'll edit my answer to specify that it would be better to change the generation process.
    – forest
    Commented Dec 18, 2022 at 23:56
  • It is misleading to say that passwords are too short or long enough. We should talk about entropy, not about length. Increasing the length can increase entropy can, but not necessarily does it. E.g. if we know that generator takes randomly an English letter at every odd position and takes always "a" at every even position, then increasing length of a password with odd length by 1 does not increase entropy at all.
    – mentallurg
    Commented Dec 19, 2022 at 8:16
  • You are confusing the entropy of the password generation algorithm, and the password breaking resistance. Those are related, but not the same in practice when the attacker doesn't know exactly which algorithm was used to generate the password.
    – A. Hersean
    Commented Dec 19, 2022 at 9:14
  • @user2357112: A possible exception to that principle would be if one has a method or device which produces blobs of more than 777 characters which are guaranteed to have adequate entropy somewhere within them, and a method which only fetches 777 bytes of such a blob [if e.g. the device repeatedly outputs key/value pairs, some of which have sensor readings and some of which include output from a CSRNG, hashing a large enough chunk of the output from such a device may yield a good source of entropy, but hashing a chunk that contains only readings...
    – supercat
    Commented Dec 19, 2022 at 17:12

You must log in to answer this question.

Not the answer you're looking for? Browse other questions tagged .