CODEWITHSUNDEEP
phpencryptionhashsha1bcrypt
Ozzy
Ozzy

Reputation: 10643

Password Hashing, BCrypt to SHA1/MD5

I have been looking at upgrading the password hashing security of one of my applications as I have been reading up about brute force attacks being considerably faster then they used to. Currently I am using sha1(md5($password)) and I see the benefits of using bcrypt + salt. My question is, Would it be any more secure if I were to do the following:

Scenario 1:

$password -> sha1 -> bcrypt -> sha1
// This would enable me to keep all existing passwords and just 
// regenerate all the hashes without waiting for the user to re login

Scenario 2:

$password -> bcrypt -> sha1
// I would have to add an extra column for the new hash until every
// user has logged in but the hash will still be sha1.

Would any of these two increase the security of the hash at all? I am no cryptographic master, far from it, I would just like a simple explanation as to if it would work, if not, and why.

Thanks

EDIT

After a little more reading, it seems that bcrypt is favoured because of its slowness in that i makes the cpu/gpu work longer before the hash is generated.

In the case of sha1 vs bcrypt, sha1 is roughly 300000 times faster then bcrypt. Which begs the question, if bcrypts advantage is slowness, surely a recursive hashing function which uses sha1 300000 times would be as secure as bcrypt?

I made this function as an example:

function bsha1($data, $salt) {

$hash = $data;

for ($i = 0; $i < 300000; ++$i) {

$hash = sha1($hash . $salt);

}

Provide it with a salt and itll return a sha1 hash where every iteration is a hashed hash and salt. This takes approximately the same ammount of time as bcrypt. Would this be as secure?

Upvotes: 2

Views: 10033

Answers (4)

BK004
BK004

Reputation: 392

You can use any standard hashing algorithm, but being standard hashing function they can be backtracked and there is a potential security risk.

You better go with any hash functions but combine it with salt with your personal keys. here is link

http://www.php.net/manual/en/faq.passwords.php#faq.passwords.fasthash

Upvotes: -2

Nomad101
Nomad101

Reputation: 1698

Short answer is yes it would help. However the long answer is no because SHA-1 and MD5 are just weak hashing algorithms now. It would be better for you to just go with SHA-2 algorithms or even wait a little longer and go directly to SHA-3.

The problem is in the hashing function. Three layers will definitely stop someone, but honestly most of the time one layer is enough to get most people to not even bother. If someone is very intent on getting in I would use SHA-2 at the very least other wise you should be fine with what you have.

EDIT::

Ok so to clarify the above. Using SHA1 with Bcrypt is not necesarilly the best way to go. I would use SHA-2 algorithms with bcrypt instead, this would give you more security than using the SHA-1. Also by layers I mean the Bcrypt is one Hash pass the SHA-1 is one Hash pass the second SHA-1 is another Hash pass. I really don't understand why this is wrong? Sorry for the difference in semantics about the layers.

EDIT2::

$Password -> Bcrypt -> SHA-2 or Bcrypt(SHA-2($Password)) Where SHA-2 is one of the SHA-2 family of hashing algorithms.

Code to be more clear than Bcrypt with SHA-2 instead of SHA-1.

Upvotes: -3

Peter Elliott
Peter Elliott

Reputation: 3322

neither scenario gives you much of a security margin over just bcrypt. That said, bcrypt is absolutely the way to go as far as a hashing algorithm that will resist brute forcing, as with a sufficiently high cost factor, it will take a much longer time to hash than any SHA-based hashing scheme.

Saying all that, Scenario 1 may be the way to go, as you are able to secure your db now instead of piecemeal as users log in. Despite what M8R-1jmw5r says in his/her answer, combining hashing algorithms doesn't give you any extra security, but it also won't really impact your security negatively.

Upvotes: 0

M8R-1jmw5r
M8R-1jmw5r

Reputation: 4996

You best upgrade to password_hash().

As it is likely you are not using PHP 5.5 yet (I assume maybe you are already for testing purposes at this time), you can use the PHP userland implementation of password_hash() also written by Ircmaxell for PHP 5.3+.

To upgrade the password hashes on login, you fetch the hash from the database and test first against the new hashing. If it returns FALSE, you test against the old hashing. If that returns TRUE, you re-hash the password with the new new hashing and store it back into the database.

Combining or chaining multiple hashes after each other - and I fear I read that in your question - is a total stupidity you should never consider. Hash algorithms are not compatible to each other and using a hash on a hash that way is doing it wrong: sha1(md5($password)) and the like effectively reduce the output space which makes it easier to attack - something you want prevent in the future.

So take the new password hashing API that there is in PHP and sleep well.

Upvotes: 12

Related Questions