openid-client 4.9.0 → 5.0.2

package/lib/client.js

@@ -1,5 +1,3 @@
-/* eslint-disable max-classes-per-file */
-
 const { inspect } = require('util');
 const stdhttp = require('http');
 const crypto = require('crypto');
@@ -7,10 +5,11 @@ const { strict: assert } = require('assert');
 const querystring = require('querystring');
 const url = require('url');
 
-const { ParseError } = require('got');
 const jose = require('jose');
 const tokenHash = require('oidc-token-hash');
 
+const isKeyObject = require('./helpers/is_key_object');
+const decodeJWT = require('./helpers/decode_jwt');
 const base64url = require('./helpers/base64url');
 const defaults = require('./helpers/defaults');
 const { assertSigningAlgValuesSupport, assertIssuerConfiguration } = require('./helpers/assert');
@@ -22,44 +21,42 @@ const { OPError, RPError } = require('./errors');
 const now = require('./helpers/unix_timestamp');
 const { random } = require('./helpers/generators');
 const request = require('./helpers/request');
-const {
-  CALLBACK_PROPERTIES, CLIENT_DEFAULTS, JWT_CONTENT, CLOCK_TOLERANCE,
-} = require('./helpers/consts');
-const issuerRegistry = require('./issuer_registry');
-const instance = require('./helpers/weak_cache');
+const { CLOCK_TOLERANCE } = require('./helpers/consts');
+const { keystores } = require('./helpers/weak_cache');
+const KeyStore = require('./helpers/keystore');
+const clone = require('./helpers/deep_clone');
 const { authenticatedPost, resolveResponseType, resolveRedirectUri } = require('./helpers/client');
+const { queryKeyStore } = require('./helpers/issuer');
 const DeviceFlowHandle = require('./device_flow_handle');
 
+const [major, minor] = process.version
+  .substr(1)
+  .split('.')
+  .map((str) => parseInt(str, 10));
+
+const rsaPssParams = major >= 17 || (major === 16 && minor >= 9);
+
 function pickCb(input) {
-  return pick(input, ...CALLBACK_PROPERTIES);
+  return pick(
+    input,
+    'access_token', // OAuth 2.0
+    'code', // OAuth 2.0
+    'error', // OAuth 2.0
+    'error_description', // OAuth 2.0
+    'error_uri', // OAuth 2.0
+    'expires_in', // OAuth 2.0
+    'id_token', // OIDC Core 1.0
+    'state', // OAuth 2.0
+    'token_type', // OAuth 2.0
+    'session_state', // OIDC Session Management
+    'response', // FAPI JARM
+  );
 }
 
 function authorizationHeaderValue(token, tokenType = 'Bearer') {
   return `${tokenType} ${token}`;
 }
 
-function cleanUpClaims(claims) {
-  if (Object.keys(claims._claim_names).length === 0) {
-    delete claims._claim_names;
-  }
-  if (Object.keys(claims._claim_sources).length === 0) {
-    delete claims._claim_sources;
-  }
-}
-
-function assignClaim(target, source, sourceName, throwOnMissing = true) {
-  return ([claim, inSource]) => {
-    if (inSource === sourceName) {
-      if (throwOnMissing && source[claim] === undefined) {
-        throw new RPError(`expected claim "${claim}" in "${sourceName}"`);
-      } else if (source[claim] !== undefined) {
-        target[claim] = source[claim];
-      }
-      delete target._claim_names[claim];
-    }
-  };
-}
-
 function verifyPresence(payload, jwt, prop) {
   if (payload[prop] === undefined) {
     throw new RPError({
@@ -93,49 +90,22 @@ function authorizationParams(params) {
   return authParams;
 }
 
-async function claimJWT(label, jwt) {
-  try {
-    const { header, payload } = jose.JWT.decode(jwt, { complete: true });
-    const { iss } = payload;
-
-    if (header.alg === 'none') {
-      return payload;
-    }
-
-    let key;
-    if (!iss || iss === this.issuer.issuer) {
-      key = await this.issuer.queryKeyStore(header);
-    } else if (issuerRegistry.has(iss)) {
-      key = await issuerRegistry.get(iss).queryKeyStore(header);
-    } else {
-      const discovered = await this.issuer.constructor.discover(iss);
-      key = await discovered.queryKeyStore(header);
-    }
-    return jose.JWT.verify(jwt, key);
-  } catch (err) {
-    if (err instanceof RPError || err instanceof OPError || err.name === 'AggregateError') {
-      throw err;
-    } else {
-      throw new RPError({
-        printf: ['failed to validate the %s JWT (%s: %s)', label, err.name, err.message],
-        jwt,
-      });
-    }
-  }
-}
-
 function getKeystore(jwks) {
-  const keystore = jose.JWKS.asKeyStore(jwks);
-  if (keystore.all().some((key) => key.type !== 'private')) {
-    throw new TypeError('jwks must only contain private keys');
+  if (
+    !isPlainObject(jwks) ||
+    !Array.isArray(jwks.keys) ||
+    jwks.keys.some((k) => !isPlainObject(k) || !('kty' in k))
+  ) {
+    throw new TypeError('jwks must be a JSON Web Key Set formatted object');
   }
-  return keystore;
+
+  return KeyStore.fromJWKS(jwks, { onlyPrivate: true });
 }
 
 // if an OP doesnt support client_secret_basic but supports client_secret_post, use it instead
 // this is in place to take care of most common pitfalls when first using discovered Issuers without
 // the support for default values defined by Discovery 1.0
-function checkBasicSupport(client, metadata, properties) {
+function checkBasicSupport(client, properties) {
   try {
     const supported = client.issuer.token_endpoint_auth_methods_supported;
     if (!supported.includes(properties.token_endpoint_auth_method)) {
@@ -147,8 +117,9 @@ function checkBasicSupport(client, metadata, properties) {
 }
 
 function handleCommonMistakes(client, metadata, properties) {
-  if (!metadata.token_endpoint_auth_method) { // if no explicit value was provided
-    checkBasicSupport(client, metadata, properties);
+  if (!metadata.token_endpoint_auth_method) {
+    // if no explicit value was provided
+    checkBasicSupport(client, properties);
   }
 
   // :fp: c'mon people... RTFM
@@ -188,36 +159,71 @@ function getDefaultsForEndpoint(endpoint, issuer, properties) {
   }
 }
 
-class BaseClient {}
-
-module.exports = (issuer, aadIssValidation = false) => class Client extends BaseClient {
-  /**
-   * @name constructor
-   * @api public
-   */
-  constructor(metadata = {}, jwks, options) {
-    super();
+class BaseClient {
+  #metadata;
+  #issuer;
+  #aadIssValidation;
+  #additionalAuthorizedParties;
+  constructor(issuer, aadIssValidation, metadata = {}, jwks, options) {
+    this.#metadata = new Map();
+    this.#issuer = issuer;
+    this.#aadIssValidation = aadIssValidation;
 
     if (typeof metadata.client_id !== 'string' || !metadata.client_id) {
       throw new TypeError('client_id is required');
     }
 
-    const properties = { ...CLIENT_DEFAULTS, ...metadata };
+    const properties = {
+      grant_types: ['authorization_code'],
+      id_token_signed_response_alg: 'RS256',
+      authorization_signed_response_alg: 'RS256',
+      response_types: ['code'],
+      token_endpoint_auth_method: 'client_secret_basic',
+      ...(this.fapi()
+        ? {
+            grant_types: ['authorization_code', 'implicit'],
+            id_token_signed_response_alg: 'PS256',
+            authorization_signed_response_alg: 'PS256',
+            response_types: ['code id_token'],
+            tls_client_certificate_bound_access_tokens: true,
+            token_endpoint_auth_method: undefined,
+          }
+        : undefined),
+      ...metadata,
+    };
+
+    if (this.fapi()) {
+      switch (properties.token_endpoint_auth_method) {
+        case 'self_signed_tls_client_auth':
+        case 'tls_client_auth':
+          break;
+        case 'private_key_jwt':
+          if (!jwks) {
+            throw new TypeError('jwks is required');
+          }
+          break;
+        case undefined:
+          throw new TypeError('token_endpoint_auth_method is required');
+        default:
+          throw new TypeError('invalid or unsupported token_endpoint_auth_method');
+      }
+    }
 
     handleCommonMistakes(this, metadata, properties);
 
     assertSigningAlgValuesSupport('token', this.issuer, properties);
-
     ['introspection', 'revocation'].forEach((endpoint) => {
       getDefaultsForEndpoint(endpoint, this.issuer, properties);
       assertSigningAlgValuesSupport(endpoint, this.issuer, properties);
     });
 
     Object.entries(properties).forEach(([key, value]) => {
-      instance(this).get('metadata').set(key, value);
+      this.#metadata.set(key, value);
       if (!this[key]) {
         Object.defineProperty(this, key, {
-          get() { return instance(this).get('metadata').get(key); },
+          get() {
+            return this.#metadata.get(key);
+          },
           enumerable: true,
         });
       }
@@ -225,20 +231,16 @@ module.exports = (issuer, aadIssValidation = false) => class Client extends Base
 
     if (jwks !== undefined) {
       const keystore = getKeystore.call(this, jwks);
-      instance(this).set('keystore', keystore);
+      keystores.set(this, keystore);
     }
 
-    if (options !== undefined) {
-      instance(this).set('options', options);
+    if (options != null && options.additionalAuthorizedParties) {
+      this.#additionalAuthorizedParties = clone(options.additionalAuthorizedParties);
     }
 
     this[CLOCK_TOLERANCE] = 0;
   }
 
-  /**
-   * @name authorizationUrl
-   * @api public
-   */
   authorizationUrl(params = {}) {
     if (!isPlainObject(params)) {
       throw new TypeError('params must be a plain object');
@@ -253,48 +255,35 @@ module.exports = (issuer, aadIssValidation = false) => class Client extends Base
     return url.format(target);
   }
 
-  /**
-   * @name authorizationPost
-   * @api public
-   */
   authorizationPost(params = {}) {
     if (!isPlainObject(params)) {
       throw new TypeError('params must be a plain object');
     }
     const inputs = authorizationParams.call(this, params);
     const formInputs = Object.keys(inputs)
-      .map((name) => `<input type="hidden" name="${name}" value="${inputs[name]}"/>`).join('\n');
+      .map((name) => `<input type="hidden" name="${name}" value="${inputs[name]}"/>`)
+      .join('\n');
 
     return `<!DOCTYPE html>
 <head>
-  <title>Requesting Authorization</title>
+<title>Requesting Authorization</title>
 </head>
 <body onload="javascript:document.forms[0].submit()">
-  <form method="post" action="${this.issuer.authorization_endpoint}">
-    ${formInputs}
-  </form>
+<form method="post" action="${this.issuer.authorization_endpoint}">
+  ${formInputs}
+</form>
 </body>
 </html>`;
   }
 
-  /**
-   * @name endSessionUrl
-   * @api public
-   */
   endSessionUrl(params = {}) {
     assertIssuerConfiguration(this.issuer, 'end_session_endpoint');
 
-    const {
-      0: postLogout,
-      length,
-    } = this.post_logout_redirect_uris || [];
+    const { 0: postLogout, length } = this.post_logout_redirect_uris || [];
 
-    const {
-      post_logout_redirect_uri = length === 1 ? postLogout : undefined,
-    } = params;
+    const { post_logout_redirect_uri = length === 1 ? postLogout : undefined } = params;
 
     let hint = params.id_token_hint;
-
     if (hint instanceof TokenSet) {
       if (!hint.id_token) {
         throw new TypeError('id_token not present in TokenSet');
@@ -322,26 +311,25 @@ module.exports = (issuer, aadIssValidation = false) => class Client extends Base
     return url.format(target);
   }
 
-  /**
-   * @name callbackParams
-   * @api public
-   */
-  callbackParams(input) { // eslint-disable-line class-methods-use-this
-    const isIncomingMessage = input instanceof stdhttp.IncomingMessage
-      || (input && input.method && input.url);
+  callbackParams(input) {
+    const isIncomingMessage =
+      input instanceof stdhttp.IncomingMessage || (input && input.method && input.url);
     const isString = typeof input === 'string';
 
     if (!isString && !isIncomingMessage) {
-      throw new TypeError('#callbackParams only accepts string urls, http.IncomingMessage or a lookalike');
+      throw new TypeError(
+        '#callbackParams only accepts string urls, http.IncomingMessage or a lookalike',
+      );
     }
-
     if (isIncomingMessage) {
       switch (input.method) {
         case 'GET':
           return pickCb(url.parse(input.url, true).query);
         case 'POST':
           if (input.body === undefined) {
-            throw new TypeError('incoming message body missing, include a body parser prior to this method call');
+            throw new TypeError(
+              'incoming message body missing, include a body parser prior to this method call',
+            );
           }
           switch (typeof input.body) {
             case 'object':
@@ -365,10 +353,6 @@ module.exports = (issuer, aadIssValidation = false) => class Client extends Base
     }
   }
 
-  /**
-   * @name callback
-   * @api public
-   */
   async callback(
     redirectUri,
     parameters,
@@ -423,7 +407,7 @@ module.exports = (issuer, aadIssValidation = false) => class Client extends Base
     };
 
     if (checks.response_type) {
-      for (const type of checks.response_type.split(' ')) { // eslint-disable-line no-restricted-syntax
+      for (const type of checks.response_type.split(' ')) {
         if (type === 'none') {
           if (params.code || params.id_token || params.access_token) {
             throw new RPError({
@@ -433,7 +417,7 @@ module.exports = (issuer, aadIssValidation = false) => class Client extends Base
             });
           }
         } else {
-          for (const param of RESPONSE_TYPE_REQUIRED_PARAMS[type]) { // eslint-disable-line no-restricted-syntax, max-len
+          for (const param of RESPONSE_TYPE_REQUIRED_PARAMS[type]) {
             if (!params[param]) {
               throw new RPError({
                 message: `${param} missing from response`,
@@ -449,7 +433,13 @@ module.exports = (issuer, aadIssValidation = false) => class Client extends Base
     if (params.id_token) {
       const tokenset = new TokenSet(params);
       await this.decryptIdToken(tokenset);
-      await this.validateIdToken(tokenset, checks.nonce, 'authorization', checks.max_age, checks.state);
+      await this.validateIdToken(
+        tokenset,
+        checks.nonce,
+        'authorization',
+        checks.max_age,
+        checks.state,
+      );
 
       if (!params.code) {
         return tokenset;
@@ -457,13 +447,16 @@ module.exports = (issuer, aadIssValidation = false) => class Client extends Base
     }
 
     if (params.code) {
-      const tokenset = await this.grant({
-        ...exchangeBody,
-        grant_type: 'authorization_code',
-        code: params.code,
-        redirect_uri: redirectUri,
-        code_verifier: checks.code_verifier,
-      }, { clientAssertionPayload, DPoP });
+      const tokenset = await this.grant(
+        {
+          ...exchangeBody,
+          grant_type: 'authorization_code',
+          code: params.code,
+          redirect_uri: redirectUri,
+          code_verifier: checks.code_verifier,
+        },
+        { clientAssertionPayload, DPoP },
+      );
 
       await this.decryptIdToken(tokenset);
       await this.validateIdToken(tokenset, checks.nonce, 'token', checks.max_age);
@@ -472,16 +465,24 @@ module.exports = (issuer, aadIssValidation = false) => class Client extends Base
         tokenset.session_state = params.session_state;
       }
 
+      if (tokenset.scope && checks.scope && this.fapi()) {
+        const expected = new Set(checks.scope.split(' '));
+        const actual = tokenset.scope.split(' ');
+        if (!actual.every(Set.prototype.has, expected)) {
+          throw new RPError({
+            message: 'unexpected scope returned',
+            checks,
+            scope: tokenset.scope,
+          });
+        }
+      }
+
       return tokenset;
     }
 
     return new TokenSet(params);
   }
 
-  /**
-   * @name oauthCallback
-   * @api public
-   */
   async oauthCallback(
     redirectUri,
     parameters,
@@ -531,7 +532,7 @@ module.exports = (issuer, aadIssValidation = false) => class Client extends Base
     };
 
     if (checks.response_type) {
-      for (const type of checks.response_type.split(' ')) { // eslint-disable-line no-restricted-syntax
+      for (const type of checks.response_type.split(' ')) {
         if (type === 'none') {
           if (params.code || params.id_token || params.access_token) {
             throw new RPError({
@@ -543,7 +544,7 @@ module.exports = (issuer, aadIssValidation = false) => class Client extends Base
         }
 
         if (RESPONSE_TYPE_REQUIRED_PARAMS[type]) {
-          for (const param of RESPONSE_TYPE_REQUIRED_PARAMS[type]) { // eslint-disable-line no-restricted-syntax, max-len
+          for (const param of RESPONSE_TYPE_REQUIRED_PARAMS[type]) {
             if (!params[param]) {
               throw new RPError({
                 message: `${param} missing from response`,
@@ -557,22 +558,35 @@ module.exports = (issuer, aadIssValidation = false) => class Client extends Base
     }
 
     if (params.code) {
-      return this.grant({
-        ...exchangeBody,
-        grant_type: 'authorization_code',
-        code: params.code,
-        redirect_uri: redirectUri,
-        code_verifier: checks.code_verifier,
-      }, { clientAssertionPayload, DPoP });
+      const tokenset = await this.grant(
+        {
+          ...exchangeBody,
+          grant_type: 'authorization_code',
+          code: params.code,
+          redirect_uri: redirectUri,
+          code_verifier: checks.code_verifier,
+        },
+        { clientAssertionPayload, DPoP },
+      );
+
+      if (tokenset.scope && checks.scope && this.fapi()) {
+        const expected = new Set(checks.scope.split(' '));
+        const actual = tokenset.scope.split(' ');
+        if (!actual.every(Set.prototype.has, expected)) {
+          throw new RPError({
+            message: 'unexpected scope returned',
+            checks,
+            scope: tokenset.scope,
+          });
+        }
+      }
+
+      return tokenset;
     }
 
     return new TokenSet(params);
   }
 
-  /**
-   * @name decryptIdToken
-   * @api private
-   */
   async decryptIdToken(token) {
     if (!this.id_token_encrypted_response_alg) {
       return token;
@@ -606,10 +620,6 @@ module.exports = (issuer, aadIssValidation = false) => class Client extends Base
     return this.validateJWT(body, expectedAlg, []);
   }
 
-  /**
-   * @name decryptJARM
-   * @api private
-   */
   async decryptJARM(response) {
     if (!this.authorization_encrypted_response_alg) {
       return response;
@@ -621,10 +631,6 @@ module.exports = (issuer, aadIssValidation = false) => class Client extends Base
     return this.decryptJWE(response, expectedAlg, expectedEnc);
   }
 
-  /**
-   * @name decryptJWTUserinfo
-   * @api private
-   */
   async decryptJWTUserinfo(body) {
     if (!this.userinfo_encrypted_response_alg) {
       return body;
@@ -636,10 +642,6 @@ module.exports = (issuer, aadIssValidation = false) => class Client extends Base
     return this.decryptJWE(body, expectedAlg, expectedEnc);
   }
 
-  /**
-   * @name decryptJWE
-   * @api private
-   */
   async decryptJWE(jwe, expectedAlg, expectedEnc = 'A128CBC-HS256') {
     const header = JSON.parse(base64url.decode(jwe.split('.')[0]));
 
@@ -657,22 +659,33 @@ module.exports = (issuer, aadIssValidation = false) => class Client extends Base
       });
     }
 
-    let keyOrStore;
-
+    const getPlaintext = (result) => new TextDecoder().decode(result.plaintext);
+    let plaintext;
     if (expectedAlg.match(/^(?:RSA|ECDH)/)) {
-      keyOrStore = instance(this).get('keystore');
+      const keystore = await keystores.get(this);
+
+      for (const { keyObject: key } of keystore.all({
+        ...jose.decodeProtectedHeader(jwe),
+        use: 'enc',
+      })) {
+        plaintext = await jose.compactDecrypt(jwe, key).then(getPlaintext, () => {});
+        if (plaintext) break;
+      }
     } else {
-      keyOrStore = await this.joseSecret(expectedAlg === 'dir' ? expectedEnc : expectedAlg);
+      plaintext = await jose
+        .compactDecrypt(jwe, this.secretForAlg(expectedAlg === 'dir' ? expectedEnc : expectedAlg))
+        .then(getPlaintext, () => {});
     }
 
-    const payload = jose.JWE.decrypt(jwe, keyOrStore);
-    return payload.toString('utf8');
+    if (!plaintext) {
+      throw new RPError({
+        message: 'failed to decrypt JWE',
+        jwt: jwe,
+      });
+    }
+    return plaintext;
   }
 
-  /**
-   * @name validateIdToken
-   * @api private
-   */
   async validateIdToken(tokenSet, nonce, returnedBy, maxAge, state) {
     let idToken = tokenSet;
 
@@ -707,9 +720,14 @@ module.exports = (issuer, aadIssValidation = false) => class Client extends Base
       }
     }
 
-    if (maxAge && (payload.auth_time + maxAge < timestamp - this[CLOCK_TOLERANCE])) {
+    if (maxAge && payload.auth_time + maxAge < timestamp - this[CLOCK_TOLERANCE]) {
       throw new RPError({
-        printf: ['too much time has elapsed since the last End-User authentication, max_age %i, auth_time: %i, now %i', maxAge, payload.auth_time, timestamp - this[CLOCK_TOLERANCE]],
+        printf: [
+          'too much time has elapsed since the last End-User authentication, max_age %i, auth_time: %i, now %i',
+          maxAge,
+          payload.auth_time,
+          timestamp - this[CLOCK_TOLERANCE],
+        ],
         now: timestamp,
         tolerance: this[CLOCK_TOLERANCE],
         auth_time: payload.auth_time,
@@ -724,8 +742,6 @@ module.exports = (issuer, aadIssValidation = false) => class Client extends Base
       });
     }
 
-    const fapi = this.constructor.name === 'FAPIClient';
-
     if (returnedBy === 'authorization') {
       if (!payload.at_hash && tokenSet.access_token) {
         throw new RPError({
@@ -741,7 +757,7 @@ module.exports = (issuer, aadIssValidation = false) => class Client extends Base
         });
       }
 
-      if (fapi) {
+      if (this.fapi()) {
         if (!payload.s_hash && (tokenSet.state || state)) {
           throw new RPError({
             message: 'missing required property s_hash',
@@ -756,14 +772,20 @@ module.exports = (issuer, aadIssValidation = false) => class Client extends Base
         }
 
         try {
-          tokenHash.validate({ claim: 's_hash', source: 'state' }, payload.s_hash, state, header.alg, key && key.crv);
+          tokenHash.validate(
+            { claim: 's_hash', source: 'state' },
+            payload.s_hash,
+            state,
+            header.alg,
+            key.jwk && key.jwk.crv,
+          );
         } catch (err) {
           throw new RPError({ message: err.message, jwt: idToken });
         }
       }
     }
 
-    if (fapi && payload.iat < timestamp - 3600) {
+    if (this.fapi() && payload.iat < timestamp - 3600) {
       throw new RPError({
         printf: ['JWT issued too far in the past, now %i, iat %i', timestamp, payload.iat],
         now: timestamp,
@@ -775,7 +797,13 @@ module.exports = (issuer, aadIssValidation = false) => class Client extends Base
 
     if (tokenSet.access_token && payload.at_hash !== undefined) {
       try {
-        tokenHash.validate({ claim: 'at_hash', source: 'access_token' }, payload.at_hash, tokenSet.access_token, header.alg, key && key.crv);
+        tokenHash.validate(
+          { claim: 'at_hash', source: 'access_token' },
+          payload.at_hash,
+          tokenSet.access_token,
+          header.alg,
+          key.jwk && key.jwk.crv,
+        );
       } catch (err) {
         throw new RPError({ message: err.message, jwt: idToken });
       }
@@ -783,7 +811,13 @@ module.exports = (issuer, aadIssValidation = false) => class Client extends Base
 
     if (tokenSet.code && payload.c_hash !== undefined) {
       try {
-        tokenHash.validate({ claim: 'c_hash', source: 'code' }, payload.c_hash, tokenSet.code, header.alg, key && key.crv);
+        tokenHash.validate(
+          { claim: 'c_hash', source: 'code' },
+          payload.c_hash,
+          tokenSet.code,
+          header.alg,
+          key.jwk && key.jwk.crv,
+        );
       } catch (err) {
         throw new RPError({ message: err.message, jwt: idToken });
       }
@@ -792,17 +826,13 @@ module.exports = (issuer, aadIssValidation = false) => class Client extends Base
     return tokenSet;
   }
 
-  /**
-   * @name validateJWT
-   * @api private
-   */
   async validateJWT(jwt, expectedAlg, required = ['iss', 'sub', 'aud', 'exp', 'iat']) {
     const isSelfIssued = this.issuer.issuer === 'https://self-issued.me';
     const timestamp = now();
     let header;
     let payload;
     try {
-      ({ header, payload } = jose.JWT.decode(jwt, { complete: true }));
+      ({ header, payload } = decodeJWT(jwt, { complete: true }));
     } catch (err) {
       throw new RPError({
         printf: ['failed to decode JWT (%s: %s)', err.name, err.message],
@@ -818,7 +848,7 @@ module.exports = (issuer, aadIssValidation = false) => class Client extends Base
     }
 
     if (isSelfIssued) {
-      required = [...required, 'sub_jwk']; // eslint-disable-line no-param-reassign
+      required = [...required, 'sub_jwk'];
     }
 
     required.forEach(verifyPresence.bind(undefined, payload, jwt));
@@ -826,7 +856,7 @@ module.exports = (issuer, aadIssValidation = false) => class Client extends Base
     if (payload.iss !== undefined) {
       let expectedIss = this.issuer.issuer;
 
-      if (aadIssValidation) {
+      if (this.#aadIssValidation) {
         expectedIss = this.issuer.issuer.replace('{tenantid}', payload.tid);
       }
 
@@ -856,7 +886,11 @@ module.exports = (issuer, aadIssValidation = false) => class Client extends Base
       }
       if (payload.nbf > timestamp + this[CLOCK_TOLERANCE]) {
         throw new RPError({
-          printf: ['JWT not active yet, now %i, nbf %i', timestamp + this[CLOCK_TOLERANCE], payload.nbf],
+          printf: [
+            'JWT not active yet, now %i, nbf %i',
+            timestamp + this[CLOCK_TOLERANCE],
+            payload.nbf,
+          ],
           now: timestamp,
           tolerance: this[CLOCK_TOLERANCE],
           nbf: payload.nbf,
@@ -894,7 +928,11 @@ module.exports = (issuer, aadIssValidation = false) => class Client extends Base
 
         if (!payload.aud.includes(this.client_id)) {
           throw new RPError({
-            printf: ['aud is missing the client_id, expected %s to be included in %j', this.client_id, payload.aud],
+            printf: [
+              'aud is missing the client_id, expected %s to be included in %j',
+              this.client_id,
+              payload.aud,
+            ],
             jwt,
           });
         }
@@ -907,7 +945,7 @@ module.exports = (issuer, aadIssValidation = false) => class Client extends Base
     }
 
     if (payload.azp !== undefined) {
-      let { additionalAuthorizedParties } = instance(this).get('options') || {};
+      let additionalAuthorizedParties = this.#additionalAuthorizedParties;
 
       if (typeof additionalAuthorizedParties === 'string') {
         additionalAuthorizedParties = [this.client_id, additionalAuthorizedParties];
@@ -925,52 +963,55 @@ module.exports = (issuer, aadIssValidation = false) => class Client extends Base
       }
     }
 
-    let key;
+    let keys;
 
     if (isSelfIssued) {
       try {
         assert(isPlainObject(payload.sub_jwk));
-        key = jose.JWK.asKey(payload.sub_jwk);
+        const key = await jose.importJWK(payload.sub_jwk, header.alg);
         assert.equal(key.type, 'public');
+        keys = [{ keyObject: key }];
       } catch (err) {
         throw new RPError({
           message: 'failed to use sub_jwk claim as an asymmetric JSON Web Key',
           jwt,
         });
       }
-      if (key.thumbprint !== payload.sub) {
+      if ((await jose.calculateJwkThumbprint(payload.sub_jwk)) !== payload.sub) {
         throw new RPError({
           message: 'failed to match the subject with sub_jwk',
           jwt,
         });
       }
     } else if (header.alg.startsWith('HS')) {
-      key = await this.joseSecret();
+      keys = [this.secretForAlg(header.alg)];
     } else if (header.alg !== 'none') {
-      key = await this.issuer.queryKeyStore(header);
+      keys = await queryKeyStore.call(this.issuer, { ...header, use: 'sig' });
     }
 
-    if (!key && header.alg === 'none') {
+    if (!keys && header.alg === 'none') {
       return { protected: header, payload };
     }
 
-    try {
-      return {
-        ...jose.JWS.verify(jwt, key, { complete: true }),
-        payload,
-      };
-    } catch (err) {
-      throw new RPError({
-        message: 'failed to validate JWT signature',
-        jwt,
-      });
+    for (const key of keys) {
+      const verified = await jose
+        .compactVerify(jwt, key instanceof Uint8Array ? key : key.keyObject)
+        .catch(() => {});
+      if (verified) {
+        return {
+          payload,
+          protected: verified.protectedHeader,
+          key,
+        };
+      }
     }
+
+    throw new RPError({
+      message: 'failed to validate JWT signature',
+      jwt,
+    });
   }
 
-  /**
-   * @name refresh
-   * @api public
-   */
   async refresh(refreshToken, { exchangeBody, clientAssertionPayload, DPoP } = {}) {
     let token = refreshToken;
 
@@ -981,11 +1022,14 @@ module.exports = (issuer, aadIssValidation = false) => class Client extends Base
       token = token.refresh_token;
     }
 
-    const tokenset = await this.grant({
-      ...exchangeBody,
-      grant_type: 'refresh_token',
-      refresh_token: String(token),
-    }, { clientAssertionPayload, DPoP });
+    const tokenset = await this.grant(
+      {
+        ...exchangeBody,
+        grant_type: 'refresh_token',
+        refresh_token: String(token),
+      },
+      { clientAssertionPayload, DPoP },
+    );
 
     if (tokenset.id_token) {
       await this.decryptIdToken(tokenset);
@@ -1014,15 +1058,24 @@ module.exports = (issuer, aadIssValidation = false) => class Client extends Base
       headers,
       body,
       DPoP,
-      // eslint-disable-next-line no-nested-ternary
-      tokenType = DPoP ? 'DPoP' : accessToken instanceof TokenSet ? accessToken.token_type : 'Bearer',
+      tokenType = DPoP
+        ? 'DPoP'
+        : accessToken instanceof TokenSet
+        ? accessToken.token_type
+        : 'Bearer',
     } = {},
   ) {
     if (accessToken instanceof TokenSet) {
       if (!accessToken.access_token) {
         throw new TypeError('access_token not present in TokenSet');
       }
-      accessToken = accessToken.access_token; // eslint-disable-line no-param-reassign
+      accessToken = accessToken.access_token;
+    }
+
+    if (!accessToken) {
+      throw new TypeError('no access token provided');
+    } else if (typeof accessToken !== 'string') {
+      throw new TypeError('invalid access token provided');
     }
 
     const requestOpts = {
@@ -1035,21 +1088,19 @@ module.exports = (issuer, aadIssValidation = false) => class Client extends Base
 
     const mTLS = !!this.tls_client_certificate_bound_access_tokens;
 
-    return request.call(this, {
-      ...requestOpts,
-      responseType: 'buffer',
-      method,
-      url: resourceUrl,
-    }, { accessToken, mTLS, DPoP });
+    return request.call(
+      this,
+      {
+        ...requestOpts,
+        responseType: 'buffer',
+        method,
+        url: resourceUrl,
+      },
+      { accessToken, mTLS, DPoP },
+    );
   }
 
-  /**
-   * @name userinfo
-   * @api public
-   */
-  async userinfo(accessToken, {
-    method = 'GET', via = 'header', tokenType, params, DPoP,
-  } = {}) {
+  async userinfo(accessToken, { method = 'GET', via = 'header', tokenType, params, DPoP } = {}) {
     assertIssuerConfiguration(this.issuer, 'userinfo_endpoint');
     const options = {
       tokenType,
@@ -1061,9 +1112,7 @@ module.exports = (issuer, aadIssValidation = false) => class Client extends Base
       throw new TypeError('#userinfo() method can only be POST or a GET');
     }
 
-    if (via === 'query' && options.method !== 'GET') {
-      throw new TypeError('userinfo endpoints will only parse query strings for GET requests');
-    } else if (via === 'body' && options.method !== 'POST') {
+    if (via === 'body' && options.method !== 'POST') {
       throw new TypeError('can only send body on POST');
     }
 
@@ -1074,7 +1123,6 @@ module.exports = (issuer, aadIssValidation = false) => class Client extends Base
     } else {
       options.headers = { Accept: 'application/json' };
     }
-
     const mTLS = !!this.tls_client_certificate_bound_access_tokens;
 
     let targetUrl;
@@ -1084,16 +1132,14 @@ module.exports = (issuer, aadIssValidation = false) => class Client extends Base
 
     targetUrl = new url.URL(targetUrl || this.issuer.userinfo_endpoint);
 
-    // when via is not header we clear the Authorization header and add either
-    // query string parameters or urlencoded body access_token parameter
-    if (via === 'query') {
-      options.headers.Authorization = undefined;
-      targetUrl.searchParams.append('access_token', accessToken instanceof TokenSet ? accessToken.access_token : accessToken);
-    } else if (via === 'body') {
+    if (via === 'body') {
       options.headers.Authorization = undefined;
       options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
       options.body = new url.URLSearchParams();
-      options.body.append('access_token', accessToken instanceof TokenSet ? accessToken.access_token : accessToken);
+      options.body.append(
+        'access_token',
+        accessToken instanceof TokenSet ? accessToken.access_token : accessToken,
+      );
     }
 
     // handle additional parameters, GET via querystring, POST via urlencoded body
@@ -1102,11 +1148,13 @@ module.exports = (issuer, aadIssValidation = false) => class Client extends Base
         Object.entries(params).forEach(([key, value]) => {
           targetUrl.searchParams.append(key, value);
         });
-      } else if (options.body) { // POST && via body
+      } else if (options.body) {
+        // POST && via body
         Object.entries(params).forEach(([key, value]) => {
           options.body.append(key, value);
         });
-      } else { // POST && via header
+      } else {
+        // POST && via header
         options.body = new url.URLSearchParams();
         options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
         Object.entries(params).forEach(([key, value]) => {
@@ -1124,7 +1172,7 @@ module.exports = (issuer, aadIssValidation = false) => class Client extends Base
     let parsed = processResponse(response, { bearer: true });
 
     if (jwt) {
-      if (!JWT_CONTENT.test(response.headers['content-type'])) {
+      if (!/^application\/jwt/.test(response.headers['content-type'])) {
         throw new RPError({
           message: 'expected application/jwt response from the userinfo_endpoint',
           response,
@@ -1149,8 +1197,9 @@ module.exports = (issuer, aadIssValidation = false) => class Client extends Base
     } else {
       try {
         parsed = JSON.parse(response.body);
-      } catch (error) {
-        throw new ParseError(error, response);
+      } catch (err) {
+        Object.defineProperty(err, 'response', { value: response });
+        throw err;
       }
     }
 
@@ -1168,62 +1217,40 @@ module.exports = (issuer, aadIssValidation = false) => class Client extends Base
     return parsed;
   }
 
-  /**
-   * @name derivedKey
-   * @api private
-   */
-  async derivedKey(len) {
-    const cacheKey = `${len}_key`;
-    if (instance(this).has(cacheKey)) {
-      return instance(this).get(cacheKey);
-    }
-
-    const hash = len <= 256 ? 'sha256' : len <= 384 ? 'sha384' : len <= 512 ? 'sha512' : false; // eslint-disable-line no-nested-ternary
+  encryptionSecret(len) {
+    const hash = len <= 256 ? 'sha256' : len <= 384 ? 'sha384' : len <= 512 ? 'sha512' : false;
     if (!hash) {
       throw new Error('unsupported symmetric encryption key derivation');
     }
 
-    const derivedBuffer = crypto.createHash(hash)
+    return crypto
+      .createHash(hash)
       .update(this.client_secret)
       .digest()
       .slice(0, len / 8);
-
-    const key = jose.JWK.asKey({ k: base64url.encode(derivedBuffer), kty: 'oct' });
-    instance(this).set(cacheKey, key);
-
-    return key;
   }
 
-  /**
-   * @name joseSecret
-   * @api private
-   */
-  async joseSecret(alg) {
+  secretForAlg(alg) {
     if (!this.client_secret) {
       throw new TypeError('client_secret is required');
     }
+
     if (/^A(\d{3})(?:GCM)?KW$/.test(alg)) {
-      return this.derivedKey(parseInt(RegExp.$1, 10));
+      return this.encryptionSecret(parseInt(RegExp.$1, 10));
     }
 
     if (/^A(\d{3})(?:GCM|CBC-HS(\d{3}))$/.test(alg)) {
-      return this.derivedKey(parseInt(RegExp.$2 || RegExp.$1, 10));
-    }
-
-    if (instance(this).has('jose_secret')) {
-      return instance(this).get('jose_secret');
+      return this.encryptionSecret(parseInt(RegExp.$2 || RegExp.$1, 10));
     }
 
-    const key = jose.JWK.asKey({ k: base64url.encode(this.client_secret), kty: 'oct' });
-    instance(this).set('jose_secret', key);
+    const secret = Buffer.alloc(
+      Math.max(parseInt(alg.substr(-3), 10) >> 3, this.client_secret.length),
+    );
+    secret.write(this.client_secret);
 
-    return key;
+    return secret;
   }
 
-  /**
-   * @name grant
-   * @api public
-   */
   async grant(body, { clientAssertionPayload, DPoP } = {}) {
     assertIssuerConfiguration(this.issuer, 'token_endpoint');
     const response = await authenticatedPost.call(
@@ -1240,10 +1267,6 @@ module.exports = (issuer, aadIssValidation = false) => class Client extends Base
     return new TokenSet(responseBody);
   }
 
-  /**
-   * @name deviceAuthorization
-   * @api public
-   */
   async deviceAuthorization(params = {}, { exchangeBody, clientAssertionPayload, DPoP } = {}) {
     assertIssuerConfiguration(this.issuer, 'device_authorization_endpoint');
     assertIssuerConfiguration(this.issuer, 'token_endpoint');
@@ -1276,10 +1299,6 @@ module.exports = (issuer, aadIssValidation = false) => class Client extends Base
     });
   }
 
-  /**
-   * @name revoke
-   * @api public
-   */
   async revoke(token, hint, { revokeBody, clientAssertionPayload } = {}) {
     assertIssuerConfiguration(this.issuer, 'revocation_endpoint');
     if (hint !== undefined && typeof hint !== 'string') {
@@ -1294,17 +1313,15 @@ module.exports = (issuer, aadIssValidation = false) => class Client extends Base
 
     const response = await authenticatedPost.call(
       this,
-      'revocation', {
+      'revocation',
+      {
         form,
-      }, { clientAssertionPayload },
+      },
+      { clientAssertionPayload },
     );
     processResponse(response, { body: false });
   }
 
-  /**
-   * @name introspect
-   * @api public
-   */
   async introspect(token, hint, { introspectBody, clientAssertionPayload } = {}) {
     assertIssuerConfiguration(this.issuer, 'introspection_endpoint');
     if (hint !== undefined && typeof hint !== 'string') {
@@ -1328,110 +1345,25 @@ module.exports = (issuer, aadIssValidation = false) => class Client extends Base
     return responseBody;
   }
 
-  /**
-   * @name fetchDistributedClaims
-   * @api public
-   */
-  async fetchDistributedClaims(claims, tokens = {}) {
-    if (!isPlainObject(claims)) {
-      throw new TypeError('claims argument must be a plain object');
-    }
-
-    if (!isPlainObject(claims._claim_sources)) {
-      return claims;
-    }
-
-    if (!isPlainObject(claims._claim_names)) {
-      return claims;
-    }
-
-    const distributedSources = Object.entries(claims._claim_sources)
-      .filter(([, value]) => value && value.endpoint);
-
-    await Promise.all(distributedSources.map(async ([sourceName, def]) => {
-      try {
-        const requestOpts = {
-          headers: {
-            Accept: 'application/jwt',
-            Authorization: authorizationHeaderValue(def.access_token || tokens[sourceName]),
-          },
-        };
-
-        const response = await request.call(this, {
-          ...requestOpts,
-          method: 'GET',
-          url: def.endpoint,
-        });
-        const body = processResponse(response, { bearer: true });
-
-        const decoded = await claimJWT.call(this, 'distributed', body);
-        delete claims._claim_sources[sourceName];
-        Object.entries(claims._claim_names).forEach(
-          assignClaim(claims, decoded, sourceName, false),
-        );
-      } catch (err) {
-        err.src = sourceName;
-        throw err;
-      }
-    }));
-
-    cleanUpClaims(claims);
-    return claims;
-  }
-
-  /**
-   * @name unpackAggregatedClaims
-   * @api public
-   */
-  async unpackAggregatedClaims(claims) {
-    if (!isPlainObject(claims)) {
-      throw new TypeError('claims argument must be a plain object');
-    }
-
-    if (!isPlainObject(claims._claim_sources)) {
-      return claims;
-    }
-
-    if (!isPlainObject(claims._claim_names)) {
-      return claims;
-    }
-
-    const aggregatedSources = Object.entries(claims._claim_sources)
-      .filter(([, value]) => value && value.JWT);
-
-    await Promise.all(aggregatedSources.map(async ([sourceName, def]) => {
-      try {
-        const decoded = await claimJWT.call(this, 'aggregated', def.JWT);
-        delete claims._claim_sources[sourceName];
-        Object.entries(claims._claim_names).forEach(assignClaim(claims, decoded, sourceName));
-      } catch (err) {
-        err.src = sourceName;
-        throw err;
-      }
-    }));
-
-    cleanUpClaims(claims);
-    return claims;
-  }
-
-  /**
-   * @name register
-   * @api public
-   */
   static async register(metadata, options = {}) {
     const { initialAccessToken, jwks, ...clientOptions } = options;
 
     assertIssuerConfiguration(this.issuer, 'registration_endpoint');
 
     if (jwks !== undefined && !(metadata.jwks || metadata.jwks_uri)) {
-      const keystore = getKeystore.call(this, jwks);
-      metadata.jwks = keystore.toJWKS(false);
+      const keystore = await getKeystore.call(this, jwks);
+      metadata.jwks = keystore.toJWKS();
     }
 
     const response = await request.call(this, {
-      headers: initialAccessToken ? {
-        Authorization: authorizationHeaderValue(initialAccessToken),
-      } : undefined,
+      headers: {
+        Accept: 'application/json',
+        ...(initialAccessToken
+          ? {
+              Authorization: authorizationHeaderValue(initialAccessToken),
+            }
+          : undefined),
+      },
       responseType: 'json',
       json: metadata,
       url: this.issuer.registration_endpoint,
@@ -1442,80 +1374,67 @@ module.exports = (issuer, aadIssValidation = false) => class Client extends Base
     return new this(responseBody, jwks, clientOptions);
   }
 
-  /**
-   * @name metadata
-   * @api public
-   */
   get metadata() {
-    const copy = {};
-    instance(this).get('metadata').forEach((value, key) => {
-      copy[key] = value;
-    });
-    return copy;
+    return clone(Object.fromEntries(this.#metadata.entries()));
   }
 
-  /**
-   * @name fromUri
-   * @api public
-   */
   static async fromUri(registrationClientUri, registrationAccessToken, jwks, clientOptions) {
     const response = await request.call(this, {
       method: 'GET',
       url: registrationClientUri,
       responseType: 'json',
-      headers: { Authorization: authorizationHeaderValue(registrationAccessToken) },
+      headers: {
+        Authorization: authorizationHeaderValue(registrationAccessToken),
+        Accept: 'application/json',
+      },
     });
     const responseBody = processResponse(response, { bearer: true });
 
     return new this(responseBody, jwks, clientOptions);
   }
 
-  /**
-   * @name requestObject
-   * @api public
-   */
-  async requestObject(requestObject = {}, {
-    sign: signingAlgorithm = this.request_object_signing_alg || 'none',
-    encrypt: {
-      alg: eKeyManagement = this.request_object_encryption_alg,
-      enc: eContentEncryption = this.request_object_encryption_enc || 'A128CBC-HS256',
+  async requestObject(
+    requestObject = {},
+    {
+      sign: signingAlgorithm = this.request_object_signing_alg || 'none',
+      encrypt: {
+        alg: eKeyManagement = this.request_object_encryption_alg,
+        enc: eContentEncryption = this.request_object_encryption_enc || 'A128CBC-HS256',
+      } = {},
     } = {},
-  } = {}) {
+  ) {
     if (!isPlainObject(requestObject)) {
       throw new TypeError('requestObject must be a plain object');
     }
 
     let signed;
     let key;
-
-    const fapi = this.constructor.name === 'FAPIClient';
     const unix = now();
     const header = { alg: signingAlgorithm, typ: 'oauth-authz-req+jwt' };
-    const payload = JSON.stringify(defaults({}, requestObject, {
-      iss: this.client_id,
-      aud: this.issuer.issuer,
-      client_id: this.client_id,
-      jti: random(),
-      iat: unix,
-      exp: unix + 300,
-      ...(fapi ? { nbf: unix } : undefined),
-    }));
-
+    const payload = JSON.stringify(
+      defaults({}, requestObject, {
+        iss: this.client_id,
+        aud: this.issuer.issuer,
+        client_id: this.client_id,
+        jti: random(),
+        iat: unix,
+        exp: unix + 300,
+        ...(this.fapi() ? { nbf: unix } : undefined),
+      }),
+    );
     if (signingAlgorithm === 'none') {
-      signed = [
-        base64url.encode(JSON.stringify(header)),
-        base64url.encode(payload),
-        '',
-      ].join('.');
+      signed = [base64url.encode(JSON.stringify(header)), base64url.encode(payload), ''].join('.');
     } else {
       const symmetric = signingAlgorithm.startsWith('HS');
       if (symmetric) {
-        key = await this.joseSecret();
+        key = this.secretForAlg(signingAlgorithm);
       } else {
-        const keystore = instance(this).get('keystore');
+        const keystore = await keystores.get(this);
 
         if (!keystore) {
-          throw new TypeError(`no keystore present for client, cannot sign using alg ${signingAlgorithm}`);
+          throw new TypeError(
+            `no keystore present for client, cannot sign using alg ${signingAlgorithm}`,
+          );
         }
         key = keystore.get({ alg: signingAlgorithm, use: 'sig' });
         if (!key) {
@@ -1523,10 +1442,12 @@ module.exports = (issuer, aadIssValidation = false) => class Client extends Base
         }
       }
 
-      signed = jose.JWS.sign(payload, key, {
-        ...header,
-        kid: symmetric ? undefined : key.kid,
-      });
+      signed = await new jose.CompactSign(new TextEncoder().encode(payload))
+        .setProtectedHeader({
+          ...header,
+          kid: symmetric ? undefined : key.jwk.kid,
+        })
+        .sign(symmetric ? key : key.keyObject);
     }
 
     if (!eKeyManagement) {
@@ -1536,25 +1457,23 @@ module.exports = (issuer, aadIssValidation = false) => class Client extends Base
     const fields = { alg: eKeyManagement, enc: eContentEncryption, cty: 'oauth-authz-req+jwt' };
 
     if (fields.alg.match(/^(RSA|ECDH)/)) {
-      [key] = await this.issuer.queryKeyStore({
-        alg: fields.alg,
-        enc: fields.enc,
-        use: 'enc',
-      }, { allowMulti: true });
+      [key] = await queryKeyStore.call(
+        this.issuer,
+        { alg: fields.alg, use: 'enc' },
+        { allowMulti: true },
+      );
     } else {
-      key = await this.joseSecret(fields.alg === 'dir' ? fields.enc : fields.alg);
+      key = this.secretForAlg(fields.alg === 'dir' ? fields.enc : fields.alg);
     }
 
-    return jose.JWE.encrypt(signed, key, {
-      ...fields,
-      kid: key.kty === 'oct' ? undefined : key.kid,
-    });
+    return new jose.CompactEncrypt(new TextEncoder().encode(signed))
+      .setProtectedHeader({
+        ...fields,
+        kid: key instanceof Uint8Array ? undefined : key.jwk.kid,
+      })
+      .encrypt(key instanceof Uint8Array ? key : key.keyObject);
   }
 
-  /**
-   * @name pushedAuthorizationRequest
-   * @api public
-   */
   async pushedAuthorizationRequest(params = {}, { clientAssertionPayload } = {}) {
     assertIssuerConfiguration(this.issuer, 'pushed_authorization_request_endpoint');
 
@@ -1602,20 +1521,8 @@ module.exports = (issuer, aadIssValidation = false) => class Client extends Base
     return responseBody;
   }
 
-  /**
-   * @name issuer
-   * @api public
-   */
-  static get issuer() {
-    return issuer;
-  }
-
-  /**
-   * @name issuer
-   * @api public
-   */
-  get issuer() { // eslint-disable-line class-methods-use-this
-    return issuer;
+  get issuer() {
+    return this.#issuer;
   }
 
   /* istanbul ignore next */
@@ -1627,7 +1534,11 @@ module.exports = (issuer, aadIssValidation = false) => class Client extends Base
       sorted: true,
     })}`;
   }
-};
+
+  fapi() {
+    return this.constructor.name === 'FAPI1Client';
+  }
+}
 
 /**
  * @name validateJARM
@@ -1656,49 +1567,156 @@ Object.defineProperty(BaseClient.prototype, 'validateJARM', {
   },
 });
 
+const RSPS = /^(?:RS|PS)(?:256|384|512)$/;
+function determineRsaAlgorithm(privateKey, privateKeyInput, valuesSupported) {
+  if (
+    typeof privateKeyInput === 'object' &&
+    typeof privateKeyInput.key === 'object' &&
+    privateKeyInput.key.alg
+  ) {
+    return privateKeyInput.key.alg;
+  }
+
+  if (Array.isArray(valuesSupported)) {
+    let candidates = valuesSupported.filter(RegExp.prototype.test.bind(RSPS));
+    if (privateKey.asymmetricKeyType === 'rsa-pss') {
+      candidates = candidates.filter((value) => value.startsWith('PS'));
+    }
+    return ['PS256', 'PS384', 'PS512', 'RS256', 'RS384', 'RS384'].find((preferred) =>
+      candidates.includes(preferred),
+    );
+  }
+
+  return 'PS256';
+}
+
+const p256 = Buffer.from([42, 134, 72, 206, 61, 3, 1, 7]);
+const p384 = Buffer.from([43, 129, 4, 0, 34]);
+const p521 = Buffer.from([43, 129, 4, 0, 35]);
+const secp256k1 = Buffer.from([43, 129, 4, 0, 10]);
+
+function determineEcAlgorithm(privateKey, privateKeyInput) {
+  // If input was a JWK
+  switch (
+    typeof privateKeyInput === 'object' &&
+    typeof privateKeyInput.key === 'object' &&
+    privateKeyInput.key.crv
+  ) {
+    case 'P-256':
+      return 'ES256';
+    case 'secp256k1':
+      return 'ES256K';
+    case 'P-384':
+      return 'ES384';
+    case 'P-512':
+      return 'ES512';
+    default:
+      break;
+  }
+
+  const buf = privateKey.export({ format: 'der', type: 'pkcs8' });
+  const i = buf[1] < 128 ? 17 : 18;
+  const len = buf[i];
+  const curveOid = buf.slice(i + 1, i + 1 + len);
+  if (curveOid.equals(p256)) {
+    return 'ES256';
+  }
+
+  if (curveOid.equals(p384)) {
+    return 'ES384';
+  }
+  if (curveOid.equals(p521)) {
+    return 'ES512';
+  }
+
+  if (curveOid.equals(secp256k1)) {
+    return 'ES256K';
+  }
+
+  throw new TypeError('unsupported DPoP private key curve');
+}
+
+const jwkCache = new WeakMap();
+async function getJwk(privateKey, privateKeyInput) {
+  if (
+    typeof privateKeyInput === 'object' &&
+    typeof privateKeyInput.key === 'object' &&
+    privateKeyInput.key.crv
+  ) {
+    return pick(privateKeyInput.key, 'kty', 'crv', 'x', 'y', 'e', 'n');
+  }
+
+  if (jwkCache.has(privateKeyInput)) {
+    return jwkCache.get(privateKeyInput);
+  }
+
+  const jwk = pick(await jose.exportJWK(privateKey), 'kty', 'crv', 'x', 'y', 'e', 'n');
+
+  if (isKeyObject(privateKeyInput)) {
+    jwkCache.set(privateKeyInput, jwk);
+  }
+
+  return jwk;
+}
+
 /**
  * @name dpopProof
  * @api private
  */
-function dpopProof(payload, jwk, accessToken) {
+async function dpopProof(payload, privateKeyInput, accessToken) {
   if (!isPlainObject(payload)) {
     throw new TypeError('payload must be a plain object');
   }
 
-  let key;
-  try {
-    key = jose.JWK.asKey(jwk);
-    assert(key.type === 'private');
-  } catch (err) {
-    throw new TypeError('"DPoP" option must be an asymmetric private key to sign the DPoP Proof JWT with');
+  let privateKey;
+  if (isKeyObject(privateKeyInput)) {
+    privateKey = privateKeyInput;
+  } else {
+    privateKey = crypto.createPrivateKey(privateKeyInput);
   }
 
-  let { alg } = key;
-
-  if (!alg && this.issuer.dpop_signing_alg_values_supported) {
-    const algs = key.algorithms('sign');
-    alg = this.issuer.dpop_signing_alg_values_supported.find((a) => algs.has(a));
+  if (privateKey.type !== 'private') {
+    throw new TypeError('"DPoP" option must be a private key');
   }
-
-  if (!alg) {
-    [alg] = key.algorithms('sign');
+  let alg;
+  switch (privateKey.asymmetricKeyType) {
+    case 'ed25519':
+    case 'ed448':
+      alg = 'EdDSA';
+      break;
+    case 'ec':
+      alg = determineEcAlgorithm(privateKey, privateKeyInput);
+      break;
+    case 'rsa':
+    case rsaPssParams && 'rsa-pss':
+      alg = determineRsaAlgorithm(
+        privateKey,
+        privateKeyInput,
+        this.issuer.dpop_signing_alg_values_supported,
+      );
+      break;
+    default:
+      throw new TypeError('unsupported DPoP private key asymmetric key type');
   }
 
-  let ath;
-  if (accessToken) {
-    ath = base64url.encode(crypto.createHash('sha256').update(accessToken).digest());
+  if (!alg) {
+    throw new TypeError('could not determine DPoP JWS Algorithm');
   }
 
-  return jose.JWS.sign({
-    iat: now(),
-    jti: random(),
-    ath,
+  return new jose.SignJWT({
+    ath: accessToken
+      ? base64url.encode(crypto.createHash('sha256').update(accessToken).digest())
+      : undefined,
     ...payload,
-  }, jwk, {
-    alg,
-    typ: 'dpop+jwt',
-    jwk: pick(key, 'kty', 'crv', 'x', 'y', 'e', 'n'),
-  });
+  })
+    .setProtectedHeader({
+      alg,
+      typ: 'dpop+jwt',
+      jwk: await getJwk(privateKey, privateKeyInput),
+    })
+    .setIssuedAt()
+    .setJti(random())
+    .sign(privateKey);
 }
 
 Object.defineProperty(BaseClient.prototype, 'dpopProof', {
@@ -1718,4 +1736,14 @@ Object.defineProperty(BaseClient.prototype, 'dpopProof', {
   },
 });
 
+module.exports = (issuer, aadIssValidation = false) =>
+  class Client extends BaseClient {
+    constructor(...args) {
+      super(issuer, aadIssValidation, ...args);
+    }
+
+    static get issuer() {
+      return issuer;
+    }
+  };
 module.exports.BaseClient = BaseClient;