fastify-jwt-webapp

fastify-jwt-webapp brings the security and simplicity of JSON Web Tokens to your fastify-based web apps, single- and multi-paged "traditional" applications are the target of this plugin, although it does not impose a server-side session to accomplish being "logged-in" from request to request. Rather, a JWT is simply stored in a client-side cookie and retrieved and verified with each request after successful login. This plugin does not assume your knowledge of JWTs themselves, but knowledge of the workflows involved, particularly as it relates to your provider, are assumed. (this plugin uses a /authorize -> authorization_code -> /oauth/token -> JWT-like workflow)

To see fastify-jwt-webapp in the wild check out my website.

Example
- index.js
- config.js
Cookie
Refresh Tokens
JWKS Caching
Options

Example

npm install --save fastify-jwt-webapp

index.js

'use strict'

require('pino-pretty')

const fastify = require('fastify')({
  https: true,
  logger: {
    prettyPrint: true,
    level: 'trace'
  }
})

const fjwt = require('fastify-jwt-webapp')

const config = require('./config')

async function main () {
  // just local TLS
  await fastify.register(require('fastify-tls-keygen'))
  // register the plugin and pass config (from examples/config.js)
  await fastify.register(fjwt, config.fjwt)

  // a homepage with a login link
  fastify.get('/', async function (req, reply) {
    reply
      .type('text/html')
      .send('<a href="/login">Click here to log-in</a>')
  })

  // a protected route that will simply display one's credentials
  fastify.get('/credentials', async function (req, reply) {
    reply.send({
      credentials: req.credentials
    })
  })

  await fastify.listen(8443, 'localhost')
}

main()
  .then(function() {
    console.log('server started')
  })
  .catch(function (err) {
    console.error(err.message)
  })

config.js

'use strict'

const config = {}

config.fjwt = {
  service: 'auth0',
  urlAuthorize: 'https://instance.auth0.com/authorize',
  urlToken: 'https://instance.auth0.com/oauth/token',
  urlJWKS: 'https://instance.auth0.com/.well-known/jwks.json',
  client_id: '',
  client_secret: '',
  redirect_uri: 'https://localhost:8443/callback',
  // the following is optional
  pathSuccessRedirect: '/credentials', // '/' by default
  pathExempt: [
    '/',
    '/login',
    '/callback'
  ], // ['/login', '/callback'] by default
  authorizationCallback: async function (jwtResponse, req, reply) {
    req.log.info('hello from authorizationCallback!')
    req.log.info('jwtResponse: %o', jwtResponse)
  }
}

module.exports = config

Cookie

Being "logged-in" is achieved by passing along the JWT along with each request, as is typical with APIs (via the Authorization header). fastify-jwt-webapp does this by storing the JWT in a cookie (options.cookie.name, "token" by default). By default this cookie is Secure, meaning that it will only be sent by the browser back to your app if the connection is secure. To change this behavior set options.cookie.secure to false. DO NOT DO THIS IN PRODUCTION. YOU HAVE BEEN WARNED. To see cookie options please see lib/config.js.

Refresh Tokens

This plugin does not treat refresh tokens, but there's no reason that you couldn't implement this functionality yourself. #sorrynotsorry

JWKS Caching

Fetching the JWKS is by far the most taxing part of this whole process; often making your request 10x slower, that's just the cost of doing business with JWTs in this context because the JWT needs to be verified on each request, and that entails having the public key, thus fetching the JWKS from options.urlJWKS on every single request. Fortunately, a JWKS doesn't change particularly frequently, fastify-jwt-webapp can cache the JWKS for options.cacheJWKSAge milliseconds, even a value like 10000 (10 seconds) will, in the long-term, add up to much less time spent fetching the JWKS and significantly snappier requests (well, at least until options.cacheJWKSAge milliseconds after the caching request, at which point the cache will be refreshed for another options.cacheJWKSAge milliseconds).

Options

Key		Default	Description
`service`	required	`auth0`	This plugin makes use of "templates" that control the parameters that are sent to the IdP. Can be `auth0` or `o365` right now.
`client_id`	required		Your client ID.
`client_secret`	required		You client secret.
`urlAuthorize`	required		The URL that your IdP uses for login, `https://yourinstance.auth0.com/authorize`, for example.
`urlToken`	required		The URL that your IdP uses for exchanging an `authorization_code` for access token(s), in this case a JWT, `https://yourinstance.auth0.com/oauth/token`, for example.
`urlJWKS`	required		The URL that serves your JWKS, `https://yourinstance.auth0.com/.well-known/jwks.json`, for example.
`cookie.domain`	required	`os.hostname()`	fastify-jwt-webapp works by setting a cookie, so you need to specify the domain for which the cookie will be sent.
`redirect_uri`	required		This is the URL to which an IdP should redirect in order to process the successful authentication, `https://myapp.example.com/callback`, for example.
`pathCallback`		`/callback`	fastify-jwt-webapp creates several endpoints in your application, this is one of them, it processes the stuff that your IdP sends over after successful authentication, by default the endpoint is `/callback`, but you can change that with this parameter. This is very related to the `redirect_uri` option mentioned above.
`pathLogin`		`/login`	This is the second endpoint that fastify-jwt-webapp adds, it redirects to `urlAuthorize` (with some other stuff along the way), it's `/login` by default, but you can change it to anything, it's just aesthetic.
`pathSuccessRedirect`		`/`	Where do you get redirected after successful authentication? `pathSuccessRedirect`, that's where.
`pathExempt`		`['/login', '/callback']`	An array of endpoint paths to be excluded from the actions of the plugin (unauthenticated routes).
`nameCredentialsDecorator`		`credentials`	After successful authentication, the fastify request object will be decorated with the payload of the JWT, you can control that decorator here, `req.theLoggedInUsersInfo` for example.
`authorizationCallback`			`authorizationCallback` is a totally optional function with signature `async function(jwtResponse, request, reply)` that is called after successful authentication, it has absolutely no effect on the plugin's actual functionality.
`cacheJWKSAge`	(disabled)		Will cache the JWKS for `cacheJWKSAge` milliseconds after the first request that needs it.
`redirectOnFail`		`false`	If set to `true` the plugin will redirect to `pathLogin` if a JWT is present, but not valid.

charlesread/fastify-jwt-webapp