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:]
    }
}