Go语言CTR模式加解密指南

import (
    "crypto/rand"
    "crypto/cipher"
)

// generateIV 生成一个适合加密的初始化向量（IV）。
// IV的长度应与底层块密码的块大小相同。
func generateIV(blockSize int) ([]byte, error) {
    iv := make([]byte, blockSize)
    if _, err := rand.Read(iv); err != nil {
        return nil, err
    }
    return iv, nil
}

// encrypt 使用CTR模式对数据进行加密。
// 它将生成的IV前置到密文数据中。
func encrypt(block cipher.Block, plaintext []byte) ([]byte, error) {
    // 1. 生成初始化向量（IV）
    iv, err := generateIV(block.BlockSize())
    if err != nil {
        return nil, err
    }

    // 2. 创建CTR模式的流密码
    stream := cipher.NewCTR(block, iv)

    // 3. 执行XORKeyStream操作进行加密
    // 注意：XORKeyStream会直接修改dst切片的内容。
    // 为了将IV和密文合并，我们创建一个足够大的切片来存储它们。
    // 另一种更简洁的方式是直接在原始明文切片上进行XOR操作，
    // 然后将IV和被修改的明文（现在是密文）拼接起来。
    // 这里我们采用后一种方式，因为它更符合Go语言的习惯，
    // 并且避免了额外的内存分配和复制。
    ciphertext := make([]byte, len(plaintext))
    copy(ciphertext, plaintext) // 复制明文，避免修改原始切片
    stream.XORKeyStream(ciphertext, ciphertext)

    // 4. 返回IV和密文的组合
    return append(iv, ciphertext...), nil
}

// decrypt 使用CTR模式对数据进行解密。
// 它从输入数据中提取IV，然后解密剩余的密文。
func decrypt(block cipher.Block, ciphertextWithIV []byte) ([]byte, error) {
    blockSize := block.BlockSize()
    if len(ciphertextWithIV) < blockSize {
        return nil, fmt.Errorf("密文长度不足以包含IV")
    }

    // 1. 提取初始化向量（IV）
    iv := ciphertextWithIV[:blockSize]
    // 2. 提取真正的密文
    ciphertext := ciphertextWithIV[blockSize:]

    // 3. 创建CTR模式的流密码（使用相同的IV）
    stream := cipher.NewCTR(block, iv)

    // 4. 执行XORKeyStream操作进行解密
    // 同样，XORKeyStream会直接修改dst切片的内容。
    // 解密后的明文将直接写入到plain切片中。
    plaintext := make([]byte, len(ciphertext))
    stream.XORKeyStream(plaintext, ciphertext)

    return plaintext, nil
}

package main

import (
    "crypto/aes"
    "crypto/cipher"
    "crypto/rand"
    "fmt"
    "log"
)

// generateIV 生成一个适合加密的初始化向量（IV）。
func generateIV(blockSize int) ([]byte, error) {
    iv := make([]byte, blockSize)
    if _, err := rand.Read(iv); err != nil {
        return nil, err
    }
    return iv, nil
}

// encrypt 使用CTR模式对数据进行加密，并将IV前置到密文。
func encrypt(block cipher.Block, plaintext []byte) ([]byte, error) {
    iv, err := generateIV(block.BlockSize())
    if err != nil {
        return nil, err
    }

    stream := cipher.NewCTR(block, iv)
    ciphertext := make([]byte, len(plaintext))
    copy(ciphertext, plaintext) // 复制明文到新切片
    stream.XORKeyStream(ciphertext, ciphertext) // 在复制的切片上进行加密

    return append(iv, ciphertext...), nil
}

// decrypt 使用CTR模式对数据进行解密，从密文中提取IV。
func decrypt(block cipher.Block, ciphertextWithIV []byte) ([]byte, error) {
    blockSize := block.BlockSize()
    if len(ciphertextWithIV) < blockSize {
        return nil, fmt.Errorf("密文长度不足以包含IV")
    }

    iv := ciphertextWithIV[:blockSize]
    ciphertext := ciphertextWithIV[blockSize:]

    stream := cipher.NewCTR(block, iv)
    plaintext := make([]byte, len(ciphertext))
    stream.XORKeyStream(plaintext, ciphertext) // 在新切片上进行解密

    return plaintext, nil
}

func main() {
    // 1. 定义加密密钥（AES-128 需要16字节密钥）
    key := []byte("a very secret key!") // 16字节密钥

    // 2. 创建AES块密码
    block, err := aes.NewCipher(key)
    if err != nil {
        log.Fatalf("创建AES密码失败: %v", err)
    }

    // 3. 待加密的原始数据
    originalValue := "foobarbaz"
    fmt.Printf("原始数据: %s\n", originalValue)

    // 4. 执行加密
    encryptedData, err := encrypt(block, []byte(originalValue))
    if err != nil {
        log.Fatalf("加密失败: %v", err)
    }
    fmt.Printf("加密后数据长度: %d (IV + 密文)\n", len(encryptedData))
    // 打印部分加密数据（注意：直接打印二进制数据可能不可读）
    // fmt.Printf("加密后数据: %x\n", encryptedData)

    // 5. 执行解密
    decryptedData, err := decrypt(block, encryptedData)
    if err != nil {
        log.Fatalf("解密失败: %v", err)
    }

    // 6. 验证解密结果
    fmt.Printf("解密后数据: %s\n", string(decryptedData))

    if string(decryptedData) == originalValue {
        fmt.Println("加密和解密成功！")
    } else {
        fmt.Println("加密和解密失败！")
    }
}