go-gin-api 路由中间件 - 签名验证(七)
概览
首先同步下项目概况:
上篇文章分享了,路由中间件 - jaeger 链路追踪(实战篇),文章反响真是出乎意料, 「go中国」 公众号也转发了,有很多朋友加我好友交流,直呼我大神,其实我哪是什么大神,只不过在本地实践了而已,对于 go 语言的使用,我还是个新人,在这里感谢大家的厚爱!
这篇文章咱们分享:路由中间件 - 签名验证。
为什么使用签名验证?
这个就不用多说了吧,主要是为了保证接口安全和识别调用方身份,基于这两点,咱们一起设计下签名。
调用方需要申请 app key 和 app secret。
app key 用来识别调用方身份。
app secret 用来加密生成签名使用。
当然生成的签名还需要满足以下几点:
可变性:每次的签名必须是不一样的。
时效性:每次请求的时效性,过期作废。
唯一性:每次的签名是唯一的。
完整性:能够对传入数据进行验证,防止篡改。
举个例子:
/api?param_1=xxx¶m_2=xxx,其中 param_1 和 param_2 是两个参数。
如果增加了签名验证,需要再传递几个参数:
ak 表示app key,用来识别调用方身份。
ts 表示时间戳,用来验证接口的时效性。
sn 表示签名加密串,用来验证数据的完整性,防止数据篡改。
sn 是通过 app secret 和 传递的参数 进行加密的。
最终传递的参数如下:
/api?param_1=xxx¶m_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¶m_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¶m_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¶m_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¶m_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¶m_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¶m_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
好了,就到这了。
上一篇: Python知识点总结篇(一)
下一篇: Python爬虫爬取异步加载的数据
推荐阅读
-
[系列] go-gin-api 路由中间件 - 日志记录(三)
-
[系列] go-gin-api 路由中间件 - Jaeger 链路追踪(六)
-
[系列] go-gin-api 路由中间件 - 签名验证(七)
-
[系列] go-gin-api 路由中间件 - 日志记录(三)
-
go-gin-api 路由中间件 - 捕获异常
-
go-gin-api 路由中间件 - Jaeger 链路追踪
-
go-gin-api 路由中间件 - 日志记录
-
[系列] go-gin-api 路由中间件 - Jaeger 链路追踪(五)
-
[系列] go-gin-api 路由中间件 - 捕获异常(四)
-
ASP.NET Core 1.0 路由、静态文件、身份验证简介、自定义中间件