@pipeline-builder/api-core 4.1.3 → 4.1.4

package/lib/services/service-keys.js

@@ -0,0 +1,354 @@
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+/**
+ * Per-service signing keys for INTERNAL service-to-service tokens (#14).
+ *
+ * Before this, every service held one shared `JWT_SECRET`, so any service could
+ * mint a token naming any OTHER service — "billing said so" was unfalsifiable,
+ * and a single compromised workload could speak for the whole fleet. Now each
+ * service signs with its OWN ES256 (EC P-256) key and consumers verify against
+ * the public halves. The `kid` is bound to the signer's NAME, so a token whose
+ * `sub` says `service:billing` but was signed with compliance's key is a
+ * forgery, not a valid token with a confusing subject.
+ *
+ * ## Why public keys are distributed by CONFIG, not by per-service JWKS endpoints
+ *
+ * The user chain (#5) fetches platform's JWKS over HTTP because there is exactly
+ * one signer and it is the one service that must be up for anybody to sign in.
+ * The service chain is the opposite shape, and three properties decided it:
+ *
+ *  1. **`verifyServicePrincipal` must stay synchronous.** The global rate
+ *     limiter's `skip` and app-factory's `/warmup` guard verify a service token
+ *     BEFORE `requireAuth` runs, in synchronous Express callbacks. An HTTP JWKS
+ *     fetch would force those async — a change that reaches into every
+ *     service's limiter wiring.
+ *  2. **No availability coupling.** With per-service JWKS endpoints, verifying a
+ *     token minted by `billing` needs `billing` to be reachable — so billing
+ *     being down would stop platform from accepting billing's in-flight calls,
+ *     turning one outage into several. A mounted file has no such edge.
+ *  3. **No N×N address config.** 10 services would each need every peer's
+ *     host/port (and compose, which has no mesh, would need them too).
+ *
+ * So the deploy generates one keypair per service, mounts each private key ONLY
+ * into its own service, and mounts ONE public bundle (read-only) everywhere:
+ *
+ *   `SERVICE_SIGNING_KEY_FILE`  this service's EC P-256 private key (PKCS#8 PEM)
+ *   `SERVICE_KEY_BUNDLE_FILE`   `{ "services": { "<name>": { "keys": [<jwk>…] } } }`
+ *
+ * Rotation is by `kid`, in the same shape as the user chain: add the new public
+ * key to the bundle (the service now publishes two), roll the bundle out, swap
+ * that service's private key, then drop the retired public key. The bundle is
+ * re-read on an interval AND on an mtime change, so a rotation needs no restart.
+ * `deploy/bin/service-signing-keys.sh` generates and rotates both halves.
+ *
+ * ## Ephemeral mode
+ *
+ * With no `SERVICE_SIGNING_KEY_FILE` configured, a keypair is generated
+ * IN-PROCESS per requested service name and registered in the in-memory bundle.
+ * That keeps single-process suites and local one-off scripts working with no key
+ * material, and it can never widen trust: the only verifier that accepts such a
+ * token is the process that minted it. It is logged once at warn level, and
+ * counted, because in a real deployment it means this service's peers will
+ * reject everything it sends.
+ */
+import crypto, {} from 'crypto';
+import { readFileSync, statSync } from 'fs';
+import jwt from 'jsonwebtoken';
+import { publicJwkFrom, publicKeyFromJwk } from '../utils/jwk.js';
+import { createLogger } from '../utils/logger.js';
+import { emitCounter } from '../utils/metric-emitter.js';
+const logger = createLogger('service-keys');
+/** The ONLY algorithm an internal service token may be signed with. */
+export const SERVICE_TOKEN_ALGORITHM = 'ES256';
+/** Subject prefix naming the calling service on a service token (`service:<name>`). */
+export const SERVICE_SUBJECT_PREFIX = 'service:';
+/** How long a loaded bundle is served before it is re-read (rotation pickup). */
+const BUNDLE_REFRESH_INTERVAL_MS = 300_000; // 5 minutes
+/** The bundle could not be loaded or does not know the key a token names. */
+export class ServiceKeyError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'ServiceKeyError';
+    }
+}
+/**
+ * This process's service identity — the `<name>` in `service:<name>` and the
+ * name its key is published under. `SERVICE_NAME` is already set per service in
+ * every deploy target (compose, minikube, ec2, eks), and is the same value the
+ * audit and metric labels use, so there is one source of truth for "who am I".
+ */
+export function serviceIdentity() {
+    return process.env.SERVICE_NAME || 'api';
+}
+// ---------------------------------------------------------------------------
+// Local signing key
+// ---------------------------------------------------------------------------
+let localKey;
+let ephemeralKeys;
+let ephemeralWarned = false;
+function loadConfiguredSigningKey(file) {
+    const serviceName = serviceIdentity();
+    let privateKey;
+    try {
+        privateKey = crypto.createPrivateKey(readFileSync(file, 'utf8'));
+    }
+    catch (error) {
+        throw new ServiceKeyError(`Could not read the service signing key at ${file}: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    // publicJwkFrom rejects anything but an EC P-256 key, so a service configured
+    // with (say) an RSA key fails HERE rather than minting tokens nobody verifies.
+    const publicJwk = publicJwkFrom(crypto.createPublicKey(privateKey));
+    return { serviceName, kid: publicJwk.kid, privateKey, publicJwk };
+}
+/**
+ * The in-process key for `serviceName` in ephemeral mode, generated on first
+ * use and registered in the in-memory bundle so this process can verify its own
+ * tokens. Keyed by NAME (not just one key) so a single-process suite can mint
+ * tokens for several services, as the real fleet does across processes.
+ */
+function ephemeralSigningKey(serviceName) {
+    ephemeralKeys ??= new Map();
+    const existing = ephemeralKeys.get(serviceName);
+    if (existing)
+        return existing;
+    if (!ephemeralWarned) {
+        ephemeralWarned = true;
+        emitCounter('service_signing_ephemeral_key_total', { service: serviceIdentity() });
+        logger.warn('SERVICE_SIGNING_KEY_FILE is not set — minting internal service tokens with an EPHEMERAL key. Only this process will accept them; every peer will reject them. Set SERVICE_SIGNING_KEY_FILE + SERVICE_KEY_BUNDLE_FILE (deploy/bin/service-signing-keys.sh).');
+    }
+    const { privateKey, publicKey } = crypto.generateKeyPairSync('ec', { namedCurve: 'prime256v1' });
+    const publicJwk = publicJwkFrom(publicKey);
+    const generated = { serviceName, kid: publicJwk.kid, privateKey, publicJwk };
+    ephemeralKeys.set(serviceName, generated);
+    return generated;
+}
+/** Whether this process signs with a mounted key (`configured`) or an in-process one. */
+export function serviceKeyMode() {
+    return process.env.SERVICE_SIGNING_KEY_FILE ? 'configured' : 'ephemeral';
+}
+/**
+ * The key `serviceName` must be signed with.
+ *
+ * In `configured` mode there is exactly ONE key — this service's — so a request
+ * to sign as some OTHER service is a bug and throws. That matters: before #14 a
+ * service could legitimately mint `service:platform` with the shared secret
+ * (api/plugin did, for its registry pushes), and under per-service keys such a
+ * token would be silently unverifiable everywhere. Failing at the mint turns
+ * that into an immediate, obvious error instead of a runtime 401.
+ */
+function signingKeyFor(serviceName) {
+    const file = process.env.SERVICE_SIGNING_KEY_FILE;
+    if (!file)
+        return ephemeralSigningKey(serviceName);
+    if (!localKey || localKey.serviceName !== serviceIdentity()) {
+        localKey = loadConfiguredSigningKey(file);
+    }
+    if (serviceName !== localKey.serviceName) {
+        throw new ServiceKeyError(`This process is '${localKey.serviceName}' and holds only its own signing key, so it cannot mint a token for '${serviceName}'. `
+            + 'Name the calling service correctly, or give the caller its own key.');
+    }
+    return localKey;
+}
+let bundle;
+function parseBundle(raw, file) {
+    let document;
+    try {
+        document = JSON.parse(raw);
+    }
+    catch (error) {
+        throw new ServiceKeyError(`${file} is not valid JSON: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    const services = document?.services;
+    if (!services || typeof services !== 'object') {
+        throw new ServiceKeyError(`${file} has no "services" object`);
+    }
+    const byKid = new Map();
+    for (const [serviceName, entry] of Object.entries(services)) {
+        for (const jwk of entry?.keys ?? []) {
+            if (!jwk?.kid)
+                continue;
+            try {
+                byKid.set(jwk.kid, { serviceName, key: publicKeyFromJwk(jwk) });
+            }
+            catch (error) {
+                // One unusable entry must not discard the rest of the bundle — the same
+                // rule the JWKS cache applies to platform's published set.
+                logger.warn('Skipping unusable service key', { serviceName, kid: jwk.kid, error: error instanceof Error ? error.message : String(error) });
+            }
+        }
+    }
+    if (byKid.size === 0)
+        throw new ServiceKeyError(`${file} contained no usable service keys`);
+    return byKid;
+}
+/**
+ * The `kid` → service map, re-read when the refresh interval has passed or the
+ * file's mtime changed (so a rotation is picked up without a restart).
+ *
+ * In ephemeral mode the "bundle" is whatever this process generated for itself.
+ * Never throws for a missing file in that mode — it just holds those keys.
+ */
+function verificationKeys() {
+    const file = process.env.SERVICE_KEY_BUNDLE_FILE;
+    if (!file) {
+        const local = new Map();
+        for (const key of ephemeralKeys?.values() ?? []) {
+            local.set(key.kid, { serviceName: key.serviceName, key: crypto.createPublicKey(key.privateKey) });
+        }
+        return local;
+    }
+    const now = Date.now();
+    let mtimeMs = 0;
+    try {
+        mtimeMs = statSync(file).mtimeMs;
+    }
+    catch {
+        // Unreadable now: keep serving a bundle already in hand (public keys don't
+        // expire, and refusing every internal call because a mount blipped would be
+        // a self-inflicted outage). With nothing in hand, fail closed below.
+        if (bundle)
+            return bundle.byKid;
+    }
+    if (bundle && bundle.mtimeMs === mtimeMs && now - bundle.loadedAt < BUNDLE_REFRESH_INTERVAL_MS) {
+        return bundle.byKid;
+    }
+    try {
+        const byKid = parseBundle(readFileSync(file, 'utf8'), file);
+        bundle = { byKid, loadedAt: now, mtimeMs };
+        return byKid;
+    }
+    catch (error) {
+        if (bundle) {
+            logger.warn('Service key bundle reload failed; continuing on the loaded copy', { file, error: error instanceof Error ? error.message : String(error) });
+            return bundle.byKid;
+        }
+        throw error instanceof ServiceKeyError ? error : new ServiceKeyError(String(error));
+    }
+}
+/**
+ * Whether `kid` belongs to an internal SERVICE key. This is how a bearer token
+ * is routed between the two ES256 chains: both user and service tokens are
+ * ES256 with a `kid`, and `kid` is an RFC 7638 thumbprint, so ownership of the
+ * id — not a claim inside the token — decides which key set may verify it.
+ * Returns `false` (never throws) when no bundle can be read; the token then
+ * takes the user chain and is rejected there.
+ */
+export function isServiceKid(kid) {
+    try {
+        return verificationKeys().has(kid);
+    }
+    catch {
+        return false;
+    }
+}
+/** Every service name the bundle publishes a key for. Diagnostics and tests. */
+export function knownServiceNames() {
+    try {
+        return [...new Set([...verificationKeys().values()].map((v) => v.serviceName))].sort();
+    }
+    catch {
+        return [];
+    }
+}
+// ---------------------------------------------------------------------------
+// Sign / verify
+// ---------------------------------------------------------------------------
+/** base64url of a JSON value, the JWS way (no padding, URL alphabet). */
+function b64uJson(value) {
+    return Buffer.from(JSON.stringify(value), 'utf-8').toString('base64url');
+}
+/**
+ * Sign `claims` as this service's internal token: ES256, `kid` = the signer's
+ * thumbprint, `sub` = `service:<serviceName>`. `iat`/`exp` and the optional
+ * issuer/audience are stamped here so there is one place that decides what a
+ * service token says.
+ *
+ * Hand-rolled (rather than `jwt.sign`) only so the header carries the `kid` in
+ * the same shape platform's signer produces — `crypto.sign` is synchronous, so
+ * unlike the KMS path this costs nothing.
+ */
+export function signServiceJwt(claims, options) {
+    const key = signingKeyFor(options.serviceName);
+    const now = Math.floor(Date.now() / 1000);
+    const body = {
+        ...claims,
+        sub: `${SERVICE_SUBJECT_PREFIX}${options.serviceName}`,
+        iat: now,
+        exp: now + options.expiresInSeconds,
+        ...(options.issuer ? { iss: options.issuer } : {}),
+        ...(options.audience ? { aud: options.audience } : {}),
+    };
+    const signingInput = `${b64uJson({ alg: SERVICE_TOKEN_ALGORITHM, typ: 'JWT', kid: key.kid })}.${b64uJson(body)}`;
+    const signature = crypto.sign('sha256', Buffer.from(signingInput, 'utf-8'), {
+        key: key.privateKey,
+        dsaEncoding: 'ieee-p1363',
+    });
+    return `${signingInput}.${signature.toString('base64url')}`;
+}
+/**
+ * Verify an internal service token, SYNCHRONOUSLY, and return its claims.
+ *
+ * The security property this function exists for: the `kid` selects the key
+ * AND names the signer, and the token's `sub` must agree. So `billing` cannot
+ * be impersonated by any other service — not even one that holds a valid key of
+ * its own — which is what the shared secret could never guarantee.
+ *
+ * @throws {jwt.JsonWebTokenError} unknown `kid`, wrong algorithm, bad
+ *         signature, expired, or a `sub` that disagrees with the signing key.
+ * @throws {ServiceKeyError} no verification bundle could be read at all — the
+ *         token's validity is UNKNOWN and the caller must not treat it as valid.
+ */
+export function verifyServiceJwt(token, options) {
+    const entry = verificationKeys().get(options.kid);
+    if (!entry) {
+        emitCounter('service_token_verify_total', { result: 'unknown_kid' });
+        throw new jwt.JsonWebTokenError(`No published service key for kid ${options.kid}`);
+    }
+    let claims;
+    try {
+        claims = jwt.verify(token, entry.key, {
+            algorithms: [SERVICE_TOKEN_ALGORITHM],
+            ...(options.issuer ? { issuer: options.issuer } : {}),
+            ...(options.audience ? { audience: options.audience } : {}),
+        });
+    }
+    catch (error) {
+        emitCounter('service_token_verify_total', { result: 'invalid' });
+        throw error;
+    }
+    if (claims.sub !== `${SERVICE_SUBJECT_PREFIX}${entry.serviceName}`) {
+        // A valid signature by the WRONG service: the key belongs to `entry.serviceName`
+        // but the token speaks for someone else. This is the cross-service forgery
+        // the shared secret made undetectable.
+        emitCounter('service_token_verify_total', { result: 'subject_mismatch', service: entry.serviceName });
+        throw new jwt.JsonWebTokenError(`Service token subject ${String(claims.sub)} was signed by ${entry.serviceName}`);
+    }
+    emitCounter('service_token_verify_total', { result: 'ok', service: entry.serviceName });
+    return claims;
+}
+/**
+ * True while this service still publishes more than one verification key — i.e.
+ * a signing-key rotation is open and the retiring key is still trusted. Feeds
+ * the `secret_rotation_previous_set{secret="SERVICE_SIGNING_KEY"}` gauge.
+ */
+export function isRetiringServiceKeyPublished() {
+    try {
+        const me = serviceIdentity();
+        return [...verificationKeys().values()].filter((v) => v.serviceName === me).length > 1;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Test seam: drop the loaded signing key, the bundle and any ephemeral keys so
+ * the next sign/verify re-reads the environment. Don't call from production code
+ * — rotation is picked up by the refresh interval and the mtime check.
+ */
+export function _resetServiceKeysForTests() {
+    localKey = undefined;
+    bundle = undefined;
+    ephemeralKeys = undefined;
+    ephemeralWarned = false;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"service-keys.js","sourceRoot":"","sources":["../../src/services/service-keys.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\n/**\n * Per-service signing keys for INTERNAL service-to-service tokens (#14).\n *\n * Before this, every service held one shared `JWT_SECRET`, so any service could\n * mint a token naming any OTHER service — \"billing said so\" was unfalsifiable,\n * and a single compromised workload could speak for the whole fleet. Now each\n * service signs with its OWN ES256 (EC P-256) key and consumers verify against\n * the public halves. The `kid` is bound to the signer's NAME, so a token whose\n * `sub` says `service:billing` but was signed with compliance's key is a\n * forgery, not a valid token with a confusing subject.\n *\n * ## Why public keys are distributed by CONFIG, not by per-service JWKS endpoints\n *\n * The user chain (#5) fetches platform's JWKS over HTTP because there is exactly\n * one signer and it is the one service that must be up for anybody to sign in.\n * The service chain is the opposite shape, and three properties decided it:\n *\n *  1. **`verifyServicePrincipal` must stay synchronous.** The global rate\n *     limiter's `skip` and app-factory's `/warmup` guard verify a service token\n *     BEFORE `requireAuth` runs, in synchronous Express callbacks. An HTTP JWKS\n *     fetch would force those async — a change that reaches into every\n *     service's limiter wiring.\n *  2. **No availability coupling.** With per-service JWKS endpoints, verifying a\n *     token minted by `billing` needs `billing` to be reachable — so billing\n *     being down would stop platform from accepting billing's in-flight calls,\n *     turning one outage into several. A mounted file has no such edge.\n *  3. **No N×N address config.** 10 services would each need every peer's\n *     host/port (and compose, which has no mesh, would need them too).\n *\n * So the deploy generates one keypair per service, mounts each private key ONLY\n * into its own service, and mounts ONE public bundle (read-only) everywhere:\n *\n *   `SERVICE_SIGNING_KEY_FILE`  this service's EC P-256 private key (PKCS#8 PEM)\n *   `SERVICE_KEY_BUNDLE_FILE`   `{ \"services\": { \"<name>\": { \"keys\": [<jwk>…] } } }`\n *\n * Rotation is by `kid`, in the same shape as the user chain: add the new public\n * key to the bundle (the service now publishes two), roll the bundle out, swap\n * that service's private key, then drop the retired public key. The bundle is\n * re-read on an interval AND on an mtime change, so a rotation needs no restart.\n * `deploy/bin/service-signing-keys.sh` generates and rotates both halves.\n *\n * ## Ephemeral mode\n *\n * With no `SERVICE_SIGNING_KEY_FILE` configured, a keypair is generated\n * IN-PROCESS per requested service name and registered in the in-memory bundle.\n * That keeps single-process suites and local one-off scripts working with no key\n * material, and it can never widen trust: the only verifier that accepts such a\n * token is the process that minted it. It is logged once at warn level, and\n * counted, because in a real deployment it means this service's peers will\n * reject everything it sends.\n */\n\nimport crypto, { type KeyObject } from 'crypto';\nimport { readFileSync, statSync } from 'fs';\nimport jwt from 'jsonwebtoken';\nimport { publicJwkFrom, publicKeyFromJwk, type PublicJwk } from '../utils/jwk.js';\nimport { createLogger } from '../utils/logger.js';\nimport { emitCounter } from '../utils/metric-emitter.js';\n\nconst logger = createLogger('service-keys');\n\n/** The ONLY algorithm an internal service token may be signed with. */\nexport const SERVICE_TOKEN_ALGORITHM = 'ES256';\n\n/** Subject prefix naming the calling service on a service token (`service:<name>`). */\nexport const SERVICE_SUBJECT_PREFIX = 'service:';\n\n/** How long a loaded bundle is served before it is re-read (rotation pickup). */\nconst BUNDLE_REFRESH_INTERVAL_MS = 300_000; // 5 minutes\n\n/** One service's published verification keys, as they appear in the bundle file. */\nexport interface ServiceKeyEntry {\n  keys: PublicJwk[];\n}\n\n/** The document `SERVICE_KEY_BUNDLE_FILE` holds: every service's public keys. */\nexport interface ServiceKeyBundle {\n  services: Record<string, ServiceKeyEntry>;\n}\n\n/** A signing key this process holds, in the forms signing needs. */\ninterface LocalSigningKey {\n  serviceName: string;\n  kid: string;\n  privateKey: KeyObject;\n  publicJwk: PublicJwk;\n}\n\n/** The bundle could not be loaded or does not know the key a token names. */\nexport class ServiceKeyError extends Error {\n  constructor(message: string) {\n    super(message);\n    this.name = 'ServiceKeyError';\n  }\n}\n\n/**\n * This process's service identity — the `<name>` in `service:<name>` and the\n * name its key is published under. `SERVICE_NAME` is already set per service in\n * every deploy target (compose, minikube, ec2, eks), and is the same value the\n * audit and metric labels use, so there is one source of truth for \"who am I\".\n */\nexport function serviceIdentity(): string {\n  return process.env.SERVICE_NAME || 'api';\n}\n\n// ---------------------------------------------------------------------------\n// Local signing key\n// ---------------------------------------------------------------------------\n\nlet localKey: LocalSigningKey | undefined;\nlet ephemeralKeys: Map<string, LocalSigningKey> | undefined;\nlet ephemeralWarned = false;\n\nfunction loadConfiguredSigningKey(file: string): LocalSigningKey {\n  const serviceName = serviceIdentity();\n  let privateKey: KeyObject;\n  try {\n    privateKey = crypto.createPrivateKey(readFileSync(file, 'utf8'));\n  } catch (error) {\n    throw new ServiceKeyError(`Could not read the service signing key at ${file}: ${error instanceof Error ? error.message : String(error)}`);\n  }\n  // publicJwkFrom rejects anything but an EC P-256 key, so a service configured\n  // with (say) an RSA key fails HERE rather than minting tokens nobody verifies.\n  const publicJwk = publicJwkFrom(crypto.createPublicKey(privateKey));\n  return { serviceName, kid: publicJwk.kid, privateKey, publicJwk };\n}\n\n/**\n * The in-process key for `serviceName` in ephemeral mode, generated on first\n * use and registered in the in-memory bundle so this process can verify its own\n * tokens. Keyed by NAME (not just one key) so a single-process suite can mint\n * tokens for several services, as the real fleet does across processes.\n */\nfunction ephemeralSigningKey(serviceName: string): LocalSigningKey {\n  ephemeralKeys ??= new Map();\n  const existing = ephemeralKeys.get(serviceName);\n  if (existing) return existing;\n\n  if (!ephemeralWarned) {\n    ephemeralWarned = true;\n    emitCounter('service_signing_ephemeral_key_total', { service: serviceIdentity() });\n    logger.warn('SERVICE_SIGNING_KEY_FILE is not set — minting internal service tokens with an EPHEMERAL key. Only this process will accept them; every peer will reject them. Set SERVICE_SIGNING_KEY_FILE + SERVICE_KEY_BUNDLE_FILE (deploy/bin/service-signing-keys.sh).');\n  }\n  const { privateKey, publicKey } = crypto.generateKeyPairSync('ec', { namedCurve: 'prime256v1' });\n  const publicJwk = publicJwkFrom(publicKey);\n  const generated: LocalSigningKey = { serviceName, kid: publicJwk.kid, privateKey, publicJwk };\n  ephemeralKeys.set(serviceName, generated);\n  return generated;\n}\n\n/** Whether this process signs with a mounted key (`configured`) or an in-process one. */\nexport function serviceKeyMode(): 'configured' | 'ephemeral' {\n  return process.env.SERVICE_SIGNING_KEY_FILE ? 'configured' : 'ephemeral';\n}\n\n/**\n * The key `serviceName` must be signed with.\n *\n * In `configured` mode there is exactly ONE key — this service's — so a request\n * to sign as some OTHER service is a bug and throws. That matters: before #14 a\n * service could legitimately mint `service:platform` with the shared secret\n * (api/plugin did, for its registry pushes), and under per-service keys such a\n * token would be silently unverifiable everywhere. Failing at the mint turns\n * that into an immediate, obvious error instead of a runtime 401.\n */\nfunction signingKeyFor(serviceName: string): LocalSigningKey {\n  const file = process.env.SERVICE_SIGNING_KEY_FILE;\n  if (!file) return ephemeralSigningKey(serviceName);\n\n  if (!localKey || localKey.serviceName !== serviceIdentity()) {\n    localKey = loadConfiguredSigningKey(file);\n  }\n  if (serviceName !== localKey.serviceName) {\n    throw new ServiceKeyError(\n      `This process is '${localKey.serviceName}' and holds only its own signing key, so it cannot mint a token for '${serviceName}'. `\n      + 'Name the calling service correctly, or give the caller its own key.',\n    );\n  }\n  return localKey;\n}\n\n// ---------------------------------------------------------------------------\n// Verification bundle\n// ---------------------------------------------------------------------------\n\ninterface LoadedBundle {\n  /** `kid` → the service that published it, plus the verification key. */\n  byKid: Map<string, { serviceName: string; key: KeyObject }>;\n  loadedAt: number;\n  mtimeMs: number;\n}\n\nlet bundle: LoadedBundle | undefined;\n\nfunction parseBundle(raw: string, file: string): Map<string, { serviceName: string; key: KeyObject }> {\n  let document: unknown;\n  try {\n    document = JSON.parse(raw);\n  } catch (error) {\n    throw new ServiceKeyError(`${file} is not valid JSON: ${error instanceof Error ? error.message : String(error)}`);\n  }\n  const services = (document as Partial<ServiceKeyBundle>)?.services;\n  if (!services || typeof services !== 'object') {\n    throw new ServiceKeyError(`${file} has no \"services\" object`);\n  }\n  const byKid = new Map<string, { serviceName: string; key: KeyObject }>();\n  for (const [serviceName, entry] of Object.entries(services)) {\n    for (const jwk of entry?.keys ?? []) {\n      if (!jwk?.kid) continue;\n      try {\n        byKid.set(jwk.kid, { serviceName, key: publicKeyFromJwk(jwk) });\n      } catch (error) {\n        // One unusable entry must not discard the rest of the bundle — the same\n        // rule the JWKS cache applies to platform's published set.\n        logger.warn('Skipping unusable service key', { serviceName, kid: jwk.kid, error: error instanceof Error ? error.message : String(error) });\n      }\n    }\n  }\n  if (byKid.size === 0) throw new ServiceKeyError(`${file} contained no usable service keys`);\n  return byKid;\n}\n\n/**\n * The `kid` → service map, re-read when the refresh interval has passed or the\n * file's mtime changed (so a rotation is picked up without a restart).\n *\n * In ephemeral mode the \"bundle\" is whatever this process generated for itself.\n * Never throws for a missing file in that mode — it just holds those keys.\n */\nfunction verificationKeys(): Map<string, { serviceName: string; key: KeyObject }> {\n  const file = process.env.SERVICE_KEY_BUNDLE_FILE;\n  if (!file) {\n    const local = new Map<string, { serviceName: string; key: KeyObject }>();\n    for (const key of ephemeralKeys?.values() ?? []) {\n      local.set(key.kid, { serviceName: key.serviceName, key: crypto.createPublicKey(key.privateKey) });\n    }\n    return local;\n  }\n\n  const now = Date.now();\n  let mtimeMs = 0;\n  try {\n    mtimeMs = statSync(file).mtimeMs;\n  } catch {\n    // Unreadable now: keep serving a bundle already in hand (public keys don't\n    // expire, and refusing every internal call because a mount blipped would be\n    // a self-inflicted outage). With nothing in hand, fail closed below.\n    if (bundle) return bundle.byKid;\n  }\n  if (bundle && bundle.mtimeMs === mtimeMs && now - bundle.loadedAt < BUNDLE_REFRESH_INTERVAL_MS) {\n    return bundle.byKid;\n  }\n\n  try {\n    const byKid = parseBundle(readFileSync(file, 'utf8'), file);\n    bundle = { byKid, loadedAt: now, mtimeMs };\n    return byKid;\n  } catch (error) {\n    if (bundle) {\n      logger.warn('Service key bundle reload failed; continuing on the loaded copy', { file, error: error instanceof Error ? error.message : String(error) });\n      return bundle.byKid;\n    }\n    throw error instanceof ServiceKeyError ? error : new ServiceKeyError(String(error));\n  }\n}\n\n/**\n * Whether `kid` belongs to an internal SERVICE key. This is how a bearer token\n * is routed between the two ES256 chains: both user and service tokens are\n * ES256 with a `kid`, and `kid` is an RFC 7638 thumbprint, so ownership of the\n * id — not a claim inside the token — decides which key set may verify it.\n * Returns `false` (never throws) when no bundle can be read; the token then\n * takes the user chain and is rejected there.\n */\nexport function isServiceKid(kid: string): boolean {\n  try {\n    return verificationKeys().has(kid);\n  } catch {\n    return false;\n  }\n}\n\n/** Every service name the bundle publishes a key for. Diagnostics and tests. */\nexport function knownServiceNames(): string[] {\n  try {\n    return [...new Set([...verificationKeys().values()].map((v) => v.serviceName))].sort();\n  } catch {\n    return [];\n  }\n}\n\n// ---------------------------------------------------------------------------\n// Sign / verify\n// ---------------------------------------------------------------------------\n\n/** base64url of a JSON value, the JWS way (no padding, URL alphabet). */\nfunction b64uJson(value: unknown): string {\n  return Buffer.from(JSON.stringify(value), 'utf-8').toString('base64url');\n}\n\n/**\n * Sign `claims` as this service's internal token: ES256, `kid` = the signer's\n * thumbprint, `sub` = `service:<serviceName>`. `iat`/`exp` and the optional\n * issuer/audience are stamped here so there is one place that decides what a\n * service token says.\n *\n * Hand-rolled (rather than `jwt.sign`) only so the header carries the `kid` in\n * the same shape platform's signer produces — `crypto.sign` is synchronous, so\n * unlike the KMS path this costs nothing.\n */\nexport function signServiceJwt(\n  claims: Record<string, unknown>,\n  options: { serviceName: string; expiresInSeconds: number; issuer?: string; audience?: string },\n): string {\n  const key = signingKeyFor(options.serviceName);\n  const now = Math.floor(Date.now() / 1000);\n  const body = {\n    ...claims,\n    sub: `${SERVICE_SUBJECT_PREFIX}${options.serviceName}`,\n    iat: now,\n    exp: now + options.expiresInSeconds,\n    ...(options.issuer ? { iss: options.issuer } : {}),\n    ...(options.audience ? { aud: options.audience } : {}),\n  };\n  const signingInput = `${b64uJson({ alg: SERVICE_TOKEN_ALGORITHM, typ: 'JWT', kid: key.kid })}.${b64uJson(body)}`;\n  const signature = crypto.sign('sha256', Buffer.from(signingInput, 'utf-8'), {\n    key: key.privateKey,\n    dsaEncoding: 'ieee-p1363',\n  });\n  return `${signingInput}.${signature.toString('base64url')}`;\n}\n\n/**\n * Verify an internal service token, SYNCHRONOUSLY, and return its claims.\n *\n * The security property this function exists for: the `kid` selects the key\n * AND names the signer, and the token's `sub` must agree. So `billing` cannot\n * be impersonated by any other service — not even one that holds a valid key of\n * its own — which is what the shared secret could never guarantee.\n *\n * @throws {jwt.JsonWebTokenError} unknown `kid`, wrong algorithm, bad\n *         signature, expired, or a `sub` that disagrees with the signing key.\n * @throws {ServiceKeyError} no verification bundle could be read at all — the\n *         token's validity is UNKNOWN and the caller must not treat it as valid.\n */\nexport function verifyServiceJwt<T = Record<string, unknown>>(\n  token: string,\n  options: { kid: string; issuer?: string; audience?: string },\n): T {\n  const entry = verificationKeys().get(options.kid);\n  if (!entry) {\n    emitCounter('service_token_verify_total', { result: 'unknown_kid' });\n    throw new jwt.JsonWebTokenError(`No published service key for kid ${options.kid}`);\n  }\n  let claims: T & { sub?: unknown };\n  try {\n    claims = jwt.verify(token, entry.key, {\n      algorithms: [SERVICE_TOKEN_ALGORITHM],\n      ...(options.issuer ? { issuer: options.issuer } : {}),\n      ...(options.audience ? { audience: options.audience } : {}),\n    }) as T & { sub?: unknown };\n  } catch (error) {\n    emitCounter('service_token_verify_total', { result: 'invalid' });\n    throw error;\n  }\n  if (claims.sub !== `${SERVICE_SUBJECT_PREFIX}${entry.serviceName}`) {\n    // A valid signature by the WRONG service: the key belongs to `entry.serviceName`\n    // but the token speaks for someone else. This is the cross-service forgery\n    // the shared secret made undetectable.\n    emitCounter('service_token_verify_total', { result: 'subject_mismatch', service: entry.serviceName });\n    throw new jwt.JsonWebTokenError(`Service token subject ${String(claims.sub)} was signed by ${entry.serviceName}`);\n  }\n  emitCounter('service_token_verify_total', { result: 'ok', service: entry.serviceName });\n  return claims;\n}\n\n/**\n * True while this service still publishes more than one verification key — i.e.\n * a signing-key rotation is open and the retiring key is still trusted. Feeds\n * the `secret_rotation_previous_set{secret=\"SERVICE_SIGNING_KEY\"}` gauge.\n */\nexport function isRetiringServiceKeyPublished(): boolean {\n  try {\n    const me = serviceIdentity();\n    return [...verificationKeys().values()].filter((v) => v.serviceName === me).length > 1;\n  } catch {\n    return false;\n  }\n}\n\n/**\n * Test seam: drop the loaded signing key, the bundle and any ephemeral keys so\n * the next sign/verify re-reads the environment. Don't call from production code\n * — rotation is picked up by the refresh interval and the mtime check.\n */\nexport function _resetServiceKeysForTests(): void {\n  localKey = undefined;\n  bundle = undefined;\n  ephemeralKeys = undefined;\n  ephemeralWarned = false;\n}\n"]}

package/lib/services/sse-ticket-store.d.ts

@@ -1,3 +1,10 @@
+import { type ReadyAwareRedis } from './env-redis.js';
+/** What a ticket authorizes: the owning org and, for subject-bound channels, the stream subject. */
+export interface SseTicketRecord {
+    orgId: string;
+    /** Stream subject the ticket is bound to (e.g. a build-log requestId). Absent for org-keyed channels. */
+    subject?: string;
+}
 /** Result of {@link SseTicketStore.issue}. */
 export type SseTicketIssueResult = {
     ok: true;
@@ -7,21 +14,31 @@ export type SseTicketIssueResult = {
     reason: 'total' | 'org';
 };
 /**
- * Store for short-lived, single-use SSE auth tickets. A client exchanges its JWT
- * for a ticket (so the token never lands in an EventSource query string / access
- * log), then redeems it on the SSE `GET`.
+ * The ONE store for short-lived, single-use SSE auth tickets, plus the
+ * stream-ownership bindings subject-bound channels need.
+ *
+ * A client exchanges its JWT for a ticket (so the token never lands in an
+ * EventSource query string / access log), then redeems it on the SSE `GET`.
  *
- * The store is the multi-replica correctness boundary: a ticket minted on pod A
- * MUST be redeemable on pod B. The Redis backend makes that true; the in-memory
- * backend is a single-process fallback for dev / single-replica installs.
+ * - **Tickets** are single-use across pods: the Redis backend redeems with
+ *   `GETDEL`, so two pods can never both spend one ticket.
+ * - **Caps count LIVE tickets** (issued, not yet redeemed, not expired) — per org
+ *   and in total. A redeemed or expired ticket frees its slot immediately.
+ * - **Ownership** records which org owns a stream subject, so a subject-bound
+ *   channel can refuse to mint a ticket for another org's stream.
+ *
+ * Both backends share these semantics; the in-memory one is correct for a
+ * single process only.
  */
 export interface SseTicketStore {
-    /** Mint a ticket for `orgId`, or reject when a rate window is saturated. */
-    issue(orgId: string): Promise<SseTicketIssueResult>;
-    /** Atomically redeem a ticket exactly once; returns its org or null if invalid/expired/spent. */
-    consume(ticketId: string): Promise<{
-        orgId: string;
-    } | null>;
+    /** Mint a ticket for `orgId` (optionally bound to `subject`), or reject when a live-ticket cap is reached. */
+    issue(orgId: string, subject?: string): Promise<SseTicketIssueResult>;
+    /** Redeem a ticket exactly once; null when unknown, expired or already spent. */
+    consume(ticketId: string): Promise<SseTicketRecord | null>;
+    /** Record the org that owns `subject` for `ttlMs`. */
+    bindOwner(subject: string, orgId: string, ttlMs: number): Promise<void>;
+    /** The org that owns `subject`, or null when none is bound. Throws when the backend can't answer. */
+    getOwner(subject: string): Promise<string | null>;
     /** Release timers/resources. In-memory clears its sweep interval; Redis is a no-op. */
     stop(): void;
 }
@@ -29,23 +46,39 @@ export interface SseTicketStore {
 export interface SseTicketStoreConfig {
     /** Ticket lifetime — long enough for the client to open the EventSource. */
     ttlMs: number;
-    /** Hard cap on tickets minted per TTL window across all orgs (abuse bound). */
+    /** Cap on LIVE tickets across all orgs (abuse / memory bound). */
     maxTotal: number;
-    /** Per-org cap on tickets minted per TTL window (single-tenant abuse bound). */
+    /** Cap on LIVE tickets per org (single-tenant fairness bound). */
     maxPerOrg: number;
     /**
-     * Optional Redis key namespace so independent channels (e.g. message
-     * notifications vs. reporting execution-status) don't share one ticket
-     * keyspace — a ticket minted for one channel must not be redeemable on
-     * another. Omit for the default (shared) namespace.
+     * Key namespace so independent channels (message notifications, reporting
+     * execution-status, a service's build-log stream) never share tickets, caps
+     * or ownership bindings — a ticket minted for one channel must not be
+     * redeemable on another. Omit for the default namespace.
      */
     keyPrefix?: string;
 }
+/** In-memory backend — single-process fallback when Redis isn't configured. */
+export declare function createMemorySseTicketStore(config: SseTicketStoreConfig): SseTicketStore;
+/** Minimal ioredis surface the Redis backend needs (GETDEL requires Redis ≥ 6.2). */
+export interface SseTicketRedis extends ReadyAwareRedis {
+    eval(script: string, numKeys: number, ...args: (string | number)[]): Promise<unknown>;
+    getdel(key: string): Promise<string | null>;
+    zrem(key: string, ...members: string[]): Promise<number>;
+    set(key: string, value: string, ...args: (string | number)[]): Promise<unknown>;
+    get(key: string): Promise<string | null>;
+}
+/**
+ * Redis backend — multi-replica safe.
+ *
+ * Fail-CLOSED: a Redis error makes `issue` reject (`total`), `consume` return
+ * null and `getOwner` throw, so an outage degrades to "no live stream" rather
+ * than handing out or accepting unvalidated tickets. `bindOwner` is best-effort.
+ */
+export declare function createRedisSseTicketStore(redis: SseTicketRedis, config: SseTicketStoreConfig): SseTicketStore;
 /**
  * Build an {@link SseTicketStore} from the standard Redis env (`REDIS_URL` or
- * `REDIS_SENTINELS`). Uses the Redis backend when configured
- * (multi-replica safe), otherwise falls back to the in-memory single-process
- * backend. A service opts in with one boot line:
- *   `const tickets = createEnvSseTicketStore({ ttlMs, maxTotal, maxPerOrg });`
+ * `REDIS_SENTINELS`): the Redis backend when configured (multi-replica safe),
+ * otherwise the in-memory single-process backend.
  */
 export declare function createEnvSseTicketStore(config: SseTicketStoreConfig): SseTicketStore;