JWT(Golang)

JWT

什么是JWT

token

tokentokencookieheadertoken

tokensession

cookietokencookietokentokensessioncookietokencookie

JWTtokenJSON Web Token

JWT tokenJWT token

POSTJWT TokenJWT Tokenlll.zzz.xxxJWT TokenJWT TokenJWT TokenAuthorizationJWT TokenJWT Token

为什么要用JWT

传统Session认证的弊端

cookiesession

session

sessionsessionsessionsessioncookiecookiesessioncookiecookiecookiecookiesession

JWT认证的优势

session

JWT Token

因为这些优势，目前无论单体应用还是分布式应用，都更加推荐用JWT token的方式进行用户认证

JWT结构

.

1.Header

JWT头是一个描述JWT元数据的JSON对象，alg属性表示签名使用的算法，默认为HMAC SHA256（写为HS256）；typ属性表示令牌的类型，JWT令牌统一写为JWT。最后，使用Base64 URL算法将上述JSON对象转换为字符串保存

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

2.Payload

有效载荷部分，是JWT的主体内容部分，也是一个JSON对象，包含需要传递的数据。 JWT指定七个默认字段供选择

iss：发行人
exp：到期时间
sub：主题
aud：用户
nbf：在此之前不可用
iat：发布时间
jti：JWT ID用于标识该JWT

除以上默认字段外，我们还可以自定义私有字段，一般会把包含用户信息的数据放到payload中，如下例：

{
  "sub": "1234567890",
  "name": "Helen",
  "admin": true
}

请注意，默认情况下JWT是未加密的，因为只是采用base64算法，拿到JWT字符串后可以转换回原本的JSON数据，任何人都可以解读其内容，因此不要构建隐私信息字段，比如用户的密码一定不能保存到JWT中，以防止信息泄露。JWT只是适合在网络中传输一些非敏感的信息

3.Signature

.

headerpayloadheaderpayloadsignatureheadersecretKeyheaderpayloadsecretKeysecretKey

JWT的种类

其实JWT(JSON Web Token)指的是一种规范，这种规范允许我们使用JWT在两个组织之间传递安全可靠的信息，JWT的具体实现可以分为以下几种：

nonsecure JWTJWSJWEpayload

1.nonsecure JWT

header

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

Signature

2.JWS

JWS ，也就是JWT Signature，其结构就是在之前nonsecure JWT的基础上，在头部声明签名算法，并在最后添加上签名。创建签名，是保证jwt不能被他人随意篡改。我们通常使用的JWT一般都是JWS

secretKey

secretKeysecretKey

JWK

到目前为止，jwt的签名算法有三种：

• HMAC【哈希消息验证码(对称)】：HS256/HS384/HS512
• RSASSA【RSA签名算法(非对称)】（RS256/RS384/RS512）
• ECDSA【椭圆曲线数据签名算法(非对称)】（ES256/ES384/ES512）

Go的运用

struct

package main

import (
   "fmt"
   "github.com/dgrijalva/jwt-go"
   "time"
)

type MyClaims struct {
   Username string `json:"username"`
   jwt.StandardClaims
}

func main() {
   mySingingKey := []byte("wiasdsafsd")
   c := MyClaims{
      Username: "jt",
      StandardClaims: jwt.StandardClaims{
         NotBefore: time.Now().Unix() - 60,
         ExpiresAt: time.Now().Unix() + 5,
         Issuer:    "jt",
      },
   }

   t := jwt.NewWithClaims(jwt.SigningMethodHS256, c)
   fmt.Println(t)
   s, err := t.SignedString(mySingingKey)
   if err != nil {
      fmt.Printf("%s", err)
   }
   fmt.Println(s)
   //time.Sleep(6 * time.Second)

   tokern, err := jwt.ParseWithClaims(s, &MyClaims{}, func(token *jwt.Token) (interface{}, error) {
      return mySingingKey, nil
   })
   if err != nil {
      fmt.Println(err)
   }
   fmt.Println(tokern.Claims.(*MyClaims).Username)
}

map

package main

import (
   "fmt"
   "github.com/dgrijalva/jwt-go"
   "time"
)

type MyClaims struct {
   Username string `json:"username"`
   jwt.StandardClaims
}

func main() {
   mySingingKey := []byte("wiasdsafsd")

   t := jwt.NewWithClaims(jwt.SigningMethodHS256, jwt.MapClaims{
      "exp":      time.Now().Unix() + 5,
      "iss":      "jt",
      "nbf":      time.Now().Unix() - 5,
      "username": "my",
   })
   s, err := t.SignedString(mySingingKey)
   if err != nil {
      fmt.Printf("%s", err)
   }
   fmt.Println(s)
   //time.Sleep(6 * time.Second)

   tokern, err := jwt.ParseWithClaims(s, &jwt.MapClaims{}, func(token *jwt.Token) (interface{}, error) {
      return mySingingKey, nil
   })
   if err != nil {
      fmt.Println(err)
   }
   fmt.Println(tokern.Claims.(*jwt.MapClaims))
}

生成解析token

以下是JWT的实际应用示例。主要有两个部分：提供用户名和密码以获取令牌；并根据请求检查该令牌。

在此示例中，我们使用了两个库，即Go中的JWT实现以及将其用作中间件的方式。

最后，在使用此代码之前，您需要将APP_KEY常量更改为机密（理想情况下，该常量将存储在代码库外部），并改进用户名/密码检查中的内容，TokenHandler以检查不仅仅是myusername/ mypassword组合。

下面的代码是gin框架对jwt的封装

package main

import (
    "fmt"
    "net/http"
    "time"

    "github.com/dgrijalva/jwt-go"
    "github.com/gin-gonic/gin"
)

//自定义一个字符串
var jwtkey = []byte("www.topgoer.com")
var str string

type Claims struct {
    UserId uint
    jwt.StandardClaims
}

func main() {
    r := gin.Default()
    r.GET("/set", setting)
    r.GET("/get", getting)
    //监听端口默认为8080
    r.Run(":8080")
}

//颁发token
func setting(ctx *gin.Context) {
    expireTime := time.Now().Add(7 * 24 * time.Hour)
    claims := &Claims{
        UserId: 2,
        StandardClaims: jwt.StandardClaims{
            ExpiresAt: expireTime.Unix(), //过期时间
            IssuedAt:  time.Now().Unix(),
            Issuer:    "127.0.0.1",  // 签名颁发者
            Subject:   "user token", //签名主题
        },
    }
    token := jwt.NewWithClaims(jwt.SigningMethodHS256, claims)
    // fmt.Println(token)
    tokenString, err := token.SignedString(jwtkey)
    if err != nil {
        fmt.Println(err)
    }
    str = tokenString
    ctx.JSON(200, gin.H{"token": tokenString})
}

//解析token
func getting(ctx *gin.Context) {
    tokenString := ctx.GetHeader("Authorization")
    //vcalidate token formate
    if tokenString == "" {
        ctx.JSON(http.StatusUnauthorized, gin.H{"code": 401, "msg": "权限不足"})
        ctx.Abort()
        return
    }

    token, claims, err := ParseToken(tokenString)
    if err != nil || !token.Valid {
        ctx.JSON(http.StatusUnauthorized, gin.H{"code": 401, "msg": "权限不足"})
        ctx.Abort()
        return
    }
    fmt.Println(111)
    fmt.Println(claims.UserId)
}

func ParseToken(tokenString string) (*jwt.Token, *Claims, error) {
    Claims := &Claims{}
    token, err := jwt.ParseWithClaims(tokenString, Claims, func(token *jwt.Token) (i interface{}, err error) {
        return jwtkey, nil
    })
    return token, Claims, err
}