How can I make MD5 more secure? Or is it really necessary?

I'm storing username and password in a MySQL database and have them hashed using MD5. However, I'm only using the standard PHP function without any modification. Now, I read that MD5 is broken. How are you doing it? Do you run it several 开发者_如何学Ctimes through a different hash mechanism or add some form of salt?

I'm amazed how people jump on the bandwagon of "damn, it's broken, I won't use it!", don't do the same mistake.

You can't make the MD5 better. Even using SHA-1 is vulnerable to same type of attacks as MD5. Using bcrypt will use A LOT more CPU than MD5 and SHA algorithms.

MD5 is designed to be fast, same as SHA. bcrypt isn't and it allows for more permutations, which makes it harder for someone to try to decrypt the original string.

You need to know why MD5 is considered "broken".

• Because it's fast to calculate a rainbow table of passwords up to 6 characters in length.

Using today's computing power, one can create an array of characters and MD5 all permutations and map them to the original string. That's how you get a rainbow table. If someone downloads your database and then compares passwords to their rainbow table - they can obtain users' original password. Reason why this is dangerous is because people use same passwords for many things - including paypal and other money processing service. That's why you use so-called salt. That makes it even harder to obtain the original string, so salting your users' passwords (let's say by reversing them and MD5-ing the reversed input) will make it harder for the attacker to revert the hash to original string.

• Because of collisions.

What's a collision? If you give hashing function two different strings and it returns the same hash - that's a collision. How does it translate to web and hashing passwords for logins? If you have the same hash for user1/password1 and user2/password2 - they could log on as someone else. That's where collisions play the role in security.

Reason why MD5 is considered broken is because MD5 returns same hash for strings that differ in small percentage. And it's not easy to calculate what that string might be! From mathematical point of view - yes, it's "broken" because if your string has 100 chars and it differs from other string in 10 chars (10% difference) - you get the same hash.

What applies for MD5 applies for ALL hashing algorithms. In the end, all of them don't have infinite number of possible hashes. However, some of them (like MD5) have less possible hashes and execute faster.

In the end, if someone got to your database - you have a bigger problem than using MD5 instead of bcrypt or SHA1.

Add a salt to each password stored that's not equal for every password

Simply use MD5("yoursite.com".$string);

MD5 is not decryptable. The only possible way to crack it is through hash tables that brute force everything. If you add a random string that only you know they cant crack it.

If you're worried about password security then you should use SHA1() (or alternative) rather than MD5(). Whilst MD5 is not decryptable, it can be beaten by either rainbow tables or matching the hash.

Salts will work against rainbow table but not against matching the hash which has been achieved with MD5.

There are a couple of things you should do.

1. Use SHA instead of MD5. SHA is more cryptographically secure than MD5. The more bits the better!
2. Use a salt. This makes rainbow table attacks more difficult.
3. Strengthen your key by calculating the hash like as follows:

:

function strenghtened_hash( $password, $salt, $n ) {
    $crypted = sha( $password . $salt );
    for( $i = 0; $i < $n; $i++ ) {
        $crypted = sha( $crypted . $password . $salt );
    }
    return $crypted;
}

Now you should be in good shape!

You might be better off using using bcrypt for password storage to prevent rainbow-table attacks in case the bad guys get hold of your DB.

At the very least, dump MD5 (although computationally fast, not very secure these days) and use something a little more secure like SHA256 with a long salt.

Switch to a different hash mechanism (you can do it incrementally as people log in) and definitely use a (different for each user) salt!

You can use a thing called a salt. It means that you also save this salt into you database. It's a random string which is more or less long and is unique for each user.

Then, to check the password, you do something like this:

<?php 
     $crypted = md5($salt.$passwordFromForm);

     if($crypted == $passwordFromDB) {
         // user logged on
     }
?>

You can make MD5 or any hashing function more strong by a method called "loop-hashing" i wrote about , read it here ,Good method to encrypte data, , using a loop "for" or "while" to encrypte password a lot of times with a random generated key number , really it's strong and so easy , so won't be scare from crackers again , no one can crack an encrypted "loop-hash" at the moment with the available databases .