Ggthjy

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. ;)

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.

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)

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.

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.

Notes:

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