[系列] go-gin-api 路由中间件 - 签名验证（七）
<p></p><div class="toc"><div class="toc-container-header">目录</div><ul><li>概览</li><li>MD5 组合<ul><li><ul><li>生成签名</li><li>验证签名</li><li>中间件 - 代码实现</li></ul></li></ul></li><li>AES 对称加密<ul><li><ul><li>生成签名</li><li>验证签名</li><li>中间件 - 代码实现</li></ul></li></ul></li><li>RSA 非对称加密<ul><li><ul><li>创建签名</li><li>验证签名</li><li>中间件 - 代码实现</li></ul></li></ul></li><li>如何调用？</li><li>性能测试<ul><li><ul><li>MD5</li><li>AES</li><li>RSA</li></ul></li></ul></li><li>PHP 与 Go 加密方法如何互通？</li><li>源码地址</li><li>go-gin-api 系列文章</li></ul></div><p></p><h2 id="概览">概览</h2>
<p>首先同步下项目概况：</p>
<p><img src="https://img2018.cnblogs.com/blog/389840/201910/389840-20191026170308608-862238191.png"></p>
<p>上篇文章分享了，路由中间件 - Jaeger 链路追踪（实战篇），文章反响真是出乎意料， 「Go中国」 公众号也转发了，有很多朋友加我好友交流，直呼我大神，其实我哪是什么大神，只不过在本地实践了而已，对于 Go 语言的使用，我还是个新人，在这里感谢大家的厚爱！</p>
<p><img src="https://img2018.cnblogs.com/blog/389840/201910/389840-20191026170317030-1826623510.png"></p>
<p>这篇文章咱们分享：路由中间件 - 签名验证。</p>
<p>为什么使用签名验证？</p>
<p>这个就不用多说了吧，主要是为了保证接口安全和识别调用方身份，基于这两点，咱们一起设计下签名。</p>
<p>调用方需要申请 App Key 和 App Secret，App Key 用来识别调用方身份，App Secret 用来加密生成签名使用。</p>
<p>当然生成的签名还需要满足以下几点：</p>
<ul>
<li>可变性：每次的签名必须是不一样的。</li>
<li>时效性：每次请求的时效性，过期作废。</li>
<li>唯一性：每次的签名是唯一的。</li>
<li>完整性：能够对传入数据进行验证，防止篡改。</li>
</ul>
<p>举个例子：</p>
<p><code>/api?param_1=xxx&param_2=xxx</code>，其中 param_1 和 param_2 是两个参数。</p>
<p>如果增加了签名验证，需要再传递几个参数：</p>
<ul>
<li>ak 表示App Key，用来识别调用方身份。</li>
<li>ts 表示时间戳，用来验证接口的时效性。</li>
<li>sn 表示签名加密串，用来验证数据的完整性，防止数据篡改。</li>
</ul>
<p>sn 是通过 App Secret 和 传递的参数 进行加密的。</p>
<p>最终传递的参数如下：</p>
<p><code>/api?param_1=xxx&param_2=xxx&ak=xxx&ts=xxx&sn=xxx</code></p>
<p>在这要说一个调试技巧，ts 和 sn 参数每次都手动生成太麻烦了，当传递 <code>debug=1</code> 的时候，会返回 ts 和 sn , 具体看下代码就清楚了。</p>
<p>这篇文章分享三种实现签名的方式，分别是：MD5 组合加密、AES 对称加密、RSA 非对称加密。</p>
<p>废话不多说，进入主题。</p>
<h2 id="md5-组合">MD5 组合</h2>
<h4 id="生成签名">生成签名</h4>
<p>首先，封装一个 Go 的 MD5 方法：</p>
<pre><code>func MD5(str string) string {
s := md5.New()
s.Write([]byte(str))
return hex.EncodeToString(s.Sum(nil))
}
</code></pre>
<p>进行加密：</p>
<pre><code>appKey = "demo"
appSecret= "xxx"
encryptStr = "param_1=xxx&param_2=xxx&ak="+appKey+"&ts=xxx"
// 自定义验证规则
sn = MD5(appSecret + encryptStr + appSecret)
</code></pre>
<h4 id="验证签名">验证签名</h4>
<p>通过传递参数，再次生成签名，如果将传递的签名与生成的签名进行对比。</p>
<p>相同，表示签名验证成功。</p>
<p>不同，表示签名验证失败。</p>
<h4 id="中间件---代码实现">中间件 - 代码实现</h4>
<pre><code>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) (mapstring, 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
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 := mapstring{
"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, params.Get(key))
} else {
str = str + fmt.Sprintf("&%v=%v", key, params.Get(key))
}
}
return str
}
</code></pre>
<h2 id="aes-对称加密">AES 对称加密</h2>
<p>在使用前，咱们先了解下什么是对称加密？</p>
<p>对称加密就是使用同一个密钥即可以加密也可以解密，这种方法称为对称加密。</p>
<p>常用算法：DES、AES。</p>
<p>其中 AES 是 DES 的升级版，密钥长度更长，选择更多，也更灵活，安全性更高，速度更快，咱们直接上手 AES 加密。</p>
<p><strong>优点</strong></p>
<p>算法公开、计算量小、加密速度快、加密效率高。</p>
<p><strong>缺点</strong></p>
<p>发送方和接收方必须商定好密钥，然后使双方都能保存好密钥，密钥管理成为双方的负担。</p>
<p><strong>应用场景</strong></p>
<p>相对大一点的数据量或关键数据的加密。</p>
<h4 id="生成签名-1">生成签名</h4>
<p>首先，封装 Go 的 AesEncrypt 加密方法 和 AesDecrypt 解密方法。</p>
<pre><code>// 加密 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)
return decrypted[:(length - unPadding)]
}
</code></pre>
<p>进行加密：</p>
<pre><code>appKey = "demo"
appSecret= "xxx"
encryptStr = "param_1=xxx&param_2=xxx&ak="+appKey+"&ts=xxx"
sn = AesEncrypt(encryptStr, appSecret)
</code></pre>
<h4 id="验证签名-1">验证签名</h4>
<pre><code>decryptStr = AesDecrypt(sn, app_secret)
</code></pre>
<p>将加密前的字符串与解密后的字符串做个对比。</p>
<p>相同，表示签名验证成功。</p>
<p>不同，表示签名验证失败。</p>
<h4 id="中间件---代码实现-1">中间件 - 代码实现</h4>
<pre><code>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) (mapstring, 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
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 := mapstring{
"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, params.Get(key))
} else {
str = str + fmt.Sprintf("&%v=%v", key, params.Get(key))
}
}
return str
}
</code></pre>
<h2 id="rsa-非对称加密">RSA 非对称加密</h2>
<p>和上面一样，在使用前，咱们先了解下什么是非对称加密？</p>
<p>非对称加密就是需要两个密钥来进行加密和解密，这两个秘钥分别是公钥（public key）和私钥（private key），这种方法称为非对称加密。</p>
<p>常用算法：RSA。</p>
<p><strong>优点</strong></p>
<p>与对称加密相比，安全性更好，加解密需要不同的密钥，公钥和私钥都可进行相互的加解密。</p>
<p><strong>缺点</strong></p>
<p>加密和解密花费时间长、速度慢，只适合对少量数据进行加密。</p>
<p><strong>应用场景</strong></p>
<p>适合于对安全性要求很高的场景，适合加密少量数据，比如支付数据、登录数据等。</p>
<h4 id="创建签名">创建签名</h4>
<p>首先，封装 Go 的 RsaPublicEncrypt 公钥加密方法 和 RsaPrivateDecrypt 解密方法。</p>
<pre><code>// 公钥加密
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
}
</code></pre>
<p>调用方 申请 公钥（public key），然后进行加密：</p>
<pre><code>appKey = "demo"
appSecret= "公钥"
encryptStr = "param_1=xxx&param_2=xxx&ak="+appKey+"&ts=xxx"
sn = RsaPublicEncrypt(encryptStr, appSecret)
</code></pre>
<h4 id="验证签名-2">验证签名</h4>
<pre><code>decryptStr = RsaPrivateDecrypt(sn, app_secret)
</code></pre>
<p>将加密前的字符串与解密后的字符串做个对比。</p>
<p>相同，表示签名验证成功。</p>
<p>不同，表示签名验证失败。</p>
<h4 id="中间件---代码实现-2">中间件 - 代码实现</h4>
<pre><code>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) (mapstring, 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
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 := mapstring{
"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, params.Get(key))
} else {
str = str + fmt.Sprintf("&%v=%v", key, params.Get(key))
}
}
return str
}
</code></pre>
<h2 id="如何调用">如何调用？</h2>
<p>与其他中间件调用方式一样，根据自己的需求自由选择。</p>
<p>比如，使用 MD5 组合：</p>
<pre><code>.Use(sign_md5.SetUp())
</code></pre>
<p>使用 AES 对称加密：</p>
<pre><code>.Use(sign_aes.SetUp())
</code></pre>
<p>使用 RSA 非对称加密：</p>
<pre><code>.Use(sign_rsa.SetUp())
</code></pre>
<h2 id="性能测试">性能测试</h2>
<p>既然 RSA 非对称加密，最安全，那么统一都使用它吧。</p>
<p>NO！NO！NO！绝对不行！</p>
<p>为什么我要激动，因为我以前遇到过这个坑呀，都是血泪的教训呀...</p>
<p>咱们挨个测试下性能：</p>
<h4 id="md5">MD5</h4>
<pre><code>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)
}
</code></pre>
<p>模拟 一百万 次请求，大概执行时长在 1.1s ~ 1.2s 左右。</p>
<h4 id="aes">AES</h4>
<pre><code>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)
}
</code></pre>
<p>模拟 一百万 次请求，大概执行时长在 1.8s ~ 1.9s 左右。</p>
<h4 id="rsa">RSA</h4>
<pre><code>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)
}
</code></pre>
<p>我不敢模拟 一百万 次请求，还不知道啥时候能搞定呢，咱们模拟 500 次试试。</p>
<p>模拟 500 次请求，大概执行时长在 1s 左右。</p>
<p>上面就是我本地的执行效果，大家可以质疑我的电脑性能差，封装的方法有问题...</p>
<p>你们也可以试试，看看性能差距是不是这么大。</p>
<h2 id="php-与-go-加密方法如何互通">PHP 与 Go 加密方法如何互通？</h2>
<p>我是写 PHP 的，生成签名的方法用 PHP 能实现吗？</p>
<p>肯定能呀！</p>
<p>我用 PHP 也实现了上面的 3 中方法，可能会有一些小调整，总体问题不大，相关 Demo 已上传到 github：</p>
<p>https://github.com/xinliangnote/Encrypt</p>
<p>好了，就到这了。</p>
<h2 id="源码地址">源码地址</h2>
<p>https://github.com/xinliangnote/go-gin-api</p>
<h2 id="go-gin-api-系列文章">go-gin-api 系列文章</h2>
<ul>
<li>1. 使用 go modules 初始化项目</li>
<li>2. 规划项目目录和参数验证</li>
<li>3. 路由中间件 - 日志记录</li>
<li>4. 路由中间件 - 捕获异常</li>
<li>5. 路由中间件 - Jaeger 链路追踪（理论篇）</li>
<li>6. 路由中间件 - Jaeger 链路追踪（实战篇）</li>
</ul>
</div>
<div id="MySignature" role="contentinfo">
<p style="text-align: center"><img src="https://img2020.cnblogs.com/blog/389840/202008/389840-20200822143814170-1389230174.png"></p>
<p style="border: #e7e7e7 1px solid; padding: 10px 10px; font-size: 12px; background-color: whitesmoke"><span style="margin-left: -14px">作者：新亮笔记（关注公众号，可申请添加微信好友）</span>
<br>
<span style="margin-left: 10px">出处：https://www.cnblogs.com/xinliangcoder</span>
<br>
<span style="margin-left: 10px; color: black">本文版权归作者和博客园共有，欢迎转载，但未经作者同意必须保留此段声明，且在文章页面明显位置给出原文连接，否则保留追究法律责任的权利。</span>
</p><br><br>
来源：https://www.cnblogs.com/xinliangcoder/p/11743815.html
頁:
[1]