@pipeline-builder/api-core 4.0.3 → 4.1.1

package/lib/middleware/step-up.d.ts

@@ -25,11 +25,18 @@ export interface StepUpTokenPayload {
 }
 /**
  * Verify a step-up token: valid signature (primary `JWT_SECRET`, or
- * `JWT_SECRET_PREVIOUS` during a rotation), allow-listed algorithm, AND the
- * `type: 'step-up'` + `jti` claims — a plain access token shares the secret and
- * `sub`, so without asserting the step-up shape it would bypass the gate.
- * Throws on any failure. Does NOT bind to a caller — `requireStepUp` does the
- * `sub` match and single-use consume.
+ * `JWT_SECRET_PREVIOUS` during a rotation), allow-listed algorithm, issuer and
+ * audience when configured, AND the `type: 'step-up'` + `jti` claims — a plain
+ * access token shares the secret and `sub`, so without asserting the step-up
+ * shape it would bypass the gate. Throws on any failure. Does NOT bind to a
+ * caller — `requireStepUp` does the `sub` match and single-use consume.
+ *
+ * Delegates to `requireAuth`'s own primitives rather than re-implementing them.
+ * The hand-rolled copy this replaced dropped TWO of their guards: it never
+ * pinned issuer/audience (so a step-up token from any other system sharing
+ * `JWT_SECRET` was accepted wherever `JWT_ISSUER`/`JWT_AUDIENCE` are set), and
+ * its previous-secret retry had no expiry/not-before carve-out, so an EXPIRED
+ * token was retried and surfaced as a signature error instead of an expiry one.
  */
 export declare function verifyStepUpToken(token: string): StepUpTokenPayload;
 /**

package/lib/middleware/step-up.js

@@ -1,39 +1,31 @@
 // Copyright 2026 Pipeline Builder Contributors
 // SPDX-License-Identifier: Apache-2.0
-import jwt from 'jsonwebtoken';
-import { isServicePrincipal } from './auth.js';
+import { buildJwtVerifyOptions, verifyJwtWithRotation, isServicePrincipal } from './auth.js';
 import { createEnvRedisClient } from '../services/env-redis.js';
 import { getHeaderString } from '../utils/headers.js';
 import { createLogger } from '../utils/logger.js';
 import { sendError } from '../utils/response.js';
 const logger = createLogger('step-up');
 const HEADER = 'x-step-up-token';
-function jwtAlgorithm() {
-    return (process.env.JWT_ALGORITHM || 'HS256');
-}
 /**
  * Verify a step-up token: valid signature (primary `JWT_SECRET`, or
- * `JWT_SECRET_PREVIOUS` during a rotation), allow-listed algorithm, AND the
- * `type: 'step-up'` + `jti` claims — a plain access token shares the secret and
- * `sub`, so without asserting the step-up shape it would bypass the gate.
- * Throws on any failure. Does NOT bind to a caller — `requireStepUp` does the
- * `sub` match and single-use consume.
+ * `JWT_SECRET_PREVIOUS` during a rotation), allow-listed algorithm, issuer and
+ * audience when configured, AND the `type: 'step-up'` + `jti` claims — a plain
+ * access token shares the secret and `sub`, so without asserting the step-up
+ * shape it would bypass the gate. Throws on any failure. Does NOT bind to a
+ * caller — `requireStepUp` does the `sub` match and single-use consume.
+ *
+ * Delegates to `requireAuth`'s own primitives rather than re-implementing them.
+ * The hand-rolled copy this replaced dropped TWO of their guards: it never
+ * pinned issuer/audience (so a step-up token from any other system sharing
+ * `JWT_SECRET` was accepted wherever `JWT_ISSUER`/`JWT_AUDIENCE` are set), and
+ * its previous-secret retry had no expiry/not-before carve-out, so an EXPIRED
+ * token was retried and surfaced as a signature error instead of an expiry one.
  */
 export function verifyStepUpToken(token) {
-    const secret = process.env.JWT_SECRET;
-    if (!secret)
+    if (!process.env.JWT_SECRET)
         throw new Error('JWT_SECRET environment variable is required');
-    const opts = { algorithms: [jwtAlgorithm()] };
-    let payload;
-    try {
-        payload = jwt.verify(token, secret, opts);
-    }
-    catch (primaryErr) {
-        const previous = process.env.JWT_SECRET_PREVIOUS;
-        if (!previous)
-            throw primaryErr;
-        payload = jwt.verify(token, previous, opts);
-    }
+    const payload = verifyJwtWithRotation(token, buildJwtVerifyOptions());
     if (payload.type !== 'step-up' || !payload.jti || !payload.sub) {
         throw new Error('INVALID_STEP_UP_TOKEN');
     }
@@ -61,6 +53,26 @@ const memSweep = setInterval(() => {
             memJti.delete(jti);
 }, 30_000);
 memSweep.unref?.();
+/**
+ * Hard ceiling on the process-local jti set.
+ *
+ * The 30s sweep alone does NOT bound it: entries only leave once their token's
+ * TTL has passed, so a burst of step-up traffic (or a flood of distinct forged
+ * jtis on a Redis-less deployment) grows the map faster than the sweep drains
+ * it. This is a replay guard, so shedding the OLDEST entries is the safe
+ * direction: the worst case is that a long-expired jti could be replayed, and
+ * expiry is enforced independently by the token's own `exp`.
+ */
+const MEM_JTI_MAX = 10_000;
+/** Drop the soonest-to-expire entries until the map is under the ceiling. */
+function evictOldestJti() {
+    if (memJti.size < MEM_JTI_MAX)
+        return;
+    const byExpiry = [...memJti.entries()].sort((a, b) => a[1] - b[1]);
+    const excess = memJti.size - MEM_JTI_MAX + 1;
+    for (let i = 0; i < excess; i += 1)
+        memJti.delete(byExpiry[i][0]);
+}
 /**
  * Consume a step-up `jti` exactly once. Returns true if this call claimed it
  * (first use), false if it was already consumed (replay). `expEpochSeconds` is
@@ -80,6 +92,7 @@ export async function consumeStepUpJti(jti, expEpochSeconds) {
     // No Redis ⇒ single-instance deployment; the process-local map IS the store.
     if (memJti.has(jti))
         return false;
+    evictOldestJti();
     memJti.set(jti, Date.now() + ttlSeconds * 1000);
     return true;
 }
@@ -135,4 +148,4 @@ export async function requireStepUp(req, res, next) {
     }
     next();
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"step-up.js","sourceRoot":"","sources":["../../src/middleware/step-up.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\n/**\n * `requireStepUp` — a shared step-up (recent-password-reverify) gate for the\n * stateless api services, mirroring the platform middleware of the same name.\n *\n * Flow: the UI hits `POST /api/auth/step-up` (platform) to re-verify the user's\n * password; platform mints a short-lived (60s) `step-up` JWT signed with the\n * SAME `JWT_SECRET` these services already verify access tokens with. The UI\n * replays it as the `X-Step-Up-Token` header on the destructive/sensitive call;\n * this middleware verifies it, binds it to the caller (`sub` match), and\n * consumes its `jti` once (Redis-backed cross-instance when configured, else a\n * bounded process-local set) so a replay inside the TTL is rejected.\n *\n * WHY here: restore endpoints on the api services (pipeline/plugin/...) are\n * step-up-gated, but step-up previously lived only in `platform`. This ports the\n * verify + single-use jti into api-core so any service can require it.\n */\n\nimport type { Request, Response, NextFunction } from 'express';\nimport jwt from 'jsonwebtoken';\nimport { isServicePrincipal } from './auth.js';\nimport { createEnvRedisClient } from '../services/env-redis.js';\nimport { getHeaderString } from '../utils/headers.js';\nimport { createLogger } from '../utils/logger.js';\nimport { sendError } from '../utils/response.js';\n\nconst logger = createLogger('step-up');\nconst HEADER = 'x-step-up-token';\n\n/** Payload of a platform-issued step-up token (see platform issueStepUpToken). */\nexport interface StepUpTokenPayload {\n  type: 'step-up';\n  sub: string;\n  jti: string;\n  iat: number;\n  exp: number;\n}\n\nfunction jwtAlgorithm(): jwt.Algorithm {\n  return (process.env.JWT_ALGORITHM || 'HS256') as jwt.Algorithm;\n}\n\n/**\n * Verify a step-up token: valid signature (primary `JWT_SECRET`, or\n * `JWT_SECRET_PREVIOUS` during a rotation), allow-listed algorithm, AND the\n * `type: 'step-up'` + `jti` claims — a plain access token shares the secret and\n * `sub`, so without asserting the step-up shape it would bypass the gate.\n * Throws on any failure. Does NOT bind to a caller — `requireStepUp` does the\n * `sub` match and single-use consume.\n */\nexport function verifyStepUpToken(token: string): StepUpTokenPayload {\n  const secret = process.env.JWT_SECRET;\n  if (!secret) throw new Error('JWT_SECRET environment variable is required');\n  const opts: jwt.VerifyOptions = { algorithms: [jwtAlgorithm()] };\n\n  let payload: StepUpTokenPayload;\n  try {\n    payload = jwt.verify(token, secret, opts) as StepUpTokenPayload;\n  } catch (primaryErr) {\n    const previous = process.env.JWT_SECRET_PREVIOUS;\n    if (!previous) throw primaryErr;\n    payload = jwt.verify(token, previous, opts) as StepUpTokenPayload;\n  }\n\n  if (payload.type !== 'step-up' || !payload.jti || !payload.sub) {\n    throw new Error('INVALID_STEP_UP_TOKEN');\n  }\n  return payload;\n}\n\n// -- Single-use jti store -----------------------------------------------------\n// Redis SET NX EX when Redis is configured (cross-instance single-use); else a\n// bounded process-local map with TTL sweep (per-process). A step-up token is\n// 60s-lived. When Redis IS configured it's the authoritative store: a Redis\n// error FAILS CLOSED (throws → STEP_UP_INVALID, user re-verifies) rather than\n// degrading to the per-instance mem guard, which would accept a cross-instance\n// replay during the outage. The mem guard is used ONLY when Redis is absent.\n\nlet _redis: { set: (...args: unknown[]) => Promise<unknown> } | null | undefined;\nfunction redis(): { set: (...args: unknown[]) => Promise<unknown> } | null {\n  if (_redis === undefined) {\n    _redis = createEnvRedisClient<{ set: (...args: unknown[]) => Promise<unknown> }>('step-up-jti');\n  }\n  return _redis;\n}\n\nconst memJti = new Map<string, number>(); // jti -> expiry epoch ms\nconst memSweep = setInterval(() => {\n  const now = Date.now();\n  for (const [jti, exp] of memJti) if (exp <= now) memJti.delete(jti);\n}, 30_000);\nmemSweep.unref?.();\n\n/**\n * Consume a step-up `jti` exactly once. Returns true if this call claimed it\n * (first use), false if it was already consumed (replay). `expEpochSeconds` is\n * the token's `exp`, so the marker auto-expires with the token.\n */\nexport async function consumeStepUpJti(jti: string, expEpochSeconds: number): Promise<boolean> {\n  const ttlSeconds = Math.max(1, expEpochSeconds - Math.floor(Date.now() / 1000));\n  const client = redis();\n  if (client) {\n    // Redis configured ⇒ authoritative cross-instance store. SET NX EX → 'OK'\n    // when newly set, null when already consumed. A thrown Redis error is NOT\n    // caught here: it propagates so `requireStepUp` fails closed (STEP_UP_INVALID)\n    // instead of silently degrading to the per-instance mem guard.\n    const res = await client.set(`stepup:jti:${jti}`, '1', 'EX', ttlSeconds, 'NX');\n    return res === 'OK';\n  }\n  // No Redis ⇒ single-instance deployment; the process-local map IS the store.\n  if (memJti.has(jti)) return false;\n  memJti.set(jti, Date.now() + ttlSeconds * 1000);\n  return true;\n}\n\n/**\n * Express middleware: require a valid, caller-bound, single-use step-up token in\n * the `X-Step-Up-Token` header. Must run AFTER `requireAuth` (needs `req.user`).\n */\nexport async function requireStepUp(req: Request, res: Response, next: NextFunction): Promise<void> {\n  // Verified internal service principals are EXEMPT: step-up is a re-verify-the-\n  // HUMAN gate (they replay a password-reverify token), which a service token\n  // structurally cannot produce. Services already bypass `requirePermission` on\n  // the same trust basis (a signed service JWT), and internal callers of a\n  // step-up-gated route — e.g. the platform org-cascade's `DELETE /quotas/:orgId`\n  // or the billing→quota entitlement sync — would otherwise be hard-blocked.\n  // Safe: a service token can only be minted with `JWT_SECRET`, so this can't be\n  // spoofed by an external client to skip step-up.\n  if (isServicePrincipal(req)) {\n    next();\n    return;\n  }\n\n  const callerSub = (req as Request & { user?: { sub?: string } }).user?.sub;\n  if (!callerSub) {\n    sendError(res, 401, 'Authentication required', 'UNAUTHORIZED');\n    return;\n  }\n\n  const token = getHeaderString(req.headers[HEADER]);\n  if (!token) {\n    sendError(res, 401, 'Step-up verification required', 'STEP_UP_REQUIRED');\n    return;\n  }\n\n  let payload: StepUpTokenPayload;\n  try {\n    payload = verifyStepUpToken(token);\n  } catch {\n    sendError(res, 401, 'Step-up token invalid or expired', 'STEP_UP_INVALID');\n    return;\n  }\n\n  if (payload.sub !== callerSub) {\n    sendError(res, 401, 'Step-up token does not match session', 'STEP_UP_MISMATCH');\n    return;\n  }\n\n  try {\n    if (!(await consumeStepUpJti(payload.jti, payload.exp))) {\n      sendError(res, 401, 'Step-up token already used or expired', 'STEP_UP_REPLAY');\n      return;\n    }\n  } catch (err) {\n    logger.error('Step-up jti consume errored', { error: String(err) });\n    sendError(res, 401, 'Step-up verification failed', 'STEP_UP_INVALID');\n    return;\n  }\n\n  next();\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"step-up.js","sourceRoot":"","sources":["../../src/middleware/step-up.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\n/**\n * `requireStepUp` — a shared step-up (recent-password-reverify) gate for the\n * stateless api services, mirroring the platform middleware of the same name.\n *\n * Flow: the UI hits `POST /api/auth/step-up` (platform) to re-verify the user's\n * password; platform mints a short-lived (60s) `step-up` JWT signed with the\n * SAME `JWT_SECRET` these services already verify access tokens with. The UI\n * replays it as the `X-Step-Up-Token` header on the destructive/sensitive call;\n * this middleware verifies it, binds it to the caller (`sub` match), and\n * consumes its `jti` once (Redis-backed cross-instance when configured, else a\n * bounded process-local set) so a replay inside the TTL is rejected.\n *\n * WHY here: restore endpoints on the api services (pipeline/plugin/...) are\n * step-up-gated, but step-up previously lived only in `platform`. This ports the\n * verify + single-use jti into api-core so any service can require it.\n */\n\nimport type { Request, Response, NextFunction } from 'express';\nimport { buildJwtVerifyOptions, verifyJwtWithRotation, isServicePrincipal } from './auth.js';\nimport { createEnvRedisClient } from '../services/env-redis.js';\nimport { getHeaderString } from '../utils/headers.js';\nimport { createLogger } from '../utils/logger.js';\nimport { sendError } from '../utils/response.js';\n\nconst logger = createLogger('step-up');\nconst HEADER = 'x-step-up-token';\n\n/** Payload of a platform-issued step-up token (see platform issueStepUpToken). */\nexport interface StepUpTokenPayload {\n  type: 'step-up';\n  sub: string;\n  jti: string;\n  iat: number;\n  exp: number;\n}\n\n/**\n * Verify a step-up token: valid signature (primary `JWT_SECRET`, or\n * `JWT_SECRET_PREVIOUS` during a rotation), allow-listed algorithm, issuer and\n * audience when configured, AND the `type: 'step-up'` + `jti` claims — a plain\n * access token shares the secret and `sub`, so without asserting the step-up\n * shape it would bypass the gate. Throws on any failure. Does NOT bind to a\n * caller — `requireStepUp` does the `sub` match and single-use consume.\n *\n * Delegates to `requireAuth`'s own primitives rather than re-implementing them.\n * The hand-rolled copy this replaced dropped TWO of their guards: it never\n * pinned issuer/audience (so a step-up token from any other system sharing\n * `JWT_SECRET` was accepted wherever `JWT_ISSUER`/`JWT_AUDIENCE` are set), and\n * its previous-secret retry had no expiry/not-before carve-out, so an EXPIRED\n * token was retried and surfaced as a signature error instead of an expiry one.\n */\nexport function verifyStepUpToken(token: string): StepUpTokenPayload {\n  if (!process.env.JWT_SECRET) throw new Error('JWT_SECRET environment variable is required');\n  const payload = verifyJwtWithRotation(token, buildJwtVerifyOptions()) as unknown as StepUpTokenPayload;\n\n  if (payload.type !== 'step-up' || !payload.jti || !payload.sub) {\n    throw new Error('INVALID_STEP_UP_TOKEN');\n  }\n  return payload;\n}\n\n// -- Single-use jti store -----------------------------------------------------\n// Redis SET NX EX when Redis is configured (cross-instance single-use); else a\n// bounded process-local map with TTL sweep (per-process). A step-up token is\n// 60s-lived. When Redis IS configured it's the authoritative store: a Redis\n// error FAILS CLOSED (throws → STEP_UP_INVALID, user re-verifies) rather than\n// degrading to the per-instance mem guard, which would accept a cross-instance\n// replay during the outage. The mem guard is used ONLY when Redis is absent.\n\nlet _redis: { set: (...args: unknown[]) => Promise<unknown> } | null | undefined;\nfunction redis(): { set: (...args: unknown[]) => Promise<unknown> } | null {\n  if (_redis === undefined) {\n    _redis = createEnvRedisClient<{ set: (...args: unknown[]) => Promise<unknown> }>('step-up-jti');\n  }\n  return _redis;\n}\n\nconst memJti = new Map<string, number>(); // jti -> expiry epoch ms\nconst memSweep = setInterval(() => {\n  const now = Date.now();\n  for (const [jti, exp] of memJti) if (exp <= now) memJti.delete(jti);\n}, 30_000);\nmemSweep.unref?.();\n\n/**\n * Hard ceiling on the process-local jti set.\n *\n * The 30s sweep alone does NOT bound it: entries only leave once their token's\n * TTL has passed, so a burst of step-up traffic (or a flood of distinct forged\n * jtis on a Redis-less deployment) grows the map faster than the sweep drains\n * it. This is a replay guard, so shedding the OLDEST entries is the safe\n * direction: the worst case is that a long-expired jti could be replayed, and\n * expiry is enforced independently by the token's own `exp`.\n */\nconst MEM_JTI_MAX = 10_000;\n\n/** Drop the soonest-to-expire entries until the map is under the ceiling. */\nfunction evictOldestJti(): void {\n  if (memJti.size < MEM_JTI_MAX) return;\n  const byExpiry = [...memJti.entries()].sort((a, b) => a[1] - b[1]);\n  const excess = memJti.size - MEM_JTI_MAX + 1;\n  for (let i = 0; i < excess; i += 1) memJti.delete(byExpiry[i][0]);\n}\n\n/**\n * Consume a step-up `jti` exactly once. Returns true if this call claimed it\n * (first use), false if it was already consumed (replay). `expEpochSeconds` is\n * the token's `exp`, so the marker auto-expires with the token.\n */\nexport async function consumeStepUpJti(jti: string, expEpochSeconds: number): Promise<boolean> {\n  const ttlSeconds = Math.max(1, expEpochSeconds - Math.floor(Date.now() / 1000));\n  const client = redis();\n  if (client) {\n    // Redis configured ⇒ authoritative cross-instance store. SET NX EX → 'OK'\n    // when newly set, null when already consumed. A thrown Redis error is NOT\n    // caught here: it propagates so `requireStepUp` fails closed (STEP_UP_INVALID)\n    // instead of silently degrading to the per-instance mem guard.\n    const res = await client.set(`stepup:jti:${jti}`, '1', 'EX', ttlSeconds, 'NX');\n    return res === 'OK';\n  }\n  // No Redis ⇒ single-instance deployment; the process-local map IS the store.\n  if (memJti.has(jti)) return false;\n  evictOldestJti();\n  memJti.set(jti, Date.now() + ttlSeconds * 1000);\n  return true;\n}\n\n/**\n * Express middleware: require a valid, caller-bound, single-use step-up token in\n * the `X-Step-Up-Token` header. Must run AFTER `requireAuth` (needs `req.user`).\n */\nexport async function requireStepUp(req: Request, res: Response, next: NextFunction): Promise<void> {\n  // Verified internal service principals are EXEMPT: step-up is a re-verify-the-\n  // HUMAN gate (they replay a password-reverify token), which a service token\n  // structurally cannot produce. Services already bypass `requirePermission` on\n  // the same trust basis (a signed service JWT), and internal callers of a\n  // step-up-gated route — e.g. the platform org-cascade's `DELETE /quotas/:orgId`\n  // or the billing→quota entitlement sync — would otherwise be hard-blocked.\n  // Safe: a service token can only be minted with `JWT_SECRET`, so this can't be\n  // spoofed by an external client to skip step-up.\n  if (isServicePrincipal(req)) {\n    next();\n    return;\n  }\n\n  const callerSub = (req as Request & { user?: { sub?: string } }).user?.sub;\n  if (!callerSub) {\n    sendError(res, 401, 'Authentication required', 'UNAUTHORIZED');\n    return;\n  }\n\n  const token = getHeaderString(req.headers[HEADER]);\n  if (!token) {\n    sendError(res, 401, 'Step-up verification required', 'STEP_UP_REQUIRED');\n    return;\n  }\n\n  let payload: StepUpTokenPayload;\n  try {\n    payload = verifyStepUpToken(token);\n  } catch {\n    sendError(res, 401, 'Step-up token invalid or expired', 'STEP_UP_INVALID');\n    return;\n  }\n\n  if (payload.sub !== callerSub) {\n    sendError(res, 401, 'Step-up token does not match session', 'STEP_UP_MISMATCH');\n    return;\n  }\n\n  try {\n    if (!(await consumeStepUpJti(payload.jti, payload.exp))) {\n      sendError(res, 401, 'Step-up token already used or expired', 'STEP_UP_REPLAY');\n      return;\n    }\n  } catch (err) {\n    logger.error('Step-up jti consume errored', { error: String(err) });\n    sendError(res, 401, 'Step-up verification failed', 'STEP_UP_INVALID');\n    return;\n  }\n\n  next();\n}\n"]}

package/lib/utils/index.d.ts

@@ -1,5 +1,6 @@
 export * from './logger.js';
 export * from './safe-require.js';
+export * from './secure-compare.js';
 export * from './crash-handlers.js';
 export * from './response.js';
 export * from './params.js';

package/lib/utils/index.js

@@ -2,6 +2,7 @@
 // SPDX-License-Identifier: Apache-2.0
 export * from './logger.js';
 export * from './safe-require.js';
+export * from './secure-compare.js';
 export * from './crash-handlers.js';
 export * from './response.js';
 export * from './params.js';
@@ -17,4 +18,4 @@ export * from './aws-scrub.js';
 export * from './ssrf.js';
 export * from './env.js';
 export * from './compliance-attributes.js';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvdXRpbHMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsK0NBQStDO0FBQy9DLHNDQUFzQztBQUV0QyxjQUFjLGFBQWEsQ0FBQztBQUM1QixjQUFjLG1CQUFtQixDQUFDO0FBQ2xDLGNBQWMscUJBQXFCLENBQUM7QUFDcEMsY0FBYyxlQUFlLENBQUM7QUFDOUIsY0FBYyxhQUFhLENBQUM7QUFDNUIsY0FBYyxjQUFjLENBQUM7QUFDN0IsY0FBYyxlQUFlLENBQUM7QUFDOUIsY0FBYyxhQUFhLENBQUM7QUFDNUIsY0FBYyxxQkFBcUIsQ0FBQztBQUNwQyxjQUFjLGtCQUFrQixDQUFDO0FBQ2pDLGNBQWMsWUFBWSxDQUFDO0FBQzNCLGNBQWMsd0JBQXdCLENBQUM7QUFDdkMsY0FBYyxxQkFBcUIsQ0FBQztBQUNwQyxjQUFjLGdCQUFnQixDQUFDO0FBQy9CLGNBQWMsV0FBVyxDQUFDO0FBQzFCLGNBQWMsVUFBVSxDQUFDO0FBQ3pCLGNBQWMsNEJBQTRCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvLyBDb3B5cmlnaHQgMjAyNiBQaXBlbGluZSBCdWlsZGVyIENvbnRyaWJ1dG9yc1xuLy8gU1BEWC1MaWNlbnNlLUlkZW50aWZpZXI6IEFwYWNoZS0yLjBcblxuZXhwb3J0ICogZnJvbSAnLi9sb2dnZXIuanMnO1xuZXhwb3J0ICogZnJvbSAnLi9zYWZlLXJlcXVpcmUuanMnO1xuZXhwb3J0ICogZnJvbSAnLi9jcmFzaC1oYW5kbGVycy5qcyc7XG5leHBvcnQgKiBmcm9tICcuL3Jlc3BvbnNlLmpzJztcbmV4cG9ydCAqIGZyb20gJy4vcGFyYW1zLmpzJztcbmV4cG9ydCAqIGZyb20gJy4vaGVhZGVycy5qcyc7XG5leHBvcnQgKiBmcm9tICcuL2lkZW50aXR5LmpzJztcbmV4cG9ydCAqIGZyb20gJy4vb2JqZWN0LmpzJztcbmV4cG9ydCAqIGZyb20gJy4vYWxpYXMtcmVzb2x2ZXIuanMnO1xuZXhwb3J0ICogZnJvbSAnLi9jb25jdXJyZW5jeS5qcyc7XG5leHBvcnQgKiBmcm9tICcuL2F1ZGl0LmpzJztcbmV4cG9ydCAqIGZyb20gJy4vc2VjcmV0LWVuY3J5cHRpb24uanMnO1xuZXhwb3J0ICogZnJvbSAnLi9tZXRyaWMtZW1pdHRlci5qcyc7XG5leHBvcnQgKiBmcm9tICcuL2F3cy1zY3J1Yi5qcyc7XG5leHBvcnQgKiBmcm9tICcuL3NzcmYuanMnO1xuZXhwb3J0ICogZnJvbSAnLi9lbnYuanMnO1xuZXhwb3J0ICogZnJvbSAnLi9jb21wbGlhbmNlLWF0dHJpYnV0ZXMuanMnO1xuIl19
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvdXRpbHMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsK0NBQStDO0FBQy9DLHNDQUFzQztBQUV0QyxjQUFjLGFBQWEsQ0FBQztBQUM1QixjQUFjLG1CQUFtQixDQUFDO0FBQ2xDLGNBQWMscUJBQXFCLENBQUM7QUFDcEMsY0FBYyxxQkFBcUIsQ0FBQztBQUNwQyxjQUFjLGVBQWUsQ0FBQztBQUM5QixjQUFjLGFBQWEsQ0FBQztBQUM1QixjQUFjLGNBQWMsQ0FBQztBQUM3QixjQUFjLGVBQWUsQ0FBQztBQUM5QixjQUFjLGFBQWEsQ0FBQztBQUM1QixjQUFjLHFCQUFxQixDQUFDO0FBQ3BDLGNBQWMsa0JBQWtCLENBQUM7QUFDakMsY0FBYyxZQUFZLENBQUM7QUFDM0IsY0FBYyx3QkFBd0IsQ0FBQztBQUN2QyxjQUFjLHFCQUFxQixDQUFDO0FBQ3BDLGNBQWMsZ0JBQWdCLENBQUM7QUFDL0IsY0FBYyxXQUFXLENBQUM7QUFDMUIsY0FBYyxVQUFVLENBQUM7QUFDekIsY0FBYyw0QkFBNEIsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8vIENvcHlyaWdodCAyMDI2IFBpcGVsaW5lIEJ1aWxkZXIgQ29udHJpYnV0b3JzXG4vLyBTUERYLUxpY2Vuc2UtSWRlbnRpZmllcjogQXBhY2hlLTIuMFxuXG5leHBvcnQgKiBmcm9tICcuL2xvZ2dlci5qcyc7XG5leHBvcnQgKiBmcm9tICcuL3NhZmUtcmVxdWlyZS5qcyc7XG5leHBvcnQgKiBmcm9tICcuL3NlY3VyZS1jb21wYXJlLmpzJztcbmV4cG9ydCAqIGZyb20gJy4vY3Jhc2gtaGFuZGxlcnMuanMnO1xuZXhwb3J0ICogZnJvbSAnLi9yZXNwb25zZS5qcyc7XG5leHBvcnQgKiBmcm9tICcuL3BhcmFtcy5qcyc7XG5leHBvcnQgKiBmcm9tICcuL2hlYWRlcnMuanMnO1xuZXhwb3J0ICogZnJvbSAnLi9pZGVudGl0eS5qcyc7XG5leHBvcnQgKiBmcm9tICcuL29iamVjdC5qcyc7XG5leHBvcnQgKiBmcm9tICcuL2FsaWFzLXJlc29sdmVyLmpzJztcbmV4cG9ydCAqIGZyb20gJy4vY29uY3VycmVuY3kuanMnO1xuZXhwb3J0ICogZnJvbSAnLi9hdWRpdC5qcyc7XG5leHBvcnQgKiBmcm9tICcuL3NlY3JldC1lbmNyeXB0aW9uLmpzJztcbmV4cG9ydCAqIGZyb20gJy4vbWV0cmljLWVtaXR0ZXIuanMnO1xuZXhwb3J0ICogZnJvbSAnLi9hd3Mtc2NydWIuanMnO1xuZXhwb3J0ICogZnJvbSAnLi9zc3JmLmpzJztcbmV4cG9ydCAqIGZyb20gJy4vZW52LmpzJztcbmV4cG9ydCAqIGZyb20gJy4vY29tcGxpYW5jZS1hdHRyaWJ1dGVzLmpzJztcbiJdfQ==

package/lib/utils/secret-encryption.d.ts

@@ -116,6 +116,10 @@ export declare class PerOrgKmsKeyProvider implements KeyProvider {
      *  Resolves to `null` for orgs with no per-org config — caller treats null as
      *  "fall through to the fallback provider", same as a cold cache miss. */
     private readonly inFlight;
+    /** Orgs the resolver has PROVEN have no per-org config — the fallback provider
+     *  is the correct answer for these, and `deriveKey` may serve them
+     *  synchronously. Distinct from "not yet resolved", which must not guess. */
+    private readonly resolvedNoPerOrgConfig;
     /** Provider used for orgs that have no per-org config. */
     private readonly fallback;
     private readonly resolver;
@@ -127,11 +131,23 @@ export declare class PerOrgKmsKeyProvider implements KeyProvider {
         region?: string;
         endpoint?: string;
     });
-    /** Sync `deriveKey` only works for already-warmed orgs. Cold orgs fall
-     *  through to the fallback provider. Callers that want per-org isolation
-     *  MUST `await deriveKeyAsync(orgId)` once first (e.g. during request setup
-     *  or as part of a warmup pass) — otherwise the org silently uses the
-     *  shared master. */
+    /**
+     * Sync derive. Only correct for an org whose config has already been
+     * RESOLVED — either it has a per-org master (use it) or it provably has no
+     * per-org config (the fallback is then the right answer).
+     *
+     * For an UNRESOLVED org this THROWS rather than guessing. It used to fall
+     * through to the fallback, which silently encrypted that org's secrets under
+     * the SHARED master and — because `kidFor` also returned undefined, so the
+     * both-kids-present mismatch guard could never fire — left them permanently
+     * undecryptable once the org warmed: `decipher.final()` then threw an opaque
+     * auth-tag error with no diagnostic. Failing loud here matches
+     * `KmsKeyProvider.deriveKey`, which has always refused to work cold.
+     *
+     * `encryptSecret`/`decryptSecret` are async and await `deriveKeyAsync`, so
+     * they resolve the org first and never hit this path; it is the backstop for
+     * a caller that reaches for the sync API directly.
+     */
     deriveKey(orgId: string): Buffer;
     deriveKeyAsync(orgId: string): Promise<Buffer>;
     kidFor(orgId: string): string | undefined;
@@ -157,7 +173,7 @@ export declare class PerOrgKmsKeyProvider implements KeyProvider {
  * Empty strings round-trip as `null` so the calling model layer can treat
  * "no secret set" identically to "field absent".
  */
-export declare function encryptSecret(plaintext: string, orgId: string, provider?: KeyProvider): EncryptedBlob;
+export declare function encryptSecret(plaintext: string, orgId: string, provider?: KeyProvider): Promise<EncryptedBlob>;
 /**
  * Decrypt an `EncryptedBlob` written by `encryptSecret`. Throws on * - unknown `alg` (forces an explicit migration when the format changes)
  * - wrong orgId (HKDF binding mismatch fails the auth tag)
@@ -166,7 +182,7 @@ export declare function encryptSecret(plaintext: string, orgId: string, provider
  * Callers handle the throw  masking the failure as `null` would hide
  * silent corruption / wrong-org reads.
  */
-export declare function decryptSecret(blob: EncryptedBlob, orgId: string, provider?: KeyProvider): string;
+export declare function decryptSecret(blob: EncryptedBlob, orgId: string, provider?: KeyProvider): Promise<string>;
 /**
  * Type guard  handy for model layers that hold a column whose value may be
  * either a clear-text string (legacy / unencrypted) OR an encrypted blob

package/lib/utils/secret-encryption.js

@@ -217,6 +217,10 @@ export class PerOrgKmsKeyProvider {
      *  Resolves to `null` for orgs with no per-org config — caller treats null as
      *  "fall through to the fallback provider", same as a cold cache miss. */
     inFlight = new Map();
+    /** Orgs the resolver has PROVEN have no per-org config — the fallback provider
+     *  is the correct answer for these, and `deriveKey` may serve them
+     *  synchronously. Distinct from "not yet resolved", which must not guess. */
+    resolvedNoPerOrgConfig = new Set();
     /** Provider used for orgs that have no per-org config. */
     fallback;
     resolver;
@@ -228,15 +232,32 @@ export class PerOrgKmsKeyProvider {
         this.region = opts.region ?? process.env.AWS_REGION ?? process.env.AWS_DEFAULT_REGION;
         this.endpoint = opts.endpoint ?? process.env.AWS_KMS_ENDPOINT;
     }
-    /** Sync `deriveKey` only works for already-warmed orgs. Cold orgs fall
-     *  through to the fallback provider. Callers that want per-org isolation
-     *  MUST `await deriveKeyAsync(orgId)` once first (e.g. during request setup
-     *  or as part of a warmup pass) — otherwise the org silently uses the
-     *  shared master. */
+    /**
+     * Sync derive. Only correct for an org whose config has already been
+     * RESOLVED — either it has a per-org master (use it) or it provably has no
+     * per-org config (the fallback is then the right answer).
+     *
+     * For an UNRESOLVED org this THROWS rather than guessing. It used to fall
+     * through to the fallback, which silently encrypted that org's secrets under
+     * the SHARED master and — because `kidFor` also returned undefined, so the
+     * both-kids-present mismatch guard could never fire — left them permanently
+     * undecryptable once the org warmed: `decipher.final()` then threw an opaque
+     * auth-tag error with no diagnostic. Failing loud here matches
+     * `KmsKeyProvider.deriveKey`, which has always refused to work cold.
+     *
+     * `encryptSecret`/`decryptSecret` are async and await `deriveKeyAsync`, so
+     * they resolve the org first and never hit this path; it is the backstop for
+     * a caller that reaches for the sync API directly.
+     */
     deriveKey(orgId) {
         const cached = this.masters.get(orgId);
-        if (!cached)
-            return this.fallback.deriveKey(orgId);
+        if (!cached) {
+            if (this.resolvedNoPerOrgConfig.has(orgId))
+                return this.fallback.deriveKey(orgId);
+            throw new Error(`PerOrgKmsKeyProvider has not resolved org ${orgId}. `
+                + 'Call `await provider.ensureWarmed(orgId)` (or use the async encryptSecret/decryptSecret) '
+                + 'before deriving a key — guessing the shared master would write secrets that cannot be decrypted later.');
+        }
         const derived = hkdfSync('sha256', cached.key, Buffer.from(orgId, 'utf8'), 'secrets-v1', 32);
         return Buffer.from(derived);
     }
@@ -245,7 +266,14 @@ export class PerOrgKmsKeyProvider {
         return this.deriveKey(orgId);
     }
     kidFor(orgId) {
-        return this.masters.get(orgId)?.kid ?? this.fallback.kidFor?.(orgId);
+        const cached = this.masters.get(orgId);
+        if (cached)
+            return cached.kid;
+        // Only speak for an org whose config is resolved; an unresolved org has no
+        // meaningful kid, and claiming one would defeat the mismatch guard.
+        if (this.resolvedNoPerOrgConfig.has(orgId))
+            return this.fallback.kidFor?.(orgId);
+        return undefined;
     }
     /**
      * Resolve the org's KMS config, call Decrypt, cache the master. Subsequent
@@ -272,6 +300,10 @@ export class PerOrgKmsKeyProvider {
         const result = await promise;
         if (result)
             this.masters.set(orgId, result);
+        // Remember the NEGATIVE outcome too, so the sync `deriveKey` can tell
+        // "no per-org config, fallback is correct" from "not resolved yet".
+        else
+            this.resolvedNoPerOrgConfig.add(orgId);
     }
     async resolveAndDecrypt(orgId) {
         let cfg = this.configs.get(orgId);
@@ -293,8 +325,22 @@ export class PerOrgKmsKeyProvider {
     evict(orgId) {
         this.masters.delete(orgId);
         this.configs.delete(orgId);
+        // Also forget a NEGATIVE resolution, or an org that gains a per-org config
+        // after being resolved as "no config" would keep using the shared master.
+        this.resolvedNoPerOrgConfig.delete(orgId);
     }
 }
+/**
+ * Derive the key for `orgId`, giving the provider a chance to do I/O first.
+ *
+ * This is why `encryptSecret`/`decryptSecret` are async: `PerOrgKmsKeyProvider`
+ * needs one KMS Decrypt the first time it sees an org, and deriving
+ * synchronously before that resolves would silently fall back to the shared
+ * master and produce secrets that cannot be decrypted afterwards.
+ */
+async function deriveKeyFor(provider, orgId) {
+    return provider.deriveKeyAsync ? provider.deriveKeyAsync(orgId) : provider.deriveKey(orgId);
+}
 /**
  * Encrypt a plaintext string for storage. Returns an `EncryptedBlob` that
  * can be JSON-serialized into the underlying column / Mongo document.
@@ -302,11 +348,13 @@ export class PerOrgKmsKeyProvider {
  * Empty strings round-trip as `null` so the calling model layer can treat
  * "no secret set" identically to "field absent".
  */
-export function encryptSecret(plaintext, orgId, provider = getDefaultProvider()) {
+export async function encryptSecret(plaintext, orgId, provider = getDefaultProvider()) {
     if (!plaintext) {
         throw new Error('Refusing to encrypt empty string; caller should store null instead');
     }
-    const key = provider.deriveKey(orgId);
+    // Resolve (and warm) the org BEFORE reading `kidFor` below, so a per-org KMS
+    // blob is always stamped with the key it was actually encrypted under.
+    const key = await deriveKeyFor(provider, orgId);
     const iv = randomBytes(12);
     const cipher = createCipheriv('aes-256-gcm', key, iv);
     const enc = Buffer.concat([cipher.update(plaintext, 'utf8'), cipher.final()]);
@@ -333,10 +381,13 @@ export function encryptSecret(plaintext, orgId, provider = getDefaultProvider())
  * Callers handle the throw  masking the failure as `null` would hide
  * silent corruption / wrong-org reads.
  */
-export function decryptSecret(blob, orgId, provider = getDefaultProvider()) {
+export async function decryptSecret(blob, orgId, provider = getDefaultProvider()) {
     if (blob.alg !== 'aes-256-gcm-v1') {
         throw new Error(`Unsupported encryption alg: ${blob.alg}`);
     }
+    // Warm first: `kidFor` and `deriveKey` below must both speak for the org's
+    // real config, or the mismatch guard silently no-ops.
+    const key = await deriveKeyFor(provider, orgId);
     // If both the provider AND the blob report a kid, they must match.
     // Mismatch usually means an operator rotated/replaced an org's KMS
     // config and is now reading a blob encrypted under the OLD key —
@@ -345,7 +396,6 @@ export function decryptSecret(blob, orgId, provider = getDefaultProvider()) {
     if (providerKid !== undefined && blob.kid !== undefined && providerKid !== blob.kid) {
         throw new Error(`KMS key id mismatch: blob was encrypted under ${blob.kid}, current provider uses ${providerKid} for org ${orgId}`);
     }
-    const key = provider.deriveKey(orgId);
     const iv = Buffer.from(blob.iv, 'base64');
     const all = Buffer.from(blob.ciphertext, 'base64');
     // Split off the 16-byte auth tag appended in encryptSecret. Any tampering
@@ -371,4 +421,4 @@ export function isEncryptedBlob(value) {
         && typeof value.iv === 'string'
         && typeof value.ciphertext === 'string');
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"secret-encryption.js","sourceRoot":"","sources":["../../src/utils/secret-encryption.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\n/**\n *  Per-org envelope encryption for secret columns.\n *\n * Today's posture for org-scoped secrets (aiProviderKeys, webhook URLs,\n * registry credentials) is clear-text in Mongo / Postgres with app-layer\n * masking on output. This module is the encryption primitive that lets the\n * model layer swap clear-text strings for `EncryptedBlob` values at write\n * time and decrypt at read time.\n *\n * Cryptography * - AES-256-GCM (authenticated encryption).\n * - Per-org key derived via HKDF-SHA256(masterKey, salt=orgId, info='secrets-v1').\n * Each org gets a unique key without operator key-management ceremony.\n * - 12-byte IV generated per encryption with `crypto.randomBytes`.\n * - 16-byte authentication tag concatenated with ciphertext (standard GCM).\n *\n * Operator configuration * - `SECRET_ENCRYPTION_KEY` env: hex- or base64-encoded 32-byte master key.\n * Required when `encryptSecret`/`decryptSecret` are called. Missing key\n * throws  encryption is fail-closed; we never silently round-trip a\n * secret as plaintext.\n *\n * KMS migration path * - The two exported functions take a `provider` parameter. The default\n * `EnvKeyProvider` implements HKDF derivation. A future `AwsKmsProvider`\n * plugs in here: it can call KMS `Encrypt` / `Decrypt` to wrap a DEK\n * rather than holding a master key in env. The on-disk blob shape\n * (`{ alg, iv, ciphertext, kid? }`) is forward-compatible  `kid`\n * carries the KMS key id when the provider needs it.\n */\n\nimport { createCipheriv, createDecipheriv, hkdfSync, randomBytes } from 'crypto';\n\n/** On-disk shape of an encrypted secret. JSON-serializable. */\nexport interface EncryptedBlob {\n  /** Algorithm tag. Bump on format change so a future migration can detect old blobs. */\n  alg: 'aes-256-gcm-v1';\n  /** Base64-encoded 12-byte IV. */\n  iv: string;\n  /** Base64-encoded ciphertext + 16-byte authentication tag concatenated. */\n  ciphertext: string;\n  /** Optional key id  populated by KMS-backed providers, ignored by the env provider. */\n  kid?: string;\n}\n\n/** Pluggable key source. Env-backed by default; KMS-backed available. */\nexport interface KeyProvider {\n  /** Derive a 32-byte symmetric key bound to `orgId`. */\n  deriveKey(orgId: string): Buffer;\n  /** Optional async variant for providers that need to do I/O (e.g.\n   *  per-org KMS lookup the first time an org is seen). Default\n   *  implementation forwards to the sync `deriveKey`. */\n  deriveKeyAsync?(orgId: string): Promise<Buffer>;\n  /** Optional KMS-key-id this provider used for `orgId`. Embedded in the\n   *  `EncryptedBlob.kid` field on write so decrypt can verify the right\n   *  KMS CMK is being used (defense against an attacker who swaps a blob\n   *  between orgs). Default returns undefined (env provider). */\n  kidFor?(orgId: string): string | undefined;\n}\n\n/**\n * Default provider  derives a per-org key from `SECRET_ENCRYPTION_KEY` via\n * HKDF-SHA256. Suitable for self-hosted / dev where operators don't have KMS.\n *\n * Fails fast if the env is missing or the key is the wrong length so misconfig\n * surfaces at first use rather than silently fingerprinting all writes with\n * a default zero key.\n */\nexport class EnvKeyProvider implements KeyProvider {\n  private readonly masterKey: Buffer;\n\n  constructor(masterKeyOverride?: string) {\n    const raw = masterKeyOverride ?? process.env.SECRET_ENCRYPTION_KEY;\n    if (!raw) {\n      throw new Error('SECRET_ENCRYPTION_KEY env is required for secret encryption');\n    }\n    // Accept either hex (64 chars) or base64 (44 chars including padding) for\n    // operator convenience  both decode to a 32-byte key.\n    const decoded = raw.length === 64 && /^[0-9a-f]+$/i.test(raw)\n      ? Buffer.from(raw, 'hex')\n      : Buffer.from(raw, 'base64');\n    if (decoded.length !== 32) {\n      throw new Error(`SECRET_ENCRYPTION_KEY must decode to 32 bytes (got ${decoded.length})`);\n    }\n    this.masterKey = decoded;\n  }\n\n  deriveKey(orgId: string): Buffer {\n    // HKDF binds the master key to the org so two orgs encrypting the same\n    // plaintext produce different ciphertexts  keeps a stolen DB unable to\n    // tell which orgs share secrets via ciphertext comparison.\n    const derived = hkdfSync( 'sha256',\n      this.masterKey,\n      Buffer.from(orgId, 'utf8'),\n      'secrets-v1',\n      32,\n    );\n    // hkdfSync returns ArrayBuffer in older Node typings; normalize to Buffer.\n    return Buffer.from(derived);\n  }\n}\n\n/**\n *  AWS-KMS-backed KeyProvider.\n *\n * Trade-off picked: store ONE master key encrypted under a KMS CMK; on\n * first use, call `kms:Decrypt` to recover the master key bytes; HKDF-\n * derive per-org from it (same as EnvKeyProvider). The process then holds\n * the plaintext master key in memory until restart.\n *\n * PROS: one KMS call per process lifetime (cheap, low p99 impact),\n * the encrypted-master-key blob is safe to commit/log/checkin,\n * KMS audit log records when the master is recovered.\n * CONS: process memory still holds the master key  same posture as\n * EnvKeyProvider once warmed up. For stronger isolation an\n * operator can move to per-record envelope encryption (call\n * GenerateDataKey on every write); that's a follow-on.\n *\n * Operator setup * 1. Create a KMS CMK with key policy allowing the platform service's\n * IAM role kms:Decrypt.\n * 2. Generate a random 32-byte master * head -c 32 /dev/urandom | base64\n * 3. Wrap it with KMS * aws kms encrypt --key-id <KEY_ID> \\\n * --plaintext <base64-from-step-2> --output text \\\n * --query CiphertextBlob\n * 4. Set on the service * SECRET_ENCRYPTION_KMS_KEY_ID=<KEY_ID>\n * SECRET_ENCRYPTION_KMS_CIPHERTEXT=<base64-output-of-step-3>\n * 5. Pick this provider via `setKeyProvider(new KmsKeyProvider())`.\n *\n * Construct lazily  importing the AWS SDK has a non-trivial cold-start\n * cost so envs that stay on EnvKeyProvider never load it.\n */\n/**\n * KMS-decrypt a base64 ciphertext into a 32-byte key. Shared by both KMS key\n * providers (single-master + per-org), which previously copy-pasted this\n * dynamic-import + Decrypt + empty/length guards. `@aws-sdk/client-kms` is\n * dynamically imported so EnvKeyProvider-only envs never load the SDK.\n */\nasync function kmsDecrypt32(keyId: string, ciphertextB64: string, region?: string, endpoint?: string): Promise<Buffer> {\n  const { KMSClient, DecryptCommand } = await import('@aws-sdk/client-kms');\n  const client = new KMSClient({ region, ...(endpoint ? { endpoint } : {}) });\n  const resp = await client.send(new DecryptCommand({\n    KeyId: keyId,\n    CiphertextBlob: Buffer.from(ciphertextB64, 'base64'),\n  }));\n  if (!resp.Plaintext) throw new Error(`KMS Decrypt returned an empty Plaintext for key ${keyId}`);\n  const buf = Buffer.from(resp.Plaintext);\n  if (buf.length !== 32) throw new Error(`KMS Decrypt returned ${buf.length}-byte key for ${keyId}; expected 32`);\n  return buf;\n}\n\nexport class KmsKeyProvider implements KeyProvider {\n  private masterKeyCache: Buffer | null = null;\n  private readonly keyId: string;\n  private readonly ciphertextB64: string;\n  private readonly region?: string;\n  private readonly endpoint?: string;\n  private decryptInFlight: Promise<Buffer> | null = null;\n\n  constructor(opts?: { keyId?: string; ciphertextBase64?: string; region?: string; endpoint?: string }) {\n    const keyId = opts?.keyId ?? process.env.SECRET_ENCRYPTION_KMS_KEY_ID;\n    const ciphertext = opts?.ciphertextBase64 ?? process.env.SECRET_ENCRYPTION_KMS_CIPHERTEXT;\n    if (!keyId) throw new Error('SECRET_ENCRYPTION_KMS_KEY_ID env is required for KmsKeyProvider');\n    if (!ciphertext) throw new Error('SECRET_ENCRYPTION_KMS_CIPHERTEXT env is required for KmsKeyProvider');\n    this.keyId = keyId;\n    this.ciphertextB64 = ciphertext;\n    this.region = opts?.region ?? process.env.AWS_REGION ?? process.env.AWS_DEFAULT_REGION;\n    this.endpoint = opts?.endpoint ?? process.env.AWS_KMS_ENDPOINT;\n  }\n\n  deriveKey(orgId: string): Buffer {\n    if (!this.masterKeyCache) {\n      throw new Error( 'KmsKeyProvider is not warmed up. Call `await provider.warmup()` once at service startup before any encrypt/decrypt.',\n      );\n    }\n    const derived = hkdfSync('sha256', this.masterKeyCache, Buffer.from(orgId, 'utf8'), 'secrets-v1', 32);\n    return Buffer.from(derived);\n  }\n\n  /**\n   * Eagerly recover the master key from KMS so subsequent `deriveKey`\n   * calls are sync. Idempotent  concurrent callers share the same in-\n   * flight promise so we don't spawn multiple KMS Decrypt requests at\n   * boot. Throws on any KMS failure; the caller (typically the service's\n   * onBeforeStart hook) decides whether to fall back to a different\n   * provider or fail-startup.\n   */\n  async warmup(): Promise<void> {\n    if (this.masterKeyCache) return;\n    if (!this.decryptInFlight) {\n      this.decryptInFlight = this.fetchAndDecrypt();\n    }\n    try {\n      this.masterKeyCache = await this.decryptInFlight;\n    } catch (err) {\n      // A transient KMS failure must not permanently poison the provider: clear\n      // the rejected in-flight promise so a later warmup() retries instead of\n      // re-awaiting the same rejection forever (matches PerOrgKmsKeyProvider).\n      this.decryptInFlight = null;\n      throw err;\n    }\n  }\n\n  private fetchAndDecrypt(): Promise<Buffer> {\n    return kmsDecrypt32(this.keyId, this.ciphertextB64, this.region, this.endpoint);\n  }\n}\n\n// Lazy singleton  operator code in long-lived services pays the env-parse\n// cost once, and tests can mint their own provider with a literal key.\nlet defaultProvider: KeyProvider | null = null;\nfunction getDefaultProvider(): KeyProvider {\n  if (!defaultProvider) defaultProvider = new EnvKeyProvider();\n  return defaultProvider;\n}\n\n/** Read the active default provider. Exposed so service code (e.g. an\n *  admin endpoint that just rotated an org's KMS config) can call\n *  `provider.evict(orgId)` on the live provider rather than reconstructing\n *  one. Triggers lazy initialization on first access, same as the internal\n *  callers below. */\nexport function getDefaultKeyProvider(): KeyProvider {\n  return getDefaultProvider();\n}\n\n/** Reset the cached default provider  for tests that mutate `process.env`. */\nexport function resetDefaultKeyProvider(): void { defaultProvider = null; }\n\n/** Replace the default provider  services that opt into KMS call this\n * once at startup with a warmed-up `KmsKeyProvider`. */\nexport function setKeyProvider(provider: KeyProvider): void { defaultProvider = provider; }\n\n/** Per-org KMS config the operator supplies. The `keyId` identifies the\n *  KMS CMK to call Decrypt on; `ciphertextBase64` is the wrapped 32-byte\n *  master generated by `aws kms encrypt` against that key. */\nexport interface PerOrgKmsConfig {\n  keyId: string;\n  ciphertextBase64: string;\n}\n\n/**\n * Async resolver that maps an org id to its KMS config. Returns `null` when\n * the org has no per-org config — the provider then falls back to the\n * `fallback` provider supplied at construction (usually an EnvKeyProvider\n * or a default KmsKeyProvider).\n */\nexport type PerOrgKmsResolver = (orgId: string) => Promise<PerOrgKmsConfig | null>;\n\n/**\n * Per-org KMS-backed KeyProvider. The blast radius of a KMS key compromise\n * is one org instead of every org under a shared master.\n *\n * Each org has its own KMS CMK + its own wrapped master (stored in Mongo\n * via the operator's setup script). On first encrypt/decrypt for an org,\n * the provider:\n *   1. Calls the resolver to fetch the org's KMS config.\n *   2. Calls `kms:Decrypt` to recover the 32-byte master.\n *   3. Caches the recovered master in-memory for the process lifetime.\n *   4. HKDF-derives per-call from that master + the org id salt.\n *\n * Blobs encrypted by this provider carry `kid = <kms-key-id>` so the\n * decrypt path detects a stale config (operator rotated the key but\n * existing rows weren't re-encrypted) BEFORE AES-GCM throws an opaque\n * authentication-tag error.\n *\n * Orgs without per-org config fall through to the `fallback` provider —\n * mixed-mode deployments where some orgs have KMS isolation and others\n * stay on the shared master are explicitly supported.\n */\nexport class PerOrgKmsKeyProvider implements KeyProvider {\n  /** Cached per-org master keys, keyed by orgId. */\n  private readonly masters = new Map<string, { key: Buffer; kid: string }>();\n  /** Resolved per-org configs cached for the process lifetime. */\n  private readonly configs = new Map<string, PerOrgKmsConfig>();\n  /** In-flight resolver promises so concurrent first-touch callers share one KMS Decrypt.\n   *  Resolves to `null` for orgs with no per-org config — caller treats null as\n   *  \"fall through to the fallback provider\", same as a cold cache miss. */\n  private readonly inFlight = new Map<string, Promise<{ key: Buffer; kid: string } | null>>();\n  /** Provider used for orgs that have no per-org config. */\n  private readonly fallback: KeyProvider;\n  private readonly resolver: PerOrgKmsResolver;\n  private readonly region?: string;\n  private readonly endpoint?: string;\n\n  constructor(opts: {\n    resolver: PerOrgKmsResolver;\n    fallback: KeyProvider;\n    region?: string;\n    endpoint?: string;\n  }) {\n    this.resolver = opts.resolver;\n    this.fallback = opts.fallback;\n    this.region = opts.region ?? process.env.AWS_REGION ?? process.env.AWS_DEFAULT_REGION;\n    this.endpoint = opts.endpoint ?? process.env.AWS_KMS_ENDPOINT;\n  }\n\n  /** Sync `deriveKey` only works for already-warmed orgs. Cold orgs fall\n   *  through to the fallback provider. Callers that want per-org isolation\n   *  MUST `await deriveKeyAsync(orgId)` once first (e.g. during request setup\n   *  or as part of a warmup pass) — otherwise the org silently uses the\n   *  shared master. */\n  deriveKey(orgId: string): Buffer {\n    const cached = this.masters.get(orgId);\n    if (!cached) return this.fallback.deriveKey(orgId);\n    const derived = hkdfSync('sha256', cached.key, Buffer.from(orgId, 'utf8'), 'secrets-v1', 32);\n    return Buffer.from(derived);\n  }\n\n  async deriveKeyAsync(orgId: string): Promise<Buffer> {\n    await this.ensureWarmed(orgId);\n    return this.deriveKey(orgId);\n  }\n\n  kidFor(orgId: string): string | undefined {\n    return this.masters.get(orgId)?.kid ?? this.fallback.kidFor?.(orgId);\n  }\n\n  /**\n   * Resolve the org's KMS config, call Decrypt, cache the master. Subsequent\n   * calls for the same org are no-ops. Concurrent callers share the in-flight\n   * Decrypt promise.\n   *\n   * Returns silently when the org has no per-org config — the fallback\n   * provider handles those orgs.\n   */\n  async ensureWarmed(orgId: string): Promise<void> {\n    if (this.masters.has(orgId)) return;\n    // Install the in-flight promise SYNCHRONOUSLY before yielding so concurrent\n    // callers find it on the second-and-later passes. Awaiting the resolver\n    // before populating the map is the bug that lets a Promise.all of 3\n    // callers fire 3 KMS Decrypts.\n    let promise = this.inFlight.get(orgId);\n    if (!promise) {\n      promise = this.resolveAndDecrypt(orgId);\n      this.inFlight.set(orgId, promise);\n      void promise.finally(() => { if (this.inFlight.get(orgId) === promise) this.inFlight.delete(orgId); });\n    }\n    const result = await promise;\n    if (result) this.masters.set(orgId, result);\n  }\n\n  private async resolveAndDecrypt(orgId: string): Promise<{ key: Buffer; kid: string } | null> {\n    let cfg = this.configs.get(orgId);\n    if (!cfg) {\n      const resolved = await this.resolver(orgId);\n      if (!resolved) return null; // no per-org config → caller uses fallback\n      cfg = resolved;\n      this.configs.set(orgId, cfg);\n    }\n    const key = await this.fetchAndDecrypt(cfg);\n    return { key, kid: cfg.keyId };\n  }\n\n  private fetchAndDecrypt(cfg: PerOrgKmsConfig): Promise<Buffer> {\n    return kmsDecrypt32(cfg.keyId, cfg.ciphertextBase64, this.region, this.endpoint);\n  }\n\n  /** Evict a cached per-org master. Use after a key rotation so the next\n   *  touch re-fetches the new wrapped master from the resolver. */\n  evict(orgId: string): void {\n    this.masters.delete(orgId);\n    this.configs.delete(orgId);\n  }\n}\n\n/**\n * Encrypt a plaintext string for storage. Returns an `EncryptedBlob` that\n * can be JSON-serialized into the underlying column / Mongo document.\n *\n * Empty strings round-trip as `null` so the calling model layer can treat\n * \"no secret set\" identically to \"field absent\".\n */\nexport function encryptSecret( plaintext: string,\n  orgId: string,\n  provider: KeyProvider = getDefaultProvider(),\n): EncryptedBlob {\n  if (!plaintext) {\n    throw new Error('Refusing to encrypt empty string; caller should store null instead');\n  }\n  const key = provider.deriveKey(orgId);\n  const iv = randomBytes(12);\n  const cipher = createCipheriv('aes-256-gcm', key, iv);\n  const enc = Buffer.concat([cipher.update(plaintext, 'utf8'), cipher.final()]);\n  const tag = cipher.getAuthTag();\n  // PerOrgKmsKeyProvider tags blobs with the KMS key id used so the\n  // decrypt path can refuse to operate if the operator later swaps in a\n  // different per-org config (a misconfigured swap shouldn't silently\n  // accept a stale blob it can't verify against the right CMK).\n  const kid = provider.kidFor?.(orgId);\n  return {\n    alg: 'aes-256-gcm-v1',\n    iv: iv.toString('base64'),\n    // GCM tag MUST travel with the ciphertext or `decryptSecret` can't\n    // verify integrity  concatenate so the on-disk shape is one field.\n    ciphertext: Buffer.concat([enc, tag]).toString('base64'),\n    ...(kid !== undefined ? { kid } : {}),\n  };\n}\n\n/**\n * Decrypt an `EncryptedBlob` written by `encryptSecret`. Throws on * - unknown `alg` (forces an explicit migration when the format changes)\n * - wrong orgId (HKDF binding mismatch fails the auth tag)\n * - tampered ciphertext (GCM auth tag check fails)\n *\n * Callers handle the throw  masking the failure as `null` would hide\n * silent corruption / wrong-org reads.\n */\nexport function decryptSecret( blob: EncryptedBlob,\n  orgId: string,\n  provider: KeyProvider = getDefaultProvider(),\n): string {\n  if (blob.alg !== 'aes-256-gcm-v1') {\n    throw new Error(`Unsupported encryption alg: ${blob.alg}`);\n  }\n  // If both the provider AND the blob report a kid, they must match.\n  // Mismatch usually means an operator rotated/replaced an org's KMS\n  // config and is now reading a blob encrypted under the OLD key —\n  // failing loud here beats letting AES-GCM throw an opaque auth-tag error.\n  const providerKid = provider.kidFor?.(orgId);\n  if (providerKid !== undefined && blob.kid !== undefined && providerKid !== blob.kid) {\n    throw new Error(`KMS key id mismatch: blob was encrypted under ${blob.kid}, current provider uses ${providerKid} for org ${orgId}`);\n  }\n  const key = provider.deriveKey(orgId);\n  const iv = Buffer.from(blob.iv, 'base64');\n  const all = Buffer.from(blob.ciphertext, 'base64');\n  // Split off the 16-byte auth tag appended in encryptSecret. Any tampering\n  //  to either the ciphertext OR the tag  causes the next `final()` to\n  // throw with \"Unsupported state or unable to authenticate data\".\n  const tag = all.subarray(all.length - 16);\n  const enc = all.subarray(0, all.length - 16);\n  const decipher = createDecipheriv('aes-256-gcm', key, iv);\n  decipher.setAuthTag(tag);\n  const dec = Buffer.concat([decipher.update(enc), decipher.final()]);\n  return dec.toString('utf8');\n}\n\n/**\n * Type guard  handy for model layers that hold a column whose value may be\n * either a clear-text string (legacy / unencrypted) OR an encrypted blob\n * (post-migration). Mixed states arise mid-migration; the model decides\n * what to do (decrypt on read, encrypt on next write).\n */\nexport function isEncryptedBlob(value: unknown): value is EncryptedBlob {\n  return ( typeof value === 'object'\n    && value !== null\n    && (value as { alg?: unknown }).alg === 'aes-256-gcm-v1'\n    && typeof (value as { iv?: unknown }).iv === 'string'\n    && typeof (value as { ciphertext?: unknown }).ciphertext === 'string'\n  );\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"secret-encryption.js","sourceRoot":"","sources":["../../src/utils/secret-encryption.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\n/**\n *  Per-org envelope encryption for secret columns.\n *\n * Today's posture for org-scoped secrets (aiProviderKeys, webhook URLs,\n * registry credentials) is clear-text in Mongo / Postgres with app-layer\n * masking on output. This module is the encryption primitive that lets the\n * model layer swap clear-text strings for `EncryptedBlob` values at write\n * time and decrypt at read time.\n *\n * Cryptography * - AES-256-GCM (authenticated encryption).\n * - Per-org key derived via HKDF-SHA256(masterKey, salt=orgId, info='secrets-v1').\n * Each org gets a unique key without operator key-management ceremony.\n * - 12-byte IV generated per encryption with `crypto.randomBytes`.\n * - 16-byte authentication tag concatenated with ciphertext (standard GCM).\n *\n * Operator configuration * - `SECRET_ENCRYPTION_KEY` env: hex- or base64-encoded 32-byte master key.\n * Required when `encryptSecret`/`decryptSecret` are called. Missing key\n * throws  encryption is fail-closed; we never silently round-trip a\n * secret as plaintext.\n *\n * KMS migration path * - The two exported functions take a `provider` parameter. The default\n * `EnvKeyProvider` implements HKDF derivation. A future `AwsKmsProvider`\n * plugs in here: it can call KMS `Encrypt` / `Decrypt` to wrap a DEK\n * rather than holding a master key in env. The on-disk blob shape\n * (`{ alg, iv, ciphertext, kid? }`) is forward-compatible  `kid`\n * carries the KMS key id when the provider needs it.\n */\n\nimport { createCipheriv, createDecipheriv, hkdfSync, randomBytes } from 'crypto';\n\n/** On-disk shape of an encrypted secret. JSON-serializable. */\nexport interface EncryptedBlob {\n  /** Algorithm tag. Bump on format change so a future migration can detect old blobs. */\n  alg: 'aes-256-gcm-v1';\n  /** Base64-encoded 12-byte IV. */\n  iv: string;\n  /** Base64-encoded ciphertext + 16-byte authentication tag concatenated. */\n  ciphertext: string;\n  /** Optional key id  populated by KMS-backed providers, ignored by the env provider. */\n  kid?: string;\n}\n\n/** Pluggable key source. Env-backed by default; KMS-backed available. */\nexport interface KeyProvider {\n  /** Derive a 32-byte symmetric key bound to `orgId`. */\n  deriveKey(orgId: string): Buffer;\n  /** Optional async variant for providers that need to do I/O (e.g.\n   *  per-org KMS lookup the first time an org is seen). Default\n   *  implementation forwards to the sync `deriveKey`. */\n  deriveKeyAsync?(orgId: string): Promise<Buffer>;\n  /** Optional KMS-key-id this provider used for `orgId`. Embedded in the\n   *  `EncryptedBlob.kid` field on write so decrypt can verify the right\n   *  KMS CMK is being used (defense against an attacker who swaps a blob\n   *  between orgs). Default returns undefined (env provider). */\n  kidFor?(orgId: string): string | undefined;\n}\n\n/**\n * Default provider  derives a per-org key from `SECRET_ENCRYPTION_KEY` via\n * HKDF-SHA256. Suitable for self-hosted / dev where operators don't have KMS.\n *\n * Fails fast if the env is missing or the key is the wrong length so misconfig\n * surfaces at first use rather than silently fingerprinting all writes with\n * a default zero key.\n */\nexport class EnvKeyProvider implements KeyProvider {\n  private readonly masterKey: Buffer;\n\n  constructor(masterKeyOverride?: string) {\n    const raw = masterKeyOverride ?? process.env.SECRET_ENCRYPTION_KEY;\n    if (!raw) {\n      throw new Error('SECRET_ENCRYPTION_KEY env is required for secret encryption');\n    }\n    // Accept either hex (64 chars) or base64 (44 chars including padding) for\n    // operator convenience  both decode to a 32-byte key.\n    const decoded = raw.length === 64 && /^[0-9a-f]+$/i.test(raw)\n      ? Buffer.from(raw, 'hex')\n      : Buffer.from(raw, 'base64');\n    if (decoded.length !== 32) {\n      throw new Error(`SECRET_ENCRYPTION_KEY must decode to 32 bytes (got ${decoded.length})`);\n    }\n    this.masterKey = decoded;\n  }\n\n  deriveKey(orgId: string): Buffer {\n    // HKDF binds the master key to the org so two orgs encrypting the same\n    // plaintext produce different ciphertexts  keeps a stolen DB unable to\n    // tell which orgs share secrets via ciphertext comparison.\n    const derived = hkdfSync( 'sha256',\n      this.masterKey,\n      Buffer.from(orgId, 'utf8'),\n      'secrets-v1',\n      32,\n    );\n    // hkdfSync returns ArrayBuffer in older Node typings; normalize to Buffer.\n    return Buffer.from(derived);\n  }\n}\n\n/**\n *  AWS-KMS-backed KeyProvider.\n *\n * Trade-off picked: store ONE master key encrypted under a KMS CMK; on\n * first use, call `kms:Decrypt` to recover the master key bytes; HKDF-\n * derive per-org from it (same as EnvKeyProvider). The process then holds\n * the plaintext master key in memory until restart.\n *\n * PROS: one KMS call per process lifetime (cheap, low p99 impact),\n * the encrypted-master-key blob is safe to commit/log/checkin,\n * KMS audit log records when the master is recovered.\n * CONS: process memory still holds the master key  same posture as\n * EnvKeyProvider once warmed up. For stronger isolation an\n * operator can move to per-record envelope encryption (call\n * GenerateDataKey on every write); that's a follow-on.\n *\n * Operator setup * 1. Create a KMS CMK with key policy allowing the platform service's\n * IAM role kms:Decrypt.\n * 2. Generate a random 32-byte master * head -c 32 /dev/urandom | base64\n * 3. Wrap it with KMS * aws kms encrypt --key-id <KEY_ID> \\\n * --plaintext <base64-from-step-2> --output text \\\n * --query CiphertextBlob\n * 4. Set on the service * SECRET_ENCRYPTION_KMS_KEY_ID=<KEY_ID>\n * SECRET_ENCRYPTION_KMS_CIPHERTEXT=<base64-output-of-step-3>\n * 5. Pick this provider via `setKeyProvider(new KmsKeyProvider())`.\n *\n * Construct lazily  importing the AWS SDK has a non-trivial cold-start\n * cost so envs that stay on EnvKeyProvider never load it.\n */\n/**\n * KMS-decrypt a base64 ciphertext into a 32-byte key. Shared by both KMS key\n * providers (single-master + per-org), which previously copy-pasted this\n * dynamic-import + Decrypt + empty/length guards. `@aws-sdk/client-kms` is\n * dynamically imported so EnvKeyProvider-only envs never load the SDK.\n */\nasync function kmsDecrypt32(keyId: string, ciphertextB64: string, region?: string, endpoint?: string): Promise<Buffer> {\n  const { KMSClient, DecryptCommand } = await import('@aws-sdk/client-kms');\n  const client = new KMSClient({ region, ...(endpoint ? { endpoint } : {}) });\n  const resp = await client.send(new DecryptCommand({\n    KeyId: keyId,\n    CiphertextBlob: Buffer.from(ciphertextB64, 'base64'),\n  }));\n  if (!resp.Plaintext) throw new Error(`KMS Decrypt returned an empty Plaintext for key ${keyId}`);\n  const buf = Buffer.from(resp.Plaintext);\n  if (buf.length !== 32) throw new Error(`KMS Decrypt returned ${buf.length}-byte key for ${keyId}; expected 32`);\n  return buf;\n}\n\nexport class KmsKeyProvider implements KeyProvider {\n  private masterKeyCache: Buffer | null = null;\n  private readonly keyId: string;\n  private readonly ciphertextB64: string;\n  private readonly region?: string;\n  private readonly endpoint?: string;\n  private decryptInFlight: Promise<Buffer> | null = null;\n\n  constructor(opts?: { keyId?: string; ciphertextBase64?: string; region?: string; endpoint?: string }) {\n    const keyId = opts?.keyId ?? process.env.SECRET_ENCRYPTION_KMS_KEY_ID;\n    const ciphertext = opts?.ciphertextBase64 ?? process.env.SECRET_ENCRYPTION_KMS_CIPHERTEXT;\n    if (!keyId) throw new Error('SECRET_ENCRYPTION_KMS_KEY_ID env is required for KmsKeyProvider');\n    if (!ciphertext) throw new Error('SECRET_ENCRYPTION_KMS_CIPHERTEXT env is required for KmsKeyProvider');\n    this.keyId = keyId;\n    this.ciphertextB64 = ciphertext;\n    this.region = opts?.region ?? process.env.AWS_REGION ?? process.env.AWS_DEFAULT_REGION;\n    this.endpoint = opts?.endpoint ?? process.env.AWS_KMS_ENDPOINT;\n  }\n\n  deriveKey(orgId: string): Buffer {\n    if (!this.masterKeyCache) {\n      throw new Error( 'KmsKeyProvider is not warmed up. Call `await provider.warmup()` once at service startup before any encrypt/decrypt.',\n      );\n    }\n    const derived = hkdfSync('sha256', this.masterKeyCache, Buffer.from(orgId, 'utf8'), 'secrets-v1', 32);\n    return Buffer.from(derived);\n  }\n\n  /**\n   * Eagerly recover the master key from KMS so subsequent `deriveKey`\n   * calls are sync. Idempotent  concurrent callers share the same in-\n   * flight promise so we don't spawn multiple KMS Decrypt requests at\n   * boot. Throws on any KMS failure; the caller (typically the service's\n   * onBeforeStart hook) decides whether to fall back to a different\n   * provider or fail-startup.\n   */\n  async warmup(): Promise<void> {\n    if (this.masterKeyCache) return;\n    if (!this.decryptInFlight) {\n      this.decryptInFlight = this.fetchAndDecrypt();\n    }\n    try {\n      this.masterKeyCache = await this.decryptInFlight;\n    } catch (err) {\n      // A transient KMS failure must not permanently poison the provider: clear\n      // the rejected in-flight promise so a later warmup() retries instead of\n      // re-awaiting the same rejection forever (matches PerOrgKmsKeyProvider).\n      this.decryptInFlight = null;\n      throw err;\n    }\n  }\n\n  private fetchAndDecrypt(): Promise<Buffer> {\n    return kmsDecrypt32(this.keyId, this.ciphertextB64, this.region, this.endpoint);\n  }\n}\n\n// Lazy singleton  operator code in long-lived services pays the env-parse\n// cost once, and tests can mint their own provider with a literal key.\nlet defaultProvider: KeyProvider | null = null;\nfunction getDefaultProvider(): KeyProvider {\n  if (!defaultProvider) defaultProvider = new EnvKeyProvider();\n  return defaultProvider;\n}\n\n/** Read the active default provider. Exposed so service code (e.g. an\n *  admin endpoint that just rotated an org's KMS config) can call\n *  `provider.evict(orgId)` on the live provider rather than reconstructing\n *  one. Triggers lazy initialization on first access, same as the internal\n *  callers below. */\nexport function getDefaultKeyProvider(): KeyProvider {\n  return getDefaultProvider();\n}\n\n/** Reset the cached default provider  for tests that mutate `process.env`. */\nexport function resetDefaultKeyProvider(): void { defaultProvider = null; }\n\n/** Replace the default provider  services that opt into KMS call this\n * once at startup with a warmed-up `KmsKeyProvider`. */\nexport function setKeyProvider(provider: KeyProvider): void { defaultProvider = provider; }\n\n/** Per-org KMS config the operator supplies. The `keyId` identifies the\n *  KMS CMK to call Decrypt on; `ciphertextBase64` is the wrapped 32-byte\n *  master generated by `aws kms encrypt` against that key. */\nexport interface PerOrgKmsConfig {\n  keyId: string;\n  ciphertextBase64: string;\n}\n\n/**\n * Async resolver that maps an org id to its KMS config. Returns `null` when\n * the org has no per-org config — the provider then falls back to the\n * `fallback` provider supplied at construction (usually an EnvKeyProvider\n * or a default KmsKeyProvider).\n */\nexport type PerOrgKmsResolver = (orgId: string) => Promise<PerOrgKmsConfig | null>;\n\n/**\n * Per-org KMS-backed KeyProvider. The blast radius of a KMS key compromise\n * is one org instead of every org under a shared master.\n *\n * Each org has its own KMS CMK + its own wrapped master (stored in Mongo\n * via the operator's setup script). On first encrypt/decrypt for an org,\n * the provider:\n *   1. Calls the resolver to fetch the org's KMS config.\n *   2. Calls `kms:Decrypt` to recover the 32-byte master.\n *   3. Caches the recovered master in-memory for the process lifetime.\n *   4. HKDF-derives per-call from that master + the org id salt.\n *\n * Blobs encrypted by this provider carry `kid = <kms-key-id>` so the\n * decrypt path detects a stale config (operator rotated the key but\n * existing rows weren't re-encrypted) BEFORE AES-GCM throws an opaque\n * authentication-tag error.\n *\n * Orgs without per-org config fall through to the `fallback` provider —\n * mixed-mode deployments where some orgs have KMS isolation and others\n * stay on the shared master are explicitly supported.\n */\nexport class PerOrgKmsKeyProvider implements KeyProvider {\n  /** Cached per-org master keys, keyed by orgId. */\n  private readonly masters = new Map<string, { key: Buffer; kid: string }>();\n  /** Resolved per-org configs cached for the process lifetime. */\n  private readonly configs = new Map<string, PerOrgKmsConfig>();\n  /** In-flight resolver promises so concurrent first-touch callers share one KMS Decrypt.\n   *  Resolves to `null` for orgs with no per-org config — caller treats null as\n   *  \"fall through to the fallback provider\", same as a cold cache miss. */\n  private readonly inFlight = new Map<string, Promise<{ key: Buffer; kid: string } | null>>();\n  /** Orgs the resolver has PROVEN have no per-org config — the fallback provider\n   *  is the correct answer for these, and `deriveKey` may serve them\n   *  synchronously. Distinct from \"not yet resolved\", which must not guess. */\n  private readonly resolvedNoPerOrgConfig = new Set<string>();\n  /** Provider used for orgs that have no per-org config. */\n  private readonly fallback: KeyProvider;\n  private readonly resolver: PerOrgKmsResolver;\n  private readonly region?: string;\n  private readonly endpoint?: string;\n\n  constructor(opts: {\n    resolver: PerOrgKmsResolver;\n    fallback: KeyProvider;\n    region?: string;\n    endpoint?: string;\n  }) {\n    this.resolver = opts.resolver;\n    this.fallback = opts.fallback;\n    this.region = opts.region ?? process.env.AWS_REGION ?? process.env.AWS_DEFAULT_REGION;\n    this.endpoint = opts.endpoint ?? process.env.AWS_KMS_ENDPOINT;\n  }\n\n  /**\n   * Sync derive. Only correct for an org whose config has already been\n   * RESOLVED — either it has a per-org master (use it) or it provably has no\n   * per-org config (the fallback is then the right answer).\n   *\n   * For an UNRESOLVED org this THROWS rather than guessing. It used to fall\n   * through to the fallback, which silently encrypted that org's secrets under\n   * the SHARED master and — because `kidFor` also returned undefined, so the\n   * both-kids-present mismatch guard could never fire — left them permanently\n   * undecryptable once the org warmed: `decipher.final()` then threw an opaque\n   * auth-tag error with no diagnostic. Failing loud here matches\n   * `KmsKeyProvider.deriveKey`, which has always refused to work cold.\n   *\n   * `encryptSecret`/`decryptSecret` are async and await `deriveKeyAsync`, so\n   * they resolve the org first and never hit this path; it is the backstop for\n   * a caller that reaches for the sync API directly.\n   */\n  deriveKey(orgId: string): Buffer {\n    const cached = this.masters.get(orgId);\n    if (!cached) {\n      if (this.resolvedNoPerOrgConfig.has(orgId)) return this.fallback.deriveKey(orgId);\n      throw new Error( `PerOrgKmsKeyProvider has not resolved org ${orgId}. `\n        + 'Call `await provider.ensureWarmed(orgId)` (or use the async encryptSecret/decryptSecret) '\n        + 'before deriving a key — guessing the shared master would write secrets that cannot be decrypted later.',\n      );\n    }\n    const derived = hkdfSync('sha256', cached.key, Buffer.from(orgId, 'utf8'), 'secrets-v1', 32);\n    return Buffer.from(derived);\n  }\n\n  async deriveKeyAsync(orgId: string): Promise<Buffer> {\n    await this.ensureWarmed(orgId);\n    return this.deriveKey(orgId);\n  }\n\n  kidFor(orgId: string): string | undefined {\n    const cached = this.masters.get(orgId);\n    if (cached) return cached.kid;\n    // Only speak for an org whose config is resolved; an unresolved org has no\n    // meaningful kid, and claiming one would defeat the mismatch guard.\n    if (this.resolvedNoPerOrgConfig.has(orgId)) return this.fallback.kidFor?.(orgId);\n    return undefined;\n  }\n\n  /**\n   * Resolve the org's KMS config, call Decrypt, cache the master. Subsequent\n   * calls for the same org are no-ops. Concurrent callers share the in-flight\n   * Decrypt promise.\n   *\n   * Returns silently when the org has no per-org config — the fallback\n   * provider handles those orgs.\n   */\n  async ensureWarmed(orgId: string): Promise<void> {\n    if (this.masters.has(orgId)) return;\n    // Install the in-flight promise SYNCHRONOUSLY before yielding so concurrent\n    // callers find it on the second-and-later passes. Awaiting the resolver\n    // before populating the map is the bug that lets a Promise.all of 3\n    // callers fire 3 KMS Decrypts.\n    let promise = this.inFlight.get(orgId);\n    if (!promise) {\n      promise = this.resolveAndDecrypt(orgId);\n      this.inFlight.set(orgId, promise);\n      void promise.finally(() => { if (this.inFlight.get(orgId) === promise) this.inFlight.delete(orgId); });\n    }\n    const result = await promise;\n    if (result) this.masters.set(orgId, result);\n    // Remember the NEGATIVE outcome too, so the sync `deriveKey` can tell\n    // \"no per-org config, fallback is correct\" from \"not resolved yet\".\n    else this.resolvedNoPerOrgConfig.add(orgId);\n  }\n\n  private async resolveAndDecrypt(orgId: string): Promise<{ key: Buffer; kid: string } | null> {\n    let cfg = this.configs.get(orgId);\n    if (!cfg) {\n      const resolved = await this.resolver(orgId);\n      if (!resolved) return null; // no per-org config → caller uses fallback\n      cfg = resolved;\n      this.configs.set(orgId, cfg);\n    }\n    const key = await this.fetchAndDecrypt(cfg);\n    return { key, kid: cfg.keyId };\n  }\n\n  private fetchAndDecrypt(cfg: PerOrgKmsConfig): Promise<Buffer> {\n    return kmsDecrypt32(cfg.keyId, cfg.ciphertextBase64, this.region, this.endpoint);\n  }\n\n  /** Evict a cached per-org master. Use after a key rotation so the next\n   *  touch re-fetches the new wrapped master from the resolver. */\n  evict(orgId: string): void {\n    this.masters.delete(orgId);\n    this.configs.delete(orgId);\n    // Also forget a NEGATIVE resolution, or an org that gains a per-org config\n    // after being resolved as \"no config\" would keep using the shared master.\n    this.resolvedNoPerOrgConfig.delete(orgId);\n  }\n}\n\n/**\n * Derive the key for `orgId`, giving the provider a chance to do I/O first.\n *\n * This is why `encryptSecret`/`decryptSecret` are async: `PerOrgKmsKeyProvider`\n * needs one KMS Decrypt the first time it sees an org, and deriving\n * synchronously before that resolves would silently fall back to the shared\n * master and produce secrets that cannot be decrypted afterwards.\n */\nasync function deriveKeyFor(provider: KeyProvider, orgId: string): Promise<Buffer> {\n  return provider.deriveKeyAsync ? provider.deriveKeyAsync(orgId) : provider.deriveKey(orgId);\n}\n\n/**\n * Encrypt a plaintext string for storage. Returns an `EncryptedBlob` that\n * can be JSON-serialized into the underlying column / Mongo document.\n *\n * Empty strings round-trip as `null` so the calling model layer can treat\n * \"no secret set\" identically to \"field absent\".\n */\nexport async function encryptSecret( plaintext: string,\n  orgId: string,\n  provider: KeyProvider = getDefaultProvider(),\n): Promise<EncryptedBlob> {\n  if (!plaintext) {\n    throw new Error('Refusing to encrypt empty string; caller should store null instead');\n  }\n  // Resolve (and warm) the org BEFORE reading `kidFor` below, so a per-org KMS\n  // blob is always stamped with the key it was actually encrypted under.\n  const key = await deriveKeyFor(provider, orgId);\n  const iv = randomBytes(12);\n  const cipher = createCipheriv('aes-256-gcm', key, iv);\n  const enc = Buffer.concat([cipher.update(plaintext, 'utf8'), cipher.final()]);\n  const tag = cipher.getAuthTag();\n  // PerOrgKmsKeyProvider tags blobs with the KMS key id used so the\n  // decrypt path can refuse to operate if the operator later swaps in a\n  // different per-org config (a misconfigured swap shouldn't silently\n  // accept a stale blob it can't verify against the right CMK).\n  const kid = provider.kidFor?.(orgId);\n  return {\n    alg: 'aes-256-gcm-v1',\n    iv: iv.toString('base64'),\n    // GCM tag MUST travel with the ciphertext or `decryptSecret` can't\n    // verify integrity  concatenate so the on-disk shape is one field.\n    ciphertext: Buffer.concat([enc, tag]).toString('base64'),\n    ...(kid !== undefined ? { kid } : {}),\n  };\n}\n\n/**\n * Decrypt an `EncryptedBlob` written by `encryptSecret`. Throws on * - unknown `alg` (forces an explicit migration when the format changes)\n * - wrong orgId (HKDF binding mismatch fails the auth tag)\n * - tampered ciphertext (GCM auth tag check fails)\n *\n * Callers handle the throw  masking the failure as `null` would hide\n * silent corruption / wrong-org reads.\n */\nexport async function decryptSecret( blob: EncryptedBlob,\n  orgId: string,\n  provider: KeyProvider = getDefaultProvider(),\n): Promise<string> {\n  if (blob.alg !== 'aes-256-gcm-v1') {\n    throw new Error(`Unsupported encryption alg: ${blob.alg}`);\n  }\n  // Warm first: `kidFor` and `deriveKey` below must both speak for the org's\n  // real config, or the mismatch guard silently no-ops.\n  const key = await deriveKeyFor(provider, orgId);\n  // If both the provider AND the blob report a kid, they must match.\n  // Mismatch usually means an operator rotated/replaced an org's KMS\n  // config and is now reading a blob encrypted under the OLD key —\n  // failing loud here beats letting AES-GCM throw an opaque auth-tag error.\n  const providerKid = provider.kidFor?.(orgId);\n  if (providerKid !== undefined && blob.kid !== undefined && providerKid !== blob.kid) {\n    throw new Error(`KMS key id mismatch: blob was encrypted under ${blob.kid}, current provider uses ${providerKid} for org ${orgId}`);\n  }\n  const iv = Buffer.from(blob.iv, 'base64');\n  const all = Buffer.from(blob.ciphertext, 'base64');\n  // Split off the 16-byte auth tag appended in encryptSecret. Any tampering\n  //  to either the ciphertext OR the tag  causes the next `final()` to\n  // throw with \"Unsupported state or unable to authenticate data\".\n  const tag = all.subarray(all.length - 16);\n  const enc = all.subarray(0, all.length - 16);\n  const decipher = createDecipheriv('aes-256-gcm', key, iv);\n  decipher.setAuthTag(tag);\n  const dec = Buffer.concat([decipher.update(enc), decipher.final()]);\n  return dec.toString('utf8');\n}\n\n/**\n * Type guard  handy for model layers that hold a column whose value may be\n * either a clear-text string (legacy / unencrypted) OR an encrypted blob\n * (post-migration). Mixed states arise mid-migration; the model decides\n * what to do (decrypt on read, encrypt on next write).\n */\nexport function isEncryptedBlob(value: unknown): value is EncryptedBlob {\n  return ( typeof value === 'object'\n    && value !== null\n    && (value as { alg?: unknown }).alg === 'aes-256-gcm-v1'\n    && typeof (value as { iv?: unknown }).iv === 'string'\n    && typeof (value as { ciphertext?: unknown }).ciphertext === 'string'\n  );\n}\n"]}