解决RSA加密中BigInteger字节数组可变长度导致的解密失败问题

import java.io.*;
import java.math.BigInteger;
import java.util.Random;

public class RSACryptographer {

    // 假设 ModPow 和 ReadFileToBinary 方法已定义
    // public static BigInteger ModPow(BigInteger base, BigInteger exponent, BigInteger modulus) { ... }
    // public static int[] ReadFileToBinary(String path) throws IOException { ... }

    public static void RSAEncryptDecrypt(String inputFilePath, String encryptedFilePath, String decryptedFilePath) throws Exception {
        Random random = new Random();

        // 1. 生成RSA密钥对
        BigInteger P = BigInteger.probablePrime(16, random); // 示例：16位素数
        BigInteger Q = BigInteger.probablePrime(16, random); // 示例：16位素数

        BigInteger N = P.multiply(Q); // 模数 N
        BigInteger f = (P.subtract(BigInteger.ONE)).multiply(Q.subtract(BigInteger.ONE)); // 欧拉函数 f(N)

        BigInteger d; // 私钥指数
        BigInteger c; // 公钥指数 (通常是e)

        // 寻找与f互质的d
        do {
            d = new BigInteger(16, random); // 示例：16位随机数
        } while (!(d.gcd(f).equals(BigInteger.ONE)) || d.compareTo(f) >= 0 || d.compareTo(BigInteger.ONE) <= 0);

        // 计算c (d的模逆元)
        c = d.modInverse(f);

        System.out.println("RSA Keys Generated:");
        System.out.println("P: " + P);
        System.out.println("Q: " + Q);
        System.out.println("N (Public Modulus): " + N);
        System.out.println("f (Phi(N)): " + f);
        System.out.println("d (Private Exponent): " + d);
        System.out.println("c (Public Exponent): " + c);
        System.out.println("------------------------------------");

        // 2. 读取原始文件数据
        int[] fileData = ReadFileToBinary(inputFilePath);

        // 3. 加密过程
        try (DataOutputStream encryptFileStream = new DataOutputStream(new FileOutputStream(encryptedFilePath))) {
            System.out.println("Starting encryption...");
            for (int messInt : fileData) {
                BigInteger message = BigInteger.valueOf(messInt); // 将单个字节转换为BigInteger

                // 确保消息小于N (对于单字节消息，通常总是小于N)
                if (message.compareTo(N) >= 0) {
                    throw new IllegalArgumentException("Message value " + message + " is too large for modulus N=" + N);
                }

                // 加密：encrypt = message^d mod N
                BigInteger encryptedBigInt = ModPow(message, d, N);

                // 将加密后的BigInteger转换为字节数组
                byte[] encryptedBytes = encryptedBigInt.toByteArray();

                // 写入字节数组的长度，然后写入字节数组本身
                encryptFileStream.writeInt(encryptedBytes.length); // 写入长度 (int占4字节)
                encryptFileStream.write(encryptedBytes);           // 写入加密数据
            }
            System.out.println("Encryption complete. Encrypted file saved to: " + encryptedFilePath);
        }

        // 4. 解密过程
        try (DataInputStream decryptFileStream = new DataInputStream(new FileInputStream(encryptedFilePath));
             FileOutputStream decryptedFileOutputStream = new FileOutputStream(decryptedFilePath)) {
            System.out.println("Starting decryption...");
            while (decryptFileStream.available() > 0) {
                // 读取加密块的长度
                int length = decryptFileStream.readInt();

                // 根据长度读取加密块的字节数组
                byte[] encryptedBytesToRead = new byte[length];
                decryptFileStream.readFully(encryptedBytesToRead); // 确保读取所有字节

                // 将字节数组转换回BigInteger密文
                BigInteger encryptedBigInt = new BigInteger(encryptedBytesToRead);

                // 解密：decrypted = encryptedBigInt^c mod N
                BigInteger decryptedBigInt = ModPow(encryptedBigInt, c, N);

                // 将解密后的BigInteger转换回原始字节
                // 由于原始消息是单个字节 (0-255)，这里取其低8位
                byte decryptedByte = (byte) (decryptedBigInt.intValue() & 0xFF);
                decryptedFileOutputStream.write(decryptedByte);
            }
            System.out.println("Decryption complete. Decrypted file saved to: " + decryptedFilePath);
        }
    }

    // 辅助方法：ModPow (模幂运算)
    // 假设这是您自己的实现，或者使用BigInteger自带的modPow
    public static BigInteger ModPow(BigInteger base, BigInteger exponent, BigInteger modulus) {
        return base.modPow(exponent, modulus);
    }

    // 辅助方法：ReadFileToBinary
    public static int[] ReadFileToBinary(String path) throws IOException {
        File file = new File(path);
        byte[] fileData = new byte[(int)file.length()];
        try (FileInputStream in = new FileInputStream(file)) {
            in.read(fileData);
        }
        int[] arrayBytes= new int[fileData.length];

        for(int i = 0; i < fileData.length; i++) {
            arrayBytes[i] = Byte.toUnsignedInt(fileData[i]);
        }
        return arrayBytes;
    }

    public static void main(String[] args) {
        try {
            // 替换为您的实际文件路径
            String input = "C:\Users\User\IdeaProjects\CryptoLab1\src\crypto\dino.png";
            String encrypted = "C:\Users\User\IdeaProjects\CryptoLab1\src\crypto\endino.png";
            String decrypted = "C:\Users\User\IdeaProjects\CryptoLab1\src\crypto\dedino.png";
            RSAEncryptDecrypt(input, encrypted, decrypted);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}