处理大整数：Java中256位BigInteger的文件读写实践

import java.math.BigInteger;
import java.util.Arrays;

public class BigIntegerUtils {

    /**
     * 将BigInteger转换为固定长度为32字节的字节数组。
     * 采用大端序，并进行适当的填充（零填充或符号扩展）。
     *
     * @param n 要转换的BigInteger。
     * @return 长度为32字节的字节数组。
     */
    public static byte[] toFixed32Bytes(BigInteger n) {
        byte[] b = n.toByteArray(); // 获取BigInteger的字节表示，大端序

        // 如果字节数组长度小于32，则进行填充
        if (b.length < 32) {
            byte[] b2 = new byte[32];
            // 计算需要填充的字节数
            int paddingLength = 32 - b.length;

            // 复制原始字节到新数组的末尾
            System.arraycopy(b, 0, b2, paddingLength, b.length);

            // 如果原始BigInteger为负数，则进行符号扩展
            // BigInteger.toByteArray()对于负数会有一个额外的符号字节，但这里我们假设是正数或需要固定32字节表示
            // 更严谨的符号扩展判断应基于BigInteger的符号和其最高位字节
            // 简单起见，这里假设我们处理的是无符号的256位数据，或者BigInteger的toByteArrary已经处理了符号位。
            // 如果b[0]是负数（即最高位为1），则表示原始BigInteger是负数，需要用-1填充。
            // BigInteger的toByteArray()返回的数组，如果首字节为负，则表示负数。
            if (n.signum() == -1) { // 如果BigInteger是负数，进行符号扩展
                for (int j = 0; j < paddingLength; ++j) {
                    b2[j] = (byte) -1; // 用全1填充（二进制补码表示的负数）
                }
            } else { // 否则用0填充
                for (int j = 0; j < paddingLength; ++j) {
                    b2[j] = (byte) 0; // 用0填充
                }
            }
            b = b2;
        } else if (b.length > 32) {
            // 如果字节数组长度大于32，说明BigInteger超出了256位的范围，或者包含额外的符号字节。
            // 此时需要截断，通常是从数组末尾截取32字节，或者处理掉BigInteger.toByteArray()可能产生的多余符号字节。
            // 例如，对于一个正数，如果toByteArrary返回33字节且第一字节为0，则可以截取后32字节。
            // 这里我们假设输入BigInteger在256位范围内，如果超出则需要根据具体业务逻辑处理。
            // 示例：如果toByteArrary返回33字节，且b[0]为0，则截取b[1]到b[32]
            if (b.length == 33 && b[0] == 0) {
                b = Arrays.copyOfRange(b, 1, 33);
            } else {
                // 如果长度不符合预期，可能需要抛出异常或进行其他处理
                throw new IllegalArgumentException("BigInteger value exceeds 256 bits or has unexpected byte representation.");
            }
        }
        return b;
    }
}

import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.file.Files;
import java.nio.file.Path;
import java.math.BigInteger;

public class BigIntegerFileReader {

    public static void main(String[] args) throws IOException {
        Path filePath = Path.of("C:\Users\User\IdeaProjects\CryptoLab1\src\crypto\DigitalSignatureGOST.png");

        // 1. 读取整个文件内容到字节数组
        byte[] fileBytes = Files.readAllBytes(filePath);

        // 2. 确定文件中包含多少个32字节的BigInteger
        int bytesPerNumber = 32; // 256位 = 32字节
        if (fileBytes.length % bytesPerNumber != 0) {
            System.err.println("警告：文件长度不是32字节的整数倍，可能存在数据损坏或格式错误。");
            // 根据实际需求决定是截断、报错还是忽略
        }
        int numberCount = fileBytes.length / bytesPerNumber;
        BigInteger[] numbers = new BigInteger[numberCount];

        // 3. 使用ByteBuffer高效地提取每个BigInteger的字节数据
        ByteBuffer buf = ByteBuffer.wrap(fileBytes); // 将整个文件字节数组包装成ByteBuffer
        byte[] currentNumberBytes = new byte[bytesPerNumber]; // 用于存放每个BigInteger的32字节数据

        for (int i = 0; i < numberCount; ++i) {
            buf.get(currentNumberBytes); // 从ByteBuffer中读取32字节到currentNumberBytes数组
            numbers[i] = new BigInteger(currentNumberBytes); // 使用字节数组构造BigInteger
            System.out.println("读取到第 " + (i + 1) + " 个BigInteger: " + numbers[i]);
        }

        // 现在，所有256位的BigInteger都已成功读取并存储在numbers数组中。
        // 可以进一步处理这些BigInteger对象。
    }
}

import java.util.BitSet;
import java.util.Arrays;

public class BitSetExample {
    public static void main(String[] args) {
        // 创建一个256位的BitSet
        BitSet bitSet = new BitSet(256);

        // 设置一些位
        bitSet.set(0);   // 设置第0位为1
        bitSet.set(255); // 设置第255位为1
        bitSet.set(63);  // 设置第63位为1

        System.out.println("原始BitSet: " + bitSet);

        // 将BitSet转换为字节数组（小端序）
        byte[] shortenedBytes = bitSet.toByteArray();
        System.out.println("BitSet转换为字节数组: " + Arrays.toString(shortenedBytes));

        // 从字节数组恢复BitSet
        BitSet restoredBitSet = BitSet.valueOf(shortenedBytes);
        System.out.println("从字节数组恢复的BitSet: " + restoredBitSet);

        // BitSet也可以从long数组或ByteBuffer中创建
        long[] longArray = {12345L, 67890L};
        BitSet fromLongs = BitSet.valueOf(longArray);
        System.out.println("从long数组创建的BitSet: " + fromLongs);
    }
}