What is more secure, having one password of length 9 (salted and hashed) or having two different passwords, each of length 8 (salted and hashed using two different salts)?

  • Comments are not for extended discussion; this conversation has been moved to chat
    – Rory Alsop
    Mar 2 '19 at 10:14
  • Can you explain how these are passwords used and what the authentication process looks like?
    – hkBst
    Mar 4 '19 at 10:28

As John Deters has noted, 2x8 is almost certainly worse - but the reasons why take a little explaining.

There were a couple of problems with LANMAN hashes (the classic case of breaking a password in half, gone awry):

  • Since passwords tend to be human-generated and somewhat short, if a single password was only a little longer than the first half (say, 8 characters), then cracking the second half would take dramatically less time - and could even give away what the first half was likely to be

  • LANMAN was just so darned fast (for the attacker to attempt, in hash operations per second)

  • LANMAN cut the passwords in two at an unfortunate length (7), that was quite susceptible to full exhaustion (and even moreso on modern GPUs)

However, your question is a little different from the LANMAN case:

  • It does not state that the 2x8 passwords are actually a single password broken in half (they could be independently generated, and random)
  • It explicitly states that the two passwords are of length 8 (rather than, say, one of length 8 and the other of length 1, the famous LANMAN worst case)
  • Unless your salts are trivially small, building rainbow tables would be infeasible - which is the purpose of salting (unlike LANMAN hashes, which were entirely unsalted)

So it's an interesting question - one that's largely answered by looking at the associated math.

Let's make some assumptions:

  • Both the 9x1 and 8x2 approaches are salted and hashed using the same salt lengths and algorithms
  • Worst case for the attacker - the passwords are randomly generated from the printable ASCII character set (95 chars), with reasonably long salts. (The question would be less interesting if the passwords were human-generated, because in practice they would usually fall to easy attacks long before the attacker would have to resort to brute force)

  • Modern hardware and speeds are fair game

  • The hash algorithm may or may not be parallelism-friendly

Given all of the above, I'd roughly expect:

  • The 1x9 hash would be 100% exhausted in 95^9 (6.302 × 10^17) hashing operations (which might be parallelized well or poorly).
  • The 2x8 hashes would be jointly 100% exhausted in (95^8)x2 (1.326 × 10^16) hashing operations (and no matter the algorithm, could easily be naively parallelized simply by cracking each hash on a different system - but can often be parallelized very efficiently on a single system as well, depending on the algorithm).

In other words:

  • That 9th character adds 95 times the work to exhaust, and might be hard to parallelize
  • Two 8-character passwords only doubles the amount of work needed, and can be trivially parallelized

Another way to think about it is that adding one more character roughly creates the same work as having to crack 95 eight-character passwords! (If this isn't intuitive, start with simple cases comparing smaller cases like 1x1 vs 1x2, until you understand it).

So all other things being equal, 1x9 should almost always be better than 2x8.

And really, this is not only a simple illustration of the power of parallelization, it should also make it obvious why allowing longer password lengths is so crucial. Each additional character in the model above adds 95 times work to the overall keyspace. So adding two characters adds 95^2 - or 9025 times - the work. Brute force quickly becomes infeasible, even for very fast and unsalted hashes.

This would make an excellent homework question. ;)

  • Agreed with your conclusion. I would of explained this in a very similar manner.
    – Overmind
    Feb 28 '19 at 6:49
  • 10
    If the 2x8 passwords are human-generated, there are good chances that the second one is just the first one with a 1 replaced by a 2. Feb 28 '19 at 12:06
  • What if one makes the hashing function for the second password 200 times as slow as the hashing function for the primary password? Making the hashing function for the primary function too slow will make a denial-of-service attack trivial (simply flood a server with lots of login requests), but if one made the secondary function slower, only people who had cracked the primary password would be able to perform a DOS using the second, and trying that would increase the likelihood of the credentials being changed before the attacker could gain access.
    – supercat
    Feb 28 '19 at 21:14
  • Why would having two passwords to crack change the paralelization significantly, assuming the input is still completely undiscernable when the output is known? I would assume that leaves just the option of computing each hash, which would seem to be equally effective spread across 8 cores on one computer as it would be 4 cores on 2 computers. Feb 28 '19 at 21:24
  • 2
    The question doesn't specify either way, but what you're describing would be a smart way to be resistant to online (interactive) attack. I'm assuming that the threat model also needs to include an offline attack, where all password hashes have been stolen, and can be attacked at speed and without thresholds, in whatever hardware context the attacker chooses. Mar 1 '19 at 19:25

Starting from math point of view ... (to simplify calculation I assume only digit passwords)

Situation A: 2 parts 8 digit password, 'bruteforce attack on part one require max 10^8 hashes, same for part. Total of max 2*10^8 hashes required '

Situation B: 1 part 9 digit password, 'bruteforce attack require max 10^9 hashes'

Math say that's B is better than A

In few words

adding more password increase bruteforce of multiplication of number of parts (in this scenario is 2x)

adding more digits increase bruteforce of power of number of digits (in this scenario is x10^1)

  • How did you end up with 10 as your base? It’s very rare that only numbers are allowed, right? With alphanumeric characters (ASCII), the base would be 36 or 62 already. And if you allow any Unicode character … Your argument is even stronger with larger bases.
    – caw
    Feb 28 '19 at 23:09
  • 3
    WaltZie started with a simple case, to make the math easier. Mar 1 '19 at 5:16

Splitting the password is almost certainly worse. It allows an eight character rainbow table to be created. It implies that all passwords in the system will be in 8 character parts. (This is exactly how NT LANMAN passwords were broken.) In your case, it would simply require two rainbow tables.

The nine character password system has no such visible flaw, implying that if you entered a proper 14 character password it would be safely stored as a single hash.

  • Salting them would automatically exclude the use of rainbow tables. But the method described would indeed reduce the strength of longer passwords, for exactly the reasons you've noted. Feb 28 '19 at 4:24
  • Er, unless it was a trivially weak (short) salt. :) Feb 28 '19 at 5:07

No meaningful answer is possible without knowing what your threat scenario is. What are you trying to protect against? Are you worried about brute force or hash cracking? In the first case, we need to know your login procedure (e.g. do I enter the passwords sequentially or in parallel?). Also, if your login procedure doesn't lock me out after thousands or millions of failed login attempts, it is broken. That's not a question of password strength.

What about users writing things down? Shoulder surfing? Phishing? What's the model behind the passwords?

There are legitimate uses of two passwords, for example one read-access password and a seperate change-enable password. I doubt you have that in mind because of your 9-letter password alternative, just throwing that out there to show that reality is more complicated than an academic question on password strength based only on length.

  • Thought-provoking! And another interesting use case for two passwords: increased resistance to insider threat (requiring two people to collude in order to use the system). Feb 28 '19 at 15:54
  • 1
    @RoyceWilliams that's far out from what the question implies, but yes it is an actual real-world use case that is more common than most people assume.
    – Tom
    Feb 28 '19 at 17:54
  • This does not provide an answer to the question. To critique or request clarification from an author, leave a comment below their post. - From Review Mar 1 '19 at 13:24
  • 2
    @SoufianeTahiri: There are many questions to which a correct answer would depend upon details that weren't asked. An explanation of factors that would affect the answer may be more informative than an answer based upon certain stated assumptions about the unasked details, and will often be more useful than one based upon unstated assumptions. This answer suggests that the answer is usually no, but recognizes the possibility of some narrow cases where it would be yes.
    – supercat
    Mar 1 '19 at 17:46

Password systems involve trade-offs between security against illegitimate access versus resistance to denial-of-service attacks. A potential advantage of split-password systems is that the two halves of the system can apply different trade-offs. For example, resilience against denial-of-service attacks may require that the first-half hashing function be fast enough to keep up with spammed access attempts, but that wouldn't be so necessary for the second-half function since only an attacker who had broken the first-half password would be able to attempt access with the second.

If Fred Jones was notified every time anyone attempted an access with an incorrect first credential, an attacker could easily flood Mr. Jones with so many notifications that they would become useless, whether or not the attacker would ever have any real likelihood of gaining access. Notifying Mr. Jones if someone enters the correct first password but fails to enter a correct second password, however, would be much more useful. Unless Mr. Jones was the person attempting to access the account, such notification would serve as a very timely and useful warning that the primary password was breached, and both passwords should be changed ASAP.


Irrespective of the details of the hashing or of plausible cracking mechanisms, the fact of the matter is that the effort needed to crack two n-bit passwords is not 2n bits. It is n + 1 bits.

So suppose that your eight character passwords, P1 and P2, each have, say, a strength equivalent of 30 bits. (Doesn't really matter, I'm just trying to pick a number to be concrete. So it takes 30 bits of effort[See note] to crack each. To crack both, it does not take 60 bits. Instead it take 31 bits of effort.

Now suppose that you take P1 and simply add a digit that is uniformly chosen (you roll a D10) and stick that on the end. Then your augmented P1 will take take about 33.3 bits of effort to crack. That is more than four times more work than going after both P1 and P2.

If you pick a single lowercase letter or digit (so 36 possibilities) at random to add to the end of P1, then this new password is more than 5 bits stronger, and so it will take 16 times as many guesses to crack this than it will to crack both P1 and P2.

Higher security vaults?

I work for 1Password, a password manager. And we receive requests to have vaults within vaults. That is a Master Password to generally unlock 1Password and then a second password to unlock some higher security data. We have declined those requests for the reasons that I (and others here) have pointed out.

The result described above is counter-intuitive is counter intuitive. People will perceive using both P1 and P2 to be more secure than just a slightly longer augmentation of P1. We also consider a person's choice of Master Password to be the weakest point of their 1Password security (other than running on a compromised machine), and so we do not want to introduce things that might encourage people to use weaker master passwords than they otherwise would. We also would like people to get the most security for the effort, and making and remembering a small addition to a master password is less effort than creating and remembering another password.


"bits of effort": n bits of effort roughly means that it takes on average 2^(n-1) guesses to find the the correct password.

  • 1
    If you're cracking them independently or serially, this makes sense. But what of the case where they have to be entered/sent together, with only a single pass/fail response? In that case it seems like it would be equivalent to a 2n length password, no?
    – Geobits
    Mar 1 '19 at 18:39

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service, privacy policy and cookie policy

Not the answer you're looking for? Browse other questions tagged or ask your own question.