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

概览

首先同步下项目概况：

上篇文章分享了，路由中间件 - 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_cbc
    func 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

好了，就到这了。

原文地址：https://www.cnblogs.com/it-3327/p/11827862.html

时间： 2024-10-09 22:59:36

go-gin-api 路由中间件 - 签名验证（七）的相关文章

[系列] go-gin-api 路由中间件 - Jaeger 链路追踪（五）

概述首先同步下项目概况: 上篇文章分享了,路由中间件 - 捕获异常,这篇文章咱们分享:路由中间件 - Jaeger 链路追踪. 啥是链路追踪? 我理解链路追踪其实是为微服务架构提供服务的,当一个请求中,请求了多个服务单元,如果请求出现了错误或异常,很难去定位是哪个服务出了问题,这时就需要链路追踪. 咱们先看一张图: 这张图的调用链还比较清晰,咱们想象一下,随着服务的越来越多,服务与服务之间调用关系也越来越多,可能就会发展成下图的情况. 这调用关系真的是... 看到这,我的内心是崩溃的. 那么问

ASP.NET Web API路由系统：路由系统的几个核心类型

虽然ASP.NET Web API框架采用与ASP.NET MVC框架类似的管道式设计,但是ASP.NET Web API管道的核心部分(定义在程序集System.Web.Http.dll中)已经移除了对System.Web.dll程序集的依赖,实现在ASP.NET Web API框架中的URL路由系统亦是如此.也就是说,ASP.NET Web API核心框架的URL路由系统与ASP.NET本身的路由系统是相对独立的.但是当我们采用基于Web Host的方式(定义在程序集System.Web.H

[系列] go-gin-api 路由中间件 - 捕获异常（四）

目录概述什么是异常? 怎么捕获异常? 封装发邮件方法自定义邮件模板封装一个中间件备注源码地址 go-gin-api 系列文章概述首先同步下项目概况: 上篇文章分享了,路由中间件 - 日志记录,这篇文章咱们分享:路由中间件 - 捕获异常.当系统发生异常时,提示 "系统异常,请联系管理员!",同时并发送 panic 告警邮件. 什么是异常? 在 Go 中异常就是 panic,它是在程序运行的时候抛出的,当 panic 抛出之后,如果在程序里没有添加任何保护措施的话,控制台就

go-gin-api 路由中间件 - 日志记录

概述首先同步下项目概况: 上篇文章分享了,规划项目目录和参数验证,其中参数验证使用的是 validator.v8 版本,现已更新到 validator.v9 版本,最新代码查看 github 即可. 这篇文章咱们分享:路由中间件 - 日志记录. 日志是特别重要的一个东西,方便我们对问题进行排查,这篇文章我们实现将日志记录到文本文件中. 这是我规划的,需要记录的参数: - request 请求数据 - request_time - request_method - request_uri - r

go-gin-api 路由中间件 - 捕获异常

概述首先同步下项目概况: 上篇文章分享了,路由中间件 - 日志记录,这篇文章咱们分享:路由中间件 - 捕获异常. 当系统发生异常时,提示 “系统异常,请联系管理员!”,并发送 panic 告警邮件.什么是异常? 在 Go 中异常就是 panic,它是在程序运行的时候抛出的,当 panic 抛出之后,如果在程序里没有添加任何保护措施的话,控制台就会在打印出 panic 的详细情况,然后终止运行. 我们可以将 panic 分为两种: 一种是有意抛出的,比如, panic("自定义的 panic 信

ASP.NET Web API 路由（上）

1 什什么是ASP.NET Web API 路由 ASP.NET Web路由其实就是一个抽象的消息处理管道,ASP.NET Web API的路由机制不同于ASP.NET的路由机制,但是与ASP.NET的路由有着相似的一套设计. 2 ASP.NET Web API 请求和响应的相关对象 ASP.NET Web API的请求是通过HtppRequestMessage作为管道来处理请求的消息,通过HtppReponseMessage作为管道来处理响应的消息.也就是ASP.NET Web API处理用户

Asp.Net Web API 2第六课——Web API路由和动作选择

Asp.Net Web API 导航 Asp.Net Web API第一课——入门http://www.cnblogs.com/aehyok/p/3432158.html Asp.Net Web API第二课——CRUD操作http://www.cnblogs.com/aehyok/p/3434578.html Asp.Net Web API第三课——.NET客户端调用Web API http://www.cnblogs.com/aehyok/p/3439698.html Asp.Net Web

Web API路由与动作(三)

本章包括三个小节如果你输入了mvc的路由规则这个可以粗略过一遍即可内容说明有点繁琐原文地址:http://www.asp.net/web-api/overview/web-api-routing-and-actions/routing-in-aspnet-web-api 3.1ASP.NET Web API中的路由本节描述ASP.NET Web API如何将HTTP请求路由到控制器如果你熟悉ASP.NET MVC,Web API路由与MVC路由十分类似.主要差别是Web API使

ASP.NET Web API 路由对象介绍

ASP.NET Web API 路由对象介绍前言在ASP.NET.ASP.NET MVC和ASP.NET Web API这些框架中都会发现有路由的身影,它们的原理都差不多,只不过在不同的环境下作了一些微小的修改,这也是根据每个框架的特性来制定的,今天我们就来看一看路由的结构,虽然我在MVC系列里写过路由的篇幅不过在这里是Web API 路由对象介绍. ASP.NET Web API路由.管道 ASP.NET Web API 开篇介绍示例 ASP.NET Web API 路由对象介绍 ASP.