Bxdty

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)?

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.

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):

• 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, for a couple of reasons:

• 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)


• the question would be uninteresting 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)


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

For the sake of the thought experiment, 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)


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