[系列] go-gin-api 路由中介軟體 - 簽名驗證(七)
目錄
- 概覽
- MD5 組合
- AES 對稱加密
- RSA 非對稱加密
- 如何呼叫?
- 效能測試
- PHP 與 Go 加密方法如何互通?
- 原始碼地址
- 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
好了,就到這了。
原始碼地址
https://github.com/xinliangnote/go-gin-api
go-gin-api 系列文章
- 1. 使用 go modules 初始化專案
- 2. 規劃專案目錄和引數驗證
- 3. 路由中介軟體 - 日誌記錄
- 4. 路由中介軟體 - 捕獲異常
- 5. 路由中介軟體 - Jaeger 鏈路追蹤(理論篇)
- 6. 路由中介軟體 - Jaeger 鏈路追蹤(實戰篇)