Jwt概念
JWT（JSON Web Token）是一个非常轻巧的规范。这个规范允许我们使用JWT在用户和服务器之间传递安全可靠的信息。
一个JWT由3个部分组成：头部(header)、载荷(payload)、签名(signature)。
这三个部分又是由一个分隔符“.” 分割开的。
header
用户说明签名的加密算法等，大概如下：
{
“typ”: “JWT”,
“alg”: “HS256”
}
payload
payload 结构是一个json或者说是map对象
目前有一个相对标准的payload格式
- sub: 该JWT所面向的用户
- iss: 该JWT的签发者
- iat(issued at): 在什么时候签发的token
- exp(expires): token什么时候过期
- nbf(not before)：token在此时间之前不能被接收处理
- jti：JWT ID为web token提供唯一标识
当然你也可以不用这些字段，可以自己随意定义。
signature
签名是由头部和荷载加上一串秘钥，经过头部声明的加密算法加密得到的。因为这个秘钥只有服务端知道，但是这个秘钥一旦泄漏了后果是很严重的。
使用
一般使用方法，则是在登录的时候生成一个token返回到客户端。客户端则可以放到header或者cookie中。每次请求数据的时候带上这个token，而服务端则去验证token是否正确，因为jwt中的秘钥只有服务器知道一旦这个token被别人修改过及时修改过再使用base64编码替换也是可以被发现的，因为签名是把header和payload加起来再么秘钥加密的。如下图：
这样做有几个好处：
- 可以减少请求数据库的次数，不需要每次数据接口请求都去访问数据库验证用户的有效性
- 可以设置过期时间，在payload中有一个字段叫exp。这个字段可以设置过期时间，如果服务端发现过期则需要中心登录或者验证身份。
- 在荷载(payload)中其实是可以作为客户端服务器端的信息交换，但是一般不会用这样的操作
- 服务器不保存session状态，更适合分布式的系统构建。每个请求不用通过hash打到固定的机器上。
但是也带来了一些问题：
- 因为服务器不保存状态，jwt状态是游离状态那么服务器就不能主动的注销。在到期之前这个token始终有效。一般的解决方法则是使用redis记录token，每次请求判断下如果redis中不存在则过期或者不合法。
- JWT中的秘钥一旦被泄漏出去，那么任何人都可以冒充别人请求数据了。
Go 使用Jwt 实现验证
简单的用Gin实现一个http服务端， 一个login接口如果账号密码正确，则为客户端添加cookie。
第二个接口则是请求数据接口，通过auth中间件来验证cookie中的token是否为之前服务端发出去的那个token，这个只有服务端能验证，因为服务端拥有秘钥。
这个是最简单的实现，没有加上上面说的redis验证。
package main
import (
"fmt"
"github.com/dgrijalva/jwt-go"
"github.com/gin-gonic/gin"
"github.com/gomodule/redigo/redis"
"time"
)
const (
SecretKey = "I have login"
)
var redisCoon redis.Conn
func main() {
router := gin.Default()
router.GET("/login", loginHandler)
router.Use(authMiddleware)
router.GET("/getData", getData)
router.Run(":2323")
}
//验证token中间件
func authMiddleware(ctx *gin.Context) {
//从cookie中获取token
if tokenStr, err := ctx.Cookie("token"); err == nil {
//获取验证之后的结果
token, err := parseToken(tokenStr)
if err != nil {
ctx.JSON(200, "token verify error")
}
//如果验证结果是false直接返回token错误我 如果成功则继续下一个handler
if token.Valid {
ctx.Next()
} else {
ctx.JSON(200, "token verify error")
ctx.Abort()
}
} else {
ctx.JSON(200, "no token")
ctx.Abort()
}
}
func getData(ctx *gin.Context) {
ctx.JSON(200, "data")
}
func loginHandler(ctx *gin.Context) {
user := ctx.Query("user")
pwd := ctx.Query("pwd")
if user == "peter" && pwd == "pwd" {
token := CreateToken(user, pwd)
//ctx.Header("Authorization", token)
ctx.SetCookie("token", token, 10, "/", "localhost", false, true)
ctx.JSON(200, "ok")
} else {
ctx.JSON(200, "user is not exit")
}
}
func parseToken(s string) (*jwt.Token, error) {
fn := func(token *jwt.Token) (interface{}, error) {
return []byte(SecretKey), nil
}
return jwt.Parse(s, fn)
}
//创建token
func CreateToken(user, pwd string) string {
token := jwt.New(jwt.SigningMethodHS256)
claims := make(jwt.MapClaims)
claims["user"] = user
// 这边的pwd 不应该放到claims 荷载中不应该有机密的数据
claims["pwd"] = pwd
token.Claims = claims
if tokenString, err := token.SignedString([]byte(SecretKey)); err == nil {
return tokenString
} else {
return ""
}
}源码
其实源码逻辑挺简单的，就是把上述流程简单的实现。
1. jwt主要对象和接口的定义
其中的SigningMethod接口是主要签名的方法，在jwt中有几个预置的签名方法。
其实如果我们自己写一个类并且实现了这个接口，其实也是可以自定义签名方法。
// token结构
type Token struct {
Raw string // 保存原始token解析的时候保存
Method SigningMethod // 保存签名方法 目前库里有HMAC RSA ECDSA
Header map[string]interface{} // jwt中的头部
Claims Claims // jwt中第二部分荷载，Claims是一个借口
Signature string // jwt中的第三部分 签名
Valid bool // 记录token是否正确
}
type Claims interface {
Valid() error
}
// 签名方法 所有的签名方法都会实现这个接口
// 具体可以参考https://github.com/dgrijalva/jwt-go/blob/master/hmac.go
type SigningMethod interface {
// 验证token的签名，如果有限返回nil
Verify(signingString, signature string, key interface{}) error
// 签名方法 接受头部和荷载编码过后的字符串和签名秘钥
// 在hmac中key必须是Key must be []byte
// 在rsa中key 必须是*rsa.PrivateKey 对象
Sign(signingString string, key interface{}) (string, error)
// 返回加密方法的名字 比如'HS256'
Alg() string
}
// 新建token
func New(method SigningMethod) *Token {
return NewWithClaims(method, MapClaims{})
}
func NewWithClaims(method SigningMethod, claims Claims) *Token {
// 组成token
return &Token{
Header: map[string]interface{}{
"typ": "JWT",
"alg": method.Alg(),
},
Claims: claims,
Method: method,
}
}
2. 创建签名
创建签名的逻辑很清晰，下面的注释中已经很清楚了。
// 传入 key 返回token或者error
func (t *Token) SignedString(key interface{}) (string, error) {
var sig, sstr string
var err error
// 生成jwt的前两部分string
if sstr, err = t.SigningString(); err != nil {
return "", err
}
// 根据不同的签名method 生成签名字符串
if sig, err = t.Method.Sign(sstr, key); err != nil {
return "", err
}
return strings.Join([]string{sstr, sig}, "."), nil
}
// 生成jwt的头部和荷载的string
func (t *Token) SigningString() (string, error) {
var err error
parts := make([]string, 2)
// 创建一个字符串数组
for i, _ := range parts {
var jsonValue []byte
if i == 0 {
// 把header部分转成[]byte
if jsonValue, err = json.Marshal(t.Header); err != nil {
return "", err
}
} else {
// 把荷载部分部转成[]byte
if jsonValue, err = json.Marshal(t.Claims); err != nil {
return "", err
}
}
// 为签名编码
parts[i] = EncodeSegment(jsonValue)
}
// 用'.'号拼接两部分然后返回
return strings.Join(parts, "."), nil
}2. 验证签名
有了创建token，就一定有验证token。这个操作一般在服务端的中间件完成。在上面的例子中也可以看到。
// 解析方法的回调函数 方法返回秘钥 可以根据不同的判断返回不同的秘钥
type Keyfunc func(*Token) (interface{}, error)
func Parse(tokenString string, keyFunc Keyfunc) (*Token, error) {
return new(Parser).Parse(tokenString, keyFunc)
}
func ParseWithClaims(tokenString string, claims Claims, keyFunc Keyfunc) (*Token, error) {
return new(Parser).ParseWithClaims(tokenString, claims, keyFunc)
}
func (p *Parser) ParseWithClaims(tokenString string, claims Claims, keyFunc Keyfunc) (*Token, error) {
// 解析tokenstring 根据'.' 风格之后用base64反编码之后组成 token对象
token, parts, err := p.ParseUnverified(tokenString, claims)
if err != nil {
return token, err
}
// 判断parse里的validmethods 是否为空 不为空则循环调用
if p.ValidMethods != nil {
var signingMethodValid = false
var alg = token.Method.Alg()
for _, m := range p.ValidMethods {
if m == alg {
signingMethodValid = true
break
}
}
if !signingMethodValid {
// signing method is not in the listed set
return token, NewValidationError(fmt.Sprintf("signing method %v is invalid", alg), ValidationErrorSignatureInvalid)
}
}
// 调用keyfunc 返回秘钥 方法从之前的调用注入的方法
var key interface{}
if keyFunc == nil {
// keyFunc was not provided. short circuiting validation
return token, NewValidationError("no Keyfunc was provided.", ValidationErrorUnverifiable)
}
if key, err = keyFunc(token); err != nil {
// keyFunc returned an error
if ve, ok := err.(*ValidationError); ok {
return token, ve
}
return token, &ValidationError{Inner: err, Errors: ValidationErrorUnverifiable}
}
vErr := &ValidationError{}
// 判断是否需要验证claims
if !p.SkipClaimsValidation {
// valid 方法中会判断 过期时间、签发人、生效时间 如果没有这3个字段则不判断
if err := token.Claims.Valid(); err != nil {
if e, ok := err.(*ValidationError); !ok {
vErr = &ValidationError{Inner: err, Errors: ValidationErrorClaimsInvalid}
} else {
vErr = e
}
}
}
// 验证jwt中第三部分 签名 调用的是签名方法定义的verify方法
token.Signature = parts[2]
if err = token.Method.Verify(strings.Join(parts[0:2], "."), token.Signature, key); err != nil {
vErr.Inner = err
vErr.Errors |= ValidationErrorSignatureInvalid
}
// 设置valid字段
if vErr.valid() {
token.Valid = true
return token, nil
}
return token, vErr
}总结
上面的源码，只是主要的流程。jwt中还有很多代码上面兵没有列出来，比如rsa，ecdsa的具体实现、claims.go里面也有很多逻辑的判断。有兴趣的话可以再深入研究。
