Go重构Java数据加密方法(AES/ECB/PKCS7,AES/CBC加密)

最近和合作厂商对接的时候,数据需要加密传输,响应数据需要再解密获取,由于我司使用的是Golang,而合作商使用的是Java,所以加密方法需要重构.

直接上代码(utils.go)

package libs
import (
 "bytes"
 "crypto/aes"
 "crypto/cipher"
 "crypto/hmac"
 "crypto/md5"
 "crypto/sha256"
 "encoding/hex"
 "errors"
 "fmt"
 "sort"
 "strings"
)
// 签名加密
func Sign(sysParam map[string]string, busParam string, method string, key string) (string, error) {
 if len(sysParam) == 0 || sysParam == nil {
 return "", errors.New("sysParam Valid")
 }
 if method == "HmacSHA256" {
 // 生成加密参数
 decodeHexKey, _ := DecodeHexUpper(key)
 busContent := EncodeAES256HexUpper(busParam, decodeHexKey)
 return signWithSHA256(sysParam, busContent, key), nil
 } else if method == "RSAWithMD5" {
 return signWithRSA(sysParam, busParam, key), nil
 } else {
 return "", errors.New("method Valid")
 }
}
// sha256方法加密
func signWithSHA256(sysParam map[string]string, busParam string, key string) string {
 if len(busParam) > 0 && busParam != "" && len(strings.TrimSpace(busParam)) > 0 {
 sysParam["content"] = busParam
 }
 var keys []string
 for k := range sysParam {
 keys = append(keys, k)
 }
 sort.Strings(keys)
 buf := make([]string, 200)
 buf = append(buf, key)
 for _, v := range keys {
 if !strings.EqualFold("sign", v) {
 sysVal := v + sysParam[v]
 buf = append(buf, sysVal)
 }
 }
 buf = append(buf, key)
 newString := ""
 for _, v := range buf {
 newString += fmt.Sprintf("%s", v)
 }
 newKey, _ := DecodeHexUpper(key)
 retStr := encodeHmacSHA256HexUpper(newString, newKey)
 return retStr
}
// 中介方法
func encodeHmacSHA256HexUpper(data string, key []byte) string {
 dataByte := []byte(data)
 encodeHmac := encodeHmacSHA256(dataByte, key)
 retStr := bytesToHexString(encodeHmac)
 return strings.ToUpper(retStr)
}
// rsa方式加密
func signWithRSA(sysParam map[string]string, busParam string, key string) string {
 // 暂时用不到,不做整理了
 fmt.Println(sysParam, busParam, key)
 return ""
}
// 16进制字符串转换成byte
func DecodeHexUpper(str string) ([]byte, error) {
 return hex.DecodeString(strings.ToLower(str))
}
// 中介方法
func EncodeAES256HexUpper(data string, key []byte) string {
 dataByte := []byte(data)
 newByte, _ := AesECBEncrypt(dataByte, key)
 retStr := encodeHexUpper([]byte(newByte))
 return retStr
}
// boss返回结果解密
func DecodeAES256HexUpper(data string, key []byte) string {
 newData := strings.ToLower(data)
 dataByte,_ := hex.DecodeString(newData)
 newByte, _ := AesECBDecrypt(dataByte, key)
 return string(newByte)
}
// 16进制转换字符串-结果大写
func encodeHexUpper(data []byte) string {
 str := bytesToHexString(data)
 return strings.ToUpper(str)
}
// byte转16进制字符串
func bytesToHexString(b []byte) string {
 return hex.EncodeToString(b)
}
// 16进制字符串转bytes
func hexStringToBytes(hexString string) []byte {
 newHexString := strings.ToUpper(hexString)
 length := len(hexString) / 2
 newByte := []byte(newHexString)
 retByte := make([]byte, length)
 for i := 0; i < length; i++ {
 pos := i * 2
 retByte[i] = byte(byteToByte(newByte[pos])<<4 | byteToByte(newByte[pos+1]))
 }
 return retByte
}
// byte转换
func byteToByte(b byte) int {
 byteList := []byte("0123456789ABCDEF")
 var ret int
 for k, v := range byteList {
 if string(v) == string(b) {
 ret = k
 }
 }
 return ret
}
// 获取md5加密字符串
func getMD5Str(str string) string {
 md5Data := md5.New()
 md5Data.Reset()
 md5Data.Write([]byte(str))
 retString := bytesToHexString(md5Data.Sum(nil))
 return retString
}
// Hmac-sha256加密
func encodeHmacSHA256(data, key []byte) []byte {
 h := hmac.New(sha256.New, key)
 h.Write(data)
 return h.Sum(nil)
}
// md5加密
func MD5Util(s string) string {
 hexDigits := []byte{'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f'}
 byteStr := []byte(s)
 MD5 := md5.New()
 MD5.Write(byteStr)
 MD5Data := MD5.Sum([]byte(nil))
 NewByte := make([]byte, len(MD5Data)*2)
 k := 0
 for i := 0; i < len(MD5Data); i++ {
 byte0 := MD5Data[i]
 NewByte[k] = hexDigits[byte0>>4&15]
 k++
 NewByte[k] = hexDigits[byte0&15]
 k++
 }
 return string(NewByte)
}
// AES/CBC解密数据--不加填充,数据加密
func AesCBCEncrypt(source string, key string) (string, error) {
 // 生成16进制加密key
 newKey := hexStringToBytes(getMD5Str(key))
 block, err := aes.NewCipher(newKey)
 if err != nil {
 return "", err
 }
 // 数据处理
 dataLen := len([]byte(source))
 m := dataLen % 16
 if m != 0 {
 for i := 0; i < 16-m; i++ {
 source = source + " "
 }
 }
 newByte := []byte(source)
 // 初始向量IV必须是唯一
 iv := hexStringToBytes(getMD5Str(key))
 // block大小和初始向量大小一定要一致
 mode := cipher.NewCBCEncrypter(block, iv)
 encryptData := make([]byte, len(newByte))
 mode.CryptBlocks(encryptData, newByte)
 return bytesToHexString(encryptData), nil
}
// AES/CBC解密数据--不加填充,数据解密
func AesCBCDecrypt(source, key string) (string, error) {
 // 生成16进制加密key
 newKey := hexStringToBytes(getMD5Str(key))
 block, err := aes.NewCipher(newKey)
 if err != nil {
 return "", err
 }
 // 16进制转换
 decodeBytes := hexStringToBytes(source)
 iv := hexStringToBytes(getMD5Str(key))
 mode := cipher.NewCBCDecrypter(block, iv)
 retData := make([]byte, len(decodeBytes))
 mode.CryptBlocks(retData, decodeBytes)
 return string(retData), nil
}
// PKCS7加填充/和PKCS5填充一样,只是填充字段多少的区别
func PKCS7Padding(cipherText []byte, blockSize int) []byte {
 padding := blockSize - len(cipherText)%blockSize
 padText := bytes.Repeat([]byte{byte(padding)}, padding)
 return append(cipherText, padText...)
}
// PKCS7解填充/和PKCS5填充一样,只是填充字段多少的区别
func PKCS7UnPadding(encrypt []byte) []byte {
 length := len(encrypt)
 unPadding := int(encrypt[length-1])
 return encrypt[:(length - unPadding)]
}
// AES/ECB/PKCS7模式加密--签名加密方式
func AesECBEncrypt(data, key []byte) ([]byte, error) {
 block, err := aes.NewCipher(key)
 if err != nil {
 return []byte{}, err
 }
 ecb := NewECBEncryptEr(block)
 // 加PKCS7填充
 content := PKCS7Padding(data, block.BlockSize())
 encryptData := make([]byte, len(content))
 // 生成加密数据
 ecb.CryptBlocks(encryptData, content)
 return encryptData, nil
}
// AES/ECB/PKCS7模式解密--签名解密方式
func AesECBDecrypt(data, key []byte) ([]byte, error) {
 block, err := aes.NewCipher(key)
 if err != nil {
 return []byte{}, err
 }
 ecb := NewECBDecryptEr(block)
 retData := make([]byte, len(data))
 ecb.CryptBlocks(retData, data)
 // 解PKCS7填充
 retData = PKCS7UnPadding(retData)
 return retData, nil
}

在用ECB加密的时候,golang认为ecb基础加密方法不安全,并在1.1之后的版本中移除了,所以后续使用需要重新做处理,网上有相关的基础加密方法(ecb.go),上代码

package libs
import "crypto/cipher"
// ecb加密方法
type ecb struct {
 b cipher.Block
 blockSize int
}
func newECB(b cipher.Block) *ecb {
 return &ecb{
 b: b,
 blockSize: b.BlockSize(),
 }
}
type ecbEncryptEr ecb
func NewECBEncryptEr(b cipher.Block) cipher.BlockMode {
 return (*ecbEncryptEr)(newECB(b))
}
func (x *ecbEncryptEr) BlockSize() int { return x.blockSize }
func (x *ecbEncryptEr) CryptBlocks(dst, src []byte) {
 if len(src)%x.blockSize != 0 {
 panic("crypto/cipher: input not full blocks")
 }
 if len(dst) < len(src) {
 panic("crypto/cipher: output smaller than input")
 }
 for len(src) > 0 {
 x.b.Encrypt(dst, src[:x.blockSize])
 src = src[x.blockSize:]
 dst = dst[x.blockSize:]
 }
}
// ecb解密方法
type ecbDecryptEr ecb
func NewECBDecryptEr(b cipher.Block) cipher.BlockMode {
 return (*ecbDecryptEr)(newECB(b))
}
func (x *ecbDecryptEr) BlockSize() int { return x.blockSize }
func (x *ecbDecryptEr) CryptBlocks(dst, src []byte) {
 if len(src)%x.blockSize != 0 {
 panic("crypto/cipher: input not full blocks")
 }
 if len(dst) < len(src) {
 panic("crypto/cipher: output smaller than input")
 }
 for len(src) > 0 {
 x.b.Decrypt(dst, src[:x.blockSize])
 src = src[x.blockSize:]
 dst = dst[x.blockSize:]
 }
}

有疑问加站长微信联系(非本文作者)

• 请尽量让自己的回复能够对别人有帮助
• 支持 Markdown 格式, **粗体**、~~删除线~~、`单行代码`
• 支持 @ 本站用户;支持表情(输入 : 提示),见 Emoji cheat sheet
• 图片支持拖拽、截图粘贴等方式上传