GoLang jwt无感刷新与SSO单点登录限制解除的方法是什么

为什么使用JWT

Jwt提供了生成token以及token验证的方法，而token是一种不用存储在服务端，只需要由用户携带即可实现认证的一种方式。在介绍JWT之前，我们也应该先了解cookie和session。

Cookie和Session

为每一位用户设定一个SessionID，每次都需要对该SessionID进行比对。这个SessionID可能会保存在Cookie中，安全性不高，并且容易过期(一般session的过期时间都为30分钟)。由于cookie和session需要保存在服务端，当用户量非常大的时候，服务端的负载就会越来越大。甚至有因此崩溃的可能。所以采用token认证的方式。

token (header.payload.signature)

每个用户在进行登录的时候如果登录信息正确就会收到服务端颁发的令牌token。当用户每次进行请求时都会携带一个token。该token会在服务端进行校验处理，复杂一点还需要经过一系列中间件的处理，确认token格式和参数是否正确。如果一切正常就需要对该用户的本次操作进行放行。

token 安全性

如果token被非用户人员获取到，由于token已经颁发，在此token生效期间服务端无法对其进行解除，因为它并不在服务端内部进行保存。也就是说服务端的token一旦颁发就无法取消。

基于token安全性的处理

access token 和 refresh token

以下access token简称 atoken，refresh token 简称 rtoken。无感刷新方式。

在用户登录的时候颁发两个token，atoken 和 rtoken。atoken 的有效期很短，根据业务实际需求可以自定义。一般设置为10分钟足够。rtoken有效期较长，一般可以设置为一星期或者一个月，根据实际业务需求可以自行定义。（根据查询资料得知 rtoken需要进行client-sercet才能有效）。当atoken过期之后可以通过rtoken进行刷新，但是rtoken过期之后，只能重新登录来获取。

当atoken丢失之后没关系，因为它有效期很短。当rtoken丢失之后也没关系，因为他需要配合client-sercet才能使用。

客户端与服务端基于无感刷新流程图

GoLang jwt无感刷新与SSO单点登录限制解除的方法是什么

golang实现atoken和rtoken

引入jwt库 go get -u github.com/golang-jwt/jwt/v4

颁发token

// GenToken 颁发token access token 和 refresh token
func GenToken(UserID int64, Username string) (atoken, rtoken string, err error) {
	rc := jwt.RegisteredClaims{
		ExpiresAt: getJWTTime(ATokenExpiredDuration),
		Issuer:    TokenIssuer,
	}
	at := MyClaim{
		UserID,
		Username,
		rc,
	}
	atoken, err = jwt.NewWithClaims(jwt.SigningMethodHS256, at).SignedString(mySecret)
	// refresh token 不需要保存任何用户信息
	rt := rc
	rt.ExpiresAt = getJWTTime(RTokenExpiredDuration)
	rtoken, err = jwt.NewWithClaims(jwt.SigningMethodHS256, rt).SignedString(mySecret)
	return
}

在验证用户登录之后，根据传入的UID和Uname，生成atoken和rtoken。在颁发token中可以规定token的过期时间

func (t *Token) SignedString(key interface{}) (string, error)
SignedString creates and returns a complete, signed JWT. The token is signed using the SigningMethod specified in the token.

SignedString该方法主要用于token的数字签名

校验token

// VerifyToken 验证Token
func VerifyToken(tokenID string) (*MyClaim, error) {
	var myc = new(MyClaim)
	token, err := jwt.ParseWithClaims(tokenID, myc, keyFunc)
	if err != nil {
		return nil, err
	}
	if !token.Valid {
		return nil, ErrorInvalidToken
	}
	return myc, nil
}

根据传入的token值来判断是否有错误，如果错误为无效，说明token格式不正确。然后校验token是否过期。

无感刷新token

// RefreshToken 通过 refresh token 刷新 atoken
func RefreshToken(atoken, rtoken string) (newAtoken, newRtoken string, err error) {
	// rtoken 无效直接返回
	if _, err = jwt.Parse(rtoken, keyFunc); err != nil {
		return
	}
	// 从旧access token 中解析出claims数据
	var claim MyClaim
	_, err = jwt.ParseWithClaims(atoken, &claim, keyFunc)
	// 判断错误是不是因为access token 正常过期导致的
	v, _ := err.(*jwt.ValidationError)
	if v.Errors == jwt.ValidationErrorExpired {
		return GenToken(claim.UserID, claim.Username)
	}
	return
}

注释已经写得很明白了，会根据旧的atoken和rtoken来返回新token。

完整实现代码

package main
import (
	"errors"
	"time"
	"github.com/golang-jwt/jwt/v4"
)
const (
	ATokenExpiredDuration  = 2 * time.Hour
	RTokenExpiredDuration  = 30 * 24 * time.Hour
	TokenIssuer            = ""
)
var (
	mySecret          = []byte("xxxx")
	ErrorInvalidToken = errors.New("verify Token Failed")
)
type MyClaim struct {
	UserID   int64  `json:"user_id"`
	Username string `json:"username"`
	jwt.RegisteredClaims
}
func getJWTTime(t time.Duration) *jwt.NumericDate {
	return jwt.NewNumericDate(time.Now().Add(t))
}
func keyFunc(token *jwt.Token) (interface{}, error) {
	return mySecret, nil
}
// GenToken 颁发token access token 和 refresh token
func GenToken(UserID int64, Username string) (atoken, rtoken string, err error) {
	rc := jwt.RegisteredClaims{
		ExpiresAt: getJWTTime(ATokenExpiredDuration),
		Issuer:    TokenIssuer,
	}
	at := MyClaim{
		UserID,
		Username,
		rc,
	}
	atoken, err = jwt.NewWithClaims(jwt.SigningMethodHS256, at).SignedString(mySecret)
	// refresh token 不需要保存任何用户信息
	rt := rc
	rt.ExpiresAt = getJWTTime(RTokenExpiredDuration)
	rtoken, err = jwt.NewWithClaims(jwt.SigningMethodHS256, rt).SignedString(mySecret)
	return
}
// VerifyToken 验证Token
func VerifyToken(tokenID string) (*MyClaim, error) {
	var myc = new(MyClaim)
	token, err := jwt.ParseWithClaims(tokenID, myc, keyFunc)
	if err != nil {
		return nil, err
	}
	if !token.Valid {
		err = ErrorInvalidToken
		return nil, err
	}
	return myc, nil
}
// RefreshToken 通过 refresh token 刷新 atoken
func RefreshToken(atoken, rtoken string) (newAtoken, newRtoken string, err error) {
	// rtoken 无效直接返回
	if _, err = jwt.Parse(rtoken, keyFunc); err != nil {
		return
	}
	// 从旧access token 中解析出claims数据
	var claim MyClaim
	_, err = jwt.ParseWithClaims(atoken, &claim, keyFunc)
	// 判断错误是不是因为access token 正常过期导致的
	v, _ := err.(*jwt.ValidationError)
	if v.Errors == jwt.ValidationErrorExpired {
		return GenToken(claim.UserID, claim.Username)
	}
	return
}

SSO(Single Sign On)单用户登录以及无感刷新token

实现思路

因为token是由服务端颁发并且每次用户的操作都要在服务端校验token的有效性。因此两个用户在不同时间段登录同一个账号，那么他们的token肯定会因为时间而有所差别。我们可以将token存放在redis中，与用户ID进行key-value绑定。如果通过userID查询到的token不同，那么说明这个用户的token已经被更换（该账号又被登录了）或者token错误。就需要重新进行登录操作。

实战代码

// parts[1]是获取到的atoken，我们使用之前定义好的解析JWT的函数来解析它
mc, err := jwt.VerifyToken(parts[1])
if err != nil {
    // 如果解析失败，可能是因为token过期，可以进入refreshToken进行判断
   if newAtoken, newRtoken, err := jwt.RefreshToken(parts[1],rtoken); err == nil {
       // 如果无错误，就更新redis中的token
      if err = redis.SetSingleUserToken(mc.Username, newAtoken); err == nil {
          // 这里根据需求返回给前端，由前端进行处理
         c.Writer.Header().Set("newAtoken", newAtoken)
         c.Writer.Header().Set("newRtoken", newRtoken)
         // 如果无错误，请求继续
          c.Next()
      }
   }
    // 这里使用的是gin框架， 如果有错误直接阻止并返回
   c.Abort()
   return
}
// 如果解析成功，就在redis中进行判断，是否单用户登录
// 通过获取redis中的token来校验是否单用户登录
token, err := redis.GetSingleUserToken(mc.Username)
if err != nil {
   serializer.ResponseError(c, e.CodeServerBusy)
   c.Abort()
   return
}

判断过程

请求从前端传来，经过认证中间件进行校验token，如果没有问题就进行redis单用户校验。
如果有问题，可能是token过期。进行无感刷新，如果刷新成功将新token设置在header中，请求继续
如果无感刷新失败请求阻止。