如何创建SHA-512哈希？Java实现SHA-512/SHA-256密码存储求助

嘿，我来帮你搞定Java里的密码哈希问题！其实你完全不用找什么额外插件——Java自带的标准库就足够实现SHA-256/SHA-512，要是想更省心，也有成熟的第三方库可以用，我一步步给你说清楚。

先给你上直接能跑的代码，核心用java.security.MessageDigest类，这是JDK自带的，不需要任何额外依赖：

SHA-512实现代码 #

import java.nio.charset.StandardCharsets;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;

public class PasswordHasher {
    public static String generateSHA512Hash(String input) {
        try {
            // 获取SHA-512算法的实例
            MessageDigest digest = MessageDigest.getInstance("SHA-512");
            // 把字符串转成UTF-8字节数组（必须指定编码，避免不同环境下乱码）
            byte[] encodedHash = digest.digest(input.getBytes(StandardCharsets.UTF_8));
            // 将字节数组转成人类可读的十六进制字符串
            StringBuilder hexString = new StringBuilder();
            for (byte b : encodedHash) {
                String hex = Integer.toHexString(0xff & b);
                // 单个十六进制字符前面补0，保证格式统一
                if (hex.length() == 1) {
                    hexString.append('0');
                }
                hexString.append(hex);
            }
            return hexString.toString();
        } catch (NoSuchAlgorithmException e) {
            // SHA-512是JDK标准支持的算法，理论上不会抛这个异常，这里做个兜底
            throw new RuntimeException("SHA-512算法不可用", e);
        }
    }

    public static void main(String[] args) {
        String password = "mySecurePassword123";
        String hashedPassword = generateSHA512Hash(password);
        System.out.println("SHA-512哈希结果：" + hashedPassword);
    }
}

改成SHA-256的方法 #

只需要把代码里的"SHA-512"换成"SHA-256"就行，其他逻辑完全一样，是不是超简单？

这里必须给你提个醒：直接存SHA哈希是非常不安全的，因为黑客可以用彩虹表（预计算的哈希字典）轻松破解。正确的做法是加盐+迭代哈希，比如用PBKDF2、BCrypt这类专门为密码设计的算法。

给你一个用标准库实现的PBKDF2-SHA512加盐哈希的可运行代码，这才是生产环境该用的：

import java.nio.charset.StandardCharsets;
import java.security.NoSuchAlgorithmException;
import java.security.SecureRandom;
import java.security.spec.InvalidKeySpecException;
import javax.crypto.SecretKeyFactory;
import javax.crypto.spec.PBEKeySpec;
import java.util.Base64;

public class SecurePasswordHasher {
    // 迭代次数：建议至少65536次，越高破解难度越大（耗时也会增加，按需调整）
    private static final int ITERATIONS = 65536;
    // 密钥长度：对应SHA-512的512位
    private static final int KEY_LENGTH = 512;
    // 盐的长度：建议至少16字节，随机生成
    private static final int SALT_LENGTH = 16;

    // 生成加盐的安全哈希（存储时把盐和哈希存在一起）
    public static String generateSecureHash(String password) {
        try {
            // 生成随机盐
            SecureRandom random = new SecureRandom();
            byte[] salt = new byte[SALT_LENGTH];
            random.nextBytes(salt);

            // 配置PBKDF2参数
            PBEKeySpec spec = new PBEKeySpec(password.toCharArray(), salt, ITERATIONS, KEY_LENGTH);
            SecretKeyFactory factory = SecretKeyFactory.getInstance("PBKDF2WithHmacSHA512");
            byte[] hash = factory.generateSecret(spec).getEncoded();

            // 把盐和哈希用Base64编码后拼接（方便存储，格式：盐:哈希）
            return Base64.getEncoder().encodeToString(salt) + ":" + Base64.getEncoder().encodeToString(hash);
        } catch (NoSuchAlgorithmException | InvalidKeySpecException e) {
            throw new RuntimeException("生成安全哈希失败", e);
        }
    }

    // 验证输入密码是否匹配存储的哈希
    public static boolean verifyPassword(String password, String storedHash) {
        try {
            // 拆分存储的盐和哈希
            String[] parts = storedHash.split(":");
            if (parts.length != 2) {
                throw new IllegalArgumentException("存储的哈希格式无效");
            }
            byte[] salt = Base64.getDecoder().decode(parts[0]);
            byte[] storedHashBytes = Base64.getDecoder().decode(parts[1]);

            // 用同样的参数生成输入密码的哈希
            PBEKeySpec spec = new PBEKeySpec(password.toCharArray(), salt, ITERATIONS, KEY_LENGTH);
            SecretKeyFactory factory = SecretKeyFactory.getInstance("PBKDF2WithHmacSHA512");
            byte[] computedHash = factory.generateSecret(spec).getEncoded();

            // 用常量时间比较哈希数组，防止时序攻击
            return MessageDigest.isEqual(storedHashBytes, computedHash);
        } catch (NoSuchAlgorithmException | InvalidKeySpecException e) {
            throw new RuntimeException("验证密码失败", e);
        }
    }

    public static void main(String[] args) {
        String password = "mySecurePassword123";
        String storedHash = generateSecureHash(password);
        System.out.println("存储的加盐哈希：" + storedHash);

        // 验证正确密码
        System.out.println("正确密码验证结果：" + verifyPassword(password, storedHash));
        // 验证错误密码
        System.out.println("错误密码验证结果：" + verifyPassword("wrongPass", storedHash));
    }
}

如果不想自己写标准库的繁琐代码，或者想用上更安全的算法（比如BCrypt、Argon2），可以用成熟的第三方库：

BCrypt（推荐，简单安全） #

BCrypt自动处理加盐，用法超级简单，只需要加个Maven/Gradle依赖就行：

<!-- Maven依赖 -->
<dependency>
    <groupId>org.mindrot</groupId>
    <artifactId>jbcrypt</artifactId>
    <version>0.4</version>
</dependency>

代码示例：

import org.mindrot.jbcrypt.BCrypt;

public class BCryptExample {
    public static String hashPassword(String password) {
        // 生成随机盐，强度设为12（范围4-31，越高越安全）
        String salt = BCrypt.gensalt(12);
        return BCrypt.hashpw(password, salt);
    }

    public static boolean verifyPassword(String password, String storedHash) {
        return BCrypt.checkpw(password, storedHash);
    }

    public static void main(String[] args) {
        String password = "mySecurePassword123";
        String hash = hashPassword(password);
        System.out.println("BCrypt哈希：" + hash);
        System.out.println("验证结果：" + verifyPassword(password, hash));
    }
}

Argon2（目前最安全的算法之一） #

Argon2是密码哈希竞赛的获胜者，安全性更高，可以用argon2-jvm库，用法也很直观，你可以自己去了解下。

1. 先搞懂安全原则：绝对不存明文，不用纯SHA，必须加盐+迭代
2. 想零依赖就用Java标准库的PBKDF2WithHmacSHA512，上面的代码直接就能跑
3. 想省心就用第三方库比如BCrypt，代码简洁还更安全
4. 跑main方法测试，确认哈希生成和密码验证正常就行

内容的提问来源于stack exchange，提问作者Samboy T