[系列] - go-gin-api 路由中间件 - 签名验证（七）

概述概览首先同步下项目概况：上篇文章分享了，路由中间件-Jaeger链路追踪（实战篇），文章反响真是出乎意料，「Go中国」公众号也转发了，有很多朋友加我好友交流，直呼我大神，其实我哪是什么大神，只不过在本地实践了而已，对于Go语言的使用，我还是个新人，在这里感谢大家的厚爱！这篇文章咱们分享：路由中 概览

首先同步下项目概况：

上篇文章分享了，路由中间件 - Jaeger 链路追踪（实战篇），文章反响真是出乎意料， 「Go中国」 公众号也转发了，有很多朋友加我好友交流，直呼我大神，其实我哪是什么大神，只不过在本地实践了而已，对于 Go 语言的使用，我还是个新人，在这里感谢大家的厚爱！

这篇文章咱们分享：路由中间件 - 签名验证。

为什么使用签名验证？

这个就不用多说了吧，主要是为了保证接口安全和识别调用方身份，基于这两点，咱们一起设计下签名。

调用方需要申请 App Key 和 App Secret。

App Key 用来识别调用方身份。

App Secret 用来加密生成签名使用。

当然生成的签名还需要满足以下几点：

可变性：每次的签名必须是不一样的。

时效性：每次请求的时效性，过期作废。

唯一性：每次的签名是唯一的。

完整性：能够对传入数据进行验证，防止篡改。

举个例子：

/API?param_1=xxx&param_2=xxx，其中 param_1 和 param_2 是两个参数。

如果增加了签名验证，需要再传递几个参数：

ak 表示App Key，用来识别调用方身份。

ts 表示时间戳，用来验证接口的时效性。

sn 表示签名加密串，用来验证数据的完整性，防止数据篡改。

sn 是通过 App Secret 和 传递的参数 进行加密的。

最终传递的参数如下：

/API?param_1=xxx&param_2=xxx&ak=xxx&ts=xxx&sn=xxx

在这说一个调试技巧，ts 和 sn 参数每次都手动生成太麻烦了，当传递 deBUG=1 的时候，会返回 ts 和 sn , 具体看下代码就清楚了。

这篇文章分享三种实现签名的方式，分别是：MD5 组合加密、AES 对称加密、RSA 非对称加密。

废话不多说，进入主题。

MD5 组合生成签名

首先，封装一个 Go 的 MD5 方法：

func MD5(str string) string {    s := md5.New()    s.Write([]byte(str))    return hex.EncodetoString(s.Sum(nil))}

进行加密：

appKey     = "demo"appSecret  = "xxx"encryptStr = "param_1=xxx&param_2=xxx&ak="+appKey+"&ts=xxx"// 自定义验证规则sn = MD5(appSecret + encryptStr + appSecret)

验证签名

通过传递参数，再次生成签名，如果将传递的签名与生成的签名进行对比。

相同，表示签名验证成功。

不同，表示签名验证失败。

中间件 - 代码实现

var AppSecret string// MD5 组合加密func SetUp() gin.HandlerFunc {    return func(c *gin.Context) {        utilgin := util.Gin{Ctx: c}        sign, err := verifySign(c)        if sign != nil {            utilgin.Response(-1, "DeBUG Sign", sign)            c.Abort()            return        }        if err != nil {            utilgin.Response(-1, err.Error(), sign)            c.Abort()            return        }        c.Next()    }}// 验证签名func verifySign(c *gin.Context) (map[string]string, error) {    _ = c.Request.ParseForm()    req   := c.Request.Form    deBUG := strings.Join(c.Request.Form["deBUG"], "")    ak    := strings.Join(c.Request.Form["ak"], "")    sn    := strings.Join(c.Request.Form["sn"], "")    ts    := strings.Join(c.Request.Form["ts"], "")    // 验证来源    value, ok := config.APIAuthConfig[ak]    if ok {        AppSecret = value["md5"]    } else {        return nil, errors.New("ak Error")    }    if deBUG == "1" {        currentUnix := util.GetCurrentUnix()        req.Set("ts", strconv.FormatInt(currentUnix, 10))        res := map[string]string{            "ts": strconv.FormatInt(currentUnix, 10),            "sn": createSign(req),        }        return res, nil    }    // 验证过期时间    timestamp := time.Now().Unix()    exp, _    := strconv.ParseInt(config.AppSignExpiry, 10, 64)    tsInt, _  := strconv.ParseInt(ts, 10, 64)    if tsInt > timestamp || timestamp - tsInt >= exp {        return nil, errors.New("ts Error")    }    // 验证签名    if sn == "" || sn != createSign(req) {        return nil, errors.New("sn Error")    }    return nil, nil}// 创建签名func createSign(params url.Values) string {    // 自定义 MD5 组合    return util.MD5(AppSecret + createEncryptStr(params) + AppSecret)}func createEncryptStr(params url.Values) string {    var key []string    var str = ""    for k := range params {        if k != "sn" && k != "deBUG" {            key = append(key, k)        }    }    sort.Strings(key)    for i := 0; i < len(key); i++ {        if i == 0 {            str = fmt.Sprintf("%v=%v", key[i], params.Get(key[i]))        } else {            str = str + fmt.Sprintf("&%v=%v", key[i], params.Get(key[i]))        }    }    return str}

AES 对称加密

在使用前，咱们先了解下什么是对称加密？

对称加密就是使用同一个密钥即可以加密也可以解密，这种方法称为对称加密。

常用算法：DES、AES。

其中 AES 是 DES 的升级版，密钥长度更长，选择更多，也更灵活，安全性更高，速度更快，咱们直接上手 AES 加密。

优点

算法公开、计算量小、加密速度快、加密效率高。

缺点

发送方和接收方必须商定好密钥，然后使双方都能保存好密钥，密钥管理成为双方的负担。

应用场景

相对大一点的数据量或关键数据的加密。

生成签名

首先，封装 Go 的 AesEncrypt 加密方法 和 AesDecrypt 解密方法。

// 加密 aes_128_cbcfunc AesEncrypt (encryptStr string, key []byte, iv string) (string, error) {    encryptBytes := []byte(encryptStr)    block, err   := aes.NewCipher(key)    if err != nil {        return "", err    }    blockSize := block.BlockSize()    encryptBytes = pkcs5padding(encryptBytes, blockSize)    blockMode := cipher.NewCBCEncrypter(block, []byte(iv))    encrypted := make([]byte, len(encryptBytes))    blockMode.CryptBlocks(encrypted, encryptBytes)    return base64.URLEnCoding.EncodetoString(encrypted), nil}// 解密func AesDecrypt (decryptStr string, key []byte, iv string) (string, error) {    decryptBytes, err := base64.URLEnCoding.DecodeString(decryptStr)    if err != nil {        return "", err    }    block, err := aes.NewCipher(key)    if err != nil {        return "", err    }    blockMode := cipher.NewCBCDecrypter(block, []byte(iv))    decrypted := make([]byte, len(decryptBytes))    blockMode.CryptBlocks(decrypted, decryptBytes)    decrypted = pkcs5Unpadding(decrypted)    return string(decrypted), nil}func pkcs5padding (cipherText []byte, blockSize int) []byte {    padding := blockSize - len(cipherText)%blockSize    padText := bytes.Repeat([]byte{byte(padding)}, padding)    return append(cipherText, padText...)}func pkcs5Unpadding (decrypted []byte) []byte {    length := len(decrypted)    unpadding := int(decrypted[length-1])    return decrypted[:(length - unpadding)]}

进行加密：

appKey     = "demo"appSecret  = "xxx"encryptStr = "param_1=xxx&param_2=xxx&ak="+appKey+"&ts=xxx"sn = AesEncrypt(encryptStr, appSecret)

验证签名

decryptStr = AesDecrypt(sn, app_secret)

将加密前的字符串与解密后的字符串做个对比。

相同，表示签名验证成功。

不同，表示签名验证失败。

中间件 - 代码实现

var AppSecret string// AES 对称加密func SetUp() gin.HandlerFunc {    return func(c *gin.Context) {        utilgin := util.Gin{Ctx: c}        sign, err := verifySign(c)        if sign != nil {            utilgin.Response(-1, "DeBUG Sign", sign)            c.Abort()            return        }        if err != nil {            utilgin.Response(-1, err.Error(), sign)            c.Abort()            return        }        c.Next()    }}// 验证签名func verifySign(c *gin.Context) (map[string]string, error) {    _ = c.Request.ParseForm()    req   := c.Request.Form    deBUG := strings.Join(c.Request.Form["deBUG"], "")    ak    := strings.Join(c.Request.Form["ak"], "")    sn    := strings.Join(c.Request.Form["sn"], "")    ts    := strings.Join(c.Request.Form["ts"], "")    // 验证来源    value, ok := config.APIAuthConfig[ak]    if ok {        AppSecret = value["aes"]    } else {        return nil, errors.New("ak Error")    }    if deBUG == "1" {        currentUnix := util.GetCurrentUnix()        req.Set("ts", strconv.FormatInt(currentUnix, 10))        sn, err := createSign(req)        if err != nil {            return nil, errors.New("sn Exception")        }        res := map[string]string{            "ts": strconv.FormatInt(currentUnix, 10),            "sn": sn,        }        return res, nil    }    // 验证过期时间    timestamp := time.Now().Unix()    exp, _    := strconv.ParseInt(config.AppSignExpiry, 10, 64)    tsInt, _  := strconv.ParseInt(ts, 10, 64)    if tsInt > timestamp || timestamp - tsInt >= exp {        return nil, errors.New("ts Error")    }    // 验证签名    if sn == "" {        return nil, errors.New("sn Error")    }    decryptStr, decryptErr := util.AesDecrypt(sn, []byte(AppSecret), AppSecret)    if decryptErr != nil {        return nil, errors.New(decryptErr.Error())    }    if decryptStr != createEncryptStr(req) {        return nil, errors.New("sn Error")    }    return nil, nil}// 创建签名func createSign(params url.Values) (string, error) {    return util.AesEncrypt(createEncryptStr(params), []byte(AppSecret), AppSecret)}func createEncryptStr(params url.Values) string {    var key []string    var str = ""    for k := range params {        if k != "sn" && k != "deBUG" {            key = append(key, k)        }    }    sort.Strings(key)    for i := 0; i < len(key); i++ {        if i == 0 {            str = fmt.Sprintf("%v=%v", key[i], params.Get(key[i]))        } else {            str = str + fmt.Sprintf("&%v=%v", key[i], params.Get(key[i]))        }    }    return str}

RSA 非对称加密

和上面一样，在使用前，咱们先了解下什么是非对称加密？

非对称加密就是需要两个密钥来进行加密和解密，这两个秘钥分别是公钥（public key）和私钥（private key），这种方法称为非对称加密。

常用算法：RSA。

优点

与对称加密相比，安全性更好，加解密需要不同的密钥，公钥和私钥都可进行相互的加解密。

缺点

加密和解密花费时间长、速度慢，只适合对少量数据进行加密。

应用场景

适合于对安全性要求很高的场景，适合加密少量数据，比如支付数据、登录数据等。

创建签名

首先，封装 Go 的 RsaPublicEncrypt 公钥加密方法 和 RsaPrivateDecrypt 解密方法。

// 公钥加密func RsaPublicEncrypt(encryptStr string, path string) (string, error) {    // 打开文件    file, err := os.Open(path)    if err != nil {        return "", err    }    defer file.Close()    // 读取文件内容    info, _ := file.Stat()    buf := make([]byte,info.Size())    file.Read(buf)    // pem 解码    block, _ := pem.Decode(buf)    // x509 解码    publicKeyInterface, err := x509.ParsePKIxpublicKey(block.Bytes)    if err != nil {        return "", err    }    // 类型断言    publicKey := publicKeyInterface.(*rsa.PublicKey)    //对明文进行加密    encryptedStr, err := rsa.EncryptPKCS1v15(rand.Reader, publicKey, []byte(encryptStr))    if err != nil {        return "", err    }    //返回密文    return base64.URLEnCoding.EncodetoString(encryptedStr), nil}// 私钥解密func RsaPrivateDecrypt(decryptStr string, path string) (string, error) {    // 打开文件    file, err := os.Open(path)    if err != nil {        return "", err    }    defer file.Close()    // 获取文件内容    info, _ := file.Stat()    buf := make([]byte,info.Size())    file.Read(buf)    // pem 解码    block, _ := pem.Decode(buf)    // X509 解码    privateKey, err := x509.ParsePKCS1PrivateKey(block.Bytes)    if err != nil {        return "", err    }    decryptBytes, err := base64.URLEnCoding.DecodeString(decryptStr)    //对密文进行解密    decrypted, _ := rsa.DecryptPKCS1v15(rand.Reader,privateKey,decryptBytes)    //返回明文    return string(decrypted), nil}

调用方 申请 公钥（public key），然后进行加密：

appKey     = "demo"appSecret  = "公钥"encryptStr = "param_1=xxx&param_2=xxx&ak="+appKey+"&ts=xxx"sn = RsaPublicEncrypt(encryptStr, appSecret)

验证签名

decryptStr = RsaPrivateDecrypt(sn, app_secret)

将加密前的字符串与解密后的字符串做个对比。

相同，表示签名验证成功。

不同，表示签名验证失败。

中间件 - 代码实现

var AppSecret string// RSA 非对称加密func SetUp() gin.HandlerFunc {    return func(c *gin.Context) {        utilgin := util.Gin{Ctx: c}        sign, err := verifySign(c)        if sign != nil {            utilgin.Response(-1, "DeBUG Sign", sign)            c.Abort()            return        }        if err != nil {            utilgin.Response(-1, err.Error(), sign)            c.Abort()            return        }        c.Next()    }}// 验证签名func verifySign(c *gin.Context) (map[string]string, error) {    _ = c.Request.ParseForm()    req   := c.Request.Form    deBUG := strings.Join(c.Request.Form["deBUG"], "")    ak    := strings.Join(c.Request.Form["ak"], "")    sn    := strings.Join(c.Request.Form["sn"], "")    ts    := strings.Join(c.Request.Form["ts"], "")    // 验证来源    value, ok := config.APIAuthConfig[ak]    if ok {        AppSecret = value["rsa"]    } else {        return nil, errors.New("ak Error")    }    if deBUG == "1" {        currentUnix := util.GetCurrentUnix()        req.Set("ts", strconv.FormatInt(currentUnix, 10))        sn, err := createSign(req)        if err != nil {            return nil, errors.New("sn Exception")        }        res := map[string]string{            "ts": strconv.FormatInt(currentUnix, 10),            "sn": sn,        }        return res, nil    }    // 验证过期时间    timestamp := time.Now().Unix()    exp, _    := strconv.ParseInt(config.AppSignExpiry, 10, 64)    tsInt, _  := strconv.ParseInt(ts, 10, 64)    if tsInt > timestamp || timestamp - tsInt >= exp {        return nil, errors.New("ts Error")    }    // 验证签名    if sn == "" {        return nil, errors.New("sn Error")    }    decryptStr, decryptErr := util.RsaPrivateDecrypt(sn, config.AppRsaPrivatefile)    if decryptErr != nil {        return nil, errors.New(decryptErr.Error())    }    if decryptStr != createEncryptStr(req) {        return nil, errors.New("sn Error")    }    return nil, nil}// 创建签名func createSign(params url.Values) (string, error) {    return util.RsaPublicEncrypt(createEncryptStr(params), AppSecret)}func createEncryptStr(params url.Values) string {    var key []string    var str = ""    for k := range params {        if k != "sn" && k != "deBUG" {            key = append(key, k)        }    }    sort.Strings(key)    for i := 0; i < len(key); i++ {        if i == 0 {            str = fmt.Sprintf("%v=%v", key[i], params.Get(key[i]))        } else {            str = str + fmt.Sprintf("&%v=%v", key[i], params.Get(key[i]))        }    }    return str}

如何调用？

与其他中间件调用方式一样，根据自己的需求自由选择。

比如，使用 MD5 组合：

.Use(sign_md5.SetUp())

使用 AES 对称加密：

.Use(sign_aes.SetUp())

使用 RSA 非对称加密：

.Use(sign_rsa.SetUp())

性能测试

既然 RSA 非对称加密，最安全，那么统一都使用它吧。

NO！NO！NO！绝对不行！

为什么我要激动，因为我以前遇到过这个坑呀，都是血泪的教训呀...

咱们挨个测试下性能：

MD5

func Md5Test(c *gin.Context) {    startTime  := time.Now()    appSecret  := "IgkibX71IEf382PT"    encryptStr := "param_1=xxx&param_2=xxx&ak=xxx&ts=1111111111"    count      := 1000000    for i := 0; i < count; i++ {        // 生成签名        util.MD5(appSecret + encryptStr + appSecret)        // 验证签名        util.MD5(appSecret + encryptStr + appSecret)    }    utilgin := util.Gin{Ctx: c}    utilgin.Response(1, fmt.Sprintf("%v次 - %v", count, time.Since(startTime)), nil)}

模拟 一百万 次请求，大概执行时长在 1.1s ~ 1.2s 左右。

AES

func AesTest(c *gin.Context) {    startTime  := time.Now()    appSecret  := "IgkibX71IEf382PT"    encryptStr := "param_1=xxx&param_2=xxx&ak=xxx&ts=1111111111"    count      := 1000000    for i := 0; i < count; i++ {        // 生成签名        sn, _ := util.AesEncrypt(encryptStr, []byte(appSecret), appSecret)        // 验证签名        util.AesDecrypt(sn, []byte(appSecret), appSecret)    }    utilgin := util.Gin{Ctx: c}    utilgin.Response(1, fmt.Sprintf("%v次 - %v", count, time.Since(startTime)), nil)}

模拟 一百万 次请求，大概执行时长在 1.8s ~ 1.9s 左右。

RSA

func RsaTest(c *gin.Context) {    startTime  := time.Now()    encryptStr := "param_1=xxx&param_2=xxx&ak=xxx&ts=1111111111"    count      := 500    for i := 0; i < count; i++ {        // 生成签名        sn, _ := util.RsaPublicEncrypt(encryptStr, "rsa/public.pem")        // 验证签名        util.RsaPrivateDecrypt(sn, "rsa/private.pem")    }    utilgin := util.Gin{Ctx: c}    utilgin.Response(1, fmt.Sprintf("%v次 - %v", count, time.Since(startTime)), nil)}

我不敢模拟 一百万 次请求，还不知道啥时候能搞定呢，咱们模拟 500 次试试。

模拟 500 次请求，大概执行时长在 1s 左右。

上面就是我本地的执行效果，大家可以质疑我的电脑性能差，封装的方法有问题...

你们也可以试试，看看性能差距是不是这么大。

PHP 与 Go 加密方法如何互通？

如果我是写 PHP 的，生成签名的方法用 PHP 能实现吗？

肯定能呀！

我用 PHP 也实现了上面的 3 种方法，可能会有一些小调整，总体问题不大，相关 Demo 已上传到 github：

https://github.com/xinliangnote/Encrypt

好了，就到这了。

总结

以上是内存溢出为你收集整理的[系列] - go-gin-api 路由中间件 - 签名验证（七）全部内容，希望文章能够帮你解决[系列] - go-gin-api 路由中间件 - 签名验证（七）所遇到的程序开发问题。

如果觉得内存溢出网站内容还不错，欢迎将内存溢出网站推荐给程序员好友。