简介

JSON Web Token(JWT)技术是一种编码字符串或令牌，包含无限的信息，URL安全，用于API身份验证。它是加密签名的。JWT身份验证的最大优点是令牌一旦发送，中间人就无法攻击和修改令牌。主要是JWT用于认证和发送机密信息。JWT使用了不同的算法(如HMAC、RSA)作为私钥/公钥进行数字签名。

JWT结构

  • Header
    • 主要包括算法和token类型，主要是jwt
  • 有效载荷
    • 包含数据信息
  • 签名
    • 它需要标头和有效负载进行编码。它验证令牌不会更改或受到攻击
  1. package main
  3. import (
  4.     "errors"
  5.     "fmt"
  6.     "net/http"
  7.     "os"
  8.     "time"
  10.     "github.com/dgrijalva/jwt-go"
  11.     "github.com/gin-gonic/gin"
  12. )
  14. // Title JWT SERVER
  15. // JWT只能在过期时失效
  16. // JWT过期后需要重新登录，会导致用户体验差，可以通过Redis存储JWT，实现JWT刷新
  17. // JWT可能会被黑客劫持，实现一个一键注销功能，不需要等待过期
  19. /**
  20.  * jwt.StandardClaims 声明
  21.  */
  23. type AuthRoleClaims struct {
  24.     v      interface{}
  25.     Method *JWTMethod
  26.     jwt.StandardClaims
  27. }
  29. type JWTMethod struct {
  30.     ExpiresAt int64
  31.     Issuer    string
  32.     key       string
  33. }
  35. type JWTService interface {
  37.     //生成TOKEN
  38.     GeneratorToken(phone string) string
  40.     //验证TOKEN
  41.     ValidatedToken(jwtToken string) (*jwt.Token, error)
  43.     //刷新TOKEN
  44.     RefreshToken(jwtToken string) (*jwt.Token, error)
  46.     //注销TOKEN
  47.     DeleteToken(jwtToken string) (*jwt.Token, error)
  48. }
  50. // jwt.NewWithClaims 生成JWT
  51. // jwt.NewWithClaims 方法根据 Claims 结构体创建 Token 示例。
  52. // param 1 jwt.SigningMethod {jwt.SigningMethodHS256, HS384, HS512}
  53. // param 2 StandardClaim 自定义类型
  54. /**
  55. type StandardClaims struct {
  56.     Audience  string `json:"aud,omitempty"`
  57.     ExpiresAt int64  `json:"exp,omitempty"`
  58.     Id        string `json:"jti,omitempty"`
  59.     IssuedAt  int64  `json:"iat,omitempty"`
  60.     Issuer    string `json:"iss,omitempty"`
  61.     NotBefore int64 f `json:"nbf,omitempty"`
  62.     Subject   string `json:"sub,omitempty"`
  63. }
  64. */
  66. func (auth *AuthRoleClaims) GeneratorToken() string {
  67.     claims := &AuthRoleClaims{
  68.         v: auth.v,
  69.         StandardClaims: jwt.StandardClaims{
  70.             ExpiresAt: auth.Method.ExpiresAt,
  71.             Issuer:    auth.Method.Issuer,
  72.             IssuedAt:  time.Now().Unix(),
  73.         },
  74.     }
  75.     token := jwt.NewWithClaims(jwt.SigningMethodHS256, claims)
  77.     //编码为String
  78.     jwt, err := token.SignedString([]byte(auth.Method.key))
  79.     if err != nil {
  80.         panic(err)
  81.     }
  82.     return jwt
  83. }
  85. func (auth *JWTMethod) ValidatedToken(jwtToken string) (*jwt.Token, error) {
  86.     return jwt.Parse(jwtToken, func(token *jwt.Token) (interface{}, error) {
  87.         if _, ok := token.Method.(*jwt.SigningMethodHMAC); !ok {
  88.             return nil, fmt.Errorf("Invalid token", token.Header)
  89.         }
  90.         return []byte(jwtToken), nil
  91.     })
  92. }
  94. //全局变量
  95. var (
  96.     START_PORT = "8080"
  97. )
  99. type WebGroup struct {
  100.     Version   uint
  101.     GroupPath string
  102. }
  104. type LoginInfo struct {
  105.     Phone    string `json:"phone"`
  106.     Password string `json:"password"`
  107. }
  109. func ResponseStatus(status int) string {
  110.     switch status {
  111.     case 200:
  112.         return "Success"
  113.     case 400:
  114.         return "User operatal error"
  115.     case 500:
  116.         return "Server Error"
  117.     }
  118.     return ""
  119. }
  121. func LoginServer() gin.HandlerFunc {
  122.     return func(ctx *gin.Context) {
  123.         login := &LoginInfo{}
  124.         if err := ctx.ShouldBindJSON(login); err != nil {
  125.             ctx.JSON(http.StatusBadRequest, gin.H{
  126.                 "msg": ResponseStatus(http.StatusBadRequest)})
  127.         }
  128.         secret := os.Getenv("SECRET")
  129.         if secret == "" {
  130.             ctx.JSON(http.StatusInternalServerError,
  131.                 errors.New("Error"))
  132.         }
  134.         claims := &AuthRoleClaims{
  135.             v: login.Phone,
  136.             Method: &JWTMethod{
  137.                 ExpiresAt: time.Now().Add(time.Second * 5).Unix(),
  138.                 Issuer:    "user",
  139.                 key:       secret,
  140.             },
  141.         }
  142.         token := claims.GeneratorToken()
  144.         ctx.JSON(http.StatusOK, gin.H{
  145.             "jwtToken": token})
  146.     }
  147. }
  149. func RegisterServer() gin.HandlerFunc {
  150.     return func(ctx *gin.Context) {
  151.         register := &LoginInfo{}
  152.         if err := ctx.ShouldBindJSON(register); err != nil {
  153.             ctx.JSON(http.StatusBadRequest, gin.H{
  154.                 "msg": ResponseStatus(http.StatusBadRequest)})
  155.         }
  157.         if len(register.Phone) != 11 || len(register.Password) <= 6 {
  158.             ctx.JSON(http.StatusBadRequest, gin.H{
  159.                 "msg": ResponseStatus(http.StatusBadRequest)})
  160.         }
  162.         ctx.JSON(http.StatusOK, gin.H{
  163.             "msg": ResponseStatus(http.StatusBadRequest)})
  164.     }
  165. }
  167. ///AUTH FUNCTIONS
  168. func InitializeAuthServer(engine *gin.Engine) {
  169.     group := &WebGroup{
  170.         Version:   1,
  171.         GroupPath: "/login",
  172.     }
  173.     v1 := engine.Group(group.GroupPath)
  174.     v1.POST("/login", LoginServer())
  175.     v1.POST("/registher", RegisterServer())
  176. }
  178. func SetupRouter() *gin.Engine {
  179.     //初始化Gin服务
  180.     server := gin.New()
  182.     //注册验证服务
  183.     InitializeAuthServer(server)
  184.     return server
  185. }
  187. func amain() {
  188.     router := SetupRouter()
  189.     router.Run(":" + START_PORT)
  190. }