1. module passport-jwt
   1. function passport-jwt.Strategy (options, verify)
   2. function passport-jwt.Strategy.super_ ()
   3. object passport-jwt.ExtractJwt
   4. object passport-jwt.Strategy.prototype
   5. object passport-jwt.Strategy.super_.prototype
2. module passport-jwt.ExtractJwt
   1. function passport-jwt.ExtractJwt.fromAuthHeader ()
   2. function passport-jwt.ExtractJwt.fromAuthHeaderWithScheme (auth_scheme)
   3. function passport-jwt.ExtractJwt.fromBodyField (field_name)
   4. function passport-jwt.ExtractJwt.fromExtractors (extractors)
   5. function passport-jwt.ExtractJwt.fromHeader (header_name)
   6. function passport-jwt.ExtractJwt.fromUrlQueryParameter (param_name)
   7. function passport-jwt.ExtractJwt.versionOneCompatibility (options)
3. module passport-jwt.Strategy
   1. function passport-jwt.Strategy (options, verify)
   2. function passport-jwt.Strategy.JwtVerifier (token, secretOrKey, options, callback)
   3. function passport-jwt.Strategy.super_ ()
4. module passport-jwt.Strategy.prototype
   1. function passport-jwt.Strategy.prototype.authenticate (req, options)
5. module passport-jwt.Strategy.super_
   1. function passport-jwt.Strategy.super_ ()
   2. function passport-jwt.Strategy.super_.Strategy ()
6. module passport-jwt.Strategy.super_.prototype
   1. function passport-jwt.Strategy.super_.prototype.authenticate (req, options)

module passport-jwt

function passport-jwt.Strategy (options, verify)

• description and source-code

  function JwtStrategy(options, verify) {
  
      passport.Strategy.call(this);
      this.name = 'jwt';
  
      this._secretOrKey = options.secretOrKey;
      if (!this._secretOrKey) {
          throw new TypeError('JwtStrategy requires a secret or key');
      }
  
      this._verify = verify;
      if (!this._verify) {
          throw new TypeError('JwtStrategy requires a verify callback');
      }
  
      this._jwtFromRequest = options.jwtFromRequest;
      if (!this._jwtFromRequest) {
          throw new TypeError('JwtStrategy requires a function to retrieve jwt from requests (see option jwtFromRequest)');
      }
  
      this._passReqToCallback = options.passReqToCallback;
      this._verifOpts = {};
  
      if (options.issuer) {
          this._verifOpts.issuer = options.issuer;
      }
  
      if (options.audience) {
          this._verifOpts.audience = options.audience;
      }
  
      if (options.algorithms) {
          this._verifOpts.algorithms = options.algorithms;
      }
  
      if (options.ignoreExpiration != null) {
          this._verifOpts.ignoreExpiration = options.ignoreExpiration;
      }
  
  }

• example usage

  n/a

function passport-jwt.Strategy.super_ ()

• description and source-code

  function Strategy() {
  }

• example usage

  n/a

module passport-jwt.ExtractJwt

function passport-jwt.ExtractJwt.fromAuthHeader ()

• description and source-code

  fromAuthHeader = function () {
      return extractors.fromAuthHeaderWithScheme(DEFAULT_AUTH_SCHEME);
  }

• example usage

  ...
  An example configuration which reads the JWT from the http
  Authorization header with the scheme 'JWT':
  
  ```js
  var JwtStrategy = require('passport-jwt').Strategy,
  ExtractJwt = require('passport-jwt').ExtractJwt;
  var opts = {}
  opts.jwtFromRequest = ExtractJwt.fromAuthHeader();
  opts.secretOrKey = 'secret';
  opts.issuer = "accounts.examplesoft.com";
  opts.audience = "yoursite.net";
  passport.use(new JwtStrategy(opts, function(jwt_payload, done) {
  User.findOne({id: jwt_payload.sub}, function(err, user) {
      if (err) {
          return done(err, false);
  ...

function passport-jwt.ExtractJwt.fromAuthHeaderWithScheme (auth_scheme)

• description and source-code

  fromAuthHeaderWithScheme = function (auth_scheme) {
      return function (request) {
  
          var token = null;
          if (request.headers[AUTH_HEADER]) {
              var auth_params = auth_hdr.parse(request.headers[AUTH_HEADER]);
              if (auth_params && auth_scheme === auth_params.scheme) {
                  token = auth_params.value;
              }
          }
          return token;
      };
  }

• example usage

  ...
      return token;
  };
  };
  
  
  
  extractors.fromAuthHeader = function () {
  return extractors.fromAuthHeaderWithScheme(DEFAULT_AUTH_SCHEME);
  };
  
  
  extractors.fromExtractors = function(extractors) {
  if (!Array.isArray(extractors)) {
      throw new TypeError('extractors.fromExtractors expects an array')
  }
  ...

function passport-jwt.ExtractJwt.fromBodyField (field_name)

• description and source-code

  fromBodyField = function (field_name) {
      return function (request) {
          var token = null;
          if (request.body && Object.prototype.hasOwnProperty.call(request.body, field_name)) {
              token = request.body[field_name];
          }
          return token;
      };
  }

• example usage

  ...
  queryParam = options.tokenQueryParameterName || 'auth_token';
  
      return function (request) {
  var authHeaderExtractor = extractors.fromAuthHeaderWithScheme(authScheme);
  var token =  authHeaderExtractor(request);
  
  if (!token) {
      var bodyExtractor = extractors.fromBodyField(bodyField);
      token = bodyExtractor(request);
  }
  
  if (!token) {
      var queryExtractor = extractors.fromUrlQueryParameter(queryParam);
      token = queryExtractor(request);
  }
  ...

function passport-jwt.ExtractJwt.fromExtractors (extractors)

• description and source-code

  fromExtractors = function (extractors) {
      if (!Array.isArray(extractors)) {
          throw new TypeError('extractors.fromExtractors expects an array')
      }
  
      return function (request) {
          var token = null;
          var index = 0;
          while(!token && index < extractors.length) {
              token = extractors[index].call(this, request);
              index ++;
          }
          return token;
      }
  }

• example usage

  ...
  
      });
  
      describe('fromExtractors', function() {
  
  it('should raise a type error when the extractor is constructed with a non-array argument', function() {
      this_should_throw = function() {
          var extractor = extract_jwt.fromExtractors({})
      }
  
      expect(this_should_throw).to.throw(TypeError)
  });
  
  
  var extractor = extract_jwt.fromExtractors([extract_jwt.fromAuthHeader(), extract_jwt.fromHeader('authorization')]);
  ...

function passport-jwt.ExtractJwt.fromHeader (header_name)

• description and source-code

  fromHeader = function (header_name) {
      return function (request) {
          var token = null;
          if (request.headers[header_name]) {
              token = request.headers[header_name];
          }
          return token;
      };
  }

• example usage

  ...
  var extract_jwt = require('../lib/extract_jwt'),
      Request = require('./mock_request');
  
  describe('Token extractor', function() {
  
      describe('fromHeader', function() {
  
          var extractor = extract_jwt.fromHeader('test_header');
  
          it('should return null no when token is present', function() {
  var req = new Request();
  
  var token = extractor(req);
  
  expect(token).to.be.null;
  ...

function passport-jwt.ExtractJwt.fromUrlQueryParameter (param_name)

• description and source-code

  fromUrlQueryParameter = function (param_name) {
      return function (request) {
          var token = null,
              parsed_url = url.parse(request.url, true);
          if (parsed_url.query && Object.prototype.hasOwnProperty.call(parsed_url.query, param_name)) {
              token = parsed_url.query[param_name];
          }
          return token;
      };
  }

• example usage

  ...
  
          if (!token) {
              var bodyExtractor = extractors.fromBodyField(bodyField);
              token = bodyExtractor(request);
          }
  
          if (!token) {
              var queryExtractor = extractors.fromUrlQueryParameter(queryParam);
              token = queryExtractor(request);
          }
  
          return token;
      };
  }
  ...

function passport-jwt.ExtractJwt.versionOneCompatibility (options)

• description and source-code

  versionOneCompatibility = function (options) {
      var authScheme = options.authScheme || DEFAULT_AUTH_SCHEME,
          bodyField = options.tokenBodyField || 'auth_token',
          queryParam = options.tokenQueryParameterName || 'auth_token';
  
      return function (request) {
          var authHeaderExtractor = extractors.fromAuthHeaderWithScheme(authScheme);
          var token =  authHeaderExtractor(request);
  
          if (!token) {
              var bodyExtractor = extractors.fromBodyField(bodyField);
              token = bodyExtractor(request);
          }
  
          if (!token) {
              var queryExtractor = extractors.fromUrlQueryParameter(queryParam);
              token = queryExtractor(request);
          }
  
          return token;
      };
  }

• example usage

  ...
  
  Identical behavior can be achieved under v2 with the versionOneCompatibility extractor:
  
  ```js
  var JwtStrategy = require('passport-jwt').Strategy,
      ExtractJwt = require('passport-jwt').ExtractJwt;
  var opts = {}
  opts.jwtFromRequest = ExtractJwt.versionOneCompatibility({ tokenBodyField = "MY_CUSTOM_BODY_FIELD
  " });
  opts.opts.secretOrKey = 'secret';
  opts.issuer = "accounts.examplesoft.com";
  opts.audience = "yoursite.net";
  passport.use(new JwtStrategy(opts, verifyFunction));
  ```
  ...

module passport-jwt.Strategy

function passport-jwt.Strategy (options, verify)

• description and source-code

  function JwtStrategy(options, verify) {
  
      passport.Strategy.call(this);
      this.name = 'jwt';
  
      this._secretOrKey = options.secretOrKey;
      if (!this._secretOrKey) {
          throw new TypeError('JwtStrategy requires a secret or key');
      }
  
      this._verify = verify;
      if (!this._verify) {
          throw new TypeError('JwtStrategy requires a verify callback');
      }
  
      this._jwtFromRequest = options.jwtFromRequest;
      if (!this._jwtFromRequest) {
          throw new TypeError('JwtStrategy requires a function to retrieve jwt from requests (see option jwtFromRequest)');
      }
  
      this._passReqToCallback = options.passReqToCallback;
      this._verifOpts = {};
  
      if (options.issuer) {
          this._verifOpts.issuer = options.issuer;
      }
  
      if (options.audience) {
          this._verifOpts.audience = options.audience;
      }
  
      if (options.algorithms) {
          this._verifOpts.algorithms = options.algorithms;
      }
  
      if (options.ignoreExpiration != null) {
          this._verifOpts.ignoreExpiration = options.ignoreExpiration;
      }
  
  }

• example usage

  n/a

function passport-jwt.Strategy.JwtVerifier (token, secretOrKey, options, callback)

• description and source-code

  JwtVerifier = function (token, secretOrKey, options, callback) {
      return jwt.verify(token, secretOrKey, options, callback);
  }

• example usage

  ...
  var token = self._jwtFromRequest(req);
  
  if (!token) {
      return self.fail(new Error("No auth token"));
  }
  
  // Verify the JWT
  JwtStrategy.JwtVerifier(token, this._secretOrKey, this._verifOpts, function(jwt_err,
  payload) {
      if (jwt_err) {
          return self.fail(jwt_err);
      } else {
          // Pass the parsed token to the user
          var verified = function(err, user, info) {
              if(err) {
                  return self.error(err);
  ...

function passport-jwt.Strategy.super_ ()

• description and source-code

  function Strategy() {
  }

• example usage

  n/a

module passport-jwt.Strategy.prototype

function passport-jwt.Strategy.prototype.authenticate (req, options)

• description and source-code

  authenticate = function (req, options) {
      var self = this;
  
      var token = self._jwtFromRequest(req);
  
      if (!token) {
          return self.fail(new Error("No auth token"));
      }
  
      // Verify the JWT
      JwtStrategy.JwtVerifier(token, this._secretOrKey, this._verifOpts, function(jwt_err, payload) {
          if (jwt_err) {
              return self.fail(jwt_err);
          } else {
              // Pass the parsed token to the user
              var verified = function(err, user, info) {
                  if(err) {
                      return self.error(err);
                  } else if (!user) {
                      return self.fail(info);
                  } else {
                      return self.success(user, info);
                  }
              };
  
              try {
                  if (self._passReqToCallback) {
                      self._verify(req, payload, verified);
                  } else {
                      self._verify(payload, verified);
                  }
              } catch(ex) {
                  self.error(ex);
              }
          }
      });
  }

• example usage

  ...
      }
      return token;
  };
  ```
  
  ### Authenticate requests
  
  Use `passport.authenticate()` specifying `'JWT'` as the strategy.
  
  ```js
  app.post('/profile', passport.authenticate('jwt', { session: false}),
      function(req, res) {
          res.send(req.user.profile);
      }
  );
  ...

module passport-jwt.Strategy.super_

function passport-jwt.Strategy.super_ ()

• description and source-code

  function Strategy() {
  }

• example usage

  n/a

function passport-jwt.Strategy.super_.Strategy ()

• description and source-code

  function Strategy() {
  }

• example usage

  n/a

module passport-jwt.Strategy.super_.prototype

function passport-jwt.Strategy.super_.prototype.authenticate (req, options)

• description and source-code

  authenticate = function (req, options) {
    throw new Error('Strategy#authenticate must be overridden by subclass');
  }

• example usage

  ...
      }
      return token;
  };
  ```
  
  ### Authenticate requests
  
  Use `passport.authenticate()` specifying `'JWT'` as the strategy.
  
  ```js
  app.post('/profile', passport.authenticate('jwt', { session: false}),
      function(req, res) {
          res.send(req.user.profile);
      }
  );
  ...