[系列] - 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/xinliangno...

好了，就到這了。

源碼地址

https://github.com/xinliangno...

[系列] - go-gin-api 路由中間件 - 簽名驗證（七）

概覽

MD5 組合

生成簽名

驗證簽名

中間件 - 代碼實現

AES 對稱加密

生成簽名

驗證簽名

中間件 - 代碼實現

RSA 非對稱加密

創建簽名

驗證簽名

中間件 - 代碼實現

如何調用？

性能測試

MD5

AES

RSA

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

源碼地址

go-gin-api 系列文章

HTML頁面關於高分屏的設置

北歐瑞典挪威芬蘭瑞士TikTok海外網紅與YouTube博主的合作模式

druid數據源 xml配置

[系列] - go-gin-api 路由中間件 - 簽名驗證（七）

[系列] - go-gin-api 路由中間件 - Jaeger 鏈路追蹤（六）

[系列] - go-gin-api 路由中間件 - Jaeger 鏈路追蹤（五）

[系列] - go-gin-api 路由中間件 - 捕獲異常（四）

[系列] - go-gin-api 路由中間件 - 日誌記錄（三）

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結