@hyper.authio/testing 0.7.0 → 0.8.0

package/README.md

@@ -33,7 +33,8 @@ await authio.close();
   UserInfo (JSON, or a signed JWT with `userInfoAsJwt`), device authorization and end session.
 - Sign-in: `authorize(url)` follows an authorization URL as a browser would and returns the callback URL (or, for
   `response_mode=web_message`, the posted parameters). It signs in `signInAs`, the `login_hint` or the first user;
-  honours PKCE (S256, plain), `prompt` (`none` answers `login_required` without a session, `login` signs in again),
+  honours PKCE (S256, plain; `code_challenge_method` is required), `prompt` (`none` answers `login_required` without a
+  session, `login` signs in again),
   `max_age`, `acr_values`, and sends RFC 9207 `iss` (`omitAuthorizationIssuer` leaves it out). ID tokens carry `nonce`,
   `sid`, `auth_time`, `acr`, `amr` and `at_hash`. `createAuthorizationCode` still mints a code directly.
 - Sign-out: the end-session endpoint checks `post_logout_redirect_uri`, echoes `state`, and posts a logout token to the
@@ -45,8 +46,23 @@ await authio.close();
 - JWE: a client with `encryption: { key, algorithm }` (RSA-OAEP or RSA-OAEP-256) gets its ID tokens, UserInfo, and
   optionally access and logout tokens encrypted; `issueAccessToken({ encryptTo })` mints one directly.
 - Personal access tokens: `personalAccessTokens: [{ token: "pat_…", sub, clientId? }]`.
-- Client authentication: `client_secret_basic`, `client_secret_post`, `private_key_jwt` (register `publicKey`) and
-  `none`.
+- Clients are configured as in Authio's console, and the fake enforces it as Authio does, refusing with an error that
+  names the setting and accepting what the client does not require:
+  - `tokenEndpointAuthMethod`: `client_secret_basic` (default with `clientSecret`), `client_secret_post`,
+    `private_key_jwt` (default with only `publicKey`) or `none` (default with neither), matched exactly
+    (`invalid_client`); a secret sent by a `none` client is ignored.
+  - `requirePkce` (default `true`, as Authio creates clients) refuses an authorization request without
+    `code_challenge`: declare `requirePkce: false` for a client with PKCE off. `pkceMethods` (default `["S256"]`)
+    refuses another method even when PKCE is not required; PKCE sent to a client that does not require it is checked
+    and accepted.
+  - `signingAlgorithm`: `RS256` (default) or `HS256`/`HS384`/`HS512` with the client secret, for the client's ID
+    tokens, UserInfo and logout tokens; `accessTokenSigningAlgorithm` the same for its access tokens, as Authio keeps
+    two settings. The secret needs at least 32, 48 or 64 bytes (RFC 7518 §3.2), or the client is refused.
+  - `issueIdTokenOnRefresh` adds a new ID token to every refresh.
+  - `frontchannelLogoutUri` (with `frontchannelLogoutSessionRequired` for `iss` and `sid`) is loaded when a session of
+    the client ends (`frontchannelDeliveries`); `frontchannelLogoutUrl` and `deliverFrontchannelLogout` do it by hand.
+  - `response_mode` other than `query` and `web_message` is refused.
+- `clock` (such as the `ManualClock` the library uses) is the time tokens are issued and checked with.
 - `issueAccessToken` options: `expiresIn` (negative for an expired token), `type` (`ID` for a non-access token),
   `issuer`, `untrusted` (a signature that does not verify).
 - `failures.set("token", [{ status: 503 }])` answers the next calls to an endpoint with errors; `deviceOutcomes`

package/dist/index.cjs

@@ -13,6 +13,8 @@ var FakeAuthio = class _FakeAuthio {
   failures = /* @__PURE__ */ new Map();
   /** Every back-channel logout token posted, in order. */
   backchannelDeliveries = [];
+  /** Every front-channel logout page loaded, in order. */
+  frontchannelDeliveries = [];
   /** What successive device-code polls answer; the last value repeats. Defaults to `["approved"]`. */
   deviceOutcomes = ["approved"];
   /** Overrides the discovery document's issuer, to test the mismatch check. */
@@ -33,6 +35,7 @@ var FakeAuthio = class _FakeAuthio {
   issued = /* @__PURE__ */ new Map();
   devicePolls = /* @__PURE__ */ new Map();
   lifetime;
+  clock;
   session;
   server;
   signingKey;
@@ -45,7 +48,8 @@ var FakeAuthio = class _FakeAuthio {
   constructor(options) {
     this.realm = options.realm ?? "fake";
     this.lifetime = options.accessTokenLifetime ?? 300;
-    for (const client of options.clients ?? []) this.clients.set(client.clientId, client);
+    this.clock = options.clock ?? { now: () => Date.now() };
+    for (const client of options.clients ?? []) this.clients.set(client.clientId, checkClient(client));
     for (const user of options.users ?? []) this.users.set(user.username, user);
     for (const pat of options.personalAccessTokens ?? []) this.personalAccessTokens.set(pat.token, pat);
   }
@@ -75,7 +79,7 @@ var FakeAuthio = class _FakeAuthio {
   }
   /** Registers a client. */
   addClient(client) {
-    this.clients.set(client.clientId, client);
+    this.clients.set(client.clientId, checkClient(client));
   }
   /** Registers a person. */
   addUser(user) {
@@ -126,7 +130,7 @@ var FakeAuthio = class _FakeAuthio {
    * Mints an access token signed by the realm key, recorded so introspection and revocation know it.
    */
   async issueAccessToken(options = {}) {
-    const now = Math.floor(Date.now() / 1e3);
+    const now = this.nowSeconds();
     const clientId = options.clientId ?? "fake-client";
     const jti = crypto.randomUUID();
     const payload = {
@@ -137,7 +141,8 @@ var FakeAuthio = class _FakeAuthio {
       ...options.sub ? { sub: options.sub } : {},
       ...options.claims
     };
-    const signed = await new jose.SignJWT(payload).setProtectedHeader({ alg: "RS256", kid: this.keyId, typ: "JWT" }).setIssuer(options.issuer ?? this.issuer).setAudience(options.audience ?? clientId).setIssuedAt(now).setNotBefore(now).setExpirationTime(now + (options.expiresIn ?? this.lifetime)).setJti(jti).sign(options.untrusted ? this.untrustedKey : this.signingKey);
+    const builder = new jose.SignJWT(payload).setIssuer(options.issuer ?? this.issuer).setAudience(options.audience ?? clientId).setIssuedAt(now).setNotBefore(now).setExpirationTime(now + (options.expiresIn ?? this.lifetime)).setJti(jti);
+    const signed = options.untrusted ? await builder.setProtectedHeader({ alg: "RS256", kid: this.keyId, typ: "JWT" }).sign(this.untrustedKey) : await this.sign(builder, this.clients.get(clientId), "JWT", this.clients.get(clientId)?.accessTokenSigningAlgorithm ?? "RS256");
     const token = options.encryptTo ? await encryptTo(signed, options.encryptTo) : signed;
     this.issued.set(token, { claims: jose.decodeJwt(signed), clientId, revoked: false });
     return token;
@@ -147,7 +152,7 @@ var FakeAuthio = class _FakeAuthio {
    * removes one) and `type` the header `typ`, to build invalid ones in tests.
    */
   async createLogoutToken(options) {
-    const now = Math.floor(Date.now() / 1e3);
+    const now = this.nowSeconds();
     const payload = {
       iss: this.issuer,
       aud: options.clientId,
@@ -160,7 +165,7 @@ var FakeAuthio = class _FakeAuthio {
       ...options.overrides
     };
     for (const key of Object.keys(payload)) if (payload[key] === void 0) delete payload[key];
-    const signed = await new jose.SignJWT(payload).setProtectedHeader({ alg: "RS256", kid: this.keyId, typ: options.type ?? "logout+jwt" }).sign(this.signingKey);
+    const signed = await this.sign(new jose.SignJWT(payload), this.clients.get(options.clientId), options.type ?? "logout+jwt");
     const encryption = this.clients.get(options.clientId)?.encryption;
     return encryption?.logoutTokens ? encryptTo(signed, encryption) : signed;
   }
@@ -188,6 +193,38 @@ var FakeAuthio = class _FakeAuthio {
     this.backchannelDeliveries.push({ clientId, uri: client.backchannelLogoutUri, logoutToken, status });
     return status;
   }
+  /**
+   * The front-channel logout URL of a client for a session: its `frontchannelLogoutUri`, with `iss` and `sid` when the
+   * client requires the session.
+   */
+  frontchannelLogoutUrl(clientId, sid) {
+    const client = this.clients.get(clientId);
+    if (!client?.frontchannelLogoutUri) throw new Error(`The fake client ${clientId} has no frontchannelLogoutUri.`);
+    const url = new URL(client.frontchannelLogoutUri);
+    if (client.frontchannelLogoutSessionRequired) {
+      url.searchParams.set("iss", this.issuer);
+      url.searchParams.set("sid", sid);
+    }
+    return url.toString();
+  }
+  /**
+   * Loads the client's front-channel logout page, as the browser does in an iframe when Authio ends a session.
+   *
+   * @returns The HTTP status the client answered, or 0 when it could not be reached.
+   */
+  async deliverFrontchannelLogout(clientId, options) {
+    const url = this.frontchannelLogoutUrl(clientId, options.sid);
+    let status = 0;
+    try {
+      const response = await fetch(url, { headers: options.headers, redirect: "manual" });
+      status = response.status;
+      await response.arrayBuffer();
+    } catch {
+      status = 0;
+    }
+    this.frontchannelDeliveries.push({ clientId, url, status });
+    return status;
+  }
   /** Marks a token revoked, as Authio would after a sign-out: an access token, or a refresh token, which is then forgotten. */
   revokeToken(token) {
     const issued = this.issued.get(token);
@@ -304,6 +341,8 @@ var FakeAuthio = class _FakeAuthio {
       acr_values_supported: ["1", "2", "3"],
       backchannel_logout_supported: true,
       backchannel_logout_session_supported: true,
+      frontchannel_logout_supported: true,
+      frontchannel_logout_session_supported: true,
       authorization_response_iss_parameter_supported: !this.omitAuthorizationIssuer
     };
   }
@@ -329,11 +368,28 @@ var FakeAuthio = class _FakeAuthio {
       response.writeHead(302, { location: location.toString() });
       response.end();
     };
+    if (query.response_mode !== void 0 && query.response_mode !== "query" && query.response_mode !== "web_message")
+      return answer({ error: "invalid_request", error_description: `The response_mode '${query.response_mode}' is not supported: Authio answers with query or web_message.` });
     if (query.response_type !== "code") return answer({ error: "unsupported_response_type", error_description: "Only code is supported." });
-    const method = query.code_challenge_method ?? (query.code_challenge ? "plain" : void 0);
-    if (method && method !== "S256" && method !== "plain") return answer({ error: "invalid_request", error_description: "Unsupported PKCE method." });
+    const method = query.code_challenge ? query.code_challenge_method : void 0;
+    const allowedMethods = client.pkceMethods ?? ["S256"];
+    if (query.code_challenge) {
+      if (!method)
+        return answer({ error: "invalid_request", error_description: "code_challenge_method is required with code_challenge: Authio does not assume plain." });
+      if (method !== "S256" && method !== "plain") return answer({ error: "invalid_request", error_description: `The PKCE method '${method}' is not supported.` });
+      if (!allowedMethods.includes(method))
+        return answer({
+          error: "invalid_request",
+          error_description: `The PKCE method '${method}' is not allowed for the client ${client.clientId}, which allows ${allowedMethods.join(", ")} (codeChallengeMethod).`
+        });
+    } else if (client.requirePkce ?? true) {
+      return answer({
+        error: "invalid_request",
+        error_description: `The client ${client.clientId} requires PKCE: send code_challenge and code_challenge_method (checks: ["pkce"]).`
+      });
+    }
     const prompts = (query.prompt ?? "").split(" ").filter(Boolean);
-    const now = Math.floor(Date.now() / 1e3);
+    const now = this.nowSeconds();
     const maxAge = query.max_age !== void 0 ? Number(query.max_age) : void 0;
     const tooOld = this.session !== void 0 && maxAge !== void 0 && now - this.session.authTime > maxAge;
     const requestedAcr = (query.acr_values ?? "").split(" ").filter(Boolean).sort().at(-1);
@@ -375,7 +431,11 @@ var FakeAuthio = class _FakeAuthio {
     let clientId = query.client_id;
     if (query.id_token_hint) {
       try {
-        const { payload } = await jose.jwtVerify(query.id_token_hint, this.verificationKey, { issuer: this.issuer });
+        const audience = [jose.decodeJwt(query.id_token_hint).aud ?? []].flat()[0];
+        const { payload } = await jose.jwtVerify(query.id_token_hint, this.verificationKeyFor(audience ? this.clients.get(audience) : void 0, query.id_token_hint), {
+          issuer: this.issuer,
+          currentDate: new Date(this.clock.now())
+        });
         clientId ??= [payload.aud ?? []].flat()[0];
       } catch {
         return send(response, { status: 400, body: { error: "invalid_request", error_description: "The id_token_hint is not valid." } });
@@ -388,9 +448,11 @@ var FakeAuthio = class _FakeAuthio {
     const ended = this.session;
     this.session = void 0;
     if (ended) this.revokeRefreshTokens({ sid: ended.sid });
-    if (ended) {
-      for (const id of ended.clients) if (this.clients.get(id)?.backchannelLogoutUri) await this.deliverBackchannelLogout(id, { sub: ended.sub, sid: ended.sid });
-    }
+    if (ended)
+      for (const id of ended.clients) {
+        if (this.clients.get(id)?.backchannelLogoutUri) await this.deliverBackchannelLogout(id, { sub: ended.sub, sid: ended.sid });
+        if (this.clients.get(id)?.frontchannelLogoutUri) await this.deliverFrontchannelLogout(id, { sid: ended.sid });
+      }
     if (!redirect) {
       response.writeHead(200, { "content-type": "text/html; charset=utf-8" });
       response.end("<!doctype html><p>You are signed out.</p>");
@@ -404,28 +466,38 @@ var FakeAuthio = class _FakeAuthio {
   async authenticate(recorded, form) {
     const invalid = (description) => ({ status: 401, body: { error: "invalid_client", error_description: description } });
     const authorization = recorded.headers.authorization;
-    let client;
-    if (authorization?.startsWith("Basic ")) {
-      const [id, secret] = Buffer.from(authorization.slice(6), "base64").toString("utf8").split(":").map(decodeURIComponent);
-      client = this.clients.get(id ?? "");
-      if (!client || !client.clientSecret || client.clientSecret !== secret) return invalid("The client credentials are wrong.");
-    } else if (form.client_assertion) {
-      client = this.clients.get(form.client_id ?? "");
-      if (!client?.publicKey) return invalid("The client has no registered key.");
-      if (form.client_assertion_type !== "urn:ietf:params:oauth:client-assertion-type:jwt-bearer") return invalid("Wrong assertion type.");
-      try {
-        const key = await jose.importJWK(client.publicKey, client.publicKey.alg);
-        const { payload } = await jose.jwtVerify(form.client_assertion, key, { issuer: client.clientId, subject: client.clientId, audience: this.issuer });
-        if (!payload.jti) return invalid("The assertion has no jti.");
-      } catch (error) {
-        return invalid(`The assertion does not verify: ${error.message}`);
+    const basic = authorization?.startsWith("Basic ") ? Buffer.from(authorization.slice(6), "base64").toString("utf8").split(":").map(decodeURIComponent) : void 0;
+    const presented = basic ? "client_secret_basic" : form.client_assertion ? "private_key_jwt" : form.client_secret !== void 0 ? "client_secret_post" : "none";
+    const client = this.clients.get((basic ? basic[0] : form.client_id) ?? "");
+    if (!client) return invalid("Unknown client.");
+    if (form.client_assertion && form.client_secret !== void 0) return invalid("A client assertion and a client secret cannot be sent together.");
+    const registered = registeredMethodOf(client);
+    if (presented !== registered && !(registered === "none" && (presented === "client_secret_basic" || presented === "client_secret_post")))
+      return invalid(`The client ${client.clientId} authenticates with ${registered} (tokenEndpointAuthMethod), not ${presented}.`);
+    switch (registered) {
+      case "client_secret_basic":
+        if (!client.clientSecret || client.clientSecret !== basic?.[1]) return invalid("The client credentials are wrong.");
+        break;
+      case "client_secret_post":
+        if (!client.clientSecret || client.clientSecret !== form.client_secret) return invalid("The client credentials are wrong.");
+        break;
+      case "private_key_jwt": {
+        if (!client.publicKey) return invalid("The client has no registered key.");
+        if (form.client_assertion_type !== "urn:ietf:params:oauth:client-assertion-type:jwt-bearer") return invalid("Wrong assertion type.");
+        try {
+          const key = await jose.importJWK(client.publicKey, client.publicKey.alg);
+          const { payload } = await jose.jwtVerify(form.client_assertion, key, {
+            issuer: client.clientId,
+            subject: client.clientId,
+            audience: this.issuer,
+            currentDate: new Date(this.clock.now())
+          });
+          if (!payload.jti) return invalid("The assertion has no jti.");
+        } catch (error) {
+          return invalid(`The assertion does not verify: ${error.message}`);
+        }
+        break;
       }
-    } else if (form.client_secret !== void 0) {
-      client = this.clients.get(form.client_id ?? "");
-      if (!client || client.clientSecret !== form.client_secret) return invalid("The client credentials are wrong.");
-    } else {
-      client = this.clients.get(form.client_id ?? "");
-      if (!client || client.clientSecret || client.publicKey) return invalid("The client must authenticate.");
     }
     recorded.clientId = client.clientId;
     return client;
@@ -460,11 +532,12 @@ var FakeAuthio = class _FakeAuthio {
         const code = this.codes.get(form.code ?? "");
         if (!code || code.clientId !== client.clientId || code.redirectUri !== form.redirect_uri) return grant("invalid_grant", "The code is not valid.");
         if (code.codeVerifier && code.codeVerifier !== form.code_verifier) return grant("invalid_grant", "PKCE verification failed.");
-        if (code.codeChallenge && !verifiesChallenge(form.code_verifier, code.codeChallenge, code.codeChallengeMethod ?? "plain"))
+        if (code.codeChallenge && !form.code_verifier) return grant("invalid_grant", "code_verifier is required: the code was issued with a code_challenge.");
+        if (code.codeChallenge && !verifiesChallenge(form.code_verifier, code.codeChallenge, code.codeChallengeMethod ?? "S256"))
           return grant("invalid_grant", "PKCE verification failed.");
         this.codes.delete(form.code);
         const user = [...this.users.values()].find((candidate) => candidate.sub === code.sub);
-        const signIn = code.sid ? { sid: code.sid, auth_time: code.authTime, acr: code.acr, amr: code.amr } : { auth_time: Math.floor(Date.now() / 1e3), acr: user.acr ?? "1", amr: user.amr ?? ["pwd"] };
+        const signIn = code.sid ? { sid: code.sid, auth_time: code.authTime, acr: code.acr, amr: code.amr } : { auth_time: this.nowSeconds(), acr: user.acr ?? "1", amr: user.amr ?? ["pwd"] };
         return this.tokenAnswer(
           client,
           {
@@ -483,10 +556,13 @@ var FakeAuthio = class _FakeAuthio {
         if (!refresh || refresh.clientId !== client.clientId) return grant("invalid_grant", "The refresh token is not valid.");
         this.refreshTokens.delete(form.refresh_token);
         const user = [...this.users.values()].find((candidate) => candidate.sub === refresh.sub);
+        const signIn = { ...refresh.sid ? { sid: refresh.sid } : {}, ...refresh.authTime ? { auth_time: refresh.authTime } : {} };
         return this.tokenAnswer(
           client,
-          { sub: refresh.sub, scope: form.scope ?? refresh.scope, claims: { ...client.claims, ...user?.claims, ...refresh.sid ? { sid: refresh.sid } : {} } },
-          user
+          { sub: refresh.sub, scope: form.scope ?? refresh.scope, claims: { ...client.claims, ...user?.claims, ...signIn } },
+          user,
+          void 0,
+          client.issueIdTokenOnRefresh ? { signIn } : void 0
         );
       }
       case "urn:ietf:params:oauth:grant-type:token-exchange": {
@@ -552,21 +628,33 @@ var FakeAuthio = class _FakeAuthio {
     if (user) {
       const refreshToken = crypto.randomUUID();
       const sid = typeof options.claims?.sid === "string" ? options.claims.sid : void 0;
-      this.refreshTokens.set(refreshToken, { clientId: client.clientId, sub: user.sub, scope: options.scope, sid, expiresAt: Math.floor(Date.now() / 1e3) + 30 * 24 * 3600 });
+      const authTime = typeof options.claims?.auth_time === "number" ? options.claims.auth_time : void 0;
+      this.refreshTokens.set(refreshToken, {
+        clientId: client.clientId,
+        sub: user.sub,
+        scope: options.scope,
+        sid,
+        authTime,
+        expiresAt: this.nowSeconds() + 30 * 24 * 3600
+      });
       body.refresh_token = refreshToken;
     }
     if (user && idToken && (options.scope ?? "").split(" ").includes("openid")) {
-      const now = Math.floor(Date.now() / 1e3);
+      const now = this.nowSeconds();
       const signIn = Object.fromEntries(Object.entries(idToken.signIn).filter(([, value]) => value !== void 0));
-      const signed = await new jose.SignJWT({
-        typ: "ID",
-        azp: client.clientId,
-        ...signIn,
-        ...idToken.nonce ? { nonce: idToken.nonce } : {},
-        at_hash: halfHash(accessToken),
-        preferred_username: user.username,
-        ...user.userInfo
-      }).setProtectedHeader({ alg: "RS256", kid: this.keyId, typ: "JWT" }).setIssuer(this.issuer).setAudience(client.clientId).setSubject(user.sub).setIssuedAt(now).setExpirationTime(now + this.lifetime).sign(this.signingKey);
+      const signed = await this.sign(
+        new jose.SignJWT({
+          typ: "ID",
+          azp: client.clientId,
+          ...signIn,
+          ...idToken.nonce ? { nonce: idToken.nonce } : {},
+          at_hash: halfHash(accessToken, client.signingAlgorithm ?? "RS256"),
+          preferred_username: user.username,
+          ...user.userInfo
+        }).setIssuer(this.issuer).setAudience(client.clientId).setSubject(user.sub).setIssuedAt(now).setExpirationTime(now + this.lifetime),
+        client,
+        "JWT"
+      );
       body.id_token = encryption && encryption.idTokens !== false ? await encryptTo(signed, encryption) : signed;
     }
     return { status: 200, body };
@@ -575,7 +663,7 @@ var FakeAuthio = class _FakeAuthio {
     const client = await this.authenticate(recorded, form);
     if ("status" in client) return client;
     const issued = this.issued.get(form.token ?? "");
-    const now = Math.floor(Date.now() / 1e3);
+    const now = this.nowSeconds();
     const refresh = this.refreshTokens.get(form.token ?? "");
     if (refresh)
       return refresh.clientId === client.clientId ? {
@@ -632,13 +720,29 @@ var FakeAuthio = class _FakeAuthio {
     const user = [...this.users.values()].find((candidate) => candidate.sub === issued.claims.sub);
     const claims = { sub: issued.claims.sub, ...user?.userInfo };
     if (!this.userInfoAsJwt) return send(response, { status: 200, body: claims });
-    const now = Math.floor(Date.now() / 1e3);
-    const signed = await new jose.SignJWT(claims).setProtectedHeader({ alg: "RS256", kid: this.keyId }).setIssuer(this.issuer).setAudience(issued.clientId).setIssuedAt(now).setExpirationTime(now + this.lifetime).sign(this.signingKey);
+    const now = this.nowSeconds();
+    const signed = await this.sign(
+      new jose.SignJWT(claims).setIssuer(this.issuer).setAudience(issued.clientId).setIssuedAt(now).setExpirationTime(now + this.lifetime),
+      this.clients.get(issued.clientId),
+      void 0
+    );
     const encryption = this.clients.get(issued.clientId)?.encryption;
     const jwt = encryption && encryption.userInfo !== false ? await encryptTo(signed, encryption) : signed;
     response.writeHead(200, { "content-type": "application/jwt" });
     response.end(jwt);
   }
+  nowSeconds() {
+    return Math.floor(this.clock.now() / 1e3);
+  }
+  sign(builder, client, type, algorithm = client?.signingAlgorithm ?? "RS256") {
+    if (algorithm === "RS256") return builder.setProtectedHeader({ alg: "RS256", kid: this.keyId, ...type ? { typ: type } : {} }).sign(this.signingKey);
+    if (!client?.clientSecret) throw new Error(`The fake client ${client?.clientId} signs with ${algorithm} and has no clientSecret.`);
+    return builder.setProtectedHeader({ alg: algorithm, ...type ? { typ: type } : {} }).sign(new TextEncoder().encode(client.clientSecret));
+  }
+  verificationKeyFor(client, token) {
+    const algorithm = String(jose.decodeProtectedHeader(token).alg ?? "");
+    return algorithm.startsWith("HS") && client?.clientSecret ? new TextEncoder().encode(client.clientSecret) : this.verificationKey;
+  }
   requireUser(username) {
     const user = this.users.get(username);
     if (!user) throw new Error(`The fake has no user ${username}.`);
@@ -665,8 +769,21 @@ function verifiesChallenge(verifier, challenge, method) {
   if (!verifier) return false;
   return method === "S256" ? crypto.createHash("sha256").update(verifier, "ascii").digest("base64url") === challenge : verifier === challenge;
 }
-function halfHash(value) {
-  return crypto.createHash("sha256").update(value, "ascii").digest().subarray(0, 16).toString("base64url");
+function halfHash(value, algorithm) {
+  const size = algorithm.endsWith("384") ? 384 : algorithm.endsWith("512") ? 512 : 256;
+  const digest = crypto.createHash(`sha${size}`).update(value, "ascii").digest();
+  return digest.subarray(0, digest.length / 2).toString("base64url");
+}
+function checkClient(client) {
+  for (const algorithm of [client.signingAlgorithm ?? "RS256", client.accessTokenSigningAlgorithm ?? "RS256"]) {
+    const minimum = { HS256: 32, HS384: 48, HS512: 64 }[algorithm];
+    if (minimum !== void 0 && Buffer.byteLength(client.clientSecret ?? "", "utf8") < minimum)
+      throw new Error(`The fake client ${client.clientId} signs with ${algorithm}, which needs a clientSecret of at least ${minimum} bytes (RFC 7518 \xA73.2).`);
+  }
+  return client;
+}
+function registeredMethodOf(client) {
+  return client.tokenEndpointAuthMethod ?? (client.clientSecret ? "client_secret_basic" : client.publicKey ? "private_key_jwt" : "none");
 }
 function send(response, answer) {
   const headers = { ...answer.headers };