go 进阶 三方库之 jwt-go

一. JWT 基础解释

1. 先了解几个问题

1. JSON数据使用base64url编码,只对JSON数据是先扁平化处理再用64个可读无冲突字符来表达,没有加密效果
2. SHA256的摘要只是为JSON数据生成一个“指纹”,防止被篡改,属于完整性范畴,也无任何加密效果
3. 摘要不等于签名,签名是用私钥加密摘要,默认情况下Token本身并没有任何加密机制,它依赖于HTTPS的通道保密能力,Token增加加密机制需要自行处理

1. 在介绍JWT之前,我们可以先说一下实现用户验证发展的几个步骤

1. 请求接口时使用http协议,http协议本身是一种无状态的协议,用户登录后,下次再次访问接口,无法判断用户身份,
2. 进而提出了Cookie 与Session, cookie是存储在客户端的,如果被截获,可能会出现跨站请求伪造的攻击,session是存在服务端的,但是现在都基于微服务,需要考虑多服务节点情况下session同步问题
3. 后续提出了基于token进行用户身份校验

1. 简单说一下token进行用户身份验证的流程：

1. 客户端使用用户名和密码请求登录, 服务端收到请求，验证用户名和密码
2. 验证成功后,服务端会签发一个token,并将token返回给客户端
3. 客户端收到token后,缓存token,后续向服务端发送请求时在header中携带服务端签发的token
4. 服务端收到请求,先对客户端请求中携带的token进行验证
5. 优点: cookie是无法跨域的,而token由于没有用到cookie(前提是将token放到请求头中)所以跨域后不会存在信息丢失问题,token机制在服务端不需要存储session信息,因为token自身包含了所有登录用户的信息,因此也就不需要session同步,更适用CDN：可以通过内容分发网络请求服务端的所有资料,更适用于移动端:因为移动端不支持cookie, 既然不使用cookie也就无需考虑CSRF

1. 什么是JWT: JWT是JSON Web Token的简称,就是上述流程当中token的一种具体实现方式,通俗地说,JWT的本质就是一个保存了用户信息的Json字符串,然后进行编码后得到一个JWT token,并且这个JWT token带有签名信息,接收后可以校验是否被篡改,所以可以用于在各方之间安全地将信息作为Json对象传输
2. JWT用户认证执行流程

1. 前端将用户信息发送给后端(建议通过SSL加密的传输(HTTPS)，从而避免敏感信息被嗅探)
2. 后端核对用户名和密码成功后,将包含用户信息的数据作为JWT的Payload,将其与JWT Header分别进行Base64编码拼接后签名,形成一个JWT Token,例如lll.zzz.xxx的字符串
3. 后端将Token字符串作为登录成功的结果返回给前端,前端在后续请求接口时将Token放入HTTP请求头中的Authorization属性中(解决XSS和XSRF问题),用户退出登录时删除保存的JWT Token
4. 后端接收到前端请求后先校验Token是否有效,比如检查签名是否正确,是否过期,token的接收方是否是自己等等

1. 说一下JWT的优点

1. 简洁：JWT Token数据量小，传输速度也很快
2. JWT是跨语言的: 因为JWT Token是以JSON加密形式保存在客户端的，所以，原则上任何web形式都支持
3. 不依赖于cookie和session, 不需要在服务端保存会话信息,特别适用于分布式微服务
4. 既然不依赖于cookie和session,可以将token缓存到redis等,就不需要考虑session多服务节点的同步问题,及cookie无法跨域的问题,更适用与单点登录, 移动端

二. JWT Token 组成

1. 前面说过JWT的本质就是一个保存了用户信息的Json字符串,编码后得到的一个JWTtoken,这个JWTtoken带有签名信息,接收后可以校验是否被篡改,那么这个Toke是怎么生成的,组成部分有哪些
2. JWT由3部分组成：Header标头,Payload有效载荷和Signature签名, 在传输的时候,将这3部分分别进行Base64编码后连接形成最终传输的字符串

JWTString=Base64(Header).Base64(Payload).HMACSHA256(base64UrlEncode(header)+"."+base64UrlEncode(payload),secret)

1. JWT Header标头,是用来描述JWT元数据的JSON对象,包含alg属性与typ属性,其中alg表示签名使用的算法,默认为HMAC SHA256(写为HS256), typ属性表示令牌的类型,在JWT令牌统一写为JWT,然后使用Base64URL算法将上述这个JSON对象转换为字符串保存,例如

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

1. Payload有效载荷,是JWT的主体内容部分,也是一个JSON对象,包含需要传递的数据,在JWT中默认有一下七个字段供选择, 这七个预定义字段并不要求强制使用,并且除以上默认字段外,我们还可以自定义私有字段,例如将包含用户信息的数据放到payload中

注意点: 默认情况下JWT只是采用base64算法进行了一次编码,并未加密的,拿到JWT字符串后可以转换回原本的JSON数据,因此不要构建隐私信息字段,比如用户的密码不要保存到JWT中,以防止信息泄露,默认情况下JWT只适合在网络中传输一些非敏感信息

//1.Payload有效载荷默认提供的七个预定义字段,不要求强制使用
iss：发行人
exp：到期时间
sub：主题
aud：用户
nbf：在此之前不可用
iat：发布时间
jti：JWT ID用于标识该JWT

//2.除了预定义的七个字段以外,我们也可以自定义Payload有效载荷字段,例如将包含用户信息的数据放到payload中
{
  "sub": "1234567890",
  "name": "Helen",
  "admin": true
}

1. Signature签名,用来校验数据是否被篡改的,将base64UrlEncode编码后的header和payload两个数据进行拼接后,通过指定的算法与密钥secret进行加密后的一串哈码,并且secret密钥保存在服务器中不对外公开,默认加密算法HMACSHA256(),Signature签名生成公式示例

根据JWT Token中是否存在Signature签名又将JWT分为两类: 不使用Signature签名的JWT称为nonsecure JWT未经过签名,不安全的JWT,其header部分也没有指定签名算法, 使用了Signature签名的通过签名保证jwt不能被他人随意篡改,我们又称为JWS

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

1. 在生成Signature签名时提到了一个secret或secretKey密钥,JWT的密钥或者密钥对,一般统一称为JSON Web Key,也就是JWK,根据对称加密与非对称加密,密钥的使用也有所不同

1. 对称加密中: secretKey指加密密钥,用来生成签名与验签
2. 非对称加密中: secretKey指私钥,只用来生成签名,但是不能用来验签(验签用的是公钥)
3. 对称加密中使用同一个密钥进行加密与解密,因此这时候公钥不能泄漏,因此对称算法只适合服务端内部使用,不适合网络第三方,非对称加密通常服务端有私钥和公钥,使用私钥加密,使用公钥可以解密,相对来说更安全

1. JWT中签名算法有三种：

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

1. 完整的执行逻辑

1. 接收到JWT Token数据后,获取header和payload通过base64解码获取到原数据,在header的alg属性中拿到签名的算法,在payload中获取有效数据
2. signature是对header和payload数据的加密无法解码出原文,用来校验整个token数据是否被篡改
3. 服务端在header中获取到加密算法后,利用该算法加上secret密钥对header,payload两个数据再次进行加密,拿到加密结果后与客户端发送过来的signature进行比对判断是否一致,
4. 注意secret密钥只保存在服务端,而且对于不同的加密算法其含义有所不同,对于MD5类型的摘要加密算法来说secret密钥代表的是盐值

三. jwt-go 使用示例

1. 简单解释

1. 下方代码中实现了一个gin框架
2. 内部提供了登入鉴权的接口/auth,与普通的业务接口/home
3. 前端携带用户信息首先请求/auth接口,接收到请求后,判断该用户是否存在,如果存在会基于jwt,秘钥,生成一个指定时间有效的token响应给调用方
4. 在进行其它业务时,例如调用/home,该接口绑定了一个jwtAuthMiddleware中间件, 接收到请求后,先执行中间件,通过jwt校验用户token是否合法有效,如果不合法则拒绝,或重定向到登入页

import (
	"encoding/base64"
	"errors"
	"fmt"
	"github.com/dgrijalva/jwt-go"
	"net/http"
	"strings"
	"time"

	"github.com/gin-gonic/gin"
)

const TokenExpireDuration = time.Hour * 2

var Secret = []byte("秘钥吗?")

type UserInfo struct {
	UserName string `json:"user_name" form:"user_name"`
	PassWord string `json:"pass_word" form:"pass_word"`
}

type MyClaims struct {
	UserName string
	jwt.StandardClaims
}

//登录鉴权函数
func authHandler(c *gin.Context) {
	//1.接收请求中的用户信息
	user := &UserInfo{}
	err := c.ShouldBindJSON(user)
	if err != nil {
		c.JSON(200, gin.H{"code": 2001, "msg": "invalid params"})
		return
	}

	//2.模拟校验判断该用户是否存在
	if user.UserName != "aaa" || user.PassWord != "123qwd" {
		c.JSON(200, gin.H{"code": 2002, "msg": "鉴权失败"})
		return
	}

	//3.存在,通过jwt,生成token签名,并响应
	cla := MyClaims{
		user.UserName,
		jwt.StandardClaims{
			ExpiresAt: time.Now().Add(TokenExpireDuration).Unix(), // 过期时间
			Issuer:    "lx-jwt",                                   // 签发人
		},
	}
	token := jwt.NewWithClaims(jwt.SigningMethodHS256, cla)
	//进行签名生成对应的token
	tokenString, _ := token.SignedString(Secret)
	c.JSON(200, gin.H{"code": 0, "msg": "success", "data": gin.H{"token": tokenString}})
	return
}

//中间件,认证token合法性
func jwtAuthMiddleware() gin.HandlerFunc {
	return func(c *gin.Context) {
		authHandler := c.Request.Header.Get("authorization")
		if authHandler == "" {
			c.JSON(200, gin.H{"code": 2003, "msg": "请求头部auth为空"})
			c.Abort()
			return
		}

		// 前两部门可以直接解析出来
		jwt := strings.Split(authHandler, ".")
		cnt := 0
		for _, val := range jwt {
			cnt++
			if cnt == 3 {
				break
			}
			msg, _ := base64.StdEncoding.DecodeString(val)
			fmt.Println("val ->", string(msg))
		}

		//调用下方自己实现的token解析函数,并且在判断token是否过期
		mc, err := ParseToken(authHandler)
		if err != nil {
			fmt.Println("err = ", err.Error())
			c.JSON(http.StatusOK, gin.H{
				"code": 2005,
				"msg":  "无效的Token",
			})
			c.Abort()
			return
		}

		// 将当前请求的username信息保存到请求的上下文c上
		c.Set("username", mc.UserName)
		c.Next() // 后续的处理函数可以用过c.Get("username")来获取当前请求的用户信息
	}
}

// parse token
func ParseToken(tokenString string) (*MyClaims, error) {
	token, err := jwt.ParseWithClaims(tokenString, &MyClaims{}, func(token *jwt.Token) (interface{}, error) {
		return Secret, nil
	})
	if err != nil {
		return nil, err
	}
	if claims, ok := token.Claims.(*MyClaims); ok && token.Valid {
		return claims, nil
	}
	return nil, errors.New("invalid token")
}

func main() {
	r := gin.Default()
	//1.登入鉴权接口,调用authHandler,对用户信息进行校验,校验通过通过jwt生成的token并返回
	r.POST("/auth", authHandler)
	//2.普通接口,该接口注册了一个jwtAuthMiddleware中间件
	//在中间件中会获取用户token,基于jwt校验是否合法,合法放行,否则拒绝
	r.GET("/home", jwtAuthMiddleware(), homeHandler)
	r.Run(":8080")
}

//普通业务接口
func homeHandler(c *gin.Context) {
	username := c.MustGet("username").(string)
	c.JSON(http.StatusOK, gin.H{
		"code": 2000,
		"msg":  "success",
		"data": gin.H{"username": username},
	})
}