I'm a few years late to the discussion, but I was just searching to figure out how to do this myself, as I was expecting that jsonwebtoken would support jwks out-of-the-box... momentarily forgetting that node doesn't have JWK support... duh. :)

Then I started doing research and looking into things based on the comments here and I figure I'll just sum up a few things.

First, I'm a bit of an odd duck in that I work a lot on small devices (and I'm old school), so writing vanilla js and reducing dependencies is more important to me than to most people. I've also become even more dependency-phobic in the wake of the malicious code that was included with npm's most popular projects this past year.

JWK-to-PEM (RSA, ECDSA)

Although there are many libraries out there that do JWK-to-PEM and PEM-to-JWK, they're kinda half-baked (i.e. only do RSA or only do JWK-to-PEM or only public keys) and have huge dependency chains. Because of that I dug into node's new RSA and ECDSA APIs (added mid-v10) a while back and created tiny, lightweight libs that to do this sort of thing in just a few kilobytes, rather than megabytes (due to node's native APIs and barebones ASN.1 handling):

Rasha.js: RSA JWK <-> PEM
Eckles.js: ECDSA JWK <-> PEM

Example:

  // barebones dependencies
  var JWT = require('jsonwebtoken');
  var Eckles = require('eckles'); // EC support
  var Rasha = require('rasha'); // RSA support

  // A wrapper that handles JWKs
  function verifyWithJwk(jwt, jwk) {
    var pem;

    if ('EC' === jwk.kty) {
      pem = Eckles.exportSync({ jwk: jwk });
    } else if ('RSA' === jwk.kty) {
      pem = Rasha.exportSync({ jwk: jwk });
    } else {
      throw new Error("Expected EC or RSA key but got '" + jwk.kty + "'");
    }

    return JWT.verify(jwt, pem);
  }

  // Usage example
  try {
    verifyWithJwk(jwt, jwk);
  } catch(e) {
    throw e;
  }

Example w/ Express:

  var JWT = require('jsonwebtoken');
  var Eckles = require('eckles'); // EC support
  var Rasha = require('rasha'); // RSA support
  var request = require('@coolaj86/urequest'); // 0-dependency API-compatible drop-in for request
  var express = require('express');
  var app = express();

  // same verify function as shown above
  function verifyWithJwk(jwt, jwk) {
    var pem;

    if ('EC' === jwk.kty) {
      pem = Eckles.exportSync({ jwk: jwk });
    } else if ('RSA' === jwk.kty) {
      pem = Rasha.exportSync({ jwk: jwk });
    } else {
      throw new Error("Expected EC or RSA key but got '" + jwk.kty + "'");
    }

    return JWT.verify(jwt, pem);
  }

  app.use('/authorized_endpoint', function (req, res, next) {
    // Grab the token from the headers
    var jwt = (req.headers.authorization||'').replace('Bearer ', '');

    // TODO: we'd want to cache keys so we don't fetch them every time
    request({ url: "https://example.com/oidc/jwks/", json: true }, function (resp) {
      var jwk = resp.body.keys[0];

      try {
        verifyWithJwk(jwt, jwk);
      } catch(e) {
        // express will catch this and show the user an error
        throw e;
      }

      // Let the user know the token is invalid
      res.send({ verified: true });
    });
  });

Because they're so small (and more-or-less complete) I vendor them rather than including them as dependencies. So they do get about 20k+ downloads per week, but directly committed into more popular packages like greenlock and rsa-compat that use them.

OIDC & Auth0 Key Fetching

If you're using the Open ID Connect .well-known/openid-configurations jwks_uri or Auth0's .well-known/jwks.json, or another URL type that follows that format, this is the lightweight solution that will allow you to use both RSA and ECDSA JWKs with jsonwebtoken:

Keyfetch.js: for fetching pure JWKs (ECDSA & RSA) to verify tokens with jsonwebtoken

var keyfetch = require('keyfetch');
var jwt = require('jsonwebtoken');
var auth = "..."; // some JWT
var token = jwt.decode(auth, { json: true, complete: true })
 
if (!isTrustedIssuer(token.payload.iss)) {
  throw new Error("untrusted issuer");
}
 
keyfetch.oidcJwk(
  token.header.kid
, token.payload.iss
).then(function (result) {
  console.log(result.jwk);
  console.log(result.thumprint);
  console.log(result.pem);
 
  jwt.verify(jwt, pem);
});

jwks-rsa

What I like about the jwks-rsa solution is that it is very specific and constructs an RSA public PEM in about the simplest way possible. In that regard it's even lighter than Rasha.js because it handles even fewer cases (and doing the same for ECDSA would not be that hard).

In fact, I'd probably use it myself if it weren't for the dependency on request - it balloons to 5.9M of dependencies across 48 packages. That just seems insane to me for something that can literally be written in ~400 lines of code (actually, it could be much smaller if you didn't need to maintain API compatibility with request as a drop-in replacement).

jwks-ecdsa

This module is built on outdated code that has dependencies which are no longer necessary (except for special use cases that you probably don't have).

It also uses axios rather than request, which is a lot better in the sense that it has very few dependencies (mostly nearly one-liners that could have reasonably been copied rather than depended on). It's still pretty heavy, but much less of a security risk because there are fewer hands in the pot.

Support for JWK #43

Description

Metadata

Metadata

Assignees

Labels

Type

Projects

Milestone

Relationships

Development

Issue actions