PBKDF2密码哈希生成与验证方法

理解PBKDF2密码哈希

在现代应用中，直接存储用户密码是极度不安全的做法。密码哈希是将密码转换为固定长度的不可逆字符串的过程。PBKDF2（Password-Based Key Derivation Function 2）是一种推荐的密钥派生函数，用于安全地存储密码。它通过多次迭代（即“拉伸”）和使用随机生成的盐值（salt）来增加计算哈希的成本，从而有效抵御暴力破解和彩虹表攻击。

盐值（Salt）的作用： 盐值是一个随机生成的数据，与密码一同参与哈希计算。每个用户的密码都应使用一个唯一的盐值。这样即使两个用户设置了相同的密码，其哈希值也会不同，极大地增强了安全性。盐值不需要保密，但必须与哈希值一同存储，以便在验证时使用。

生成密码哈希

生成密码哈希是存储用户密码的第一步。此过程涉及生成一个随机盐值，然后使用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.Base64; // 用于将字节数组转换为字符串以便存储和显示

public class PasswordHasher {

    // 定义PBKDF2算法的参数
    private static final String ALGORITHM = "PBKDF2WithHmacSHA1"; // 算法名称
    private static final int ITERATIONS = 65536; // 迭代次数，应足够高以增加计算成本
    private static final int KEY_LENGTH = 128; // 密钥长度（位），通常为128位或256位
    private static final int SALT_LENGTH = 16; // 盐值长度（字节）

    /**
     * 生成密码的哈希值和对应的盐值。
     *
     * @param password 待哈希的原始密码
     * @return 包含哈希值和盐值的PasswordHashResult对象
     * @throws NoSuchAlgorithmException 如果PBKDF2WithHmacSHA1算法不可用
     * @throws InvalidKeySpecException 如果PBEKeySpec规范无效
     */
    public PasswordHashResult generateHash(String password)
            throws NoSuchAlgorithmException, InvalidKeySpecException {

        SecureRandom random = new SecureRandom();
        byte[] salt = new byte[SALT_LENGTH];
        random.nextBytes(salt); // 生成随机盐值

        KeySpec spec = new PBEKeySpec(password.toCharArray(), salt, ITERATIONS, KEY_LENGTH);
        SecretKeyFactory factory = SecretKeyFactory.getInstance(ALGORITHM);

        byte[] hash = factory.generateSecret(spec).getEncoded();

        // 返回哈希值和盐值，通常需要将它们转换为字符串（如Base64）以便存储
        return new PasswordHashResult(Base64.getEncoder().encodeToString(hash),
                                      Base64.getEncoder().encodeToString(salt));
    }

    /**
     * 用于存储哈希值和盐值的简单数据结构。
     */
    public static class PasswordHashResult {
        private final String hashedPassword;
        private final String salt;

        public PasswordHashResult(String hashedPassword, String salt) {
            this.hashedPassword = hashedPassword;
            this.salt = salt;
        }

        public String getHashedPassword() {
            return hashedPassword;
        }

        public String getSalt() {
            return salt;
        }
    }

    // 示例用法：
    public static void main(String[] args) {
        PasswordHasher hasher = new PasswordHasher();
        try {
            String userPassword = "MySecurePassword123";
            PasswordHashResult result = hasher.generateHash(userPassword);

            System.out.println("原始密码: " + userPassword);
            System.out.println("生成的哈希: " + result.getHashedPassword());
            System.out.println("对应的盐值: " + result.getSalt());

        } catch (NoSuchAlgorithmException | InvalidKeySpecException e) {
            e.printStackTrace();
        }
    }
}

注意事项：

• 迭代次数（ITERATIONS）和密钥长度（KEY_LENGTH）： 这些参数直接影响哈希的计算成本和安全性。应选择足够高的值，以平衡安全性与性能。随着硬件性能的提升，这些值也应适时调整。
• 盐值存储： generateHash方法会生成一个唯一的盐值。这个盐值必须与生成的哈希值一起存储在数据库中（通常是作为单独的列），以便在后续的密码验证过程中使用。

验证密码

密码验证的关键在于：你不能从哈希值中恢复原始密码。 相反，当用户尝试登录时，你需要做的是：

1. 从数据库中检索该用户存储的哈希值和对应的盐值。
2. 使用用户输入的密码（来自登录界面）、检索到的盐值以及相同的PBKDF2算法参数，重新计算一个新的哈希值。
3. 比较这个新计算出的哈希值与数据库中存储的哈希值。如果它们完全匹配，则密码正确；否则，密码不正确。

import javax.crypto.SecretKeyFactory;
import javax.crypto.spec.PBEKeySpec;
import java.security.MessageDigest; // 用于安全地比较字节数组
import java.security.NoSuchAlgorithmException;
import java.security.spec.InvalidKeySpecException;
import java.util.Base64;

public class PasswordVerifier {

    private static final String ALGORITHM = "PBKDF2WithHmacSHA1";
    private static final int ITERATIONS = 65536;
    private static final int KEY_LENGTH = 128;

    /**
     * 验证用户输入的密码是否与存储的哈希值匹配。
     *
     * @param inputPassword 用户在登录时输入的密码
     * @param storedHashedPassword 从数据库中获取的已哈希密码（Base64编码）
     * @param storedSalt 从数据库中获取的盐值（Base64编码）
     * @return 如果密码匹配返回true，否则返回false
     * @throws NoSuchAlgorithmException 如果PBKDF2WithHmacSHA1算法不可用
     * @throws InvalidKeySpecException 如果PBEKeySpec规范无效
     */
    public boolean verifyPassword(String inputPassword, String storedHashedPassword, String storedSalt)
            throws NoSuchAlgorithmException, InvalidKeySpecException {

        // 将Base64编码的哈希值和盐值解码回字节数组
        byte[] saltBytes = Base64.getDecoder().decode(storedSalt);
        byte[] storedHashBytes = Base64.getDecoder().decode(storedHashedPassword);

        // 使用用户输入的密码和存储的盐值重新计算哈希值
        KeySpec spec = new PBEKeySpec(inputPassword.toCharArray(), saltBytes, ITERATIONS, KEY_LENGTH);
        SecretKeyFactory factory = SecretKeyFactory.getInstance(ALGORITHM);
        byte[] inputHashBytes = factory.generateSecret(spec).getEncoded();

        // 使用MessageDigest.isEqual()进行常量时间比较，防止时序攻击
        return MessageDigest.isEqual(inputHashBytes, storedHashBytes);
    }

    // 示例用法：
    public static void main(String[] args) {
        PasswordHasher hasher = new PasswordHasher();
        PasswordVerifier verifier = new PasswordVerifier();

        try {
            String userPassword = "MySecurePassword123";
            // 1. 生成并存储哈希和盐值（模拟注册过程）
            PasswordHasher.PasswordHashResult storedResult = hasher.generateHash(userPassword);
            String storedHashedPassword = storedResult.getHashedPassword();
            String storedSalt = storedResult.getSalt();

            System.out.println("--- 模拟存储 ---");
            System.out.println("存储的哈希: " + storedHashedPassword);
            System.out.println("存储的盐值: " + storedSalt);
            System.out.println("----------------\n");

            // 2. 验证正确的密码
            String loginAttempt1 = "MySecurePassword123";
            boolean isCorrect = verifier.verifyPassword(loginAttempt1, storedHashedPassword, storedSalt);
            System.out.println("尝试登录密码: '" + loginAttempt1 + "' -> 验证结果: " + (isCorrect ? "成功" : "失败"));

            // 3. 验证错误的密码
            String loginAttempt2 = "WrongPassword";
            boolean isWrong = verifier.verifyPassword(loginAttempt2, storedHashedPassword, storedSalt);
            System.out.println("尝试登录密码: '" + loginAttempt2 + "' -> 验证结果: " + (isWrong ? "成功" : "失败"));

            // 4. 验证大小写不同的密码（通常被视为不同密码）
            String loginAttempt3 = "mysecurepassword123";
            boolean isCaseDiff = verifier.verifyPassword(loginAttempt3, storedHashedPassword, storedSalt);
            System.out.println("尝试登录密码: '" + loginAttempt3 + "' -> 验证结果: " + (isCaseDiff ? "成功" : "失败"));

        } catch (NoSuchAlgorithmException | InvalidKeySpecException e) {
            e.printStackTrace();
        }
    }
}

关键点：

• MessageDigest.isEqual(byte[] digesta, byte[] digestb)： 这是进行字节数组比较的推荐方法。它执行一个“常量时间”比较，这意味着无论两个数组是否相同，比较所需的时间都是恒定的。这可以有效防止“时序攻击”（Timing Attack），即攻击者通过测量比较时间来推断密码信息。直接使用Arrays.equals()可能会在不匹配时提前返回，从而泄露信息。
• 参数一致性： 在生成哈希和验证哈希时，必须使用相同的算法名称、迭代次数和密钥长度。任何参数的不一致都将导致验证失败。

总结与最佳实践

通过上述方法，我们实现了基于PBKDF2算法的Java密码哈希生成与验证机制。这种方法提供了强大的安全性，有效保护用户密码免受常见攻击。

额外建议和最佳实践：

• 选择合适的迭代次数： 迭代次数应根据当前硬件性能和安全需求进行调整。目标是使哈希计算对单个用户来说是可接受的（例如，几十到几百毫秒），但对于攻击者来说，在短时间内尝试大量密码变得非常昂贵。
• 更新算法和参数： 随着计算能力的提升，当前安全的迭代次数和算法可能在未来变得不安全。定期审查并更新哈希算法和参数是必要的。
• 异常处理： 在生产代码中，应妥善处理NoSuchAlgorithmException和InvalidKeySpecException，通常是通过日志记录并向用户显示一个通用的错误消息。
• 密码策略： 除了哈希，还应强制执行强密码策略，例如要求密码长度、包含大小写字母、数字和特殊字符。
• HTTPS/TLS： 确保所有密码传输都通过加密连接（如HTTPS/TLS），以防止中间人攻击窃取明文密码。
• 密码重置流程： 实现安全的密码重置流程，通常涉及发送一次性链接或验证码到用户的注册邮箱或手机。