Java AES/ECB 解密与 Bzip2 流迁移至 Golang 教程

final Key k = new SecretKeySpec(keyString.getBytes(), "AES");
Cipher c = Cipher.getInstance("AES"); // 默认通常是 AES/ECB/PKCS5Padding 或 AES/ECB/NoPadding
c.init(Cipher.DECRYPT_MODE, k);

final InputStream in = new BufferedInputStream(new FileInputStream(fileNameToDecrypt));
final CipherInputStream instream = new CipherInputStream(in, c);

// 消费 Bzip2 头部 "BZ"
if (instream.read() != 'B') { /* Error */ }
if (instream.read() != 'Z') { /* Error */ }

final CBZip2InputStream zip = new CBZip2InputStream(instream); // 从消费 "BZ" 后的流开始解压

c, _ := aes.NewCipher([]byte(keyString))
// 错误：Java AES/ECB 模式不使用 IV
iv := []byte{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
             0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}
d := cipher.NewCBCDecrypter(c, iv) // 错误：使用了 CBC 模式

fi, _ := os.Open(fileNameToDecrypt)
stat, _ := fi.Stat()
enc := make([]byte, stat.Size())
dec := make([]byte, stat.Size())
fi.Read(enc)
d.CryptBlocks(dec, enc) // 解密整个文件
instream := bytes.NewBuffer(dec)
zip := bzip2.NewReader(instream) // Golang bzip2 reader 期望 "BZ" 头部

package main

import (
    "bytes"
    "compress/bzip2"
    "crypto/aes"
    "io"
    "log"
    "os"
)

// decryptAESECB 从 src io.Reader 读取加密数据，使用 ECB 模式解密，并将解密后的数据写入 dec io.Writer。
// keyString 是 AES 密钥。
func decryptAESECB(src io.Reader, dec io.Writer, keyString string) error {
    // 1. 初始化 AES 密码器
    key := []byte(keyString)
    block, err := aes.NewCipher(key)
    if err != nil {
        return err
    }

    blockSize := block.BlockSize() // AES 块大小为 16 字节
    if blockSize != aes.BlockSize {
        return io.ErrShortBuffer // 确保块大小是标准的 AES 块大小
    }

    // 2. 准备输入输出缓冲区
    bufIn := make([]byte, blockSize)  // 用于读取加密数据块
    bufOut := make([]byte, blockSize) // 用于存储解密后的数据块

    // 3. 逐块进行 ECB 解密
    for {
        // 从源读取一个块
        n, err := io.ReadFull(src, bufIn) // 使用 io.ReadFull 确保读取到完整的块
        if err != nil {
            if err == io.EOF { // 读取到文件末尾
                break
            }
            if err == io.ErrUnexpectedEOF && n > 0 { // 文件末尾不足一个完整块，通常表示数据损坏或未正确填充
                // 根据实际情况处理，例如，如果确定没有填充，可以尝试解密剩余部分
                // 但对于标准 ECB，通常要求输入是块大小的整数倍
                log.Printf("Warning: Unexpected EOF, read %d bytes. Data might be truncated or improperly padded.", n)
                // 这里为了演示，我们假设输入是块对齐的，直接返回错误
                return err
            }
            return err
        }

        // 解密当前块
        block.Decrypt(bufOut, bufIn)

        // 将解密后的块写入目标
        _, err = dec.Write(bufOut)
        if err != nil {
            return err
        }
    }
    return nil
}

// decryptAndDecompress 函数执行完整的解密和解压缩流程
// src io.Reader 是加密且压缩的原始输入流
// dst io.Writer 是最终解密解压缩后的输出流
// keyString 是 AES 密钥
func decryptAndDecompress(src io.Reader, dst io.Writer, keyString string) error {
    // 1. 创建一个 bytes.Buffer 作为中间缓冲区，用于存储 ECB 解密后的数据
    // 这样 bzip2.NewReader 可以从这个缓冲区读取完整的解密流
    decryptedBuffer := new(bytes.Buffer)

    // 2. 执行 AES/ECB 解密
    err := decryptAESECB(src, decryptedBuffer, keyString)
    if err != nil {
        return err
    }

    // 3. 创建 bzip2.Reader。注意：此时 decryptedBuffer 包含完整的解密数据，包括 "BZ" 头部。
    bzip2Reader := bzip2.NewReader(decryptedBuffer)

    // 4. 将解压缩后的数据复制到最终目标
    _, err = io.Copy(dst, bzip2Reader)
    if err != nil {
        return err
    }

    return nil
}

package main

import (
    "bytes"
    "compress/bzip2"
    "crypto/aes"
    "io"
    "log"
    "os"
)

// 辅助函数：模拟加密和压缩过程（为测试目的，实际应用中可能从文件读取）
func createEncryptedBzip2Data(plainText, keyString string) ([]byte, error) {
    key := []byte(keyString)
    block, err := aes.NewCipher(key)
    if err != nil {
        return nil, err
    }
    blockSize := block.BlockSize()

    // 1. 压缩数据
    var bzip2Buf bytes.Buffer
    bzip2Writer, err := bzip2.NewWriter(&bzip2Buf, nil) // bzip2.NewWriter 默认会写入 "BZ" 头部
    if err != nil {
        return nil, err
    }
    _, err = bzip2Writer.Write([]byte(plainText))
    if err != nil {
        return nil, err
    }
    err = bzip2Writer.Close() // 必须关闭以刷新所有数据
    if err != nil {
        return nil, err
    }
    compressedData := bzip2Buf.Bytes()

    // 2. 填充数据使其成为块大小的倍数（如果需要）
    paddingLen := blockSize - (len(compressedData) % blockSize)
    if paddingLen == blockSize {
        paddingLen = 0 // 如果已经是倍数，不需要填充
    }
    paddedData := make([]byte, len(compressedData)+paddingLen)
    copy(paddedData, compressedData)
    // 对于 NoPadding，填充字节不重要；对于 PKCS5Padding，需要填充特定值
    // 这里我们假设 Java 端也是 NoPadding 或数据恰好是块对齐的
    // 或者如果 Java 使用 PKCS5Padding，Go 端解密后需要手动移除

    // 3. ECB 加密
    encryptedData := make([]byte, len(paddedData))
    for i := 0; i < len(paddedData); i += blockSize {
        block.Encrypt(encryptedData[i:i+blockSize], paddedData[i:i+blockSize])
    }

    return encryptedData, nil
}


// decryptAESECB 从 src io.Reader 读取加密数据，使用 ECB 模式解密，并将解密后的数据写入 dec io.Writer。
// keyString 是 AES 密钥。
func decryptAESECB(src io.Reader, dec io.Writer, keyString string) error {
    key := []byte(keyString)
    block, err := aes.NewCipher(key)
    if err != nil {
        return err
    }

    blockSize := block.BlockSize()
    if blockSize != aes.BlockSize {
        return io.ErrShortBuffer
    }

    bufIn := make([]byte, blockSize)
    bufOut := make([]byte, blockSize)

    for {
        n, err := io.ReadFull(src, bufIn)
        if err != nil {
            if err == io.EOF {
                break
            }
            if err == io.ErrUnexpectedEOF && n > 0 {
                // 实际生产环境应谨慎处理，可能需要根据具体填充方案进行截断或报错
                log.Printf("Warning: Unexpected EOF, read %d bytes. Data might be truncated or improperly padded.", n)
                return err
            }
            return err
        }

        block.Decrypt(bufOut, bufIn)
        _, err = dec.Write(bufOut)
        if err != nil {
            return err
        }
    }
    return nil
}

// decryptAndDecompress 函数执行完整的解密和解压缩流程
func decryptAndDecompress(src io.Reader, dst io.Writer, keyString string) error {
    decryptedBuffer := new(bytes.Buffer)
    err := decryptAESECB(src, decryptedBuffer, keyString)
    if err != nil {
        return err
    }

    bzip2Reader := bzip2.NewReader(decryptedBuffer)
    _, err = io.Copy(dst, bzip2Reader)
    if err != nil {
        return err
    }
    return nil
}

func main() {
    secretKey := "averysecretkey12" // 16 字节密钥
    originalText := "Hello, this is a test string to be encrypted and then compressed using bzip2."

    // 模拟创建加密的 Bzip2 数据
    encryptedData, err := createEncryptedBzip2Data(originalText, secretKey)
    if err != nil {
        log.Fatalf("Error creating encrypted data: %v", err)
    }

    // 将模拟的加密数据写入一个 bytes.Reader 作为输入源
    encryptedReader := bytes.NewReader(encryptedData)

    // 创建一个 bytes.Buffer 作为解密解压缩后的输出目标
    var finalOutput bytes.Buffer

    log.Println("Starting decryption and decompression...")
    err = decryptAndDecompress(encryptedReader, &finalOutput, secretKey)
    if err != nil {
        log.Fatalf("Decryption and decompression failed: %v", err)
    }

    log.Println("Decryption and decompression successful!")
    log.Printf("Original Text: %s", originalText)
    log.Printf("Decrypted Text: %s", finalOutput.String())

    if originalText == finalOutput.String() {
        log.Println("Verification successful: Decrypted text matches original.")
    } else {
        log.Println("Verification failed: Decrypted text does NOT match original.")
    }

    // 实际应用中，你可以这样从文件读取和写入：
    // inputFile, err := os.Open("encrypted_file.bin")
    // if err != nil { log.Fatal(err) }
    // defer inputFile.Close()

    // outputFile, err := os.Create("decrypted_output.txt")
    // if err != nil { log.Fatal(err) }
    // defer outputFile.Close()

    // err = decryptAndDecompress(inputFile, outputFile, secretKey)
    // if err != nil { log.Fatal(err) }
    // log.Println("File decrypted and decompressed successfully.")
}