golang gin后端开发框架（四）：JWT和PASETO校验中间件
1. Token-based Authentication
在这种验证机制中，用户第一次登录需要POST自己的用户名和密码，在服务器端检验用户名和密码正确之后，就可以签署一个令牌，并将其返回给客户端
在此之后，客户端就可以用这个access_token来访问服务器上的资源，服务器只会验证该令牌是否有效
同时，access_token有一定的生命周期，在这个周期内，客户端都可以通过这个token来访问服务器的资源
2. JWT
JWT -- JSON Web Token
2.1 JWT简介
JWT是一个base64编码的字符串，主要由三部分组成：
- header
- payload
- verify signature
其中header和payload是base64编码的，而没有加密，这意味着我们可以编码或者解码任意的payload，但是最后的蓝色部分，也就是JWT签名，保证了只有服务器有私钥来签署这个token
JWT提供了很多签名算法，可以分为以下几类：
- 对称秘钥加密算法：适用于共享秘钥的场景，本地，典型的算法有：HS256、HS384、HS512
- 非对称加密算法：私钥对token签名，公钥验证token，可以提供第三方服务，典型的算法有：RS256、PS256、ES256等
JWT的问题是什么？
（1）不安全的加密算法
JWT给开发者提供了很多的加密算法选择，其中就包括了已知的易受攻击的算法
（2）在header中包含了签名算法的种类
攻击者只需要将header中的alg字段设置为none就可以绕过签名验证过程
在知道服务器使用非对称加密算法的情况下，修改alg为一个对称加密算法
2.2 在golang中实现JWT
首先我们定义一个token maker的接口，在之后会使用PASETO和JWT来实现这个接口
Maker接口包括了两个方法，分别是创建token和验证token：
type Maker interface {
// CreateToken 创建一个token
CreateToken(username string, duration time.Duration) (string, error)
// VerifyToken 验证token
VerifyToken(token string) (*Payload, error)
}
现在定义token的payload结构体，其中应该包含一些我们需要的字段，一般意义上就是用户名、创建时间、过期时间、tokenID这几个信息：
type Payload struct {
ID uuid.UUID `json:"id" `
Username string `json:"username" `
IssuedAt time.Time `json:"issued_at" `
ExpiredAt time.Time `json:"expired_at" `
}
然后对外提供一个创建payload的函数：
func NewPayload(username string, duration time.Duration) (*Payload, error) {
tokenID, err := uuid.NewRandom()
if err != nil {
return nil, err
}
payload := &Payload{
ID: tokenID,
Username: username,
IssuedAt: time.Now(),
ExpiredAt: time.Now().Add(duration),
}
return payload, nil
}
现在我们就可以开始实现JWT token的代码了，其需要实现Maker接口定义的两个方法
func (maker *JWTMaker) CreateToken(username string, duration time.Duration) (string, error) {
payload, err := NewPayload(username, duration)
if err != nil {
return "", err
}
jwtToken := jwt.NewWithClaims(jwt.SigningMethodHS256, payload)
return jwtToken.SignedString([]byte(maker.secretKey))
}
值得注意的是，在jwt.NewWithClaims()方法中，我们传入payload时会报错，仔细看提示会发现jwt需要我们定义的payload结构体提供一个验证功能，就是一个 func(payload *Payload) Valid() error 签名的函数
我们就可以做一个简单的过期时间验证：
func (payload *Payload) Valid() error {
if time.Now().After(payload.ExpiredAt) {
return ErrExpiredToken
}
return nil
}
同样，我们再去实现验证token的方法：
func (maker *JWTMaker) VerifyToken(token string) (*Payload, error) {
keyFunc := func(token *jwt.Token) (interface{}, error) {
_, ok := token.Method.(*jwt.SigningMethodHMAC)
if !ok {
return nil, ErrInvalidToken
}
return []byte(maker.secretKey), nil
}
jwtToken, err := jwt.ParseWithClaims(token, &Payload{}, keyFunc)
if err != nil {
verr, ok := err.(*jwt.ValidationError)
if ok && errors.Is(verr.Inner, ErrExpiredToken) {
return nil, ErrExpiredToken
}
return nil, ErrInvalidToken
}
payload, ok := jwtToken.Claims.(*Payload)
if !ok {
return nil, ErrInvalidToken
}
return payload, nil
}
在 jwtToken, err := jwt.ParseWithClaims(token, &Payload{}, keyFunc) 中
keyFunc需要我们自己实现，其作用是验证header中的签名算法是否合法，防止一些琐碎的攻击
同样err在jwt包内部是被隐藏的，对于验证失败的令牌有两种情况：令牌过期或者令牌不合法
所以我们需要做一次类型断言，找出具体的错误来做返回
3. PASETO
PASETO -- Platform-Agnostic SEcurity TOkens
3.1 PASETO简介
每一个版本的PASETO都包含了强大的加密套件，选择对应的加密算法只需要选择PASETO版本即可
最多只能有两个版本同时处于活跃状态
相比于JWT，PASETO所做的改变在于：
- 不会向用户开放所有的加密算法
- header中不再含有alg字段，也不会有none算法
- payload使用加密算法，而不是简单的编码
PASETO的令牌结构：
3.2 在golang中实现PASETO
PASETO的实现要比JWT简单一些，我们同样还是使用对称加密算法来实现，首先是创建token的方法：
func (maker *PasetoMaker) CreateToken(username string, duration time.Duration) (string, error) {
payload, err := NewPayload(username, duration)
if err != nil {
return "", err
}
return maker.paseto.Encrypt(maker.symmetricKey, payload, nil)
}
然后是验证token：
func (maker *PasetoMaker) VerifyToken(token string) (*Payload, error) {
payload := &Payload{}
if err := maker.paseto.Decrypt(token, maker.symmetricKey, payload, nil); err != nil {
return nil, ErrInvalidToken
}
if err := payload.Valid(); err != nil {
return nil, err
}
return payload, nil
}
至此我们就完成了PASETO对称加密的token
4. 实现token验证中间件
首先客户端需要提供登录信息，包括了用户名和密码。然后服务器创建一个token返回给客户端，用于之后的身份验证
const (
authorizationHeaderKey = "authorization"
authorizationTypeBearer = "bearer"
authorizationPayloadKey = "authorization_payload"
)
func authMiddleware(tokenMaker Maker) gin.HandlerFunc {
return func(ctx *gin.Context) {
authorizationHeader := ctx.GetHeader(authorizationHeaderKey)
if len(authorizationHeader) == 0 {
err := errors.New("authorization header is not provide")
ctx.AbortWithStatusJSON(http.StatusUnauthorized, gin.H{"error": err})
return
}
fields := strings.Fields(authorizationHeader)
if len(fields) < 2 {
err := errors.New("invalid authorization header format")
ctx.AbortWithStatusJSON(http.StatusUnauthorized, gin.H{"error": err})
return
}
authorizationType := strings.ToLower(fields[0])
if authorizationType != authorizationTypeBearer {
err := fmt.Errorf("unsupported authorization type %s", authorizationType)
ctx.AbortWithStatusJSON(http.StatusUnauthorized, gin.H{"error": err})
return
}
accessToken := fields[1]
payload, err := tokenMaker.VerifyToken(accessToken)
if err != nil {
ctx.AbortWithStatusJSON(http.StatusUnauthorized, gin.H{"error": err})
return
}
ctx.Set(authorizationPayloadKey, payload)
ctx.Next()
}
}
然后我们可以将需要授权的api做一个路由组，使用这个中间件
同时我们在授权阶段可以简单的使用一个ctx.MustGet()方法来取得token中的payload，里面包含有用户名的验证信息，这样就可以保证用户只可以访问自己的相关内容
