How Can I Securely Hash Passwords in Java Using PBKDF2?

How to Securely Hash Passwords for Storage

Storing passwords in plaintext poses a significant security risk. To protect sensitive data, it is crucial to hash passwords before storing them. This process involves converting plaintext passwords into a fixed-size, encrypted format that is irreversible and computationally expensive to break. Java provides robust facilities for password hashing, ensuring the security of user credentials.

Using PBKDF2 for Secure Password Hashing

The SunJCE library in Java 6 introduces PBKDF2 (Password-Based Key Derivation Function 2), an industry-standard algorithm for password hashing. It is designed to prevent brute-force attacks and rainbow table attacks by incorporating a random salt and a high computational cost.

Implementing Password Hashing using PBKDF2

1. Create a salt: Generate a random salt to prevent the use of precomputed rainbow tables.
2. Hash the password: Utilize the PBKDF2 algorithm to derive a hash from the password and salt.
3. Store the hashed password: Save the salt and the hashed password securely in the database.

Verifying Passwords during Login

When a user logs in:

1. Retrieve salt: Obtain the salt associated with the user's account.
2. Hash the submitted password: Compute the hash of the submitted password using the retrieved salt.
3. Compare hashes: Check if the computed hash matches the stored hashed password. If they match, the password is correct.

Example Code for Password Hashing

import java.security.NoSuchAlgorithmException;
import java.security.SecureRandom;
import java.security.spec.InvalidKeySpecException;
import java.security.spec.KeySpec;
import java.util.Arrays;
import java.util.Base64;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

import javax.crypto.SecretKeyFactory;
import javax.crypto.spec.PBEKeySpec;

public class PasswordAuthentication {

  public String hash(char[] password) {
    byte[] salt = new byte[SIZE / 8];
    random.nextBytes(salt);
    byte[] dk = pbkdf2(password, salt, 1 << cost);
    byte[] hash = new byte[salt.length + dk.length];
    System.arraycopy(salt, 0, hash, 0, salt.length);
    System.arraycopy(dk, 0, hash, salt.length, dk.length);
    return ID + cost + '$' + enc.encodeToString(hash);
  }

  public boolean authenticate(char[] password, String token) {
    Matcher m = layout.matcher(token);
    if (!m.matches())
      throw new IllegalArgumentException("Invalid token format");
    int iterations = iterations(Integer.parseInt(m.group(1)));
    byte[] hash = Base64.getUrlDecoder().decode(m.group(2));
    byte[] salt = Arrays.copyOfRange(hash, 0, SIZE / 8);
    byte[] check = pbkdf2(password, salt, iterations);
    int zero = 0;
    for (int idx = 0; idx < check.length; ++idx)
      zero |= hash[salt.length + idx] ^ check[idx];
    return zero == 0;
  }

  private byte[] pbkdf2(char[] password, byte[] salt, int iterations) {
    KeySpec spec = new PBEKeySpec(password, salt, iterations, SIZE);
    try {
      SecretKeyFactory f = SecretKeyFactory.getInstance(ALGORITHM);
      return f.generateSecret(spec).getEncoded();
    }
    catch (NoSuchAlgorithmException ex) {
      throw new IllegalStateException("Missing algorithm: " + ALGORITHM, ex);
    }
    catch (InvalidKeySpecException ex) {
      throw new IllegalStateException("Invalid SecretKeyFactory", ex);
    }
  }
}

Conclusion

Hashing passwords using PBKDF2 is an essential security measure to protect user data. By implementing robust password hashing, developers can significantly enhance the security of their applications and minimize the risk of data breaches.

The above is the detailed content of How Can I Securely Hash Passwords in Java Using PBKDF2?. For more information, please follow other related articles on the PHP Chinese website!