Iris jwt 使用

jwt分为三个部分：

​ 一、header，用来存储算法和token类型等信息
​ 二、payload， 一些简单的信息
​ 三、签名，来验证token是否合法

iris-jwt

这是初始化jwt中间件的配置参数。

type Config struct {
    ValidationKeyGetter jwt.Keyfunc
    // 用来设置请求中经过那个key获取Token，默认是 "jwt", user := ctx.Values().Get("jwt").(*jwt.Token)
    ContextKey string
    ErrorHandler errorHandler
    CredentialsOptional bool
    Extractor TokenExtractor
    Debug bool
    EnableAuthOnOptions bool
    SigningMethod jwt.SigningMethod
    // 是否验证过时时间，若是为true，则验证Claims中的exp字段。
    Expiration bool
}

初始化jwt中间件：
    jwtHandler := jwtmiddleware.New(jwtmiddleware.Config{
        ValidationKeyGetter: func(token *jwt.Token) (interface{}, error) {
            return []byte("My Secret"), nil
        },
        SigningMethod: jwt.SigningMethodHS256,
    })

使用中间件：
    needauth := app.Party("/auth", jwtHandler.Serve)
    {   // /auth路径下全部的请求都须要jwt验证
        needauth.Get("/ping", myHandler)
    }

验证过程：
    一、token能够设置从Header中获取FromAuthHeader(ctx context.Context)， 也能够从Parameter获取FromParameter(param string) TokenExtractor， 也能够自定义一个，还能够对加密过的token解密等。

    二、获取完token以后，此时token是个字符串，未通过验证，也为未成对象。解析成对象以后，经过keyFun返回的的key验证token，返回token对象。最后执行ctx.Values().Set(m.Config.ContextKey, parsedToken)将解析完的token放到jwt这个key中。
    上面说的keyFun：
    jwtHandler := jwtmiddleware.New(jwtmiddleware.Config{
        ValidationKeyGetter: func(token *jwt.Token) (interface{}, error) {
            return []byte("My Secret"), nil
        },
        SigningMethod: jwt.SigningMethodHS256,
    })
    这个方法接收Token对象，返回一个用于验证token的key。这里会有什么骚操做呢，好像能够拿到Token胡搞一番，返回一个key。做者的目的好像是能够根据token返回不一样的key。
这里可能为了不token被盗，使用动态的key，key值能够经过token的时间来生成， 快过时了从新生成新的key。

每次生成新的token都须要用户名和密码，用户名和密码保存在js中，浏览器关闭，而且token过时后则须要从新登录。即便token被盗，时间也不会过久。
因为js中保存了用户名和密码，即便token过时了，也能从新生成token。

或者使用ip认证也能够。

    三、检查完了以后进入下一个中间件，或者Handler。
    

设置token的过程：
    一、生成token对象，而后签名，完了。
        token := jwt.NewWithClaims(jwt.SigningMethodHS256, jwt.MapClaims{
            "useewhat": "eyJ1c2Vld2hhdCI6IiJ9",
        })
        tokenString, _ := token.SignedString([]byte("My Secret"))
        ctx.Header("Authorization", "bearer "+tokenString)
    
    // Claims也能够是： jwt.StandardClaims
    type StandardClaims struct {
        Audience  string `json:"aud,omitempty"`
        ExpiresAt int64  `json:"exp,omitempty"`
        Id        string `json:"jti,omitempty"`
        IssuedAt  int64  `json:"iat,omitempty"`
        Issuer    string `json:"iss,omitempty"`
        NotBefore int64  `json:"nbf,omitempty"`
        Subject   string `json:"sub,omitempty"`
    }

安全性

因为jwt的payload部分也是可见的，能够把信息加密后再放到Claims中，获取到Claims后，再经过一个中间件解密。
也能够把上面的tokenString的payload部分加密， 收到请求后，自定义一个FromAuthHeader来解密payload部分。

过时时间

处于安全考虑，能够设置一个固定的时间，不进行更新jwt。过时了以后须要从新登录。可能会出现用户用着的时候忽然退出登录的状况。
也能够更新token，不过若是token被盗以后很难回收。由于key是固定的。啊，想到骚操做了。返回上面的文档。

下面是一个写的惨不忍睹的例子：

import (
    "github.com/kataras/iris"

    "github.com/dgrijalva/jwt-go"
    jwtmiddleware "github.com/iris-contrib/middleware/jwt"
)

type Response struct {
    Text string `json:"text"`
}

func main() {
    app := iris.New()

    myHandler := func(ctx iris.Context) {
        user := ctx.Values().Get("jwt").(*jwt.Token)

        ctx.Writef("This is an authenticated request\n")
        ctx.Writef("Claim content:\n")

        ctx.Writef("%s", user.Signature)
    }

    jwtHandler := jwtmiddleware.New(jwtmiddleware.Config{
        ValidationKeyGetter: func(token *jwt.Token) (interface{}, error) {
            return []byte("My Secret"), nil
        },
        SigningMethod: jwt.SigningMethodHS256,
    })

    getjwt := func(ctx iris.Context) {
        token := jwt.NewWithClaims(jwt.SigningMethodHS256, jwt.MapClaims{
            "useewhat": "我已经加过密了，你看不到",
        })

        tokenString, _ := token.SignedString([]byte("My Secret"))
        ctx.Header("Authorization", "bearer "+tokenString)

        response := "Get it"

        ctx.JSON(response)
    }

    needauth := app.Party("/", jwtHandler.Serve)
    {
        needauth.Get("/ping", myHandler)
    }

    app.Get("/getjwt", getjwt)

    app.Run(iris.Addr("localhost:3001"))
}