当前位置：移动技术网 > IT编程>脚本编程>Go语言 > [系列] go-gin-api 路由中间件 - 签名验证（七）

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

2019年10月27日 | 移动技术网IT编程 | 我要评论

md5 组合
aes 对称加密
rsa 非对称加密
php 与 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_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

好了，就到这了。

源码地址

go-gin-api 系列文章

您可能感兴趣的文章:

如对本文有疑问，点击进行留言回复！！

Go Web 编程中的模板库应用指南(超详细)

如果你有过web编程的经验，那么或多或少都听说过或者使用过模板。简而言之，模板是可用于创建动态内容的文本文件。例如，你有一个网站导航栏的模板，其中动态内容的一部... [阅读全文]
如何用golang运行第一个项目

安装一些必要的环境1.下载go sdk (本人装的是1.9) 2.下载golang3.下载git 因为有些依赖要用 go get 去github上获取 4.配... [阅读全文]
Go打包二进制文件的实现

背景众所周知，go语言可打包成目标平台二进制文件是其一大优势，如此go项目在服务器不需要配置go环境和依赖就可跑起来。操作需求：打包部署到centos7笔者打包... [阅读全文]
golang包快速生成base64验证码的方法

base64captcha快速生成base64编码图片验证码字符串支持多种样式,算术,数字,字母,混合模式,语音模式.base64是网络上最常见的用于传输8bi... [阅读全文]
使用Go语言创建WebSocket服务的实现示例

今天介绍如何用 go 语言创建 websocket 服务，文章的前两部分简要介绍了 websocket 协议以及用 go 标准库如何创建 websocket 服... [阅读全文]
Golang通过小程序获取微信openid的方法示例

为什么要获取小程序的 openid在开发微信小程序的过程中，小程序可以通过微信官方提供的登录能力方便地获取微信提供的用户身份标识，快速建立小程序内的用户体系。那... [阅读全文]
golang语言编码规范的实现

本规范旨在为日常go项目开发提供一个代码的规范指导，方便团队形成一个统一的代码风格，提高代码的可读性，规范性和统一性。本规范将从命名规范，注释规范，代码风格和 ... [阅读全文]
Windows下安装VScode 并使用及中文配置方法

首先明确一点，vscode是开发go应用的基础编辑器，是microsoft（微软的产品），可以运行在windows、linux、mac os x上使用，默认提供... [阅读全文]
GoLang之使用Context控制请求超时的实现

起因之前接触了一个需求：提供一个接口，这个接口有一个超时时间，如果超时了返回超时异常；这个接口中调用其他的接口，如果调用超时了，所有... [阅读全文]
Golang HTTP 服务平滑重启及升级的思路

golang http服务在上线时，需要重新编译可执行文件，关闭正在运行的进程，然后再启动新的运行进程。对于访问频率比较高的面向终端用户的产品，关闭、重启的过程... [阅读全文]