Go语言中MD5基块密码的实现探讨与现代加密实践建议

package main

import (
    "crypto/aes"
    "crypto/cipher"
    "crypto/rand"
    "encoding/hex"
    "fmt"
    "io"
    "log"
)

// generateKey 生成一个随机的AES密钥
func generateKey(length int) ([]byte, error) {
    key := make([]byte, length)
    if _, err := io.ReadFull(rand.Reader, key); err != nil {
        return nil, fmt.Errorf("failed to generate key: %w", err)
    }
    return key, nil
}

// encryptAESGCM 使用AES-GCM加密数据
func encryptAESGCM(plaintext []byte, key []byte) ([]byte, error) {
    block, err := aes.NewCipher(key)
    if err != nil {
        return nil, fmt.Errorf("failed to create AES cipher: %w", err)
    }

    gcm, err := cipher.NewGCM(block)
    if err != nil {
        return nil, fmt.Errorf("failed to create GCM: %w", err)
    }

    // 生成一个随机的Nonce（必须是唯一的，但不需要保密）
    nonce := make([]byte, gcm.NonceSize())
    if _, err := io.ReadFull(rand.Reader, nonce); err != nil {
        return nil, fmt.Errorf("failed to generate nonce: %w", err)
    }

    // 加密数据，附带认证标签
    ciphertext := gcm.Seal(nonce, nonce, plaintext, nil)
    return ciphertext, nil
}

// decryptAESGCM 使用AES-GCM解密数据
func decryptAESGCM(ciphertext []byte, key []byte) ([]byte, error) {
    block, err := aes.NewCipher(key)
    if err != nil {
        return nil, fmt.Errorf("failed to create AES cipher: %w", err)
    }

    gcm, err := cipher.NewGCM(block)
    if err != nil {
        return nil, fmt.Errorf("failed to create GCM: %w", err)
    }

    // 从密文中提取Nonce
    nonceSize := gcm.NonceSize()
    if len(ciphertext) < nonceSize {
        return nil, fmt.Errorf("ciphertext too short")
    }
    nonce, encryptedMessage := ciphertext[:nonceSize], ciphertext[nonceSize:]

    // 解密数据并验证认证标签
    plaintext, err := gcm.Open(nil, nonce, encryptedMessage, nil)
    if err != nil {
        return nil, fmt.Errorf("failed to decrypt or authenticate: %w", err)
    }
    return plaintext, nil
}

func main() {
    // 生成一个256位的AES密钥 (32字节)
    key, err := generateKey(32)
    if err != nil {
        log.Fatalf("Error generating key: %v", err)
    }
    fmt.Printf("Generated Key (hex): %s\n", hex.EncodeToString(key))

    plaintext := []byte("这是一条需要加密的秘密消息。")
    fmt.Printf("Original Plaintext: %s\n", plaintext)

    // 加密
    encryptedData, err := encryptAESGCM(plaintext, key)
    if err != nil {
        log.Fatalf("Error encrypting: %v", err)
    }
    fmt.Printf("Encrypted Data (hex): %s\n", hex.EncodeToString(encryptedData))

    // 解密
    decryptedData, err := decryptAESGCM(encryptedData, key)
    if err != nil {
        log.Fatalf("Error decrypting: %v", err)
    }
    fmt.Printf("Decrypted Plaintext: %s\n", decryptedData)

    // 尝试用错误的密钥解密
    badKey, _ := generateKey(32) // 错误的密钥
    _, err = decryptAESGCM(encryptedData, badKey)
    if err != nil {
        fmt.Printf("Attempt to decrypt with wrong key (expected error): %v\n", err)
    }

    // 尝试篡改密文
    if len(encryptedData) > gcm.NonceSize()+1 {
        tamperedData := make([]byte, len(encryptedData))
        copy(tamperedData, encryptedData)
        tamperedData[gcm.NonceSize()] ^= 0x01 // 篡改密文的一个字节
        _, err = decryptAESGCM(tamperedData, key)
        if err != nil {
            fmt.Printf("Attempt to decrypt tampered data (expected error): %v\n", err)
        }
    }
}