@broberg/sso 0.20.0 → 0.21.1

package/dist/{chunk-KEBSZBHL.cjs → chunk-XQEHSHLR.cjs}

@@ -1,6 +1,8 @@
 'use strict';
 
 var jose = require('jose');
+var fs = require('fs');
+var http = require('http');
 
 // src/config.ts
 var SsoConfigError = class extends Error {
@@ -16,6 +18,12 @@ function required(env, name, hint) {
   }
   return raw.trim();
 }
+function parseClientAuth(raw) {
+  const v = raw?.trim();
+  if (!v) return void 0;
+  if (v === "secret" || v === "fly") return v;
+  throw new SsoConfigError(`SSO_CLIENT_AUTH must be "secret" or "fly" (got ${JSON.stringify(raw)}).`);
+}
 var DEFAULT_SESSION_MAX_AGE = 60 * 60 * 24 * 7;
 function loadSsoConfig(env = process.env) {
   const rawIssuer = required(
@@ -70,7 +78,8 @@ function loadSsoConfig(env = process.env) {
     cookieName: env.SSO_COOKIE_NAME?.trim() || "bid_session",
     sessionMaxAge,
     postLogoutRedirectUri: env.SSO_POST_LOGOUT_REDIRECT_URI?.trim() || void 0,
-    clientSecret: env.SSO_CLIENT_SECRET?.trim() || void 0
+    clientSecret: env.SSO_CLIENT_SECRET?.trim() || void 0,
+    clientAuth: parseClientAuth(env.SSO_CLIENT_AUTH)
   };
 }
 
@@ -286,6 +295,184 @@ function createJwksCache(options) {
     }
   };
 }
+var DEFAULT_ISSUER = "https://id.broberg.ai";
+var FLY_SOCKET = "/.fly/api";
+var NoWorkloadIdentityError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "NoWorkloadIdentityError";
+  }
+};
+var TicketExchangeError = class extends Error {
+  constructor(message, code, status) {
+    super(message);
+    this.code = code;
+    this.status = status;
+    this.name = "TicketExchangeError";
+  }
+  code;
+  status;
+};
+var TicketUnavailableError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "TicketUnavailableError";
+  }
+};
+function flyOidcOverSocket(aud) {
+  return new Promise((resolve, reject) => {
+    const body = JSON.stringify({ aud });
+    const req = http.request(
+      { socketPath: FLY_SOCKET, path: "/v1/tokens/oidc", method: "POST", headers: { "content-type": "application/json", "content-length": Buffer.byteLength(body) } },
+      (res) => {
+        let data = "";
+        res.setEncoding("utf8");
+        res.on("data", (c) => data += c);
+        res.on("end", () => {
+          if ((res.statusCode ?? 0) >= 200 && (res.statusCode ?? 0) < 300) resolve(data.trim());
+          else reject(new TicketUnavailableError(`Fly OIDC answered ${res.statusCode}`));
+        });
+      }
+    );
+    req.on("error", (e) => reject(new TicketUnavailableError(`Fly OIDC socket: ${e.message}`)));
+    req.end(body);
+  });
+}
+function jwtExp(token) {
+  try {
+    const payload = JSON.parse(Buffer.from(token.split(".")[1] ?? "", "base64url").toString("utf8"));
+    return typeof payload.exp === "number" ? payload.exp : null;
+  } catch {
+    return null;
+  }
+}
+async function readTicketResponse(res, issuer, target, now) {
+  let body = {};
+  try {
+    body = await res.json();
+  } catch {
+  }
+  if (res.status >= 500) throw new TicketUnavailableError(`${issuer} answered ${res.status}`);
+  if (!res.ok || !body.access_token) {
+    const desc = body.error_description ?? "";
+    const code = desc.includes(":") ? desc.slice(0, desc.indexOf(":")).trim() : body.error ?? "exchange_refused";
+    throw new TicketExchangeError(`BID refused the ticket for ${target}: ${desc || body.error || res.status}`, code, res.status);
+  }
+  const nowSec = Math.floor(now() / 1e3);
+  const exp = jwtExp(body.access_token) ?? nowSec + (body.expires_in ?? 300);
+  return { token: body.access_token, exp };
+}
+function createTicketClient(options = {}) {
+  const issuer = (options.issuer ?? DEFAULT_ISSUER).replace(/\/+$/, "");
+  const renewBeforeSec = options.renewBeforeSec ?? 30;
+  const env = options.env ?? process.env;
+  const fetchImpl = options.fetchImpl ?? fetch;
+  const now = options.now ?? (() => Date.now());
+  const flyOidc = options.flyOidc ?? flyOidcOverSocket;
+  const onFly = options.onFly ?? (() => !!env.FLY_APP_NAME && fs.existsSync(FLY_SOCKET));
+  const cache = /* @__PURE__ */ new Map();
+  const inFlight = /* @__PURE__ */ new Map();
+  let dpopKey = null;
+  const ownKey = () => dpopKey ??= createDpopKey();
+  async function platformToken() {
+    if (onFly()) return flyOidc(issuer);
+    const url = env.ACTIONS_ID_TOKEN_REQUEST_URL;
+    const bearer = env.ACTIONS_ID_TOKEN_REQUEST_TOKEN;
+    if (url && bearer) {
+      let res;
+      try {
+        res = await fetchImpl(`${url}&audience=${encodeURIComponent(issuer)}`, { headers: { authorization: `Bearer ${bearer}` } });
+      } catch (e) {
+        throw new TicketUnavailableError(`GitHub OIDC endpoint unreachable: ${e instanceof Error ? e.message : String(e)}`);
+      }
+      if (!res.ok) throw new TicketUnavailableError(`GitHub OIDC endpoint answered ${res.status}`);
+      const { value } = await res.json();
+      if (!value) throw new TicketUnavailableError("GitHub OIDC endpoint returned no token");
+      return value;
+    }
+    throw new NoWorkloadIdentityError(
+      "No workload identity to exchange for a ticket: not on a Fly machine (FLY_APP_NAME + /.fly/api) and not in a GitHub Actions job (ACTIONS_ID_TOKEN_REQUEST_URL/_TOKEN \u2014 add `permissions: id-token: write`). A Mac session keeps using its session key."
+    );
+  }
+  async function exchange(audience, scope) {
+    const subject = await platformToken();
+    const form = new URLSearchParams({
+      grant_type: "urn:ietf:params:oauth:grant-type:token-exchange",
+      subject_token: subject,
+      subject_token_type: "urn:ietf:params:oauth:token-type:jwt",
+      audience
+    });
+    if (scope) form.set("scope", scope);
+    let res;
+    try {
+      const tokenUrl = `${issuer}/oauth2/token`;
+      const headers = { "content-type": "application/x-www-form-urlencoded" };
+      if (options.dpop) headers.dpop = await createDpopProof(await ownKey(), { method: "POST", url: tokenUrl, now });
+      res = await fetchImpl(tokenUrl, { method: "POST", headers, body: form });
+    } catch (e) {
+      throw new TicketUnavailableError(`${issuer} unreachable: ${e instanceof Error ? e.message : String(e)}`);
+    }
+    return readTicketResponse(res, issuer, audience, now);
+  }
+  const client = {
+    async authHeaders({ audience, scope, method, url }) {
+      const ticket = await client.get({ audience, scope });
+      if (!options.dpop) return { authorization: `Bearer ${ticket}` };
+      return { authorization: `DPoP ${ticket}`, dpop: await createDpopProof(await ownKey(), { method, url, ticket, now }) };
+    },
+    async get({ audience, scope }) {
+      const key = `${audience} ${scope ?? ""}`;
+      const hit = cache.get(key);
+      if (hit && hit.exp - renewBeforeSec > now() / 1e3) return hit.token;
+      const pending = inFlight.get(key);
+      if (pending) return pending;
+      const p = exchange(audience, scope).then((t) => {
+        cache.set(key, t);
+        return t.token;
+      }).finally(() => inFlight.delete(key));
+      inFlight.set(key, p);
+      return p;
+    }
+  };
+  return client;
+}
+var shared = null;
+function fetchTicket(opts) {
+  shared ??= createTicketClient();
+  return shared.get(opts);
+}
+async function exchangeUserToken(opts) {
+  const issuer = (opts.issuer ?? DEFAULT_ISSUER).replace(/\/+$/, "");
+  const target = opts.resource ?? opts.audience;
+  if (!target) throw new TicketExchangeError("exchangeUserToken needs a receiver: resource (its URL) or audience (BID's name for it)", "malformed_request", 0);
+  const fetchImpl = opts.fetchImpl ?? fetch;
+  const now = opts.now ?? (() => Date.now());
+  const form = new URLSearchParams({
+    grant_type: "urn:ietf:params:oauth:grant-type:token-exchange",
+    subject_token: opts.subjectToken,
+    subject_token_type: "urn:ietf:params:oauth:token-type:access_token"
+  });
+  if (opts.resource) form.set("resource", opts.resource);
+  if (opts.audience) form.set("audience", opts.audience);
+  if (opts.scope) form.set("scope", opts.scope);
+  const tokenUrl = `${issuer}/oauth2/token`;
+  const headers = { "content-type": "application/x-www-form-urlencoded" };
+  if (opts.clientSecret) {
+    headers.authorization = `Basic ${btoa(`${encodeURIComponent(opts.clientId)}:${encodeURIComponent(opts.clientSecret)}`)}`;
+  } else {
+    form.set("client_id", opts.clientId);
+  }
+  if (opts.dpopKey) headers.dpop = await createDpopProof(opts.dpopKey, { method: "POST", url: tokenUrl, now });
+  let res;
+  try {
+    res = await fetchImpl(tokenUrl, { method: "POST", headers, body: form });
+  } catch (e) {
+    throw new TicketUnavailableError(`${issuer} unreachable: ${e instanceof Error ? e.message : String(e)}`);
+  }
+  return readTicketResponse(res, issuer, target, now);
+}
+
+// src/client.ts
 var SsoError = class extends Error {
   constructor(message) {
     super(message);
@@ -370,6 +557,7 @@ var INVITATION_OUTCOMES = /* @__PURE__ */ new Set([
 var MIGRATION_STATES = /* @__PURE__ */ new Set(["ready", "invited", "expired", "not_invited"]);
 var BACKCHANNEL_EVENT = "http://schemas.openid.net/event/backchannel-logout";
 var MAX_INVITATIONS = 500;
+var FLY_CLIENT_ASSERTION_TYPE = "urn:broberg:params:oauth:client-assertion-type:fly-oidc";
 function excerptForLog(raw, clientSecret) {
   let text = raw.replace(/\s+/g, " ").trim();
   if (clientSecret) text = text.split(clientSecret).join("[redacted client_secret]");
@@ -405,6 +593,18 @@ var ALLOWED_ALGS = [
 function createSsoClient(config, options = {}) {
   const fetchImpl = options.fetchImpl ?? fetch;
   const timeoutMs = options.timeoutMs ?? 1e4;
+  const flyOidc = options.flyOidc ?? flyOidcOverSocket;
+  async function tokenEndpointAuth(tokenEndpoint) {
+    if (config.clientAuth !== "fly") return config.clientSecret ? { client_secret: config.clientSecret } : {};
+    let assertion;
+    try {
+      assertion = await flyOidc(tokenEndpoint);
+    } catch (e) {
+      throw new SsoError(`fly client assertion unavailable: could not get a Fly OIDC token for ${tokenEndpoint} \u2014 ${e instanceof Error ? e.message : String(e)}`);
+    }
+    if (!assertion) throw new SsoError(`fly client assertion unavailable: Fly returned an empty token for ${tokenEndpoint}`);
+    return { client_assertion_type: FLY_CLIENT_ASSERTION_TYPE, client_assertion: assertion };
+  }
   async function appPost(path, bearer, payload, what) {
     const url = new URL(path, config.issuer).toString();
     const ctrl = new AbortController();
@@ -688,7 +888,7 @@ function createSsoClient(config, options = {}) {
         // ALWAYS sent, secret or not. See SsoConfig.clientSecret: the two
         // prove different things, so a confidential client keeps PKCE.
         code_verifier: codeVerifier,
-        ...config.clientSecret ? { client_secret: config.clientSecret } : {}
+        ...await tokenEndpointAuth(token_endpoint)
       })
     });
     const raw = await res.text();
@@ -782,6 +982,11 @@ function createSsoClient(config, options = {}) {
         code_challenge: await challengeFor(codeVerifier),
         code_challenge_method: "S256",
         nonce,
+        // F084.183 — the redirect the code is BOUND to, the same value /oauth2/token sends.
+        // Without it BID bound the code to the client's FIRST registered redirect, and an
+        // app served from another of its registered hosts (Jam on jams.party) got
+        // «invalid_grant — redirect_uri mismatch» at the exchange.
+        redirect_uri: config.redirectUri,
         ...input.intent === "signup" ? { intent: "signup", name: input.name, terms_version: input.termsVersion } : {},
         ...input.endUserIp ? { end_user_ip: input.endUserIp } : {}
       });
@@ -868,7 +1073,7 @@ function createSsoClient(config, options = {}) {
           grant_type: "refresh_token",
           refresh_token: refreshToken,
           client_id: config.clientId,
-          ...config.clientSecret ? { client_secret: config.clientSecret } : {}
+          ...await tokenEndpointAuth(token_endpoint)
         })
       });
       const raw = await res.text();
@@ -974,6 +1179,84 @@ function createSsoClient(config, options = {}) {
   };
 }
 
+// src/dpop.ts
+async function createDpopKey() {
+  const { privateKey, publicKey } = await jose.generateKeyPair("ES256", { extractable: false });
+  const jwk = await jose.exportJWK(publicKey);
+  const publicJwk = { kty: jwk.kty, crv: jwk.crv, x: jwk.x, y: jwk.y };
+  return { privateKey, publicJwk, jkt: await jose.calculateJwkThumbprint(publicJwk) };
+}
+var enc2 = new TextEncoder();
+var b64url3 = (bytes) => btoa(String.fromCharCode(...new Uint8Array(bytes))).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
+async function accessTokenHash(ticket) {
+  return b64url3(await crypto.subtle.digest("SHA-256", enc2.encode(ticket)));
+}
+function normalizeHtu(url) {
+  const u = new URL(url);
+  return `${u.protocol}//${u.host}${u.pathname}`;
+}
+async function createDpopProof(key, opts) {
+  const payload = {
+    jti: crypto.randomUUID(),
+    htm: opts.method.toUpperCase(),
+    htu: normalizeHtu(opts.url),
+    iat: Math.floor((opts.now?.() ?? Date.now()) / 1e3)
+  };
+  if (opts.ticket !== void 0) payload.ath = await accessTokenHash(opts.ticket);
+  return new jose.SignJWT(payload).setProtectedHeader({ typ: "dpop+jwt", alg: "ES256", jwk: key.publicJwk }).sign(key.privateKey);
+}
+function createMemoryReplayStore(now = () => Date.now()) {
+  const entries = /* @__PURE__ */ new Map();
+  return {
+    async seen(key, ttlMs) {
+      const t = now();
+      for (const [k, until] of entries) if (until <= t) entries.delete(k);
+      if (entries.has(key)) return true;
+      entries.set(key, t + ttlMs);
+      return false;
+    }
+  };
+}
+var ASYMMETRIC = /* @__PURE__ */ new Set(["ES256", "ES384", "ES512", "EdDSA", "PS256", "PS384", "PS512", "RS256", "RS384", "RS512"]);
+async function verifyDpopProof(proof, o) {
+  let header;
+  try {
+    header = jose.decodeProtectedHeader(proof);
+  } catch {
+    throw new SsoError("DPoP proof is not a JWS");
+  }
+  if (header.typ !== "dpop+jwt") throw new SsoError(`DPoP proof has typ ${JSON.stringify(header.typ)}, not "dpop+jwt"`);
+  if (!header.alg || !ASYMMETRIC.has(header.alg)) throw new SsoError(`DPoP proof alg ${JSON.stringify(header.alg)} is not an accepted asymmetric algorithm`);
+  const jwk = header.jwk;
+  if (!jwk || typeof jwk !== "object") throw new SsoError("DPoP proof carries no jwk");
+  if ("d" in jwk) throw new SsoError("DPoP proof jwk contains a private key");
+  let payload;
+  try {
+    const key = await jose.importJWK(jwk, header.alg);
+    ({ payload } = await jose.jwtVerify(proof, key, { typ: "dpop+jwt", algorithms: [header.alg] }));
+  } catch (e) {
+    throw new SsoError(`DPoP proof signature rejected: ${e instanceof Error ? e.message : String(e)}`);
+  }
+  if (await jose.calculateJwkThumbprint(jwk) !== o.jkt) throw new SsoError("DPoP proof key does not match the ticket's cnf.jkt");
+  if (payload.htm !== o.method.toUpperCase()) throw new SsoError(`DPoP proof is for ${JSON.stringify(payload.htm)}, the request is ${o.method.toUpperCase()}`);
+  let htu;
+  try {
+    htu = normalizeHtu(String(payload.htu));
+  } catch {
+    throw new SsoError("DPoP proof htu is not a URL");
+  }
+  if (htu !== normalizeHtu(o.url)) throw new SsoError(`DPoP proof is for ${htu}, the request is ${normalizeHtu(o.url)}`);
+  const nowSec = Math.floor(o.now() / 1e3);
+  if (typeof payload.iat !== "number" || Math.abs(nowSec - payload.iat) > o.iatWindowSec) {
+    throw new SsoError(`DPoP proof iat is outside \xB1${o.iatWindowSec}s`);
+  }
+  if (payload.ath !== await accessTokenHash(o.ticket)) throw new SsoError("DPoP proof ath does not match this ticket");
+  if (typeof payload.jti !== "string" || payload.jti === "") throw new SsoError("DPoP proof has no jti");
+  if (await o.replay.seen(`${o.jkt}:${payload.jti}`, o.iatWindowSec * 2 * 1e3)) {
+    throw new SsoError("DPoP proof was already used (jti replay)");
+  }
+}
+
 // src/tokens.ts
 var warned = false;
 function memoryTokenStore(options = {}) {
@@ -1023,13 +1306,16 @@ function newSid() {
 
 exports.ALLOWED_ALGS = ALLOWED_ALGS;
 exports.AVATAR_TYPES = AVATAR_TYPES;
+exports.DEFAULT_ISSUER = DEFAULT_ISSUER;
 exports.DEFAULT_SESSION_MAX_AGE = DEFAULT_SESSION_MAX_AGE;
 exports.EMBEDDED_FLOW_MAX_AGE = EMBEDDED_FLOW_MAX_AGE;
+exports.FLY_CLIENT_ASSERTION_TYPE = FLY_CLIENT_ASSERTION_TYPE;
 exports.JwksError = JwksError;
 exports.JwksUnavailableError = JwksUnavailableError;
 exports.JwksUnknownKeyError = JwksUnknownKeyError;
 exports.MAX_AVATAR_BYTES = MAX_AVATAR_BYTES;
 exports.MAX_INVITATIONS = MAX_INVITATIONS;
+exports.NoWorkloadIdentityError = NoWorkloadIdentityError;
 exports.SsoAppApiError = SsoAppApiError;
 exports.SsoAvatarRejectedError = SsoAvatarRejectedError;
 exports.SsoConfigError = SsoConfigError;
@@ -1038,20 +1324,31 @@ exports.SsoInsufficientScopeError = SsoInsufficientScopeError;
 exports.SsoIntrospectionUnavailableError = SsoIntrospectionUnavailableError;
 exports.SsoReauthError = SsoReauthError;
 exports.SsoTokenInactiveError = SsoTokenInactiveError;
+exports.TicketExchangeError = TicketExchangeError;
+exports.TicketUnavailableError = TicketUnavailableError;
+exports.accessTokenHash = accessTokenHash;
 exports.cookieHeader = cookieHeader;
+exports.createDpopKey = createDpopKey;
+exports.createDpopProof = createDpopProof;
 exports.createJwksCache = createJwksCache;
+exports.createMemoryReplayStore = createMemoryReplayStore;
 exports.createSsoClient = createSsoClient;
+exports.createTicketClient = createTicketClient;
+exports.exchangeUserToken = exchangeUserToken;
 exports.expiresAtFrom = expiresAtFrom;
+exports.fetchTicket = fetchTicket;
 exports.loadSsoConfig = loadSsoConfig;
 exports.mediaType = mediaType;
 exports.memoryTokenStore = memoryTokenStore;
 exports.newSid = newSid;
+exports.normalizeHtu = normalizeHtu;
 exports.openEmbeddedFlow = openEmbeddedFlow;
 exports.readCookie = readCookie;
 exports.sealEmbeddedFlow = sealEmbeddedFlow;
 exports.signSession = signSession;
 exports.signValue = signValue;
+exports.verifyDpopProof = verifyDpopProof;
 exports.verifySession = verifySession;
 exports.verifyValue = verifyValue;
-//# sourceMappingURL=chunk-KEBSZBHL.cjs.map
-//# sourceMappingURL=chunk-KEBSZBHL.cjs.map
+//# sourceMappingURL=chunk-XQEHSHLR.cjs.map
+//# sourceMappingURL=chunk-XQEHSHLR.cjs.map