Java实现Argon2加密

以下是使用 Argon2 算法的 Java 实现，用于安全密码哈希存储。Argon2 是密码哈希竞赛（PHC）的获胜者，被公认为当前最安全的密码哈希算法之一。

1. 添加依赖

首先，在 pom.xml 中添加 Bouncy Castle 或 Argon2 JVM 支持：

选项1：Bouncy Castle（推荐）

<dependency>
    <groupId>org.bouncycastle</groupId>
    <artifactId>bcprov-jdk15on</artifactId>
    <version>1.70</version>
</dependency>

选项2：Argon2 JVM

<dependency>
    <groupId>de.mkammerer</groupId>
    <artifactId>argon2-jvm</artifactId>
    <version>2.11</version>
</dependency>

2. 完整代码实现（基于 Bouncy Castle）

import org.bouncycastle.crypto.generators.Argon2BytesGenerator;
import org.bouncycastle.crypto.params.Argon2Parameters;
import java.security.SecureRandom;
import java.util.Base64;

public class Argon2PasswordHasher {

    // Argon2 配置参数（可根据硬件性能调整）
    private static final int ITERATIONS = 10;          // 迭代次数
    private static final int MEMORY = 65536;          // 内存消耗（KB）
    private static final int PARALLELISM = 1;         // 并行线程数
    private static final int SALT_LENGTH = 16;        // 盐值长度（字节）
    private static final int HASH_LENGTH = 32;        // 哈希输出长度（字节）

    /**
     * 生成 Argon2 哈希密码（格式：盐值:哈希值）
     */
    public static String hashPassword(String password) {
        // 生成随机盐值
        byte[] salt = generateSalt(SALT_LENGTH);

        // 配置 Argon2 参数
        Argon2Parameters.Builder builder = new Argon2Parameters.Builder(Argon2Parameters.ARGON2_id)
                .withSalt(salt)
                .withIterations(ITERATIONS)
                .withMemoryAsKB(MEMORY)
                .withParallelism(PARALLELISM);

        // 生成哈希
        Argon2BytesGenerator generator = new Argon2BytesGenerator();
        generator.init(builder.build());
        byte[] hash = new byte[HASH_LENGTH];
        generator.generateBytes(password.toCharArray(), hash);

        // 返回 Base64 编码的盐值和哈希
        return Base64.getEncoder().encodeToString(salt) + ":" + 
               Base64.getEncoder().encodeToString(hash);
    }

    /**
     * 验证密码
     */
    public static boolean verifyPassword(String inputPassword, String storedHash) {
        // 拆分盐值和哈希
        String[] parts = storedHash.split(":");
        byte[] salt = Base64.getDecoder().decode(parts[0]);
        byte[] originalHash = Base64.getDecoder().decode(parts[1]);

        // 使用相同盐值重新计算哈希
        Argon2Parameters.Builder builder = new Argon2Parameters.Builder(Argon2Parameters.ARGON2_id)
                .withSalt(salt)
                .withIterations(ITERATIONS)
                .withMemoryAsKB(MEMORY)
                .withParallelism(PARALLELISM);

        Argon2BytesGenerator generator = new Argon2BytesGenerator();
        generator.init(builder.build());
        byte[] newHash = new byte[HASH_LENGTH];
        generator.generateBytes(inputPassword.toCharArray(), newHash);

        // 对比哈希值
        return MessageDigest.isEqual(originalHash, newHash);
    }

    /**
     * 生成随机盐值
     */
    private static byte[] generateSalt(int length) {
        SecureRandom random = new SecureRandom();
        byte[] salt = new byte[length];
        random.nextBytes(salt);
        return salt;
    }

    // 测试示例
    public static void main(String[] args) {
        String password = "MySecurePassword123!";

        // 哈希密码
        String hashedPassword = hashPassword(password);
        System.out.println("Hashed Password: " + hashedPassword);

        // 验证密码
        boolean isValid = verifyPassword(password, hashedPassword);
        System.out.println("Password Valid: " + isValid); // true

        isValid = verifyPassword("WrongPassword", hashedPassword);
        System.out.println("Wrong Password Valid: " + isValid); // false
    }
}

3. 关键参数说明

参数	推荐值	作用
ITERATIONS	10-20	增加计算时间，防御暴力破解
MEMORY	64MB-1GB (65536 KB)	增加内存消耗，防御GPU/ASIC攻击
PARALLELISM	1-2	并行线程数（通常1即可）
SALT_LENGTH	16字节	确保每个密码哈希唯一
HASH_LENGTH	32字节	输出哈希长度（与SHA-256一致）