一. JWT是什么
二. JWT標準規范
三. 核心代碼簡析
四. 登錄授權示例
五. JWT 使用方式
六. JWT注意事項

一. JWT是什么

JSON Web Token（JWT）是目前最流行的跨域身份驗證解決方案，簡單說，OAuth 就是一種授權機制，資料的所有者告訴系統，同意授權第三方應用進入系統，獲取這些資料，系統從而產生一個短期的進入令(token)，用來代替密碼，供第三方應用使用，，

傳統的授權認證方式，需要持久化session資料，寫入資料庫或檔案持久層等，且授權校驗依賴于資料持久層，這樣的方式，對于結構維護成本大，實作單點登錄較為復雜，且沒有分布式架構，無法支持橫向擴展，風險較大(如果持久層失敗，整個認證體系都會掛掉)，

JWT則無須持久化會話資料，是以加密簽名的方式實作了用戶身份認證授權，很好的解決了跨域身份驗證，分布式session共享、單點登錄和橫向擴展等問題，

二. JWT標準規范

JWT由三部分組成，即頭部、負載與簽名，Token格式為 token=頭部+'.'+載荷+'.'+簽名，

{"token":"eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJleHAiOjE1Nzg0MDQ5OTUsImlhdCI6MTU3ODQwMTM5NX0.waG8rvOZLM2pKDeKg7frMKlV8lAty1Og5LDjrVMJRsI"}

1. Header： 用于說明簽名的加密演算法等，下面型別的json經過base64編碼后得到JWT頭部，

{
  "typ": "JWT",
  "alg": "HS256"
}

2. Payload： 標準定義了7個欄位，載荷json經過base64編碼后得到JWT的載荷，

{
  iss (issuer)：簽發人
  exp (expiration time)：過期時間
  sub (subject)：主題
  aud (audience)：受眾
  nbf (Not Before)：生效時間
  iat (Issued At)：簽發時間
  jti (JWT ID)：編號
}

示例：

{
    "sub": "1",
    "iss": "http://localhost:8000/user/sign_up",
    "iat": 1451888119,
    "exp": 1454516119,
    "nbf": 1451888119,
    "jti": "37c107e4609ddbcc9c096ea5ee76c667"
}

3.Signature： 將頭部和載荷用'.'號連接，再加上一串密鑰，經過頭部宣告的加密演算法加密后得到簽名，

HMACSHA256(
    base64UrlEncode(header) + "." +
    base64UrlEncode(payload),
    secret
)

三. 核心代碼簡析

1. 資料結構

// A JWT Token.  Different fields will be used depending on whether you're
// creating or parsing/verifying a token.
type Token struct {
   Raw       string                 // The raw token.  Populated when you Parse a token
   Method    SigningMethod          // The signing method used or to be used
   Header    map[string]interface{} // （頭部）The first segment of the token
   Claims    Claims                 // （負載）The second segment of the token
   Signature string                 // （簽名）The third segment of the token.  Populated when you Parse a token
   Valid     bool                   // Is the token valid?  Populated when you Parse/Verify a token
}

// Structured version of Claims Section, as referenced at
// https://tools.ietf.org/html/rfc7519#section-4.1
// See examples for how to use this with your own claim types
type StandardClaims struct {
   Id        string `json:"jti,omitempty"`  //編號
   Subject   string `json:"sub,omitempty"`  //主題
   Issuer    string `json:"iss,omitempty"`  //簽發人
   Audience  string `json:"aud,omitempty"`  //受眾
   ExpiresAt int64  `json:"exp,omitempty"`  //過期時間
   IssuedAt  int64  `json:"iat,omitempty"` //簽發時間
   NotBefore int64  `json:"nbf,omitempty"`  //生效時間
}

2. 生成Token

var(
   key []byte = []byte("This is secret!")
)
// 產生json web token
func GenToken() string {
   claims := &jwt.StandardClaims{
      NotBefore: int64(time.Now().Unix()),
      ExpiresAt: int64(time.Now().Unix() + 1000),
      Issuer:    "Bitch",
   }

   token := jwt.NewWithClaims(jwt.SigningMethodHS256, claims)
   ss, err := token.SignedString(key)
   if err != nil {
      logs.Error(err)
      return ""
   }
   return ss
}

3. 校驗Token

// 校驗token是否有效
func CheckToken(token string) bool {
   _, err := jwt.Parse(token, func(*jwt.Token) (interface{}, error) {
      return key, nil
   })
   if err != nil {
      fmt.Println("parase with claims failed.", err)
      return false
   }
   return true
}

四. 登錄授權示例

handler/auth.go

package handler

import (
   "fmt"
   "github.com/dgrijalva/jwt-go"
   "github.com/dgrijalva/jwt-go/request"
   "net/http"
)

const (
   SecretKey = "ODcyNDYsIMzY0N"
)

func ValidateTokenMiddleware(w http.ResponseWriter, r *http.Request, next http.HandlerFunc) {
   token, err := request.ParseFromRequest(r, request.AuthorizationHeaderExtractor,
      func(token *jwt.Token) (interface{}, error) {
         return []byte(SecretKey), nil
      })

   if err == nil {
      if token.Valid {
         next(w, r)
      } else {
         w.WriteHeader(http.StatusUnauthorized)
         fmt.Fprint(w, "Token is not valid")
      }
   } else {
      w.WriteHeader(http.StatusUnauthorized)
      fmt.Fprint(w, "Unauthorized access to this resource")
   }
}

handler/account.go

package handler

import (
   "encoding/json"
   "fmt"
   "github.com/dgrijalva/jwt-go"
   "log"
   "net/http"
   "strings"
   "time"
)

func fatal(err error) {
   if err != nil {
      log.Fatal(err)
   }
}

type UserCredentials struct {
   Username string `json:"username"`
   Password string `json:"password"`
}

type User struct {
   ID       int    `json:"id"`
   Name     string `json:"name"`
   Username string `json:"username"`
   Password string `json:"password"`
}

type Response struct {
   Data string `json:"data"`
}

type Token struct {
   Token string `json:"token"`
}

func LoginHandler(w http.ResponseWriter, r *http.Request) {
   var user UserCredentials
   err := json.NewDecoder(r.Body).Decode(&user)
   if err != nil {
      w.WriteHeader(http.StatusForbidden)
      fmt.Fprint(w, "Error in request")
      return
   }

   if strings.ToLower(user.Username) != "admin" {
      if user.Password != "123456" {
         w.WriteHeader(http.StatusForbidden)
         fmt.Fprint(w, "Invalid credentials")
         return
      }
   }

   // 創建Token
   token := jwt.New(jwt.SigningMethodHS256)
   claims := make(jwt.MapClaims)
   claims["exp"] = time.Now().Add(time.Hour * time.Duration(1)).Unix()
   claims["iat"] = time.Now().Unix()
   token.Claims = claims

   //if err != nil {
   // w.WriteHeader(http.StatusInternalServerError)
   // fmt.Fprintln(w, "Error extracting the key")
   // fatal(err)
   //}

   tokenString, err := token.SignedString([]byte(SecretKey))
   if err != nil {
      w.WriteHeader(http.StatusInternalServerError)
      fmt.Fprintln(w, "Error while signing the token")
      fatal(err)
   }

   response := Token{tokenString}
   JsonResponse(response, w)
}

func FundHandler(w http.ResponseWriter, r *http.Request) {
   response := Response{"賬戶余額：1000W"}
   JsonResponse(response, w)
}

func JsonResponse(response interface{}, w http.ResponseWriter) {
   obj, err := json.Marshal(response)
   if err != nil {
      http.Error(w, err.Error(), http.StatusInternalServerError)
      return
   }

   w.WriteHeader(http.StatusOK)
   w.Header().Set("Content-Type", "application/json")
   w.Write(obj)
}

main.go

import (
   "github.com/codegangsta/negroni"
   "log"
   "net/http"
   "proxy/handler"
)

func Server() {
   http.HandleFunc("/login", handler.LoginHandler)

   http.Handle("/data", negroni.New(
      negroni.HandlerFunc(handler.ValidateTokenMiddleware), //中間件
      negroni.Wrap(http.HandlerFunc(handler.FundHandler)),
   ))

   log.Println("服務已啟動...")
   http.ListenAndServe(":8080", nil)
}

func main() {
   Server()
}

五. JWT 使用方式

客戶端收到服務器回傳的 JWT，可以儲存在 Cookie 里面，也可以儲存在 localStorage，

此后，客戶端每次與服務器通信，都要帶上這個 JWT，你可以把它放在 Cookie 里面自動發送，但是這樣不能跨域，所以更好的做法是放在HTTP請求的頭資訊Authorization欄位里面（或放在POST 請求的資料體里面），

Authorization: Bearer <token>

六. JWT注意事項

JWT默認不加密，但可以加密，生成原始令牌后，可以使用改令牌再次對其進行加密，
JWT不僅可用于認證，還可用于資訊交換，善用JWT有助于減少服務器請求資料庫的次數，
JWT的最大缺點是服務器不保存會話狀態，一旦JWT簽發，在有效期內將會一直有效，
JWT的有效期不宜設定太長，認證資訊，因此一旦資訊泄露，任何人都可以獲得令牌的所有權限，
為了減少JWT資料盜用和竊取的風險，JWT建議使用加密的HTTPS協議進行傳輸，

參考：
http://www.ruanyifeng.com/blog/2019/04/oauth_design.html 關于OAuth2.0
https://blog.csdn.net/wangshubo1989/article/details/74529333
https://blog.csdn.net/idwtwt/article/details/80865209
https://baijiahao.baidu.com/s?id=1608021814182894637&wfr=spider&for=pc
http://www.ruanyifeng.com/blog/2018/07/json_web_token-tutorial.html

轉載請註明出處，本文鏈接：https://www.uj5u.com/houduan/51205.html

標籤：Go

上一篇：Go并發編程