使用JWT进行身份校验

在前面几节中，我们已经基本的完成了API’s的编写

但是，还存在一些非常严重的问题，例如，我们现在的API是可以随意调用的，这显然还不够完美，是有问题的

那么我们采用 jwt-go （GoDoc）的方式来简单解决这个问题

项目地址：https://github.com/EDDYCJY/go-gin-example

下载依赖包

首先，我们下载jwt-go的依赖包

  1. go get -u github.com/dgrijalva/jwt-go

编写jwt工具包

我们需要编写一个jwt的工具包，我们在pkg下的util目录新建jwt.go，写入文件内容：

  1. package util
  3. import (
  4.     "time"
  6.     jwt "github.com/dgrijalva/jwt-go"
  8.     "gin-blog/pkg/setting"
  9. )
  11. var jwtSecret = []byte(setting.JwtSecret)
  13. type Claims struct {
  14.     Username string `json:"username"`
  15.     Password string `json:"password"`
  16.     jwt.StandardClaims
  17. }
  19. func GenerateToken(username, password string) (string, error) {
  20.     nowTime := time.Now()
  21.     expireTime := nowTime.Add(3 * time.Hour)
  23.     claims := Claims{
  24.         username,
  25.         password,
  26.         jwt.StandardClaims {
  27.             ExpiresAt : expireTime.Unix(),
  28.             Issuer : "gin-blog",
  29.         },
  30.     }
  32.     tokenClaims := jwt.NewWithClaims(jwt.SigningMethodHS256, claims)
  33.     token, err := tokenClaims.SignedString(jwtSecret)
  35.     return token, err
  36. }
  38. func ParseToken(token string) (*Claims, error) {
  39.     tokenClaims, err := jwt.ParseWithClaims(token, &Claims{}, func(token *jwt.Token) (interface{}, error) {
  40.         return jwtSecret, nil
  41.     })
  43.     if tokenClaims != nil {
  44.         if claims, ok := tokenClaims.Claims.(*Claims); ok && tokenClaims.Valid {
  45.             return claims, nil
  46.         }
  47.     }
  49.     return nil, err
  50. }

在这个工具包，我们涉及到

  • NewWithClaims(method SigningMethod, claims Claims)，method对应着SigningMethodHMAC struct{}，其包含SigningMethodHS256、SigningMethodHS384、SigningMethodHS512三种crypto.Hash方案
  • func (t *Token) SignedString(key interface{}) 该方法内部生成签名字符串，再用于获取完整、已签名的token
  • func (p *Parser) ParseWithClaims 用于解析鉴权的声明，方法内部主要是具体的解码和校验的过程，最终返回*Token
  • func (m MapClaims) Valid() 验证基于时间的声明exp, iat, nbf，注意如果没有任何声明在令牌中，仍然会被认为是有效的。并且对于时区偏差没有计算方法

有了jwt工具包，接下来我们要编写要用于Gin的中间件，我们在middleware下新建jwt目录，新建jwt.go文件，写入内容：

  1. package jwt
  3. import (
  4.     "time"
  5.     "net/http"
  7.     "github.com/gin-gonic/gin"
  9.     "gin-blog/pkg/util"
  10.     "gin-blog/pkg/e"
  11. )
  13. func JWT() gin.HandlerFunc {
  14.     return func(c *gin.Context) {
  15.         var code int
  16.         var data interface{}
  18.         code = e.SUCCESS
  19.         token := c.Query("token")
  20.         if token == "" {
  21.             code = e.INVALID_PARAMS
  22.         } else {
  23.             claims, err := util.ParseToken(token)
  24.             if err != nil {
  25.                 code = e.ERROR_AUTH_CHECK_TOKEN_FAIL
  26.             } else if time.Now().Unix() > claims.ExpiresAt {
  27.                 code = e.ERROR_AUTH_CHECK_TOKEN_TIMEOUT
  28.             }
  29.         }
  31.         if code != e.SUCCESS {
  32.             c.JSON(http.StatusUnauthorized, gin.H{
  33.                 "code" : code,
  34.                 "msg" : e.GetMsg(code),
  35.                 "data" : data,
  36.             })
  38.             c.Abort()
  39.             return
  40.         }
  42.         c.Next()
  43.     }
  44. }

如何获取Token

那么我们如何调用它呢，我们还要获取Token呢？

1、 我们要新增一个获取Token的API

在models下新建auth.go文件，写入内容：

  1. package models
  3. type Auth struct {
  4.     ID int `gorm:"primary_key" json:"id"`
  5.     Username string `json:"username"`
  6.     Password string `json:"password"`
  7. }
  9. func CheckAuth(username, password string) bool {
  10.     var auth Auth
  11.     db.Select("id").Where(Auth{Username : username, Password : password}).First(&auth)
  12.     if auth.ID > 0 {
  13.         return true
  14.     }
  16.     return false
  17. }

在routers下的api目录新建auth.go文件，写入内容：

  1. package api
  3. import (
  4.     "log"
  5.     "net/http"
  7.     "github.com/gin-gonic/gin"
  8.     "github.com/astaxie/beego/validation"
  10.     "gin-blog/pkg/e"
  11.     "gin-blog/pkg/util"
  12.     "gin-blog/models"
  13. )
  15. type auth struct {
  16.     Username string `valid:"Required; MaxSize(50)"`
  17.     Password string `valid:"Required; MaxSize(50)"`
  18. }
  20. func GetAuth(c *gin.Context) {
  21.     username := c.Query("username")
  22.     password := c.Query("password")
  24.     valid := validation.Validation{}
  25.     a := auth{Username: username, Password: password}
  26.     ok, _ := valid.Valid(&a)
  28.     data := make(map[string]interface{})
  29.     code := e.INVALID_PARAMS
  30.     if ok {
  31.         isExist := models.CheckAuth(username, password)
  32.         if isExist {
  33.             token, err := util.GenerateToken(username, password)
  34.             if err != nil {
  35.                 code = e.ERROR_AUTH_TOKEN
  36.             } else {
  37.                 data["token"] = token
  39.                 code = e.SUCCESS
  40.             }
  42.         } else {
  43.             code = e.ERROR_AUTH
  44.         }
  45.     } else {
  46.         for _, err := range valid.Errors {
  47.             log.Println(err.Key, err.Message)
  48.         }
  49.     }
  51.     c.JSON(http.StatusOK, gin.H{
  52.         "code" : code,
  53.         "msg" : e.GetMsg(code),
  54.         "data" : data,
  55.     })
  56. }

我们打开routers目录下的router.go文件，修改文件内容（新增获取token的方法）：

  1. package routers
  3. import (
  4.     "github.com/gin-gonic/gin"
  6.     "gin-blog/routers/api"
  7.     "gin-blog/routers/api/v1"
  8.     "gin-blog/pkg/setting"
  9. )
  11. func InitRouter() *gin.Engine {
  12.     r := gin.New()
  14.     r.Use(gin.Logger())
  16.     r.Use(gin.Recovery())
  18.     gin.SetMode(setting.RunMode)
  20.     r.GET("/auth", api.GetAuth)
  22.     apiv1 := r.Group("/api/v1")
  23.     {
  24.         ...
  25.     }
  27.     return r
  28. }

验证Token

获取token的API方法就到这里啦，让我们来测试下是否可以正常使用吧！

重启服务后，用GET方式访问http://127.0.0.1:8000/auth?username=test&password=test123456，查看返回值是否正确

  1. {
  2.   "code": 200,
  3.   "data": {
  4.     "token": "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJ1c2VybmFtZSI6InRlc3QiLCJwYXNzd29yZCI6InRlc3QxMjM0NTYiLCJleHAiOjE1MTg3MjAwMzcsImlzcyI6Imdpbi1ibG9nIn0.-kK0V9E06qTHOzupQM_gHXAGDB3EJtJS4H5TTCyWwW8"
  5.   },
  6.   "msg": "ok"
  7. }

我们有了token的API，也调用成功了

将中间件接入Gin

2、 接下来我们将中间件接入到Gin的访问流程中

我们打开routers目录下的router.go文件，修改文件内容（新增引用包和中间件引用）

  1. package routers
  3. import (
  4.     "github.com/gin-gonic/gin"
  6.     "gin-blog/routers/api"
  7.     "gin-blog/routers/api/v1"
  8.     "gin-blog/pkg/setting"
  9.     "gin-blog/middleware/jwt"
  10. )
  12. func InitRouter() *gin.Engine {
  13.     r := gin.New()
  15.     r.Use(gin.Logger())
  17.     r.Use(gin.Recovery())
  19.     gin.SetMode(setting.RunMode)
  21.     r.GET("/auth", api.GetAuth)
  23.     apiv1 := r.Group("/api/v1")
  24.     apiv1.Use(jwt.JWT())
  25.     {
  26.         ...
  27.     }
  29.     return r
  30. }

当前目录结构：

  1. gin-blog/
  2. ├── conf
  3. │   └── app.ini
  4. ├── main.go
  5. ├── middleware
  6. │   └── jwt
  7. │       └── jwt.go
  8. ├── models
  9. │   ├── article.go
  10. │   ├── auth.go
  11. │   ├── models.go
  12. │   └── tag.go
  13. ├── pkg
  14. │   ├── e
  15. │   │   ├── code.go
  16. │   │   └── msg.go
  17. │   ├── setting
  18. │   │   └── setting.go
  19. │   └── util
  20. │       ├── jwt.go
  21. │       └── pagination.go
  22. ├── routers
  23. │   ├── api
  24. │   │   ├── auth.go
  25. │   │   └── v1
  26. │   │       ├── article.go
  27. │   │       └── tag.go
  28. │   └── router.go
  29. ├── runtime

到这里，我们的JWT编写就完成啦！

验证功能

我们来测试一下，再次访问

正确的反馈应该是

  1. {
  2.   "code": 400,
  3.   "data": null,
  4.   "msg": "请求参数错误"
  5. }
  7. {
  8.   "code": 20001,
  9.   "data": null,
  10.   "msg": "Token鉴权失败"
  11. }

我们需要访问http://127.0.0.1:8000/auth?username=test&password=test123456，得到token

  1. {
  2.   "code": 200,
  3.   "data": {
  4.     "token": "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJ1c2VybmFtZSI6InRlc3QiLCJwYXNzd29yZCI6InRlc3QxMjM0NTYiLCJleHAiOjE1MTg3MjQ2OTMsImlzcyI6Imdpbi1ibG9nIn0.KSBY6TeavV_30kfmP7HWLRYKP5TPEDgHtABe9HCsic4"
  5.   },
  6.   "msg": "ok"
  7. }

再用包含token的URL参数去访问我们的应用API，

访问http://127.0.0.1:8000/api/v1/articles?token=eyJhbGci...，检查接口返回值

  1. {
  2.   "code": 200,
  3.   "data": {
  4.     "lists": [
  5.       {
  6.         "id": 2,
  7.         "created_on": 1518700920,
  8.         "modified_on": 0,
  9.         "tag_id": 1,
  10.         "tag": {
  11.           "id": 1,
  12.           "created_on": 1518684200,
  13.           "modified_on": 0,
  14.           "name": "tag1",
  15.           "created_by": "",
  16.           "modified_by": "",
  17.           "state": 0
  18.         },
  19.         "content": "test-content",
  20.         "created_by": "test-created",
  21.         "modified_by": "",
  22.         "state": 0
  23.       }
  24.     ],
  25.     "total": 1
  26.   },
  27.   "msg": "ok"
  28. }

返回正确，至此我们的jwt-go在Gin中的验证就完成了！

参考

本系列示例代码