对称加密

很常见的加密算法。

注意！！！

Gzip压缩是为了减少体积，并不是非必须得做法，但是通常都是先压缩再加密的。

为了更好的传输，一般得到的加密后的字节数组对象要转成base64编码。

加密过程

原始数据 
  → GZip 压缩 
  → RC4 加密 
  → 传输/存储为 src

解密过程

src（加密+压缩的数据）
  → RC4 解密（用固定密钥）  
  → GZip 解压  
  → 得到原始明文

示例代码

package main

import (
	"bytes"
	"compress/gzip"
	"crypto/rc4"
	"encoding/base64"
	"fmt"
	"io/ioutil"
	"log"
)

const token = "123456"

// EncodeRc4 使用 RC4 算法加密数据
func EncodeRc4(src, key []byte) []byte {
	c, err := rc4.NewCipher(key)
	if err != nil {
		log.Fatalf("Failed to create RC4 cipher: %v", err)
	}
	dst := make([]byte, len(src))
	c.XORKeyStream(dst, src)
	return dst
}

// GZipCompress 压缩数据
func GZipCompress(data []byte) ([]byte, error) {
	var buf bytes.Buffer
	writer := gzip.NewWriter(&buf)
	_, err := writer.Write(data)
	if err != nil {
		return nil, err
	}
	err = writer.Close()
	if err != nil {
		return nil, err
	}
	return buf.Bytes(), nil
}

// EncodeBody 将原始数据加密并压缩
func EncodeBody(src []byte) (string, error) {
	// 先进行GZip压缩
	compressedData, err := GZipCompress(src)
	if err != nil {
		return "", fmt.Errorf("gzip compress failed: %w", err)
	}

	// 使用RC4加密
	key := []byte(token)
	encodedData := EncodeRc4(compressedData, key)

	// 对加密后的数据进行Base64编码以便传输
	encodedStr := base64.StdEncoding.EncodeToString(encodedData)
	return encodedStr, nil
}

// DecodeRc4 使用 RC4 算法解密数据
func DecodeRc4(src, key []byte) []byte {
	c, _ := rc4.NewCipher(key)
	dst := make([]byte, len(src))
	c.XORKeyStream(dst, src)
	return dst
}

// GZipUncompress 解压缩数据
func GZipUncompress(in []byte) ([]byte, error) {
	reader, err := gzip.NewReader(bytes.NewReader(in))
	if err != nil {
		return nil, err
	}
	defer reader.Close()
	return ioutil.ReadAll(reader)
}

// DecodeBody 将加密并压缩的数据解密并解压
func DecodeBody(src string) ([]byte, error) {
	// Base64解码
	decodedBytes, err := base64.StdEncoding.DecodeString(src)
	if err != nil {
		return nil, fmt.Errorf("base64 decode failed: %w", err)
	}

	// 使用RC4解密
	key := []byte(token)
	decodeData := DecodeRc4(decodedBytes, key)

	// 解压缩
	uncompressedData, err := GZipUncompress(decodeData)
	if err != nil {
		return nil, fmt.Errorf("gzip uncompress failed: %w", err)
	}
	return uncompressedData, nil
}
func main() {
	originalData := []byte("Hello, this is a test message that will be encrypted and compressed.")

	// 加密
	encryptedStr, err := EncodeBody(originalData)
	if err != nil {
		log.Fatalf("Failed to encode body: %v", err)
	}
	fmt.Println("Encrypted and compressed data (Base64):", encryptedStr)

	// 解密
	decryptedData, err := DecodeBody(encryptedStr)
	if err != nil {
		log.Fatalf("Failed to decode body: %v", err)
	}
	fmt.Println("Decrypted and decompressed data:", string(decryptedData))

	// 验证原始数据和解密后的数据是否一致
	if string(originalData) == string(decryptedData) {
		fmt.Println("成功：加密解密过程正确无误！")
	} else {
		fmt.Println("失败：加密解密过程中出现了错误！")
	}
}