Question

Does using multiple algorithms make passwords more secure? (Or less?)

Just to be clear, I’m NOT talking about doing anything like this:

key = Hash(Hash(salt + password))

I’m talking about using two separate algorithms and matching both:

key1 = Hash1(user_salt1 + password)
key2 = Hash2(user_salt2 + password)

Then requiring both to match when authenticating. I’ve seen this suggested as a way eliminate collision matches, but I’m wondering about unintended consequences, such as creating a ‘weakest link’ scenario or providing information that makes the user database easier to crack, since this method provides more data than a single key does. E.g. something like combining information the hash to find them more easily. Also if collisions were truly eliminated, you could theoretically brute force the actual password not just a matching password. In fact, you’d have to in order to brute force the system at all.

I’m not actually planning to implement this, but I’m curious whether or not this is actually an improvement over the standard practice of single key = Hash(user_salt + password).

EDIT:

Many good answers, so just to surmise here, this should have been obvious looking back, but you do create a weakest link by using both, because the matches of weaker of the two algorithms can be tried against the other. Example if you used a weak (fast) MD5 and a PBKDF2, I’d brute force the MD5 first, then try any match I found against the other, so by having the MD5 (or whatever) you actual make the situation worse. Also even if both are among the more secure set (bcrypt+PBKDF2 for example), you double your exposure to one of them breaking.

Answer 1

The only thing this would help with would be reducing the possibility of collisions. As you mention, there are several drawbacks (weakest link being a big one).

If the goal is to reduce the possibility of collisions, the best solution would simply be to use a single secure algorithm (e.g. bcrypt) with a larger hash.