Question

I saw some guy who encrypt users password multiple times with MD5 to improve security. I’m not sure if this works but it doesn’t look good. So, does it make sense?

Answer 1

Let’s assume the hash function you use would be a perfect one-way function. Then you can view its output like that of a “random oracle”, its output values are in a finite range of values (2^128 for MD5).

Now what happens if you apply the hash multiple times? The output will still stay in the same range (2^128). It’s like you saying “Guess my random number!” twenty times, each time thinking of a new number – that doesn’t make it harder or easier to guess. There isn’t any “more random” than random. That’s not a perfect analogy, but I think it helps to illustrate the problem.

Considering brute-forcing a password, your scheme doesn’t add any security at all. Even worse, the only thing you could “accomplish” is to weaken the security by introducing some possibility to exploit the repeated application of the hash function. It’s unlikely, but at least it’s guaranteed that you for sure won’t win anything.

So why is still not all lost with this approach? It’s because of the notion that the others made with regard to having thousands of iterations instead of just twenty. Why is this a good thing, slowing the algorithm down? It’s because most attackers will try to gain access using a dictionary (or rainbow table using often-used passwords, hoping that one of your users was negligent enough to use one of those (I’m guilty, at least Ubuntu told me upon installation). But on the other hand it’s inhumane to require your users to remember let’s say 30 random characters.

That’s why we need some form of trade-off between easy to remember passwords but at the same time making it as hard as possible for attackers to guess them. There are two common practices, salts and slowing the process down by applying lots of iterations of some function instead of a single iteration. PKCS#5 is a good example to look into.

In your case applying MD5 20000 instead of 20 times would slow attackers using a dictionary significantly down, because each of their input passwords would have to go through the ordinary procedure of being hashed 20000 times in order to be still useful as an attack. Note that this procedure does not affect brute-forcing as illustrated above.

But why is using a salt still better? Because even if you apply the hash 20000 times, a resourceful attacker could pre-compute a large database of passwords, hashing each of them 20000 times, effectively generating a customized rainbow table specifically targeted at your application. Having done this they could quite easily attack your application or any other application using your scheme. That’s why you also need to generate a high cost per password, to make such rainbow tables impractical to use.

If you want to be on the really safe side, use something like PBKDF2 illustrated in PKCS#5.