Most modern PHP applications access important user information and store them in a database. For example, web app might have a registration system for new users. But how should you store usernames and passwords in the database?
You must always think about security. If passwords are stored in plain text, what happens if an attacker gains access to your database? He can easily read all of the users’ passwords. That’s why we use a technique called password hashing to prevent attackers from getting user passwords.
In this article you’ll learn how to store the passwords securely in the database so that, even if your database falls into wrong hands, no damage will be done.
What Is Password Hashing
Hashing is not a new concept. It has been in practical use for quite a long time. To understand hashing, think about fingerprints. Every person has a unique fingerprint. Similarly, each string can have a unique fixed-size “digital fingerprint” called a hash. For a good hashing algorithm, it’s very rare that two different strings will have same hash (called a collision).
The most important feature of hashes is that the hash generation process is one way. The one way property indicates that it’s impossible to recover the original text from its hash. Therefore password hashing perfectly suits our need for secure password storage. Instead of storing a password in plain text, we can hash the password and store the resulting hash. If an attacker later gains access to the database, he can’t recover original password from the hash.
But what about authentication? You can no longer compare the password entered by user in a login form with the hash stored in the database. You need to hash the login password and compare the result with the hash stored in the database.
How Hashing Is Done In PHP
There are different algorithms for generating hash of a text. The most popular ones are: MD5, SHA1, and Bcrypt. Each of these algorithms are supported in PHP. You really should be using Bcrypt, but I’ll present the other alternatives first because they help illustrate what you need to do to protect your passwords.
Let’s start with PHP’s
md5() function which can hash passwords according to the MD5 hashing algorithm. The following example demonstrates the registration process:
<?php $username = $_POST["username"]; $password = $_POST["password"]; // create connection to database // ... // sanitize the inputs // ... // create an MD5 hash of the password $password = md5($password); // save the values to the database $sql = "INSERT INTO users (username, password) VALUES (:username, :password)"; $stmt = $db->prepare($sql); $stmt->execute(array( ":username" => $username, ":password" => $password ));
And the following example shows the authentication process:
<?php $username = $_POST["username"]; $password = $_POST["password"]; // create connection to database // ... // sanitize the input // ... // create an MD5 hash of the password $password = md5($password); // retrieve the information from the database $sql = "SELECT * FROM users WHERE username=:username AND password=:password"; $stmt = $db->prepare($sql); $stmt->execute(array( ":username" => $username, ":password" => $password )); $row = $stmt->fetch();
In the above example,
md5() creates a 128-bit hash out of the given password. It’s also possible to use
sha1() instead of
md5() which produces a 160-bit hash (which means there’s less chance of a collision).
If you generate an MD5 hash of the string “MySecretPassword” and output it to the browser, it will look like the following:
“MySecretPassword” when hashed with SHA1 will produce the following output:
Never hash a password two times. It does not add extra security; rather, it makes the hash weak and inefficient. For example, don’t try to create an MD5 hash of a password and then provide it as input to
sha1(). It simply increases the probability of hash collisions.
Taking Password Hashing to the Next Level
Researchers have found several flaws in the SHA1 and MD5 algorithms. That’s why modern PHP applications shouldn’t use these two hash functions. Rather, they should use hash algorithms from the SHA2 family like SHA256 or SHA512. As the name suggest, they produce hashes of length 256 and 512 bits. They are newer and considerably stronger than MD5. As the number of bits increase, the probability of a collision decreases. Either of the above two is more than sufficient to keep your application secure.
The following code shows how to use SHA256 hashing in PHP:
<?php $password = hash("sha256", $password);
PHP offers the built-in function
hash(). The first argument to the function is the algorithm name (you can pass algorithm names like sha256, sha512, md5, sha1, and many others). The second argument is the string that will be hashed. The result it returns is the hashed string.
An important security measure to follow is always hash your users’ passwords before storing them in your database, and use modern hashing algorithms like Bcrypt, sha256, or sha512 to do so. When you do, even if an attacker gains access to your database, he won’t have the actual passwords of your users. This article explains the principles behind hashing, salts, and Bcrypt.