加密解密时遇到的问题

Cactus li2024年4月3日...大约 8 分钟

使用更大的 RSA 密钥涉及到以下几个关键步骤：

生成新的、更大尺寸的密钥对（公钥和私钥）
安全地存储和分发密钥
- 后端需要安全地存储新的私钥。
- 前端需要获取新的公钥。
更新前端代码以使用新的公钥进行加密。
更新后端代码以使用新的私钥进行解密，并确保相关的 maxDataSize 计算是基于新密钥尺寸的。

下面详细说明每个步骤：

步骤 1：生成新的、更大尺寸的密钥对

你可以使用 Java 的 KeyPairGenerator 来生成新的密钥对。推荐使用 2048 位，这是当前广泛接受的安全标准。

import java.security.*;
import java.security.spec.PKCS8EncodedKeySpec;
import java.security.spec.X509EncodedKeySpec;
import java.util.Base64;

public class RsaKeyGenerator {

    public static void main(String[] args) throws NoSuchAlgorithmException {
        int keySize = 2048; // 或者 1024, 但推荐 2048 或更高

        KeyPairGenerator keyPairGen = KeyPairGenerator.getInstance("RSA");
        keyPairGen.initialize(keySize);
        KeyPair keyPair = keyPairGen.generateKeyPair();

        PublicKey publicKey = keyPair.getPublic();
        PrivateKey privateKey = keyPair.getPrivate();

        // --- 获取密钥的编码格式，通常用于存储或传输 ---

        // 公钥 (通常使用 X.509 格式)
        byte[] publicKeyBytes = publicKey.getEncoded();
        String publicKeyBase64 = Base64.getEncoder().encodeToString(publicKeyBytes);
        System.out.println("----- Public Key (Base64 Encoded X.509) -----");
        System.out.println(publicKeyBase64);
        System.out.println("---------------------------------------------\n");


        // 私钥 (通常使用 PKCS#8 格式)
        byte[] privateKeyBytes = privateKey.getEncoded();
        String privateKeyBase64 = Base64.getEncoder().encodeToString(privateKeyBytes);
        System.out.println("----- Private Key (Base64 Encoded PKCS#8) -----");
        System.out.println(privateKeyBase64);
        System.out.println("----------------------------------------------");

        // 你需要将生成的 publicKeyBase64 提供给前端
        // 将生成的 privateKeyBase64 安全地存储在后端
    }

    // --- 辅助方法：从 Base64 字符串加载回密钥对象 (示例) ---

    public static PublicKey loadPublicKey(String base64PublicKey) throws Exception {
        byte[] keyBytes = Base64.getDecoder().decode(base64PublicKey);
        X509EncodedKeySpec spec = new X509EncodedKeySpec(keyBytes);
        KeyFactory keyFactory = KeyFactory.getInstance("RSA");
        return keyFactory.generatePublic(spec);
    }

    public static PrivateKey loadPrivateKey(String base64PrivateKey) throws Exception {
        byte[] keyBytes = Base64.getDecoder().decode(base64PrivateKey);
        PKCS8EncodedKeySpec spec = new PKCS8EncodedKeySpec(keyBytes);
        KeyFactory keyFactory = KeyFactory.getInstance("RSA");
        return keyFactory.generatePrivate(spec);
    }
}

运行这段代码会生成一对新的 2048 位 RSA 密钥，并以 Base64 编码的字符串形式打印出来。

步骤 2：安全地存储和分发密钥

后端私钥：
- 绝对不要硬编码在代码里或提交到版本控制系统（如 Git）。
- 安全存储方式：
  - Java KeyStore (JKS 或 PKCS12): 将私钥存储在受密码保护的密钥库文件中。
  - 配置文件： 存储在受严格权限控制的配置文件中（确保文件只有运行后端服务的用户可读）。
  - 环境变量： 通过环境变量传递（注意安全性，某些系统下环境变量可能被其他进程看到）。
  - Secrets Management 系统： 使用专门的密钥管理服务（如 HashiCorp Vault, AWS Secrets Manager, Azure Key Vault）。这是生产环境的最佳实践。
- 将上面生成的 privateKeyBase64 字符串保存到你选择的安全位置。
前端公钥：
- 公钥是公开的，安全性要求较低，但需要保证其完整性（即前端拿到的是正确的、未被篡改的公钥）。
- 分发方式：
  - 硬编码： 可以直接将 publicKeyBase64 字符串嵌入到前端代码（JavaScript、移动应用代码等）中。这是最简单的方式，但更新密钥需要重新部署前端。
  - 配置文件： 前端从配置文件加载。
  - API 获取： 前端启动时通过一个安全的 API 端点从后端获取公钥。这使得密钥更新更灵活。
- 将 publicKeyBase64 字符串提供给前端开发人员或按上述方式部署。

步骤 3：更新前端代码

前端的加密逻辑需要修改，以加载并使用新的公钥。具体实现取决于前端使用的语言和加密库。

概念性 JavaScript 示例 (假设使用 JSEncrypt 库):

// 1. 替换旧的公钥字符串
// const publicKey = '-----BEGIN PUBLIC KEY-----\n OLD_KEY_CONTENT \n-----END PUBLIC KEY-----';
const publicKeyBase64 = 'YOUR_NEW_PUBLIC_KEY_BASE64_STRING_FROM_STEP_1'; // <--- 使用新的 Base64 公钥串

// 如果库直接接受 Base64 或者需要特定格式，按库要求处理
// JSEncrypt 通常需要 PEM 格式，但也可以处理原始 Base64，或需要手动转换
// 假设 JSEncrypt 可以处理这种 Base64 (可能需要库特定函数加载)
// 或者转换成 PEM 格式:
const pemHeader = "-----BEGIN PUBLIC KEY-----\n";
const pemFooter = "\n-----END PUBLIC KEY-----";
const publicKeyPem = pemHeader + publicKeyBase64.match(/.{1,64}/g).join('\n') + pemFooter;


// 2. 初始化加密器，使用新公钥
// var encrypt = new JSEncrypt(); // 旧的初始化方式可能不同
// encrypt.setPublicKey(publicKey); // 旧的设置方式

var encrypt = new JSEncrypt();
encrypt.setPublicKey(publicKeyPem); // <-- 使用加载了新公钥的实例

// 3. 加密数据 (确保你的字符串先正确编码为 UTF-8, 如果库不自动处理)
var dataToEncrypt = "李李李李李李李李李李李李李李李李李李李"; // 18 个 "李"
var encryptedData = encrypt.encrypt(dataToEncrypt); // 加密过程通常不变

if (encryptedData === false) {
    console.error("Encryption failed. Check key or data.");
} else {
    // 发送 encryptedData 到后端
    console.log("Encrypted:", encryptedData);
}

关键点： 确保前端库能正确加载和使用提供的 Base64 或 PEM 格式的新公钥。

步骤 4：更新后端代码

后端的解密逻辑需要修改：

加载新的私钥： 从你选择的安全存储位置（KeyStore、文件、环境变量、Secrets Manager）读取 privateKeyBase64 字符串，并使用类似上面 loadPrivateKey 的方法将其转换成 PrivateKey 对象。
使用新私钥进行解密： 将加载的新的 PrivateKey 对象传递给 Cipher.init() 方法。
（可选但重要）更新 maxDataSize 计算（如果你的代码中有显式计算）： 如果你的代码（例如 unpadV15 函数外部）有计算 maxDataSize 的逻辑，必须确保它现在基于新的密钥尺寸。
- 对于 2048 位密钥，模长是 256 字节。
- maxDataSize = 256 - 11 = 245 字节 (对于 PKCS#1 v1.5 填充)。
- 通常，标准的 Cipher.doFinal() 在解密时会隐式处理填充和长度检查，你可能不需要手动计算 maxDataSize，除非你的 unpadV15 是自定义实现的一部分，并且 maxDataSize 是从外部传入的。如果 maxDataSize 是在 unpadV15 所在类的构造函数或初始化块中根据 PrivateKey 计算的，那么只要加载了新的 PrivateKey，它就应该自动更新。

后端解密代码概念性示例：

import javax.crypto.Cipher;
import java.security.KeyFactory;
import java.security.PrivateKey;
import java.security.spec.PKCS8EncodedKeySpec;
import java.util.Base64;
// ... 其他 import ...

public class BackendDecryption {

    private PrivateKey privateKey;
    // private int maxDataSize; // 可能不需要显式存储，Cipher 会处理

    public BackendDecryption(String base64PrivateKey) throws Exception {
        // 从安全存储加载私钥字符串
        this.privateKey = loadPrivateKey(base64PrivateKey); // 使用步骤 1 中的辅助方法

        // 如果需要显式计算 maxDataSize (通常不需要，除非自定义 unpad)
        // int keySizeInBytes = ((java.security.interfaces.RSAKey) privateKey).getModulus().bitLength() / 8;
        // this.maxDataSize = keySizeInBytes - 11; // 11 for PKCS1Padding
    }

    // 从 Base64 加载私钥
    private static PrivateKey loadPrivateKey(String base64PrivateKey) throws Exception {
        byte[] keyBytes = Base64.getDecoder().decode(base64PrivateKey);
        PKCS8EncodedKeySpec spec = new PKCS8EncodedKeySpec(keyBytes);
        KeyFactory keyFactory = KeyFactory.getInstance("RSA");
        return keyFactory.generatePrivate(spec);
    }


    public byte[] decrypt(String encryptedBase64Data) throws Exception {
        byte[] encryptedBytes = Base64.getDecoder().decode(encryptedBase64Data);

        // 使用标准的 JCE Cipher 进行解密，它会处理 PKCS#1 v1.5 填充移除
        // 注意：如果你使用了上面那个自定义的 unpadV15 方法，这里的调用方式会不同
        //      这里假设使用标准库进行解密和去填充
        Cipher cipher = Cipher.getInstance("RSA/ECB/PKCS1Padding"); // 或其他你使用的模式/填充
        cipher.init(Cipher.DECRYPT_MODE, this.privateKey); // <-- 使用新的私钥

        // doFinal 会解密并移除填充，如果填充无效或长度不对（基于密钥大小），会抛异常
        byte[] decryptedBytes = cipher.doFinal(encryptedBytes);

        return decryptedBytes;

        /*
        // 如果你坚持使用那个自定义的 unpadV15 方法：
        Cipher rawCipher = Cipher.getInstance("RSA/ECB/NoPadding"); // 使用 NoPadding
        rawCipher.init(Cipher.DECRYPT_MODE, this.privateKey);
        byte[] paddedBytes = rawCipher.doFinal(encryptedBytes);

        // 假设 unpadV15 是这个类的方法，并且 maxDataSize 已正确设置
        // (或者 unpadV15 内部能自己计算 maxDataSize)
        int keySizeInBytes = ((java.security.interfaces.RSAKey) privateKey).getModulus().bitLength() / 8;
        int currentMaxDataSize = keySizeInBytes - 11;
        // 你需要将 currentMaxDataSize 传递给 unpadV15 或让 unpadV15 可以访问它
        byte[] decryptedBytes = unpadV15(paddedBytes, currentMaxDataSize); // 假设 unpadV15 修改为接受 maxDataSize

        return decryptedBytes;
        */
    }

    // --- 假设你的 unpadV15 方法在这里，并做了相应修改 ---
    // private byte[] unpadV15(byte[] padded, int maxDataSize) throws BadPaddingException {
    //    // ... 你的 unpadV15 代码 ...
    //    // 确保这里的 maxDataSize 是基于新密钥计算的
    //    if (n > maxDataSize) { bp = true; }
    //    // ...
    // }


    public static void main(String[] args) {
        try {
            // 1. 从安全存储获取新的私钥 Base64 字符串
            String newPrivateKeyBase64 = "YOUR_NEW_PRIVATE_KEY_BASE64_STRING_FROM_STEP_1";

            // 2. 创建解密器实例
            BackendDecryption decryptor = new BackendDecryption(newPrivateKeyBase64);

            // 3. 模拟接收前端加密的数据 (这里应该是前端用新公钥加密后的 Base64 数据)
            String encryptedDataFromFrontend = "BASE64_ENCRYPTED_DATA_USING_NEW_PUBLIC_KEY"; // 替换为实际数据

            // 4. 解密
            byte[] decryptedDataBytes = decryptor.decrypt(encryptedDataFromFrontend);

            // 5. 将解密后的字节转换回字符串 (使用与加密前相同的编码)
            String originalString = new String(decryptedDataBytes, "UTF-8");

            System.out.println("Decrypted String: " + originalString);

            // 现在应该能成功解密 18 个 "李" 了
            assert originalString.equals("李李李李李李李李李李李李李李李李李李李");

        } catch (Exception e) {
            System.err.println("Decryption failed: " + e.getMessage());
            e.printStackTrace();
            // 如果还是报 BadPaddingException，检查：
            // 1. 前后端使用的密钥是否确实是配对的？
            // 2. 前端加密的数据是否正确传输到后端（没有损坏或截断）？
            // 3. 加密和解密使用的 Cipher 实例配置 ("RSA/ECB/PKCS1Padding") 是否一致？
            // 4. 如果使用自定义 unpadV15，maxDataSize 是否正确更新？
        }
    }
}

更换为更大的 RSA 密钥是解决数据长度限制问题的正确方法。核心在于生成新密钥对、安全部署（公钥给前端，私钥安全存后端），并更新两端的代码以使用新密钥。对于后端，特别要注意加载正确的私钥，并确保任何与最大数据长度相关的计算都基于新密钥的尺寸。推荐使用 Java 标准库的 Cipher（如 RSA/ECB/PKCS1Padding）进行解密，它能自动处理填充移除和长度校验，通常比自定义实现更健壮、更安全。

加密解密时遇到的问题

步骤 1：生成新的、更大尺寸的密钥对

步骤 2：安全地存储和分发密钥

步骤 3：更新前端代码

步骤 4：更新后端代码

（可选但重要）更新 maxDataSize 计算（如果你的代码中有显式计算）： 如果你的代码（例如 unpadV15 函数外部）有计算 maxDataSize 的逻辑，必须确保它现在基于新的密钥尺寸。

（可选但重要）更新 maxDataSize 计算（如果你的代码中有显式计算）：如果你的代码（例如 unpadV15 函数外部）有计算 maxDataSize 的逻辑，必须确保它现在基于新的密钥尺寸。