Java中PBKDF2密码哈希的生成与验证指南

import javax.crypto.SecretKeyFactory;
import javax.crypto.spec.PBEKeySpec;
import java.security.NoSuchAlgorithmException;
import java.security.SecureRandom;
import java.security.spec.InvalidKeySpecException;
import java.util.Arrays;

/**
 * 封装密码哈希和盐值信息的类
 */
class PasswordInfo {
    private final byte[] hash;
    private final byte[] salt;

    public PasswordInfo(byte[] hash, byte[] salt) {
        this.hash = hash;
        this.salt = salt;
    }

    public byte[] getHash() {
        return Arrays.copyOf(hash, hash.length); // 返回副本以防止外部修改
    }

    public byte[] getSalt() {
        return Arrays.copyOf(salt, salt.length); // 返回副本以防止外部修改
    }
}

public class PasswordHasher {

    // PBKDF2算法参数
    private static final String ALGORITHM = "PBKDF2WithHmacSHA1"; // 注意：原问题中的"BPKDF2WithmacSHA1"应为"PBKDF2WithHmacSHA1"
    private static final int ITERATIONS = 65536; // 迭代次数，建议至少60000次
    private static final int KEY_LENGTH = 128;   // 密钥长度，单位为位，128位即16字节

    /**
     * 生成密码的哈希值和随机盐值。
     *
     * @param password 待哈希的原始密码
     * @return 包含哈希值和盐值的PasswordInfo对象
     * @throws NoSuchAlgorithmException 如果指定的算法不可用
     * @throws InvalidKeySpecException  如果密钥规范无效
     */
    public PasswordInfo generateHash(String password) throws NoSuchAlgorithmException, InvalidKeySpecException {
        // 1. 生成随机盐值
        SecureRandom random = new SecureRandom();
        byte[] salt = new byte[16]; // 16字节（128位）的盐值
        random.nextBytes(salt);

        // 2. 配置PBKDF2算法参数
        // PBEKeySpec需要密码字符数组、盐值、迭代次数和密钥长度
        PBEKeySpec spec = new PBEKeySpec(password.toCharArray(), salt, ITERATIONS, KEY_LENGTH);

        // 3. 获取SecretKeyFactory实例
        SecretKeyFactory factory = SecretKeyFactory.getInstance(ALGORITHM);

        // 4. 生成哈希值
        byte[] hash = factory.generateSecret(spec).getEncoded();

        return new PasswordInfo(hash, salt);
    }
}

// 延续 PasswordHasher 类
public class PasswordHasher {
    // ... (generateHash 方法和常量) ...

    /**
     * 验证用户输入的密码是否与存储的哈希值匹配。
     *
     * @param passwordInput 用户输入的密码
     * @param storedHash    数据库中存储的密码哈希值
     * @param storedSalt    数据库中存储的盐值
     * @return 如果密码匹配返回true，否则返回false
     * @throws NoSuchAlgorithmException 如果指定的算法不可用
     * @throws InvalidKeySpecException  如果密钥规范无效
     */
    public boolean verifyPassword(String passwordInput, byte[] storedHash, byte[] storedSalt)
            throws NoSuchAlgorithmException, InvalidKeySpecException {
        // 1. 使用用户输入的密码和存储的盐值重新生成哈希
        // 确保使用与生成时相同的迭代次数和密钥长度
        PBEKeySpec spec = new PBEKeySpec(passwordInput.toCharArray(), storedSalt, ITERATIONS, KEY_LENGTH);
        SecretKeyFactory factory = SecretKeyFactory.getInstance(ALGORITHM);
        byte[] newHash = factory.generateSecret(spec).getEncoded();

        // 2. 比较新生成的哈希与存储的哈希
        // 使用Arrays.equals进行常量时间比较，防止时序攻击
        return Arrays.equals(newHash, storedHash);
    }
}

import java.security.NoSuchAlgorithmException;
import java.security.spec.InvalidKeySpecException;
import java.util.Base64; // 用于字节数组和字符串之间的转换，便于存储和显示

public class Main {
    public static void main(String[] args) {
        PasswordHasher hasher = new PasswordHasher();
        String originalPassword = "mySecretPassword123";

        try {
            // --- 步骤1: 注册用户时生成并存储密码哈希和盐值 ---
            System.out.println("--- 密码生成 ---");
            PasswordInfo passwordInfo = hasher.generateHash(originalPassword);
            byte[] storedHash = passwordInfo.getHash();
            byte[] storedSalt = passwordInfo.getSalt();

            // 在实际应用中，您会将 storedHash 和 storedSalt 存储到数据库中
            System.out.println("原始密码: " + originalPassword);
            System.out.println("存储哈希 (Base64): " + Base64.getEncoder().encodeToString(storedHash));
            System.out.println("存储盐值 (Base64): " + Base64.getEncoder().encodeToString(storedSalt));

            System.out.println("\n--- 密码验证 ---");

            // --- 步骤2: 用户登录时验证密码 ---
            String loginAttemptPassword1 = "mySecretPassword123"; // 正确密码
            String loginAttemptPassword2 = "wrongPassword";       // 错误密码

            // 模拟从数据库加载存储的哈希和盐值
            // byte[] loadedStoredHash = ...;
            // byte[] loadedStoredSalt = ...;

            // 尝试验证正确密码
            boolean isCorrect1 = hasher.verifyPassword(loginAttemptPassword1, storedHash, storedSalt);
            System.out.println("尝试登录密码: '" + loginAttemptPassword1 + "' -> 验证结果: " + (isCorrect1 ? "成功" : "失败"));

            // 尝试验证错误密码
            boolean isCorrect2 = hasher.verifyPassword(loginAttemptPassword2, storedHash, storedSalt);
            System.out.println("尝试登录密码: '" + loginAttemptPassword2 + "' -> 验证结果: " + (isCorrect2 ? "成功" : "失败"));

            // 即使是相同的密码，如果盐值不同，哈希也会不同
            System.out.println("\n--- 相同密码不同盐值的哈希 ---");
            PasswordInfo anotherPasswordInfo = hasher.generateHash(originalPassword);
            System.out.println("原始密码: " + originalPassword);
            System.out.println("新生成哈希 (Base64): " + Base64.getEncoder().encodeToString(anotherPasswordInfo.getHash()));
            System.out.println("新生成盐值 (Base64): " + Base64.getEncoder().encodeToString(anotherPasswordInfo.getSalt()));
            System.out.println("新哈希与原哈希是否相同: " + Arrays.equals(anotherPasswordInfo.getHash(), storedHash));


        } catch (NoSuchAlgorithmException | InvalidKeySpecException e) {
            System.err.println("密码操作发生错误: " + e.getMessage());
            e.printStackTrace();
        }
    }
}