Iris jwt 使用

jwt分为三个部分：

​ 1、header，用来存储算法和token类型等信息
​ 2、payload， 一些简单的信息
​ 3、签名，来验证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)
    }

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

    2、获取完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认证也可以。

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

设置token的过程：
    1、生成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"))
}