用vue和go实现登录加密

前端使用CryptoJS默认加密方法：

var pass = CryptoJS.AES.encrypt(formData.password, key.value).toString()

使用 CryptoJS.AES.encrypt() 时不指定加密模式和参数时，CryptoJS 默认会执行以下操作

var encrypted = CryptoJS.AES.encrypt(
  "明文", 
  "密钥", 
  {
    format: CryptoJS.format.OpenSSL // 关键！默认使用 OpenSSL 兼容格式
  }
).toString()

默认生成的加密数据包含：

‌头部标识‌：Salted__（8字节）

‌随机盐值‌：（8字节）

‌实际加密数据‌：密文数据（长度根据明文变化）

封装解密函数，go语言环境当中自带以下依赖，可以直接使用

package handlers

import (
	"crypto/aes"
	"crypto/cipher"
	"crypto/md5"
	"encoding/base64"
	"errors"
)

// AesDecryptCBCOpenSSL 解密经过CryptoJS（AES-CBC模式）加密的字符串
// 参数：
//   - cipherText: Base64编码的加密字符串（包含OpenSSL格式的salt头）
//   - key: 用户提供的原始密钥
// 返回值：
//   - 解密后的原始字符串
//   - 错误信息（解密失败时）
func AesDecryptCBCOpenSSL(cipherText, key string) (string, error) {
	// 步骤1：Base64解码
	cipherBytes, err := base64.StdEncoding.DecodeString(cipherText)
	if err != nil {
		return "", err
	}

	// 步骤2：验证OpenSSL头部格式（CryptoJS默认生成的格式）
	// 前8字节应为 "Salted__" 后跟8字节的随机盐值
	if len(cipherBytes) < 16 || string(cipherBytes[:8]) != "Salted__" {
		return "", errors.New("invalid OpenSSL salted encryption format")
	}

	// 步骤3：提取盐值（第9-16字节）
	salt := cipherBytes[8:16]
	// 步骤4：通过EVP KDF生成实际的加密密钥和IV
	keyAndIV := evpKDF([]byte(key), salt, 32, 16) // 生成32字节密钥+16字节IV

	// 分割密钥和初始化向量
	keyBytes := keyAndIV[:32]
	ivBytes := keyAndIV[32:]

	// 步骤5：获取真正的加密数据（移除头部和盐值）
	data := cipherBytes[16:]
	
	// 步骤6：创建AES-CBC解密器
	block, err := aes.NewCipher(keyBytes)
	if err != nil {
		return "", err
	}

	// 步骤7：执行解密（会原地修改data的内容）
	mode := cipher.NewCBCDecrypter(block, ivBytes)
	mode.CryptBlocks(data, data)

	// 步骤8：移除PKCS#7填充
	data = pkcs7Unpad(data, block.BlockSize())

	return string(data), nil
}

// evpKDF 实现OpenSSL的EVP_BytesToKey密钥派生函数
// 参数：
//   - password: 用户提供的原始密钥
//   - salt: 随机盐值
//   - keyLen: 需要的密钥长度（单位字节）
//   - ivLen: 需要的IV长度（单位字节）
// 返回值：
//   - 派生后的密钥和IV的字节组合
func evpKDF(password, salt []byte, keyLen, ivLen int) []byte {
	digest := md5.New()
	var prev []byte
	var result []byte

	// 循环直到生成足够的密钥材料
	for len(result) < keyLen+ivLen {
		digest.Reset()
		digest.Write(prev)       // 写入前次结果
		digest.Write(password)   // 写入密码
		digest.Write(salt)       // 写入盐值
		prev = digest.Sum(nil)   // 计算MD5值
		result = append(result, prev...)  // 累积结果
	}

	// 返回组合后的密钥和IV
	return result[:keyLen+ivLen]
}

// pkcs7Unpad 移除PKCS#7填充
// 参数：
//   - data: 解密后的字节数组（含填充）
//   - blockSize: 块大小（AES为16字节）
// 返回值：
//   - 移除填充后的原始数据
func pkcs7Unpad(data []byte, blockSize int) []byte {
	if len(data) == 0 {
		return nil
	}

	// 获取最后一个字节的填充值
	padLen := int(data[len(data)-1])
	
	// 验证填充有效性
	if padLen > len(data) || padLen > blockSize {
		// 无效填充直接返回原数据（可能需要处理错误）
		return data
	}
	
	// 移除填充
	return data[:len(data)-padLen]
}

go语言实现加密和解密：

package main

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

// AES-GCM 加密
func AesEncryptGCM(plaintext []byte, key []byte) ([]byte, error) {
    block, err := aes.NewCipher(key)
    if err != nil {
        return nil, err
    }

    gcm, err := cipher.NewGCM(block)
    if err != nil {
        return nil, err
    }

    nonce := make([]byte, gcm.NonceSize())
    if _, err := io.ReadFull(rand.Reader, nonce); err != nil {
        return nil, err
    }

    return gcm.Seal(nonce, nonce, plaintext, nil), nil
}

// AES-GCM 解密
func AesDecryptGCM(ciphertext []byte, key []byte) ([]byte, error) {
    block, err := aes.NewCipher(key)
    if err != nil {
        return nil, err
    }

    gcm, err := cipher.NewGCM(block)
    if err != nil {
        return nil, err
    }

    nonceSize := gcm.NonceSize()
    if len(ciphertext) < nonceSize {
        return nil, errors.New("invalid ciphertext")
    }

    nonce, ciphertext := ciphertext[:nonceSize], ciphertext[nonceSize:]
    return gcm.Open(nil, nonce, ciphertext, nil)
}

func main() {
    key := []byte("0123456789abcdef0123456789abcdef") // 32 字节 = AES-256

    plaintext := []byte("SensitiveData需要加密的内容")

    // 加密
    ciphertext, _ := AesEncryptGCM(plaintext, key)
    fmt.Printf("加密后的 HEX: %x\n", ciphertext)
    //如果需要把加密后的字符串保存到数据库当中需要转为Base64 编码
	encoded := base64.StdEncoding.EncodeToString(ciphertext)
	user.Password = encoded  // 存储安全编码后的字符串
    // 解密
    decode, _ := base64.StdEncoding.DecodeString(user.Password)
    decrypted, _ := AesDecryptGCM(decode, key)
    
    fmt.Printf("解密结果: %s\n", decrypted)
}