@spfn/auth 0.3.0-beta.24 → 0.3.0-beta.25

package/dist/nextjs/api.js

@@ -209,6 +209,18 @@ var COOKIE_NAMES = {
   get OAUTH_PENDING() {
     return `spfn_oauth_pending${getCookieSuffix()}`;
   },
+  /**
+   * Pending second-factor session (privateKey, keyId, challengeHash) (#95)
+   *
+   * Its own name and its own audience, separate from OAUTH_PENDING. The two
+   * coexist: a person who starts a social login in one tab while a password
+   * step-up is outstanding in another has both flows live, and one name would
+   * mean the second overwrote the first — sealing a session with a private key
+   * that does not match the key being activated.
+   */
+  get MFA_PENDING() {
+    return `spfn_mfa_pending${getCookieSuffix()}`;
+  },
   /** OAuth CSRF nonce — double-submit against the (encrypted) state.nonce at callback */
   get OAUTH_CSRF() {
     return `spfn_oauth_csrf${getCookieSuffix()}`;
@@ -457,20 +469,23 @@ function uaFamily(userAgent) {
 
 // src/nextjs/interceptors/error-envelope.ts
 function refusalEnvelope(error, setCookies = []) {
-  const body = error.toJSON();
   return {
     status: error.statusCode,
-    body: {
-      ...body,
-      error: {
-        code: body.__type,
-        message: body.message,
-        requestId: mintRequestId()
-      }
-    },
+    body: refusalBody(error),
     setCookies
   };
 }
+function refusalBody(error) {
+  const body = error.toJSON();
+  return {
+    ...body,
+    error: {
+      code: body.__type,
+      message: body.message,
+      requestId: mintRequestId()
+    }
+  };
+}
 function mintRequestId() {
   const bytes = crypto.getRandomValues(new Uint8Array(16));
   return Array.from(bytes, (byte) => byte.toString(16).padStart(2, "0")).join("");
@@ -620,6 +635,149 @@ var loginRegisterInterceptor = {
   }
 };
 
+// src/nextjs/interceptors/mfa-verify.ts
+import { SessionPendingExpiredError, SessionPendingMismatchError } from "@spfn/auth/errors";
+
+// src/server/lib/link-credentials.ts
+import crypto3 from "crypto";
+import { env as env4 } from "@spfn/auth/config";
+function hashCredential(secret) {
+  return crypto3.createHash("sha256").update(secret).digest("base64url");
+}
+
+// src/nextjs/session-helpers.ts
+import * as jose2 from "jose";
+import { cookies } from "next/headers.js";
+import { env as env5 } from "@spfn/auth/config";
+import { logger } from "@spfn/core/logger";
+async function getPendingSessionKey(purpose) {
+  const secret = env5.SPFN_AUTH_SESSION_SECRET;
+  const encoder = new TextEncoder();
+  const data = encoder.encode(purpose === "oauth" ? `oauth-pending:${secret}` : `mfa-pending:${secret}`);
+  const hashBuffer = await crypto.subtle.digest("SHA-256", data);
+  return new Uint8Array(hashBuffer);
+}
+async function sealPendingSession(data, ttl = 600) {
+  return await sealFor("oauth", data, ttl);
+}
+async function sealPendingMfaSession(data, ttl = 600) {
+  return await sealFor("mfa", data, ttl);
+}
+async function sealFor(purpose, data, ttl) {
+  return await new jose2.EncryptJWT({ data }).setProtectedHeader({ alg: "dir", enc: "A256GCM" }).setIssuedAt().setExpirationTime(`${ttl}s`).setIssuer("spfn-auth").setAudience(purpose === "oauth" ? "spfn-oauth" : "spfn-mfa").encrypt(await getPendingSessionKey(purpose));
+}
+async function unsealPendingSession(jwt2) {
+  const { payload } = await jose2.jwtDecrypt(jwt2, await getPendingSessionKey("oauth"), {
+    issuer: "spfn-auth",
+    audience: "spfn-oauth"
+  });
+  return payload.data;
+}
+async function unsealPendingMfaSession(jwt2) {
+  const { payload } = await jose2.jwtDecrypt(jwt2, await getPendingSessionKey("mfa"), {
+    issuer: "spfn-auth",
+    audience: "spfn-mfa"
+  });
+  return payload.data;
+}
+
+// src/nextjs/interceptors/mfa-verify.ts
+var MFA_PATH_PATTERN = /^\/_auth\/(login|password\/reset\/complete|oauth\/[\w-]+\/native|oauth\/finalize|mfa\/verify)$/;
+var PENDING_TTL_SECONDS = 600;
+function challengeSecretOf(body) {
+  const challenge = body?.challenge;
+  if (typeof challenge === "string") {
+    return challenge;
+  }
+  const secret = challenge?.secret;
+  return typeof secret === "string" ? secret : void 0;
+}
+async function pendingKeyFor(ctx) {
+  if (ctx.metadata.privateKey && ctx.metadata.keyId) {
+    return {
+      privateKey: ctx.metadata.privateKey,
+      keyId: ctx.metadata.keyId,
+      algorithm: ctx.metadata.algorithm
+    };
+  }
+  const oauthPending = ctx.cookies.get(COOKIE_NAMES.OAUTH_PENDING);
+  return oauthPending ? await unsealPendingSession(oauthPending) : null;
+}
+async function bakePendingCookie(ctx) {
+  const secret = challengeSecretOf(ctx.response.body);
+  const pending = secret ? await pendingKeyFor(ctx) : null;
+  if (!secret || !pending) {
+    return;
+  }
+  ctx.setCookies.push({
+    name: COOKIE_NAMES.MFA_PENDING,
+    value: await sealPendingMfaSession({ ...pending, challengeHash: hashCredential(secret) }, PENDING_TTL_SECONDS),
+    options: {
+      httpOnly: true,
+      secure: cookieSecure,
+      sameSite: "lax",
+      maxAge: PENDING_TTL_SECONDS,
+      path: "/"
+    }
+  });
+  authLogger.interceptor.login.debug("Second-factor pending cookie set", { keyId: pending.keyId });
+}
+function refuse(ctx, error) {
+  authLogger.interceptor.login.warn("Second-factor session not sealed", { reason: error.name });
+  ctx.response.ok = false;
+  ctx.response.status = error.statusCode;
+  ctx.response.statusText = "Unauthorized";
+  ctx.response.body = refusalBody(error);
+}
+async function sealVerifiedSession(ctx) {
+  const cookie = ctx.cookies.get(COOKIE_NAMES.MFA_PENDING);
+  if (!cookie) {
+    refuse(ctx, new SessionPendingExpiredError());
+    return;
+  }
+  const pending = await unsealPendingMfaSession(cookie);
+  const { userId, keyId, challengeHash } = ctx.response.body || {};
+  if (pending.challengeHash !== challengeHash || pending.keyId !== keyId) {
+    refuse(ctx, new SessionPendingMismatchError());
+    return;
+  }
+  const ttl = getSessionTtl();
+  const sealed = await sealSession({
+    userId,
+    privateKey: pending.privateKey,
+    keyId: pending.keyId,
+    algorithm: pending.algorithm,
+    ...bindingSessionFields(ctx.response.body, ctx.request.headers["user-agent"])
+  }, ttl);
+  pushSessionCookies(ctx, sealed, pending.keyId, ttl);
+  await pushCsrfCookie(ctx.setCookies, pending.keyId, ttl);
+}
+function pushSessionCookies(ctx, sealed, keyId, ttl) {
+  const options = { httpOnly: true, secure: cookieSecure, sameSite: "lax", path: "/" };
+  ctx.setCookies.push({ name: COOKIE_NAMES.SESSION, value: sealed, options: { ...options, maxAge: ttl } });
+  ctx.setCookies.push({ name: COOKIE_NAMES.SESSION_KEY_ID, value: keyId, options: { ...options, maxAge: ttl } });
+  ctx.setCookies.push({ name: COOKIE_NAMES.MFA_PENDING, value: "", options: { ...options, maxAge: 0 } });
+}
+var mfaVerifyInterceptor = {
+  pathPattern: MFA_PATH_PATTERN,
+  method: "POST",
+  response: async (ctx, next) => {
+    try {
+      if (ctx.response.status === 202) {
+        await bakePendingCookie(ctx);
+      } else if (ctx.response.status === 200 && ctx.path === "/_auth/mfa/verify") {
+        await sealVerifiedSession(ctx);
+      }
+    } catch (error) {
+      authLogger.interceptor.login.error("Second-factor session handling failed", error);
+      if (ctx.path === "/_auth/mfa/verify") {
+        refuse(ctx, new SessionPendingExpiredError());
+      }
+    }
+    await next();
+  }
+};
+
 // src/nextjs/interceptors/general-auth.ts
 import { SessionContextChangedError, SessionRenewalRequiredError } from "@spfn/auth/errors";
 
@@ -635,8 +793,16 @@ function requiresAuth(path) {
     // Send verification code
     /^\/_auth\/codes\/verify$/,
     // Verify code
-    /^\/_auth\/exists$/
+    /^\/_auth\/exists$/,
     // Check account exists
+    // The two halves of a second-factor step-up (#95). Public for the same
+    // reason `login` is — the key they activate is inactive until they
+    // succeed, so there is nothing to sign them with — and public *here* for
+    // one more: a browser holding a stale session cookie would otherwise have
+    // this rule refresh or clear that session on the way out, over the fresh
+    // one `mfaVerifyInterceptor` just sealed.
+    /^\/_auth\/mfa\/verify$/,
+    /^\/_auth\/mfa\/verify\/options$/
   ];
   return !publicPaths.some((pattern) => pattern.test(path));
 }
@@ -966,10 +1132,10 @@ var keyRotationInterceptor = {
 };
 
 // src/server/lib/oauth/state.ts
-import * as jose2 from "jose";
-import { env as env4 } from "@spfn/auth/config";
+import * as jose3 from "jose";
+import { env as env6 } from "@spfn/auth/config";
 async function getStateKey() {
-  const secret = env4.SPFN_AUTH_SESSION_SECRET;
+  const secret = env6.SPFN_AUTH_SESSION_SECRET;
   const encoder = new TextEncoder();
   const data = encoder.encode(`oauth-state:${secret}`);
   const hashBuffer = await crypto.subtle.digest("SHA-256", data);
@@ -995,7 +1161,7 @@ async function createOAuthState(params) {
     algorithm: params.algorithm,
     metadata: params.metadata
   };
-  const jwe = await new jose2.EncryptJWT({ state }).setProtectedHeader({ alg: "dir", enc: "A256GCM" }).setIssuedAt().setExpirationTime("10m").encrypt(key);
+  const jwe = await new jose3.EncryptJWT({ state }).setProtectedHeader({ alg: "dir", enc: "A256GCM" }).setIssuedAt().setExpirationTime("10m").encrypt(key);
   return encodeURIComponent(jwe);
 }
 
@@ -1014,31 +1180,6 @@ function isSafeReturnPath(returnPath) {
   return !/^\/[^/?#]*:/.test(returnPath);
 }
 
-// src/nextjs/session-helpers.ts
-import * as jose3 from "jose";
-import { cookies } from "next/headers.js";
-import { env as env5 } from "@spfn/auth/config";
-import { logger } from "@spfn/core/logger";
-async function getPendingSessionKey() {
-  const secret = env5.SPFN_AUTH_SESSION_SECRET;
-  const encoder = new TextEncoder();
-  const data = encoder.encode(`oauth-pending:${secret}`);
-  const hashBuffer = await crypto.subtle.digest("SHA-256", data);
-  return new Uint8Array(hashBuffer);
-}
-async function sealPendingSession(data, ttl = 600) {
-  const key = await getPendingSessionKey();
-  return await new jose3.EncryptJWT({ data }).setProtectedHeader({ alg: "dir", enc: "A256GCM" }).setIssuedAt().setExpirationTime(`${ttl}s`).setIssuer("spfn-auth").setAudience("spfn-oauth").encrypt(key);
-}
-async function unsealPendingSession(jwt2) {
-  const key = await getPendingSessionKey();
-  const { payload } = await jose3.jwtDecrypt(jwt2, key, {
-    issuer: "spfn-auth",
-    audience: "spfn-oauth"
-  });
-  return payload.data;
-}
-
 // src/nextjs/interceptors/oauth.ts
 var UNSAFE_RETURN_URL_MESSAGE = "returnUrl must be a relative path within the app";
 function refuseUnsafeReturnUrl() {
@@ -1158,7 +1299,7 @@ var oauthFinalizeInterceptor = {
   pathPattern: /^\/_auth\/oauth\/finalize$/,
   method: "POST",
   response: async (ctx, next) => {
-    if (!ctx.response.ok) {
+    if (!ctx.response.ok || ctx.response.status === 202) {
       await next();
       return;
     }
@@ -1351,6 +1492,7 @@ var authInterceptors = [
   signupLinkInterceptor,
   passwordResetInterceptor,
   loginRegisterInterceptor,
+  mfaVerifyInterceptor,
   keyRotationInterceptor,
   oauthUrlInterceptor,
   oauthFinalizeInterceptor,