Java 使用密码加密/解密字符串的完整安全实现指南

秋墨同学_7270

发布时间：2026-02-15 11:30:02

959人浏览过

来源于php中文网

原创

Java 使用密码加密/解密字符串的完整安全实现指南

本文详解如何在 java 中基于用户密码安全地加密和解密字符串，重点解决 ecb 模式缺陷、iv 缺失、字节与字符串编码混淆等常见错误，并提供可持久化存储的 base64 编码方案。

本文详解如何在 java 中基于用户密码安全地加密和解密字符串，重点解决 ecb 模式缺陷、iv 缺失、字节与字符串编码混淆等常见错误，并提供可持久化存储的 base64 编码方案。

在实际开发中，直接用密码加密敏感字符串（如 API 密钥、配置项）是常见需求，但若实现不当，极易引入严重安全隐患。原始代码存在多个关键问题：

❌ 使用 AES/ECB/PKCS5Padding：ECB 模式不使用初始化向量（IV），相同明文始终生成相同密文，完全不具备语义安全性，易受模式分析攻击；
❌ 加密后直接 new String(encryptedBytes)：二进制密文转为字符串会因字符编码（如 UTF-8）导致数据损坏，解密时字节长度不匹配，直接抛出 IllegalBlockSizeException；
❌ 盐值（salt）未保存且每次随机生成：generatePBEKeySpec 中调用 generateRandomString(16) 生成新 salt，但加密与解密使用的 salt 不一致，导致密钥派生结果不同；
❌ 未显式指定字符集：getBytes() 默认使用平台编码，跨环境运行结果不可靠。

✅ 正确方案必须满足以下安全原则：

使用 CBC 或 GCM 等带 IV 的强模式（本例采用 AES/CBC/PKCS5Padding）；
盐值（salt）与 IV 必须随密文一同持久化，并以确定性方式分离；
所有二进制数据（密文、salt、IV）统一通过 Base64 编码 转为安全字符串，避免编码污染；
显式指定 UTF-8 字符集，确保跨平台一致性；
采用更现代的密钥派生算法（如 PBKDF2WithHmacSHA256）提升抗暴力破解能力。

以下是经过生产验证的完整实现：

java-api-doc-generator

分析 Java Spring Boot 后端 Controller 代码，自动生成 Markdown 格式的接口文档。当用户说“生成 Java 接口文档”、“生成 API 文档”、“从 Spring 代码生成文档”时触发。

下载

package de.alexx1.birthdaynotf.helper;

import javax.crypto.Cipher;
import javax.crypto.SecretKey;
import javax.crypto.SecretKeyFactory;
import javax.crypto.spec.IvParameterSpec;
import javax.crypto.spec.PBEKeySpec;
import javax.crypto.spec.SecretKeySpec;
import java.security.Key;
import java.security.SecureRandom;
import java.security.spec.KeySpec;
import java.util.Arrays;
import java.util.Base64;

public class SecurityManager {
    private static final String ALGORITHM = "AES/CBC/PKCS5Padding"; // ✅ 改用 CBC 模式
    private static final String CHARSET = "UTF-8";
    private static final int KEY_SIZE = 128;
    private static final int ITERATIONS = 65536;
    private static final int SALT_LENGTH = 16;
    private static final SecureRandom secureRandom = new SecureRandom();
    private static final Base64.Encoder base64Encoder = Base64.getEncoder();
    private static final Base64.Decoder base64Decoder = Base64.getDecoder();

    public static String encrypt(String plainText, String password) throws Exception {
        byte[] salt = generateSalt(); // ? 生成唯一 salt
        SecretKey secretKey = generateSecretKey(password, salt);
        Key key = new SecretKeySpec(secretKey.getEncoded(), "AES");

        Cipher cipher = Cipher.getInstance(ALGORITHM);
        cipher.init(Cipher.ENCRYPT_MODE, key); // ✅ 自动产生 IV
        byte[] iv = cipher.getIV();
        byte[] encryptedBytes = cipher.doFinal(plainText.getBytes(CHARSET));

        // ? 将 salt + iv + ciphertext 合并为单字节数组
        byte[] encryptedData = new byte[salt.length + iv.length + encryptedBytes.length];
        System.arraycopy(salt, 0, encryptedData, 0, salt.length);
        System.arraycopy(iv, 0, encryptedData, salt.length, iv.length);
        System.arraycopy(encryptedBytes, 0, encryptedData, salt.length + iv.length, encryptedBytes.length);

        return base64Encoder.encodeToString(encryptedData); // ✅ 安全转为字符串
    }

    public static String decrypt(String encryptedBase64, String password) throws Exception {
        byte[] encryptedData = base64Decoder.decode(encryptedBase64); // ✅ 先 Base64 解码

        // ? 拆分 salt (16B), IV (16B), ciphertext (剩余)
        byte[] salt = Arrays.copyOfRange(encryptedData, 0, SALT_LENGTH);
        byte[] iv = Arrays.copyOfRange(encryptedData, SALT_LENGTH, SALT_LENGTH + 16);
        byte[] cipherText = Arrays.copyOfRange(encryptedData, SALT_LENGTH + 16, encryptedData.length);

        SecretKey secretKey = generateSecretKey(password, salt);
        Key key = new SecretKeySpec(secretKey.getEncoded(), "AES");

        Cipher cipher = Cipher.getInstance(ALGORITHM);
        cipher.init(Cipher.DECRYPT_MODE, key, new IvParameterSpec(iv)); // ✅ 显式传入 IV
        byte[] decryptedBytes = cipher.doFinal(cipherText);

        return new String(decryptedBytes, CHARSET); // ✅ 显式指定 UTF-8
    }

    private static SecretKey generateSecretKey(String password, byte[] salt) throws Exception {
        SecretKeyFactory factory = SecretKeyFactory.getInstance("PBKDF2WithHmacSHA256"); // ✅ 更强哈希
        KeySpec spec = new PBEKeySpec(password.toCharArray(), salt, ITERATIONS, KEY_SIZE);
        return factory.generateSecret(spec);
    }

    private static byte[] generateSalt() {
        byte[] salt = new byte[SALT_LENGTH];
        secureRandom.nextBytes(salt);
        return salt;
    }
}

✅ 使用示例（安全可靠）

public class Main {
    public static void main(String[] args) throws Exception {
        String original = "my-secret-token-2024";
        String password = "My$tr0ngP@ss!";

        String encrypted = SecurityManager.encrypt(original, password);
        System.out.println("Encrypted (Base64): " + encrypted);
        // 输出类似: "QnF...ZmE=" —— 可安全存入数据库或配置文件

        String decrypted = SecurityManager.decrypt(encrypted, password);
        System.out.println("Decrypted: " + decrypted); // → "my-secret-token-2024"
        assert original.equals(decrypted) : "解密失败！";
    }
}