@hyper.authio/testing 0.1.1 → 0.7.0

package/README.md

@@ -27,10 +27,24 @@ const token = await authio.issueAccessToken({
 await authio.close();
 ```
 
-- Endpoints: discovery, JWKS, token (client credentials, authorization code via `createAuthorizationCode`, refresh
-  with rotation, token exchange including connected accounts, password, device code), introspection (answered
-  according to who asks, like Authio), revocation, UserInfo (JSON, or a signed JWT with `userInfoAsJwt`) and device
-  authorization.
+- Endpoints: discovery (every endpoint it advertises is served), JWKS, authorization, token (client credentials,
+  authorization code with ID tokens, refresh with rotation, token exchange including connected accounts, password,
+  device code, personal access token), introspection (answered according to who asks, like Authio), revocation,
+  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),
+  `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
+  `backchannelLogoutUri` of every client of the session (`backchannelDeliveries`); `deliverBackchannelLogout` and
+  `createLogoutToken` do it by hand. Ending a session revokes its refresh tokens; `revokeRefreshTokens({ sub | sid })`
+  and `revokeToken(token)` revoke them by hand.
+- Refresh tokens carry the session's `sid` through refreshes and are introspectable by the client they were issued to
+  (`token_type` `Refresh`), as a BFF's session check needs.
+- 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`.
 - `issueAccessToken` options: `expiresIn` (negative for an expired token), `type` (`ID` for a non-access token),

package/dist/index.cjs

@@ -11,23 +11,32 @@ var FakeAuthio = class _FakeAuthio {
   requests = [];
   /** Answers the next requests to an endpoint with these errors, in order, before answering normally. */
   failures = /* @__PURE__ */ new Map();
+  /** Every back-channel logout token posted, in order. */
+  backchannelDeliveries = [];
   /** 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. */
   discoveryIssuer;
-  /** Answers UserInfo as `application/jwt`, signed by the realm key. */
+  /** Answers UserInfo as `application/jwt`, signed by the realm key (and encrypted for a client with a key). */
   userInfoAsJwt = false;
+  /** Leaves `iss` out of authorization responses, to test the RFC 9207 check. */
+  omitAuthorizationIssuer = false;
   /** Answers connected-account exchanges. Defaults to granting a token for the provider. */
   connectionResponder;
+  /** The person the authorization endpoint signs in when the request names none with `login_hint`. Defaults to the first user. */
+  signInAs;
   clients = /* @__PURE__ */ new Map();
   users = /* @__PURE__ */ new Map();
+  personalAccessTokens = /* @__PURE__ */ new Map();
   codes = /* @__PURE__ */ new Map();
   refreshTokens = /* @__PURE__ */ new Map();
   issued = /* @__PURE__ */ new Map();
   devicePolls = /* @__PURE__ */ new Map();
   lifetime;
+  session;
   server;
   signingKey;
+  verificationKey;
   untrustedKey;
   publicJwk;
   baseUrl;
@@ -38,6 +47,7 @@ var FakeAuthio = class _FakeAuthio {
     this.lifetime = options.accessTokenLifetime ?? 300;
     for (const client of options.clients ?? []) this.clients.set(client.clientId, 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);
   }
   /**
    * Starts the fake on a random loopback port.
@@ -59,6 +69,10 @@ var FakeAuthio = class _FakeAuthio {
   get jwks() {
     return { keys: [this.publicJwk] };
   }
+  /** The session the authorization endpoint keeps (one browser), or `undefined` when nobody is signed in. */
+  get currentSession() {
+    return this.session ? { sub: this.session.sub, sid: this.session.sid, authTime: this.session.authTime } : void 0;
+  }
   /** Registers a client. */
   addClient(client) {
     this.clients.set(client.clientId, client);
@@ -67,6 +81,14 @@ var FakeAuthio = class _FakeAuthio {
   addUser(user) {
     this.users.set(user.username, user);
   }
+  /** Registers a personal access token. */
+  addPersonalAccessToken(token) {
+    this.personalAccessTokens.set(token.token, token);
+  }
+  /** Ends the signed-in session without notifying anyone, as if it expired. */
+  endSession() {
+    this.session = void 0;
+  }
   /**
    * Registers an authorization code for a person, as the authorization endpoint would after sign-in.
    */
@@ -79,10 +101,27 @@ var FakeAuthio = class _FakeAuthio {
       redirectUri: options.redirectUri,
       scope: options.scope,
       codeVerifier: options.codeChallengeVerifier,
-      resource: options.resource
+      resource: options.resource,
+      nonce: options.nonce
     });
     return code;
   }
+  /**
+   * Follows an authorization URL as a browser would, signing in `signInAs` (or the `login_hint`), and returns what
+   * Authio sent back: the callback URL for `response_mode=query`, the posted message's parameters for `web_message`.
+   */
+  async authorize(authorizationUrl) {
+    const response = await fetch(authorizationUrl, { redirect: "manual" });
+    const location = response.headers.get("location");
+    if (location) {
+      const callback = new URL(location);
+      return { parameters: Object.fromEntries(callback.searchParams), callbackUrl: location };
+    }
+    const html = await response.text();
+    const message = /data-authorization-response='([^']*)'/.exec(html)?.[1];
+    if (!message) throw new Error(`The fake answered the authorization with HTTP ${response.status} and no response.`);
+    return { parameters: JSON.parse(decodeURIComponent(message)), callbackUrl: void 0 };
+  }
   /**
    * Mints an access token signed by the realm key, recorded so introspection and revocation know it.
    */
@@ -98,14 +137,68 @@ var FakeAuthio = class _FakeAuthio {
       ...options.sub ? { sub: options.sub } : {},
       ...options.claims
     };
-    const token = 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);
-    this.issued.set(token, { claims: jose.decodeJwt(token), clientId, revoked: false });
+    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 token = options.encryptTo ? await encryptTo(signed, options.encryptTo) : signed;
+    this.issued.set(token, { claims: jose.decodeJwt(signed), clientId, revoked: false });
     return token;
   }
-  /** Marks a token revoked, as Authio would after a sign-out. */
+  /**
+   * Mints a back-channel logout token for a client, signed by the realm key. `overrides` replaces claims (`undefined`
+   * removes one) and `type` the header `typ`, to build invalid ones in tests.
+   */
+  async createLogoutToken(options) {
+    const now = Math.floor(Date.now() / 1e3);
+    const payload = {
+      iss: this.issuer,
+      aud: options.clientId,
+      iat: now,
+      exp: now + 120,
+      jti: crypto.randomUUID(),
+      ...options.sub ? { sub: options.sub } : {},
+      ...options.sid ? { sid: options.sid } : {},
+      events: { "http://schemas.openid.net/event/backchannel-logout": {} },
+      ...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 encryption = this.clients.get(options.clientId)?.encryption;
+    return encryption?.logoutTokens ? encryptTo(signed, encryption) : signed;
+  }
+  /**
+   * Posts a back-channel logout token to the client's `backchannelLogoutUri`, as Authio does when a session ends.
+   *
+   * @returns The HTTP status the client answered, or 0 when it could not be reached.
+   */
+  async deliverBackchannelLogout(clientId, options = {}) {
+    const client = this.clients.get(clientId);
+    if (!client?.backchannelLogoutUri) throw new Error(`The fake client ${clientId} has no backchannelLogoutUri.`);
+    const logoutToken = await this.createLogoutToken({ clientId, sub: options.sub, sid: options.sid });
+    let status = 0;
+    try {
+      const response = await fetch(client.backchannelLogoutUri, {
+        method: "POST",
+        headers: { "content-type": "application/x-www-form-urlencoded" },
+        body: new URLSearchParams({ logout_token: logoutToken }).toString()
+      });
+      status = response.status;
+      await response.arrayBuffer();
+    } catch {
+      status = 0;
+    }
+    this.backchannelDeliveries.push({ clientId, uri: client.backchannelLogoutUri, logoutToken, 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);
     if (issued) issued.revoked = true;
+    this.refreshTokens.delete(token);
+  }
+  /** Revokes every refresh token of a person, or of one Authio session (`sid`), as Authio does when a session ends. */
+  revokeRefreshTokens(options) {
+    for (const [token, refresh] of this.refreshTokens)
+      if (options.sid !== void 0 && refresh.sid === options.sid || options.sid === void 0 && options.sub !== void 0 && refresh.sub === options.sub)
+        this.refreshTokens.delete(token);
   }
   /** Forgets the recorded requests. */
   clearRequests() {
@@ -126,6 +219,7 @@ var FakeAuthio = class _FakeAuthio {
     const pair = await jose.generateKeyPair("RS256", { extractable: true });
     const untrusted = await jose.generateKeyPair("RS256");
     this.signingKey = pair.privateKey;
+    this.verificationKey = pair.publicKey;
     this.untrustedKey = untrusted.privateKey;
     this.publicJwk = { ...await jose.exportJWK(pair.publicKey), kid: this.keyId, alg: "RS256", use: "sig" };
     this.server = http.createServer((request, response) => {
@@ -141,7 +235,8 @@ var FakeAuthio = class _FakeAuthio {
     const body = await readBody(request);
     const form = Object.fromEntries(new URLSearchParams(request.headers["content-type"]?.includes("form") ? body : ""));
     const headers = Object.fromEntries(Object.entries(request.headers).map(([name, value]) => [name, Array.isArray(value) ? value.join(", ") : value ?? ""]));
-    const recorded = { method: request.method ?? "GET", path: url.pathname, headers, form };
+    const query = Object.fromEntries(url.searchParams);
+    const recorded = { method: request.method ?? "GET", path: url.pathname, headers, form, query };
     this.requests.push(recorded);
     const prefix = `/realms/${this.realm}`;
     const path = url.pathname.startsWith(prefix) ? url.pathname.slice(prefix.length) : url.pathname;
@@ -153,6 +248,8 @@ var FakeAuthio = class _FakeAuthio {
         return send(response, { status: 200, body: this.discovery() });
       case "/protocol/openid-connect/certs":
         return send(response, { status: 200, body: this.jwks });
+      case "/protocol/openid-connect/auth":
+        return this.authorizeEndpoint(query, response);
       case "/protocol/openid-connect/token":
         return send(response, await this.token(recorded, form));
       case "/protocol/openid-connect/token/introspect":
@@ -163,6 +260,8 @@ var FakeAuthio = class _FakeAuthio {
         return this.userInfo(headers, response);
       case "/protocol/openid-connect/auth/device":
         return send(response, await this.device(recorded, form));
+      case "/protocol/openid-connect/logout":
+        return this.endSessionEndpoint(query, response);
       default:
         return send(response, { status: 404, body: { error: "not_found" } });
     }
@@ -179,12 +278,129 @@ var FakeAuthio = class _FakeAuthio {
       end_session_endpoint: `${base}/logout`,
       device_authorization_endpoint: `${base}/auth/device`,
       jwks_uri: `${base}/certs`,
-      grant_types_supported: ["authorization_code", "refresh_token", "client_credentials", "password", "urn:ietf:params:oauth:grant-type:device_code", "urn:ietf:params:oauth:grant-type:token-exchange"],
+      scopes_supported: ["openid", "profile", "email", "phone", "roles", "offline_access"],
+      response_types_supported: ["code"],
+      response_modes_supported: ["query", "web_message"],
+      grant_types_supported: [
+        "authorization_code",
+        "refresh_token",
+        "client_credentials",
+        "password",
+        "urn:ietf:params:oauth:grant-type:device_code",
+        "urn:ietf:params:oauth:grant-type:token-exchange",
+        "personal_access_token"
+      ],
+      subject_types_supported: ["public"],
+      id_token_signing_alg_values_supported: ["RS256"],
+      id_token_encryption_alg_values_supported: ["RSA-OAEP", "RSA-OAEP-256"],
+      id_token_encryption_enc_values_supported: ["A128CBC-HS256", "A192CBC-HS384", "A256CBC-HS512"],
+      userinfo_signing_alg_values_supported: ["RS256"],
+      userinfo_encryption_alg_values_supported: ["RSA-OAEP", "RSA-OAEP-256"],
+      userinfo_encryption_enc_values_supported: ["A128CBC-HS256", "A192CBC-HS384", "A256CBC-HS512"],
       token_endpoint_auth_methods_supported: ["client_secret_basic", "client_secret_post", "private_key_jwt", "none"],
-      code_challenge_methods_supported: ["S256"],
-      authorization_response_iss_parameter_supported: true
+      code_challenge_methods_supported: ["S256", "plain"],
+      prompt_values_supported: ["none", "login", "select_account", "consent"],
+      display_values_supported: ["page", "popup"],
+      acr_values_supported: ["1", "2", "3"],
+      backchannel_logout_supported: true,
+      backchannel_logout_session_supported: true,
+      authorization_response_iss_parameter_supported: !this.omitAuthorizationIssuer
     };
   }
+  authorizeEndpoint(query, response) {
+    const client = this.clients.get(query.client_id ?? "");
+    if (!client) return send(response, { status: 400, body: { error: "invalid_request", error_description: "Unknown client_id." } });
+    if (!query.redirect_uri || client.redirectUris && !client.redirectUris.includes(query.redirect_uri))
+      return send(response, { status: 400, body: { error: "invalid_request", error_description: "The redirect_uri is not registered." } });
+    const answer = (parameters) => {
+      const values = {};
+      for (const [name, value] of Object.entries({ ...parameters, state: query.state, iss: this.omitAuthorizationIssuer ? void 0 : this.issuer }))
+        if (value !== void 0) values[name] = value;
+      if (query.response_mode === "web_message") {
+        const message = encodeURIComponent(JSON.stringify(values));
+        response.writeHead(200, { "content-type": "text/html; charset=utf-8" });
+        response.end(
+          `<!doctype html><html><body data-authorization-response='${message}'><script>window.opener&&window.opener.postMessage({type:"authorization_response",response:JSON.parse(decodeURIComponent(document.body.dataset.authorizationResponse))},${JSON.stringify(new URL(query.redirect_uri).origin)});</script></body></html>`
+        );
+        return;
+      }
+      const location = new URL(query.redirect_uri);
+      for (const [name, value] of Object.entries(values)) location.searchParams.set(name, value);
+      response.writeHead(302, { location: location.toString() });
+      response.end();
+    };
+    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 prompts = (query.prompt ?? "").split(" ").filter(Boolean);
+    const now = Math.floor(Date.now() / 1e3);
+    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);
+    const weaker = this.session !== void 0 && requestedAcr !== void 0 && Number(this.session.acr) < Number(requestedAcr);
+    if (prompts.includes("none") && (!this.session || tooOld || weaker)) return answer({ error: "login_required", error_description: "Nobody is signed in." });
+    if (!this.session || prompts.includes("login") || tooOld || weaker || query.login_hint && this.users.get(query.login_hint)?.sub !== this.session.sub) {
+      const username = (query.login_hint && this.users.has(query.login_hint) ? query.login_hint : void 0) ?? this.signInAs ?? this.users.keys().next().value;
+      const user = username ? this.users.get(username) : void 0;
+      if (!user) return answer({ error: "access_denied", error_description: "The fake has no user to sign in." });
+      const acr = requestedAcr ?? user.acr ?? "1";
+      this.session = {
+        sub: user.sub,
+        sid: crypto.randomUUID().replace(/-/g, ""),
+        authTime: now,
+        acr,
+        amr: user.amr ?? (Number(acr) >= 2 ? ["pwd", "otp", "mfa"] : ["pwd"]),
+        clients: /* @__PURE__ */ new Set()
+      };
+    }
+    this.session.clients.add(client.clientId);
+    const code = crypto.randomUUID();
+    this.codes.set(code, {
+      clientId: client.clientId,
+      sub: this.session.sub,
+      redirectUri: query.redirect_uri,
+      scope: query.scope,
+      codeChallenge: query.code_challenge,
+      codeChallengeMethod: method,
+      resource: query.resource,
+      nonce: query.nonce,
+      sid: this.session.sid,
+      authTime: this.session.authTime,
+      acr: this.session.acr,
+      amr: this.session.amr
+    });
+    answer({ code });
+  }
+  async endSessionEndpoint(query, response) {
+    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 });
+        clientId ??= [payload.aud ?? []].flat()[0];
+      } catch {
+        return send(response, { status: 400, body: { error: "invalid_request", error_description: "The id_token_hint is not valid." } });
+      }
+    }
+    const client = clientId ? this.clients.get(clientId) : void 0;
+    const redirect = query.post_logout_redirect_uri;
+    if (redirect && (!client || client.postLogoutRedirectUris && !client.postLogoutRedirectUris.includes(redirect)))
+      return send(response, { status: 400, body: { error: "invalid_request", error_description: "The post_logout_redirect_uri is not registered." } });
+    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 (!redirect) {
+      response.writeHead(200, { "content-type": "text/html; charset=utf-8" });
+      response.end("<!doctype html><p>You are signed out.</p>");
+      return;
+    }
+    const location = new URL(redirect);
+    if (query.state) location.searchParams.set("state", query.state);
+    response.writeHead(302, { location: location.toString() });
+    response.end();
+  }
   async authenticate(recorded, form) {
     const invalid = (description) => ({ status: 401, body: { error: "invalid_client", error_description: description } });
     const authorization = recorded.headers.authorization;
@@ -215,10 +431,23 @@ var FakeAuthio = class _FakeAuthio {
     return client;
   }
   async token(recorded, form) {
+    const grant = (error, description) => ({ status: 400, body: { error, error_description: description } });
+    if (form.grant_type === "personal_access_token") {
+      const pat = this.personalAccessTokens.get(form.client_secret ?? "");
+      if (!pat || form.client_id && pat.clientId && form.client_id !== pat.clientId)
+        return { status: 401, body: { error: "invalid_client", error_description: "The personal access token is not valid." } };
+      const clientId = pat.clientId ?? "authio";
+      recorded.clientId = clientId;
+      return this.tokenAnswer(this.clients.get(clientId) ?? { clientId }, {
+        sub: pat.sub,
+        scope: form.scope,
+        audience: form.resource,
+        claims: { amr: "personal_access_token", actor_type: "personal_access_token", credential_id: pat.sub, ...pat.claims }
+      });
+    }
     const client = await this.authenticate(recorded, form);
     if ("status" in client) return client;
     const scope = form.scope ?? client.defaultScopes?.join(" ");
-    const grant = (error, description) => ({ status: 400, body: { error, error_description: description } });
     switch (form.grant_type) {
       case "client_credentials":
         return this.tokenAnswer(client, { sub: client.clientId, scope, audience: form.resource, claims: client.claims });
@@ -231,12 +460,22 @@ 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"))
+          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"] };
         return this.tokenAnswer(
           client,
-          { sub: user.sub, scope: code.scope, audience: form.resource ?? code.resource, claims: { ...client.claims, ...user.claims, preferred_username: user.username } },
-          user
+          {
+            sub: user.sub,
+            scope: code.scope,
+            audience: form.resource ?? code.resource,
+            claims: { ...client.claims, ...user.claims, ...signIn, preferred_username: user.username }
+          },
+          user,
+          void 0,
+          { nonce: code.nonce, signIn }
         );
       }
       case "refresh_token": {
@@ -246,7 +485,7 @@ var FakeAuthio = class _FakeAuthio {
         const user = [...this.users.values()].find((candidate) => candidate.sub === refresh.sub);
         return this.tokenAnswer(
           client,
-          { sub: refresh.sub, scope: form.scope ?? refresh.scope, claims: { ...client.claims, ...user?.claims } },
+          { sub: refresh.sub, scope: form.scope ?? refresh.scope, claims: { ...client.claims, ...user?.claims, ...refresh.sid ? { sid: refresh.sid } : {} } },
           user
         );
       }
@@ -263,12 +502,12 @@ var FakeAuthio = class _FakeAuthio {
           };
           return "status" in answer && typeof answer.status === "number" ? answer : { status: 200, body: answer };
         }
-        const { iss: _issuer, aud: _audience, exp: _expiry, iat: _issuedAt, nbf: _notBefore, jti: _jti, ...claims } = subject.claims;
+        const { iss: _issuer, aud: _audience, exp: _expiry, iat: _issuedAt, nbf: _notBefore, jti: _jti, scope: _scope, ...claims } = subject.claims;
         return this.tokenAnswer(client, {
           sub: subject.claims.sub,
           scope: form.scope ?? subject.claims.scope,
           audience: form.resource,
-          claims: { ...claims, act: { client_id: client.clientId, sub: client.clientId } }
+          claims: { ...claims, act: { client_id: client.clientId } }
         }, void 0, form.requested_token_type);
       }
       case "urn:ietf:params:oauth:grant-type:device_code": {
@@ -293,13 +532,15 @@ var FakeAuthio = class _FakeAuthio {
         return grant("unsupported_grant_type", `The grant ${form.grant_type} is not supported.`);
     }
   }
-  async tokenAnswer(client, options, user, issuedTokenType) {
+  async tokenAnswer(client, options, user, issuedTokenType, idToken) {
+    const encryption = client.encryption;
     const accessToken = await this.issueAccessToken({
       clientId: client.clientId,
       sub: options.sub,
       scope: options.scope,
       audience: options.audience ?? client.clientId,
-      claims: options.claims
+      claims: options.claims,
+      ...encryption?.accessTokens ? { encryptTo: encryption } : {}
     });
     const body = {
       access_token: accessToken,
@@ -310,9 +551,24 @@ var FakeAuthio = class _FakeAuthio {
     };
     if (user) {
       const refreshToken = crypto.randomUUID();
-      this.refreshTokens.set(refreshToken, { clientId: client.clientId, sub: user.sub, scope: options.scope });
+      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 });
       body.refresh_token = refreshToken;
     }
+    if (user && idToken && (options.scope ?? "").split(" ").includes("openid")) {
+      const now = Math.floor(Date.now() / 1e3);
+      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);
+      body.id_token = encryption && encryption.idTokens !== false ? await encryptTo(signed, encryption) : signed;
+    }
     return { status: 200, body };
   }
   async introspect(recorded, form) {
@@ -320,6 +576,20 @@ var FakeAuthio = class _FakeAuthio {
     if ("status" in client) return client;
     const issued = this.issued.get(form.token ?? "");
     const now = Math.floor(Date.now() / 1e3);
+    const refresh = this.refreshTokens.get(form.token ?? "");
+    if (refresh)
+      return refresh.clientId === client.clientId ? {
+        status: 200,
+        body: {
+          active: true,
+          token_type: "Refresh",
+          client_id: refresh.clientId,
+          sub: refresh.sub,
+          exp: refresh.expiresAt,
+          ...refresh.scope ? { scope: refresh.scope } : {},
+          ...refresh.sid ? { sid: refresh.sid } : {}
+        }
+      } : { status: 200, body: { active: false } };
     if (!issued || issued.revoked || (issued.claims.exp ?? 0) <= now) return { status: 200, body: { active: false } };
     const audiences = [issued.claims.aud ?? []].flat();
     const allowed = issued.clientId === client.clientId && audiences.includes(client.clientId) ? true : audiences.some((audience) => this.clients.get(audience)?.introspectionClients?.includes(client.clientId) || audience === client.clientId);
@@ -362,7 +632,10 @@ 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 jwt = await new jose.SignJWT(claims).setProtectedHeader({ alg: "RS256", kid: this.keyId }).setIssuer(this.issuer).setAudience(issued.clientId).setIssuedAt().sign(this.signingKey);
+    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 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);
   }
@@ -379,8 +652,22 @@ function endpointOf(path) {
   if (path.endsWith("/userinfo")) return "userinfo";
   if (path.endsWith("/auth/device")) return "device";
   if (path.endsWith("/openid-configuration")) return "discovery";
+  if (path.endsWith("/auth")) return "authorize";
+  if (path.endsWith("/logout")) return "logout";
   return void 0;
 }
+async function encryptTo(signed, encryption) {
+  const algorithm = encryption.algorithm ?? "RSA-OAEP-256";
+  const key = await jose.importJWK({ ...encryption.key, alg: algorithm, use: "enc", key_ops: void 0 }, algorithm);
+  return new jose.CompactEncrypt(new TextEncoder().encode(signed)).setProtectedHeader({ alg: algorithm, enc: encryption.encryptionMethod ?? "A256CBC-HS512", typ: "JWE", cty: "JWT", ...encryption.key.kid ? { kid: encryption.key.kid } : {} }).encrypt(key);
+}
+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 send(response, answer) {
   const headers = { ...answer.headers };
   if (answer.body !== void 0) headers["content-type"] ??= "application/json";