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

2019年10月10日 325点热度 0人点赞 0条评论

概览

首先同步下项目概况:

图片

上篇文章分享了,路由中间件 - 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 方法:

  1. func MD5(str string) string {

  2. s := md5.New()

  3. s.Write([]byte(str))

  4. return hex.EncodeToString(s.Sum(nil))

  5. }

进行加密:

  1. appKey = "demo"

  2. appSecret = "xxx"

  3. encryptStr = "param_1=xxx&param_2=xxx&ak="+appKey+"&ts=xxx"


  4. // 自定义验证规则

  5. sn = MD5(appSecret + encryptStr + appSecret)

验证签名

通过传递参数,再次生成签名,如果将传递的签名与生成的签名进行对比。

相同,表示签名验证成功。

不同,表示签名验证失败。

中间件 - 代码实现

  1. var AppSecret string


  2. // MD5 组合加密

  3. func SetUp() gin.HandlerFunc {


  4. return func(c *gin.Context) {

  5. utilGin := util.Gin{Ctx: c}


  6. sign, err := verifySign(c)


  7. if sign != nil {

  8. utilGin.Response(-1, "Debug Sign", sign)

  9. c.Abort()

  10. return

  11. }


  12. if err != nil {

  13. utilGin.Response(-1, err.Error(), sign)

  14. c.Abort()

  15. return

  16. }


  17. c.Next()

  18. }

  19. }


  20. // 验证签名

  21. func verifySign(c *gin.Context) (map[string]string, error) {

  22. _ = c.Request.ParseForm()

  23. req := c.Request.Form

  24. debug := strings.Join(c.Request.Form["debug"], "")

  25. ak := strings.Join(c.Request.Form["ak"], "")

  26. sn := strings.Join(c.Request.Form["sn"], "")

  27. ts := strings.Join(c.Request.Form["ts"], "")


  28. // 验证来源

  29. value, ok := config.ApiAuthConfig[ak]

  30. if ok {

  31. AppSecret = value["md5"]

  32. } else {

  33. return nil, errors.New("ak Error")

  34. }


  35. if debug == "1" {

  36. currentUnix := util.GetCurrentUnix()

  37. req.Set("ts", strconv.FormatInt(currentUnix, 10))

  38. res := map[string]string{

  39. "ts": strconv.FormatInt(currentUnix, 10),

  40. "sn": createSign(req),

  41. }

  42. return res, nil

  43. }


  44. // 验证过期时间

  45. timestamp := time.Now().Unix()

  46. exp, _ := strconv.ParseInt(config.AppSignExpiry, 10, 64)

  47. tsInt, _ := strconv.ParseInt(ts, 10, 64)

  48. if tsInt > timestamp || timestamp - tsInt >= exp {

  49. return nil, errors.New("ts Error")

  50. }


  51. // 验证签名

  52. if sn == "" || sn != createSign(req) {

  53. return nil, errors.New("sn Error")

  54. }


  55. return nil, nil

  56. }


  57. // 创建签名

  58. func createSign(params url.Values) string {

  59. // 自定义 MD5 组合

  60. return util.MD5(AppSecret + createEncryptStr(params) + AppSecret)

  61. }


  62. func createEncryptStr(params url.Values) string {

  63. var key []string

  64. var str = ""

  65. for k := range params {

  66. if k != "sn" && k != "debug" {

  67. key = append(key, k)

  68. }

  69. }

  70. sort.Strings(key)

  71. for i := 0; i < len(key); i++ {

  72. if i == 0 {

  73. str = fmt.Sprintf("%v=%v", key[i], params.Get(key[i]))

  74. } else {

  75. str = str + fmt.Sprintf("&%v=%v", key[i], params.Get(key[i]))

  76. }

  77. }

  78. return str

  79. }

AES 对称加密

在使用前,咱们先了解下什么是对称加密?

对称加密就是使用同一个密钥即可以加密也可以解密,这种方法称为对称加密。

常用算法:DES、AES。

其中 AES 是 DES 的升级版,密钥长度更长,选择更多,也更灵活,安全性更高,速度更快,咱们直接上手 AES 加密。

优点

算法公开、计算量小、加密速度快、加密效率高。

缺点

发送方和接收方必须商定好密钥,然后使双方都能保存好密钥,密钥管理成为双方的负担。

应用场景

相对大一点的数据量或关键数据的加密。

生成签名

首先,封装 Go 的 AesEncrypt 加密方法 和 AesDecrypt 解密方法。

  1. // 加密 aes_128_cbc

  2. func AesEncrypt (encryptStr string, key []byte, iv string) (string, error) {

  3. encryptBytes := []byte(encryptStr)

  4. block, err := aes.NewCipher(key)

  5. if err != nil {

  6. return "", err

  7. }


  8. blockSize := block.BlockSize()

  9. encryptBytes = pkcs5Padding(encryptBytes, blockSize)


  10. blockMode := cipher.NewCBCEncrypter(block, []byte(iv))

  11. encrypted := make([]byte, len(encryptBytes))

  12. blockMode.CryptBlocks(encrypted, encryptBytes)

  13. return base64.URLEncoding.EncodeToString(encrypted), nil

  14. }


  15. // 解密

  16. func AesDecrypt (decryptStr string, key []byte, iv string) (string, error) {

  17. decryptBytes, err := base64.URLEncoding.DecodeString(decryptStr)

  18. if err != nil {

  19. return "", err

  20. }


  21. block, err := aes.NewCipher(key)

  22. if err != nil {

  23. return "", err

  24. }


  25. blockMode := cipher.NewCBCDecrypter(block, []byte(iv))

  26. decrypted := make([]byte, len(decryptBytes))


  27. blockMode.CryptBlocks(decrypted, decryptBytes)

  28. decrypted = pkcs5UnPadding(decrypted)

  29. return string(decrypted), nil

  30. }


  31. func pkcs5Padding (cipherText []byte, blockSize int) []byte {

  32. padding := blockSize - len(cipherText)%blockSize

  33. padText := bytes.Repeat([]byte{byte(padding)}, padding)

  34. return append(cipherText, padText...)

  35. }


  36. func pkcs5UnPadding (decrypted []byte) []byte {

  37. length := len(decrypted)

  38. unPadding := int(decrypted[length-1])

  39. return decrypted[:(length - unPadding)]

  40. }

进行加密:

  1. appKey = "demo"

  2. appSecret = "xxx"

  3. encryptStr = "param_1=xxx&param_2=xxx&ak="+appKey+"&ts=xxx"


  4. sn = AesEncrypt(encryptStr, appSecret)

验证签名

  1. decryptStr = AesDecrypt(sn, app_secret)

将加密前的字符串与解密后的字符串做个对比。

相同,表示签名验证成功。

不同,表示签名验证失败。

中间件 - 代码实现

  1. var AppSecret string


  2. // AES 对称加密

  3. func SetUp() gin.HandlerFunc {


  4. return func(c *gin.Context) {

  5. utilGin := util.Gin{Ctx: c}


  6. sign, err := verifySign(c)


  7. if sign != nil {

  8. utilGin.Response(-1, "Debug Sign", sign)

  9. c.Abort()

  10. return

  11. }


  12. if err != nil {

  13. utilGin.Response(-1, err.Error(), sign)

  14. c.Abort()

  15. return

  16. }


  17. c.Next()

  18. }

  19. }


  20. // 验证签名

  21. func verifySign(c *gin.Context) (map[string]string, error) {

  22. _ = c.Request.ParseForm()

  23. req := c.Request.Form

  24. debug := strings.Join(c.Request.Form["debug"], "")

  25. ak := strings.Join(c.Request.Form["ak"], "")

  26. sn := strings.Join(c.Request.Form["sn"], "")

  27. ts := strings.Join(c.Request.Form["ts"], "")


  28. // 验证来源

  29. value, ok := config.ApiAuthConfig[ak]

  30. if ok {

  31. AppSecret = value["aes"]

  32. } else {

  33. return nil, errors.New("ak Error")

  34. }


  35. if debug == "1" {

  36. currentUnix := util.GetCurrentUnix()

  37. req.Set("ts", strconv.FormatInt(currentUnix, 10))


  38. sn, err := createSign(req)

  39. if err != nil {

  40. return nil, errors.New("sn Exception")

  41. }


  42. res := map[string]string{

  43. "ts": strconv.FormatInt(currentUnix, 10),

  44. "sn": sn,

  45. }

  46. return res, nil

  47. }


  48. // 验证过期时间

  49. timestamp := time.Now().Unix()

  50. exp, _ := strconv.ParseInt(config.AppSignExpiry, 10, 64)

  51. tsInt, _ := strconv.ParseInt(ts, 10, 64)

  52. if tsInt > timestamp || timestamp - tsInt >= exp {

  53. return nil, errors.New("ts Error")

  54. }


  55. // 验证签名

  56. if sn == "" {

  57. return nil, errors.New("sn Error")

  58. }


  59. decryptStr, decryptErr := util.AesDecrypt(sn, []byte(AppSecret), AppSecret)

  60. if decryptErr != nil {

  61. return nil, errors.New(decryptErr.Error())

  62. }

  63. if decryptStr != createEncryptStr(req) {

  64. return nil, errors.New("sn Error")

  65. }

  66. return nil, nil

  67. }


  68. // 创建签名

  69. func createSign(params url.Values) (string, error) {

  70. return util.AesEncrypt(createEncryptStr(params), []byte(AppSecret), AppSecret)

  71. }


  72. func createEncryptStr(params url.Values) string {

  73. var key []string

  74. var str = ""

  75. for k := range params {

  76. if k != "sn" && k != "debug" {

  77. key = append(key, k)

  78. }

  79. }

  80. sort.Strings(key)

  81. for i := 0; i < len(key); i++ {

  82. if i == 0 {

  83. str = fmt.Sprintf("%v=%v", key[i], params.Get(key[i]))

  84. } else {

  85. str = str + fmt.Sprintf("&%v=%v", key[i], params.Get(key[i]))

  86. }

  87. }

  88. return str

  89. }

RSA 非对称加密

和上面一样,在使用前,咱们先了解下什么是非对称加密?

非对称加密就是需要两个密钥来进行加密和解密,这两个秘钥分别是公钥(public key)和私钥(private key),这种方法称为非对称加密。

常用算法:RSA。

优点

与对称加密相比,安全性更好,加解密需要不同的密钥,公钥和私钥都可进行相互的加解密。

缺点

加密和解密花费时间长、速度慢,只适合对少量数据进行加密。

应用场景

适合于对安全性要求很高的场景,适合加密少量数据,比如支付数据、登录数据等。

创建签名

首先,封装 Go 的 RsaPublicEncrypt 公钥加密方法 和 RsaPrivateDecrypt 解密方法。

  1. // 公钥加密

  2. func RsaPublicEncrypt(encryptStr string, path string) (string, error) {

  3. // 打开文件

  4. file, err := os.Open(path)

  5. if err != nil {

  6. return "", err

  7. }

  8. defer file.Close()


  9. // 读取文件内容

  10. info, _ := file.Stat()

  11. buf := make([]byte,info.Size())

  12. file.Read(buf)


  13. // pem 解码

  14. block, _ := pem.Decode(buf)


  15. // x509 解码

  16. publicKeyInterface, err := x509.ParsePKIXPublicKey(block.Bytes)

  17. if err != nil {

  18. return "", err

  19. }


  20. // 类型断言

  21. publicKey := publicKeyInterface.(*rsa.PublicKey)


  22. //对明文进行加密

  23. encryptedStr, err := rsa.EncryptPKCS1v15(rand.Reader, publicKey, []byte(encryptStr))

  24. if err != nil {

  25. return "", err

  26. }


  27. //返回密文

  28. return base64.URLEncoding.EncodeToString(encryptedStr), nil

  29. }


  30. // 私钥解密

  31. func RsaPrivateDecrypt(decryptStr string, path string) (string, error) {

  32. // 打开文件

  33. file, err := os.Open(path)

  34. if err != nil {

  35. return "", err

  36. }

  37. defer file.Close()


  38. // 获取文件内容

  39. info, _ := file.Stat()

  40. buf := make([]byte,info.Size())

  41. file.Read(buf)


  42. // pem 解码

  43. block, _ := pem.Decode(buf)


  44. // X509 解码

  45. privateKey, err := x509.ParsePKCS1PrivateKey(block.Bytes)

  46. if err != nil {

  47. return "", err

  48. }

  49. decryptBytes, err := base64.URLEncoding.DecodeString(decryptStr)


  50. //对密文进行解密

  51. decrypted, _ := rsa.DecryptPKCS1v15(rand.Reader,privateKey,decryptBytes)


  52. //返回明文

  53. return string(decrypted), nil

  54. }

调用方 申请 公钥(public key),然后进行加密:

  1. appKey = "demo"

  2. appSecret = "公钥"

  3. encryptStr = "param_1=xxx&param_2=xxx&ak="+appKey+"&ts=xxx"


  4. sn = RsaPublicEncrypt(encryptStr, appSecret)

验证签名

  1. decryptStr = RsaPrivateDecrypt(sn, app_secret)

将加密前的字符串与解密后的字符串做个对比。

相同,表示签名验证成功。

不同,表示签名验证失败。

中间件 - 代码实现

  1. var AppSecret string


  2. // RSA 非对称加密

  3. func SetUp() gin.HandlerFunc {


  4. return func(c *gin.Context) {

  5. utilGin := util.Gin{Ctx: c}


  6. sign, err := verifySign(c)


  7. if sign != nil {

  8. utilGin.Response(-1, "Debug Sign", sign)

  9. c.Abort()

  10. return

  11. }


  12. if err != nil {

  13. utilGin.Response(-1, err.Error(), sign)

  14. c.Abort()

  15. return

  16. }


  17. c.Next()

  18. }

  19. }


  20. // 验证签名

  21. func verifySign(c *gin.Context) (map[string]string, error) {

  22. _ = c.Request.ParseForm()

  23. req := c.Request.Form

  24. debug := strings.Join(c.Request.Form["debug"], "")

  25. ak := strings.Join(c.Request.Form["ak"], "")

  26. sn := strings.Join(c.Request.Form["sn"], "")

  27. ts := strings.Join(c.Request.Form["ts"], "")


  28. // 验证来源

  29. value, ok := config.ApiAuthConfig[ak]

  30. if ok {

  31. AppSecret = value["rsa"]

  32. } else {

  33. return nil, errors.New("ak Error")

  34. }


  35. if debug == "1" {

  36. currentUnix := util.GetCurrentUnix()

  37. req.Set("ts", strconv.FormatInt(currentUnix, 10))


  38. sn, err := createSign(req)

  39. if err != nil {

  40. return nil, errors.New("sn Exception")

  41. }


  42. res := map[string]string{

  43. "ts": strconv.FormatInt(currentUnix, 10),

  44. "sn": sn,

  45. }

  46. return res, nil

  47. }


  48. // 验证过期时间

  49. timestamp := time.Now().Unix()

  50. exp, _ := strconv.ParseInt(config.AppSignExpiry, 10, 64)

  51. tsInt, _ := strconv.ParseInt(ts, 10, 64)

  52. if tsInt > timestamp || timestamp - tsInt >= exp {

  53. return nil, errors.New("ts Error")

  54. }


  55. // 验证签名

  56. if sn == "" {

  57. return nil, errors.New("sn Error")

  58. }


  59. decryptStr, decryptErr := util.RsaPrivateDecrypt(sn, config.AppRsaPrivateFile)

  60. if decryptErr != nil {

  61. return nil, errors.New(decryptErr.Error())

  62. }

  63. if decryptStr != createEncryptStr(req) {

  64. return nil, errors.New("sn Error")

  65. }

  66. return nil, nil

  67. }


  68. // 创建签名

  69. func createSign(params url.Values) (string, error) {

  70. return util.RsaPublicEncrypt(createEncryptStr(params), AppSecret)

  71. }


  72. func createEncryptStr(params url.Values) string {

  73. var key []string

  74. var str = ""

  75. for k := range params {

  76. if k != "sn" && k != "debug" {

  77. key = append(key, k)

  78. }

  79. }

  80. sort.Strings(key)

  81. for i := 0; i < len(key); i++ {

  82. if i == 0 {

  83. str = fmt.Sprintf("%v=%v", key[i], params.Get(key[i]))

  84. } else {

  85. str = str + fmt.Sprintf("&%v=%v", key[i], params.Get(key[i]))

  86. }

  87. }

  88. return str

  89. }

如何调用?

与其他中间件调用方式一样,根据自己的需求自由选择。

比如,使用 MD5 组合:

  1. .Use(sign_md5.SetUp())

使用 AES 对称加密:

  1. .Use(sign_aes.SetUp())

使用 RSA 非对称加密:

  1. .Use(sign_rsa.SetUp())

性能测试

既然 RSA 非对称加密,最安全,那么统一都使用它吧。

NO!NO!NO!绝对不行!

为什么我要激动,因为我以前遇到过这个坑呀,都是血泪的教训呀...

咱们挨个测试下性能:

MD5

  1. func Md5Test(c *gin.Context) {

  2. startTime := time.Now()

  3. appSecret := "IgkibX71IEf382PT"

  4. encryptStr := "param_1=xxx&param_2=xxx&ak=xxx&ts=1111111111"

  5. count := 1000000

  6. for i := 0; i < count; i++ {

  7. // 生成签名

  8. util.MD5(appSecret + encryptStr + appSecret)


  9. // 验证签名

  10. util.MD5(appSecret + encryptStr + appSecret)

  11. }

  12. utilGin := util.Gin{Ctx: c}

  13. utilGin.Response(1, fmt.Sprintf("%v次 - %v", count, time.Since(startTime)), nil)

  14. }

模拟 一百万 次请求,大概执行时长在 1.1s ~ 1.2s 左右。


AES

  1. func AesTest(c *gin.Context) {

  2. startTime := time.Now()

  3. appSecret := "IgkibX71IEf382PT"

  4. encryptStr := "param_1=xxx&param_2=xxx&ak=xxx&ts=1111111111"

  5. count := 1000000

  6. for i := 0; i < count; i++ {

  7. // 生成签名

  8. sn, _ := util.AesEncrypt(encryptStr, []byte(appSecret), appSecret)


  9. // 验证签名

  10. util.AesDecrypt(sn, []byte(appSecret), appSecret)

  11. }

  12. utilGin := util.Gin{Ctx: c}

  13. utilGin.Response(1, fmt.Sprintf("%v次 - %v", count, time.Since(startTime)), nil)

  14. }

模拟 一百万 次请求,大概执行时长在 1.8s ~ 1.9s 左右。


RSA

  1. func RsaTest(c *gin.Context) {

  2. startTime := time.Now()

  3. encryptStr := "param_1=xxx&param_2=xxx&ak=xxx&ts=1111111111"

  4. count := 500

  5. for i := 0; i < count; i++ {

  6. // 生成签名

  7. sn, _ := util.RsaPublicEncrypt(encryptStr, "rsa/public.pem")


  8. // 验证签名

  9. util.RsaPrivateDecrypt(sn, "rsa/private.pem")

  10. }

  11. utilGin := util.Gin{Ctx: c}

  12. utilGin.Response(1, fmt.Sprintf("%v次 - %v", count, time.Since(startTime)), nil)

  13. }

我不敢模拟 一百万 次请求,还不知道啥时候能搞定呢,咱们模拟 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 系列文章

图片

12730[系列] - go-gin-api 路由中间件 - 签名验证(七)

root

这个人很懒,什么都没留下

文章评论