理解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方法会生成一个唯一的盐值。这个盐值必须与生成的哈希值一起存储在数据库中（通常是作为单独的列），以便在后续的密码验证过程中使用。
验证密码
密码验证的关键在于：你不能从哈希值中恢复原始密码。 相反，当用户尝试登录时，你需要做的是：
- 从数据库中检索该用户存储的哈希值和对应的盐值。
- 使用用户输入的密码（来自登录界面）、检索到的盐值以及相同的PBKDF2算法参数，重新计算一个新的哈希值。
- 比较这个新计算出的哈希值与数据库中存储的哈希值。如果它们完全匹配，则密码正确；否则，密码不正确。
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();
}
}
}关键点：
立即学习“Java免费学习笔记（深入）”；
- MessageDigest.isEqual(byte[] digesta, byte[] digestb)： 这是进行字节数组比较的推荐方法。它执行一个“常量时间”比较，这意味着无论两个数组是否相同，比较所需的时间都是恒定的。这可以有效防止“时序攻击”（Timing Attack），即攻击者通过测量比较时间来推断密码信息。直接使用Arrays.equals()可能会在不匹配时提前返回，从而泄露信息。
- 参数一致性： 在生成哈希和验证哈希时，必须使用相同的算法名称、迭代次数和密钥长度。任何参数的不一致都将导致验证失败。
总结与最佳实践
通过上述方法，我们实现了基于PBKDF2算法的Java密码哈希生成与验证机制。这种方法提供了强大的安全性，有效保护用户密码免受常见攻击。
额外建议和最佳实践：
- 选择合适的迭代次数： 迭代次数应根据当前硬件性能和安全需求进行调整。目标是使哈希计算对单个用户来说是可接受的（例如，几十到几百毫秒），但对于攻击者来说，在短时间内尝试大量密码变得非常昂贵。
- 更新算法和参数： 随着计算能力的提升，当前安全的迭代次数和算法可能在未来变得不安全。定期审查并更新哈希算法和参数是必要的。
- 异常处理： 在生产代码中，应妥善处理NoSuchAlgorithmException和InvalidKeySpecException，通常是通过日志记录并向用户显示一个通用的错误消息。
- 密码策略： 除了哈希，还应强制执行强密码策略，例如要求密码长度、包含大小写字母、数字和特殊字符。
- HTTPS/TLS： 确保所有密码传输都通过加密连接（如HTTPS/TLS），以防止中间人攻击窃取明文密码。
- 密码重置流程： 实现安全的密码重置流程，通常涉及发送一次性链接或验证码到用户的注册邮箱或手机。
