GoLang jwt無感重新整理與SSO單點登入限制解除方法詳解

2023-03-31 06:01:50

前言

為什麼使用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實現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
}

判斷過程