nodejs express-jwt解析

作用是什么

---

express-jwt是nodejs的一个中间件，他来验证指定http请求的JsonWebTokens的有效性，如果有效就将JsonWebTokens的值设置到req.user里面，然后路由到相应的router。 此模块允许您使用Node.js应用程序中的JWT令牌来验证HTTP请求。 JWT通常用于保护API端点。

express-jwt和jsonwebtoken是什么关系

---

express-jwt内部引用了jsonwebtoken，对其封装使用。 在实际的项目中这两个都需要引用，他们两个的定位不一样。jsonwebtoken是用来生成token给客户端的，express-jwt是用来验证token的。

如何使用

---

安装

npm install express-jwt

设置需要保护的API

var expressJWT = require('express-jwt');

var secretOrPrivateKey = "hello  BigManing"  //加密token 校验token时要使用
app.use(expressJWT({
    secret: secretOrPrivateKey   
}).unless({
    path: ['/getToken']  //除了这个地址，其他的URL都需要验证
}));

校验token失败时的处理

app.use(function (err, req, res, next) {
  if (err.name === 'UnauthorizedError') {   
      //  这个需要根据自己的业务逻辑来处理（ 具体的err值 请看下面）
    res.status(401).send('invalid token...');
  }
});

1. token过期时的err值：

   {
       "name": "UnauthorizedError",
       "message": "jwt expired",
       "code": "invalid_token",
       "status": 401,
       "inner": {
           "name": "TokenExpiredError",
           "message": "jwt expired",
           "expiredAt": "2017-08-03T10:08:44.000Z"
       }
   }

2. token无效时的err值：

   {
       "name": "UnauthorizedError",
       "message": "invalid signature",
       "code": "invalid_token",
       "status": 401,
       "inner": {
           "name": "JsonWebTokenError",
           "message": "invalid signature"
       }
   }

定义返回给客户端token的接口

var jwt = require('jsonwebtoken');

//  何时返回token  要根据自己的业务逻辑
app.get('/getToken', function (req, res) {
    res.json({
        result: 'ok',
        token: jwt.sign({
            name: "BinMaing",
            data: "============="
        }, secretOrPrivateKey, {
                expiresIn: 60 * 1
            })
    })
});

带着token访问/getData接口

// 访问这个地址  ， token 要放到 authorization 这个header里，
// 对应的值以Bearer开头然后空一格，接近着是token值。为什么会这样，请看下面后续。
app.get('/getData', function (req, res) {
            res.send(req.user)
});

查看返回的结果：

{
    "name": "BinMaing",
    "data": "=============",
    "iat": 1501814188,
    "exp": 1501814248
}

后续

客户端携带token正确的姿势

放到 authorization 这个header里， 对应的值以Bearer开头然后空一格

authorization:Bearer eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJuYW1lIjoiQmluTWFpbmciLCJkYXRhIjoiPT09PT09PT09PT09PSIsImlhdCI6MTUwMTgxNDE4OCwiZXhwIjoxNTAxODE0MjQ4fQ.GoxGlc6E02W5VvqDNawaOrj3MPO-4UYeFdngKR4bVTE

为什么会这样携带token，请看express-jwt源码里是如何获取token的：

//1 从options中获取token  这个忽略  因为 在设置 需要保护的API 时 并没有传递 getToken 这个方法
 if (options.getToken && typeof options.getToken === 'function') {
      try {
        token = options.getToken(req);
      } catch (e) {
        return next(e);
      }
      //2 从authorization中获取token
    } else if (req.headers && req.headers.authorization) {
      // --这是关键代码-----开始切割--------->
      var parts = req.headers.authorization.split(' '); 
      if (parts.length == 2) {
        var scheme = parts[0];
        var credentials = parts[1];

        if (/^Bearer$/i.test(scheme)) {
          token = credentials; // <-------最终获取到token---------          
        } else {
          if (credentialsRequired) {
            return next(new UnauthorizedError('credentials_bad_scheme', { message: 'Format is Authorization: Bearer [token]' }));
          } else {
            return next();
          }
        }
        //3 以上两个途径都没有token时 就报错呗
      } else {
        return next(new UnauthorizedError('credentials_bad_format', { message: 'Format is Authorization: Bearer [token]' }));
      }
    }

express-jwt 作为中间件都做了什么

总体流程：

Created with Raphaël 2.1.0 前端访问/getData URL express-jwt中间件 是否携带了token？ 验证token是否成功 后台 /getData 逻辑 结束 yes no yes no

源码赏析（）：

var middleware = function(req, res, next) {
    var token;
    // 1 请求method为 options时的处理
    if (req.method === 'OPTIONS' && req.headers.hasOwnProperty('access-control-request-headers')) {
      var hasAuthInAccessControl = !!~req.headers['access-control-request-headers']
                                    .split(',').map(function (header) {
                                      return header.trim();
                                    }).indexOf('authorization');

      if (hasAuthInAccessControl) {
        return next();
      }
    }
  //2  获取token（上面已经解释过了）
    if (options.getToken && typeof options.getToken === 'function') {
      try {
        token = options.getToken(req);
      } catch (e) {
        return next(e);
      }
    } else if (req.headers && req.headers.authorization) {
      var parts = req.headers.authorization.split(' ');
      if (parts.length == 2) {
        var scheme = parts[0];
        var credentials = parts[1];

        if (/^Bearer$/i.test(scheme)) {
          token = credentials;
        } else {
          if (credentialsRequired) {
            return next(new UnauthorizedError('credentials_bad_scheme', { message: 'Format is Authorization: Bearer [token]' }));
          } else {
            return next();
          }
        }
      } else {
        return next(new UnauthorizedError('credentials_bad_format', { message: 'Format is Authorization: Bearer [token]' }));
      }
    }

    if (!token) {
      if (credentialsRequired) {
        return next(new UnauthorizedError('credentials_required', { message: 'No authorization token was found' }));
      } else {
        return next();
      }
    }

 // 3 解码 token
    var dtoken;
    try {
      dtoken = jwt.decode(token, { complete: true }) || {};
    } catch (err) {
      return next(new UnauthorizedError('invalid_token', err));
    }

// 4 依次执行下面操作
    async.waterfall([
     // 获取我们传递 secret
      function getSecret(callback){
        var arity = secretCallback.length;
        if (arity == 4) {
          secretCallback(req, dtoken.header, dtoken.payload, callback);
        } else { // arity == 3
          secretCallback(req, dtoken.payload, callback);
        }
      },
      // 用secret验证token  这段代码是不是很熟悉  没错 就是调用了jsonwebtoken验证token的方法 
      function verifyToken(secret, callback) {
        jwt.verify(token, secret, options, function(err, decoded) {
          if (err) {
            callback(new UnauthorizedError('invalid_token', err));
          } else {
            callback(null, decoded);
          }
        });
      },
      // 检查token 是否被注销了  这个是express-jwt的功能
      function checkRevoked(decoded, callback) {
        isRevokedCallback(req, dtoken.payload, function (err, revoked) {
          if (err) {
            callback(err);
          }
          else if (revoked) {
            callback(new UnauthorizedError('revoked_token', {message: 'The token has been revoked.'}));
          } else {
            callback(null, decoded);
          }
        });
      }
// 最终的结果汇集到这里了 
    ], function (err, result){
      if (err) { return next(err); }  // 有错误 直接就返回了
      if (_resultProperty) {
        set(res, _resultProperty, result);
      } else {
        set(req, _requestProperty, result);
      }
      next();  // 没问题  就流转到对应的url 逻辑操作里面
    });
  };

express-jwt 与jsonwebtoken

express-jwt是对jsonwebtoken进行了封装，在验证策略方面做了很多扩展，具体扩展请看这里。如果你的验证策略很简单，使用jsonwebtoken就足够了，如下面事例：

// 自定义 验证策略 中间件
app.use(function(req, res, next) {
// 定义 不用token 的api
    if (req.originalUrl.indexOf('/getToken') >= 0) {
        return next();
    }
//定义 用token的api  对其验证
     var token = rq.body.token || rq.query.token || rq.headers["x-access-token"];
    jwt.verify(token, "secretOrPrivateKey", function(err, decoded) {
        if (err) {
            // 返回错误信息
            res.send({
                success: false,
                message: 'Failed to authenticate token. Make sure to include the ' +
                    'token returned from /users call in the authorization header ' +
                    ' as a Bearer token'
            });
            return;
        } else {
            // 解析必要的数据（相应字段为定义token时的字段）
            req.username = decoded.username;
            req.orgname = decoded.orgName;
            logger.debug(util.format('Decoded from JWT token: username - %s, orgname - %s', decoded.username, decoded.orgName));
            // 跳出中间件
            return next();
        }
    });
});