Gin实践 连载四 使用JWT进行身份校验

使用JWT进行身份验证

在前面几节中，我们已经基本的完成了API’s的编写
但是，还存在一些非常严重的问题，例如，我们现在的API是可以随意调用的，这显然还不够完美，是有问题的
那么我们采用 jwt-go （GoDoc）的方式来简单解决这个问题

下载依赖包

首先，我们下载jwt-go的依赖包
go get github.com/dgrijalva/jwt-go

编写jwt工具包

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

package util

import (
	"gin_log/pkg/setting"
	"github.com/dgrijalva/jwt-go"
	"time"
)

var jwtSecret = []byte(setting.JwtSecret)

type Claims struct {
	Username string `json:"username"`
	Password string `json:"password"`
	jwt.StandardClaims
}

func GenerateToken(username, password string) (string, error) {
	claims := Claims{
		username,
		password,
		jwt.StandardClaims{
			ExpiresAt: time.Now().Add(3 * time.Hour).Unix(),
			Issuer: "gin_blog",
		},
	}
	tokenClaims := jwt.NewWithClaims(jwt.SigningMethodHS256, claims)
	token, err := tokenClaims.SignedString(jwtSecret)
	return token, err
}
func ParseToken(token string) (*Claims, error) {
	tokenClaims, err := jwt.ParseWithClaims(token, &Claims{}, func(token *jwt.Token) (any, error) {
		return jwtSecret, nil
	})
	if tokenClaims != nil {
		if claims, ok := tokenClaims.Claims.(Claims); ok && tokenClaims.Valid {
			return &claims, nil
		}
	}
	return nil, err
}

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

• 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文件，写入内容：

package jwt

import (
	"gin_log/pkg/e"
	"gin_log/pkg/util"
	"github.com/gin-gonic/gin"
	"net/http"
	"strings"
)

func JWT() gin.HandlerFunc {
	return func(context *gin.Context) {
		var (
			code int
			data any
		)
		code = e.SUCCESS
		token := context.GetHeader("token")
		if token == "" {
			code = e.INVALID_PARAMS
		}else{
			_, err := util.ParseToken(token)
			if err != nil {
				// 1. token过期
				if strings.HasPrefix(err.Error(), "token is expired by") {
					code = e.ERROR_AUTH_CHECK_TOKEN_TIMEOUT
				// 2. token解析失败
				}else {
					// TODO 这里需要单独调试一下
					code = e.ERROR_AUTH_CHECK_TOKEN_FAIL
				}
			}
		}
		if code != e.SUCCESS {
			context.JSON(http.StatusOK, gin.H{
				"code": code,
				"msg": e.GetMsg(code),
				"data": data,
			})
			context.Abort()
			return
		}
		context.Next()
	}
}

如何获取token

那么我们如何调用它呢，我们还要获取Token呢？
1、 我们要新增一个获取Token的API
在models下新建auth.go文件，写入内容：

package models

type Auth struct {
	ID int `gorm:"primaryKey" json:"id"`
	Username string `json:"username"`
	Password string `json:"password"`
}
func CheckAuth(username, password string) bool {
	var auth Auth
	db.Select("id").Where(Auth{Username: username, Password: password}).Take(&auth)
	return auth.ID > 0
}

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

package v1

import (
	"gin_log/models"
	"gin_log/pkg/e"
	"gin_log/pkg/util"
	"github.com/astaxie/beego/validation"
	"github.com/gin-gonic/gin"
	"log"
	"net/http"
)

type auth struct {
	Username string `valid:"Required;MaxSize(50)"`
	Password string `valid:"Required;MaxSize(50)"`
}
func GetAuth(c *gin.Context) {
	username := c.Query("username")
	password := c.Query("password")

	valid := validation.Validation{}
	au := auth{Username: username, Password: password}
	ok, _ := valid.Valid(&au)

	code := e.INVALID_PARAMS
	data := map[string]any{}

	if ok {
		exist := models.CheckAuth(username, password)
		if exist {
			token, err := util.GenerateToken(username, password)
			if err != nil {
				code = e.ERROR_AUTH_TOKEN
			}else{
				data["token"] = token
				code = e.SUCCESS
			}
		}else{
			code = e.ERROR_AUTH
		}
	}else{
		for _, err := range valid.Errors {
			log.Println(err.Key, err.Message)
		}
	}

	c.JSON(http.StatusOK, gin.H{
		"code": code,
		"msg": e.GetMsg(code),
		"data": data,
	})
}

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

r.GET("/auth", v1.GetAuth)

验证Token

获取token的API方法就到这里啦，让我们来测试下是否可以正常使用吧！
重启服务后，用GET方式访问http://127.0.0.1:8000/auth?username=test&password=test123456，查看返回值是否正确

{
  "code": 200,
  "data": {
    "token": "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJ1c2VybmFtZSI6InRlc3QiLCJwYXNzd29yZCI6InRlc3QxMjM0NTYiLCJleHAiOjE1MTg3MjAwMzcsImlzcyI6Imdpbi1ibG9nIn0.-kK0V9E06qTHOzupQM_gHXAGDB3EJtJS4H5TTCyWwW8"
  },
  "msg": "ok"
}

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

将中间件接入gin

接下来我们将中间件接入到Gin的访问流程中
我们打开routers目录下的router.go文件，修改文件内容（新增引用包和中间件引用）

	r.GET("/auth", v1.GetAuth)

	apiv1 := r.Group("/api/v1")
	apiv1.Use(jwt.JWT())

当前目录结构：

gin-blog/
├── conf
│   └── app.ini
├── main.go
├── middleware
│   └── jwt
│       └── jwt.go
├── models
│   ├── article.go
│   ├── auth.go
│   ├── models.go
│   └── tag.go
├── pkg
│   ├── e
│   │   ├── code.go
│   │   └── msg.go
│   ├── setting
│   │   └── setting.go
│   └── util
│       ├── jwt.go
│       └── pagination.go
├── routers
│   ├── api
│   │   ├── auth.go
│   │   └── v1
│   │       ├── article.go
│   │       └── tag.go
│   └── router.go
├── runtime

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

验证功能

我们来测试一下，再次访问
http://127.0.0.1:8000/api/v1/articles
http://127.0.0.1:8000/api/v1/articles header: token:123456

{
	"code": 400,
	"data": null,
	"msg": "请求参数错误"
}

{
	"code": 20001,
	"data": null,
	"msg": "Token鉴权失败"
}

再用包含token的URL参数去访问我们的应用API，
访问http://127.0.0.1:8000/api/v1/articles?token=eyJhbGci...，检查接口返回值

{
  "code": 200,
  "data": {
    "lists": [
      {
        "id": 2,
        "created_on": 1518700920,
        "modified_on": 0,
        "tag_id": 1,
        "tag": {
          "id": 1,
          "created_on": 1518684200,
          "modified_on": 0,
          "name": "tag1",
          "created_by": "",
          "modified_by": "",
          "state": 0
        },
        "content": "test-content",
        "created_by": "test-created",
        "modified_by": "",
        "state": 0
      }
    ],
    "total": 1
  },
  "msg": "ok"
}

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