raindancers-cloudfront 0.0.38 → 0.0.40

package/lib/cloudfront/cloudfront-functions/auth-check.js

@@ -142,11 +142,53 @@ function getOriginalPath(request) {
     return request.uri + '?' + qs;
 }
 
-function redirectToAuth(originalPath, host) {
+// A live PKCE sign-in is represented by the pair of cookies (oauth_state +
+// code_verifier) minted on the redirect that started it. The browser drops both
+// at Max-Age=600, so their PRESENCE (with a well-formed, decodable state) is the
+// practical "unexpired flow" signal available to a CloudFront Function — it has
+// no way to read a cookie's own expiry. Reusing an existing pair instead of
+// minting a new one is what stops a redirect provoked mid-sign-in (e.g. a
+// background notification poll from a sibling panel on the shared cookie domain)
+// from overwriting the state the in-flight sign-in carries, which the callback
+// compares strictly and rejects with "400 Invalid state parameter".
+function inflightAuthFlow(cookies) {
+    if (!cookies) { return null; }
+    var stateCookie = cookies.oauth_state;
+    var verifierCookie = cookies.code_verifier;
+    if (!stateCookie || !stateCookie.value || !verifierCookie || !verifierCookie.value) {
+        return null;
+    }
+    try {
+        JSON.parse(base64urlDecode(stateCookie.value));
+    } catch (e) {
+        return null;
+    }
+    return { state: stateCookie.value, codeVerifier: verifierCookie.value };
+}
+
+function redirectToAuth(originalPath, host, cookies) {
+    var domainAttr = COOKIE_DOMAIN ? '; Domain=' + COOKIE_DOMAIN : '';
+
+    // If a sign-in is already in flight, reissue the redirect REUSING its state
+    // and verifier, and set NO cookies — do not clobber the live flow. The
+    // challenge is re-derived from the stored verifier so the authorize URL stays
+    // consistent with the PKCE exchange the callback performs for whichever flow
+    // completes.
+    var inflight = inflightAuthFlow(cookies);
+    if (inflight) {
+        var reusedChallenge = generateCodeChallenge(inflight.codeVerifier);
+        return {
+            statusCode: 302,
+            headers: {
+                location: { value: buildAzureAuthUrl(inflight.state, reusedChallenge, host) },
+                'cache-control': { value: 'no-store' }
+            }
+        };
+    }
+
     var state = generateState(originalPath, host);
     var codeVerifier = generateCodeVerifier();
     var codeChallenge = generateCodeChallenge(codeVerifier);
-    var domainAttr = COOKIE_DOMAIN ? '; Domain=' + COOKIE_DOMAIN : '';
     return {
         statusCode: 302,
         headers: {
@@ -203,13 +245,13 @@ async function handler(event) {
     // Check for session cookie (supports both __Secure- with domain and __Host- without)
     var sessionCookie = cookies['__Secure-auth_session'] || cookies['__Host-auth_session'];
     if (!sessionCookie) {
-        return redirectToAuth(getOriginalPath(request), host);
+        return redirectToAuth(getOriginalPath(request), host, request.cookies);
     }
     
     var token = sessionCookie.value;
     
     if (!token || token.length === 0) {
-        return redirectToAuth(getOriginalPath(request), host);
+        return redirectToAuth(getOriginalPath(request), host, request.cookies);
     }
     
     try {
@@ -217,12 +259,12 @@ async function handler(event) {
         var parts = token.split('.');
         
         if (parts.length !== 3) {
-            return redirectToAuth(originalPath, host);
+            return redirectToAuth(originalPath, host, request.cookies);
         }
         
         var isValid = await validateHmacSignature(token);
         if (!isValid) {
-            return redirectToAuth(originalPath, host);
+            return redirectToAuth(originalPath, host, request.cookies);
         }
         
         var payload = JSON.parse(base64urlDecode(parts[1]));
@@ -232,7 +274,7 @@ async function handler(event) {
             if (ENABLE_REFRESH) {
                 return redirectToRefresh(originalPath, host);
             }
-            return redirectToAuth(originalPath, host);
+            return redirectToAuth(originalPath, host, request.cookies);
         }
         
         // Check if session is revoked (denylist approach)
@@ -242,7 +284,7 @@ async function handler(event) {
                 var isRevoked = await kvsHandle.get('revoked:' + jti);
                 if (isRevoked) {
                     console.log('Session revoked: ' + jti);
-                    return redirectToAuth(originalPath, host);
+                    return redirectToAuth(originalPath, host, request.cookies);
                 }
             } catch (e) {
                 console.log('KVS error checking revocation: ' + e);
@@ -265,6 +307,6 @@ async function handler(event) {
         
         return request;
     } catch (e) {
-        return redirectToAuth(getOriginalPath(request), host);
+        return redirectToAuth(getOriginalPath(request), host, request.cookies);
     }
 }

package/lib/cloudfront/cloudfront-functions/function-composer.d.ts

@@ -19,6 +19,24 @@ export interface ComposerConfig {
      */
     readonly loginRedirectPath?: string;
 }
+/**
+ * Minify CloudFront Function source with terser.
+ *
+ * CloudFront Functions have a hard 10KB code-size limit. Both the composed
+ * (multi-module) path and the standalone auth-check path must minify, using
+ * the SAME options, so a function that fits in one path fits in the other.
+ *
+ * `minify_sync` throws on a parse error and, in its documented failure mode,
+ * can return `{ error }` with no `code`. An earlier `minified.code || assembled`
+ * fallback caught that second case and silently shipped the UN-minified source,
+ * which is how an 11KB function reached CloudFront and 413'd at deploy. This
+ * helper never falls back: a thrown error propagates, and a missing `code` is
+ * turned into a thrown error too — a minify failure is always a build error.
+ *
+ * The `reserved` names are the CloudFront-required top-level identifiers that
+ * must survive mangling.
+ */
+export declare function minifyFunctionCode(source: string): string;
 /**
  * Generates a combined CloudFront Function from modular check functions
  * based on requested extensions

package/lib/cloudfront/cloudfront-functions/function-composer.js

@@ -34,10 +34,51 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.FunctionComposer = void 0;
+exports.minifyFunctionCode = minifyFunctionCode;
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
 const terser_1 = require("terser");
 const securedCloudFront_1 = require("../patterns/securedCloudFront");
+/**
+ * Minify CloudFront Function source with terser.
+ *
+ * CloudFront Functions have a hard 10KB code-size limit. Both the composed
+ * (multi-module) path and the standalone auth-check path must minify, using
+ * the SAME options, so a function that fits in one path fits in the other.
+ *
+ * `minify_sync` throws on a parse error and, in its documented failure mode,
+ * can return `{ error }` with no `code`. An earlier `minified.code || assembled`
+ * fallback caught that second case and silently shipped the UN-minified source,
+ * which is how an 11KB function reached CloudFront and 413'd at deploy. This
+ * helper never falls back: a thrown error propagates, and a missing `code` is
+ * turned into a thrown error too — a minify failure is always a build error.
+ *
+ * The `reserved` names are the CloudFront-required top-level identifiers that
+ * must survive mangling.
+ */
+function minifyFunctionCode(source) {
+    const result = (0, terser_1.minify_sync)(source, {
+        compress: {
+            dead_code: true,
+            drop_console: false,
+            passes: 2,
+        },
+        mangle: {
+            reserved: ['handler', 'event', 'kvsHandle'],
+        },
+        format: {
+            comments: false,
+        },
+    });
+    // `minify_sync` returns `{ error }` (not typed by @types/terser) instead of
+    // throwing; `code` is undefined on failure. Treat a missing `code` as the
+    // failure signal and surface the runtime error if terser attached one.
+    if (result.code === undefined) {
+        const err = result.error;
+        throw new Error(`CloudFront Function minification failed: ${err ?? 'terser produced no output'}`);
+    }
+    return result.code;
+}
 /**
  * Generates a combined CloudFront Function from modular check functions
  * based on requested extensions
@@ -122,21 +163,9 @@ class FunctionComposer {
         const kvsDecl = 'const kvsHandle = cf.kvs();\n';
         assembled = assembled.replace(/const kvsHandle = cf\.kvs\(\);\s*/g, '');
         // Minify with terser to stay well under the 10KB CloudFront Function limit.
-        const minified = (0, terser_1.minify_sync)(assembled, {
-            compress: {
-                dead_code: true,
-                drop_console: false,
-                passes: 2,
-            },
-            mangle: {
-                reserved: ['handler', 'event', 'kvsHandle'],
-            },
-            format: {
-                comments: false,
-            },
-        });
+        const minified = minifyFunctionCode(assembled);
         // Prepend the CloudFront-specific preamble back
-        const code = cfImport + cryptoRequire + kvsDecl + (minified.code || assembled);
+        const code = cfImport + cryptoRequire + kvsDecl + minified;
         const sizeKB = Buffer.byteLength(code, 'utf-8') / 1024;
         if (sizeKB > 10) {
             throw new Error(`CloudFront Function exceeds 10KB limit: ${sizeKB.toFixed(2)}KB (extensions: ${extensions.join(', ')})`);
@@ -186,4 +215,4 @@ class FunctionComposer {
     }
 }
 exports.FunctionComposer = FunctionComposer;
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"function-composer.js","sourceRoot":"","sources":["../../../src/cloudfront/cloudfront-functions/function-composer.ts"],"names":[],"mappings":"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","sourcesContent":["import * as fs from 'fs';\nimport * as path from 'path';\nimport { minify_sync } from 'terser';\nimport { Extension, ExtensionConfig, RoleMatchMode } from '../patterns/securedCloudFront';\n\nexport interface ComposerConfig {\n  readonly tenantId?: string;\n  readonly cognitoDomain?: string;\n  readonly clientId?: string;\n  readonly redirectUri?: string;\n  readonly cookieDomain?: string;\n  readonly requireMfa?: boolean;\n  /** Enable header stripping and injection from JWT claims. @default false */\n  readonly enableHeaderInjection?: boolean;\n  /** Map of header name → JWT claim key. e.g. { 'x-customer-id': 'customer_id' } */\n  readonly headerInjectionClaims?: Record<string, string>;\n  /** Enable refresh redirect for expired-but-valid tokens. @default false */\n  readonly enableRefresh?: boolean;\n  /**\n   * Custom-UI mode: first-party path to redirect unauthenticated users to\n   * (e.g. '/login'). When set, the shared auth-check module is used with a\n   * relative redirect instead of an external IdP authorize URL.\n   */\n  readonly loginRedirectPath?: string;\n}\n\n/**\n * Generates a combined CloudFront Function from modular check functions\n * based on requested extensions\n */\nexport class FunctionComposer {\n  private readonly modulesDir: string;\n\n  constructor() {\n    this.modulesDir = path.join(__dirname, 'modules');\n  }\n\n  /**\n   * Generate combined function code based on requested extensions\n   */\n  public compose(extensions: Extension[], config?: ExtensionConfig, composerConfig?: ComposerConfig): string {\n    const parts: string[] = [];\n\n    // Always include shared utilities\n    parts.push(this.loadModule('shared-utils.js'));\n\n    // Include required check modules\n    const checks: string[] = [];\n\n    if (extensions.includes(Extension.REWRITE_TO_INDEX_HTML)) {\n      parts.push(this.loadModule('url-rewrite.js'));\n      checks.push('rewrite');\n    }\n\n    if (extensions.includes(Extension.REQUIRE_TLS_13)) {\n      parts.push(this.loadModule('tls-check.js'));\n      checks.push('tls');\n    }\n\n    if (extensions.includes(Extension.REQUIRE_AUTH)) {\n      // Custom-UI mode uses the shared auth-check module (header injection +\n      // refresh capable) with a first-party /login redirect, even though the\n      // identity provider is Cognito.\n      const isCustomUi = composerConfig?.loginRedirectPath !== undefined && composerConfig.loginRedirectPath !== '';\n      const isCognito = composerConfig?.cognitoDomain !== undefined && !isCustomUi;\n      let authModule = this.loadModule(isCognito ? 'cognito-auth-check.js' : 'auth-check.js');\n      if (composerConfig) {\n        if (composerConfig.cognitoDomain) {\n          authModule = authModule.replace(/COGNITO_DOMAIN_PLACEHOLDER/g, composerConfig.cognitoDomain);\n        }\n        if (composerConfig.tenantId) {\n          authModule = authModule.replace(/TENANT_ID_PLACEHOLDER/g, composerConfig.tenantId);\n        }\n        if (composerConfig.clientId) {\n          authModule = authModule.replace(/CLIENT_ID_PLACEHOLDER/g, composerConfig.clientId);\n        }\n        if (composerConfig.redirectUri) {\n          authModule = authModule.replace(/REDIRECT_URI_PLACEHOLDER/g, composerConfig.redirectUri);\n        }\n        if (composerConfig.cookieDomain !== undefined) {\n          authModule = authModule.replace(/COOKIE_DOMAIN_PLACEHOLDER/g, composerConfig.cookieDomain);\n        }\n\n        // Header injection placeholders\n        const enableHeaderInjection = composerConfig.enableHeaderInjection ?? false;\n        authModule = authModule.replace(/ENABLE_HEADER_INJECTION_PLACEHOLDER/g, String(enableHeaderInjection));\n\n        if (enableHeaderInjection && composerConfig.headerInjectionClaims) {\n          const map = composerConfig.headerInjectionClaims;\n          authModule = authModule.replace(/HEADER_INJECTION_MAP_PLACEHOLDER/g, JSON.stringify(map));\n          authModule = authModule.replace(/HEADER_INJECTION_KEYS_PLACEHOLDER/g, JSON.stringify(Object.keys(map)));\n        } else {\n          authModule = authModule.replace(/HEADER_INJECTION_MAP_PLACEHOLDER/g, '{}');\n          authModule = authModule.replace(/HEADER_INJECTION_KEYS_PLACEHOLDER/g, '[]');\n        }\n\n        // Refresh redirect placeholder\n        const enableRefresh = composerConfig.enableRefresh ?? false;\n        authModule = authModule.replace(/ENABLE_REFRESH_PLACEHOLDER/g, String(enableRefresh));\n\n        // Custom-UI login-redirect placeholder (empty string => IdP-redirect mode)\n        authModule = authModule.replace(/LOGIN_REDIRECT_PATH_PLACEHOLDER/g, composerConfig.loginRedirectPath ?? '');\n      }\n      parts.push(authModule);\n      checks.push('auth');\n    }\n\n    // Generate handler function\n    parts.push(this.generateHandler(checks, config, composerConfig));\n\n    let assembled = parts.join('\\n\\n');\n\n    // Extract the CloudFront-specific import (terser can't parse ES module imports in script mode).\n    // We'll prepend it back after minification.\n    const cfImport = \"import cf from 'cloudfront';\\n\";\n    assembled = assembled.replace(/import cf from 'cloudfront';\\s*/g, '');\n\n    // Also extract `var crypto = require('crypto');` — terser handles it fine but\n    // CloudFront Functions need it at the top level.\n    const cryptoRequire = \"var crypto = require('crypto');\\n\";\n    assembled = assembled.replace(/var crypto = require\\('crypto'\\);\\s*/g, '');\n\n    // Extract KVS handle declaration (depends on cf import)\n    const kvsDecl = 'const kvsHandle = cf.kvs();\\n';\n    assembled = assembled.replace(/const kvsHandle = cf\\.kvs\\(\\);\\s*/g, '');\n\n    // Minify with terser to stay well under the 10KB CloudFront Function limit.\n    const minified = minify_sync(assembled, {\n      compress: {\n        dead_code: true,\n        drop_console: false,\n        passes: 2,\n      },\n      mangle: {\n        reserved: ['handler', 'event', 'kvsHandle'],\n      },\n      format: {\n        comments: false,\n      },\n    });\n\n    // Prepend the CloudFront-specific preamble back\n    const code = cfImport + cryptoRequire + kvsDecl + (minified.code || assembled);\n    const sizeKB = Buffer.byteLength(code, 'utf-8') / 1024;\n\n    if (sizeKB > 10) {\n      throw new Error(`CloudFront Function exceeds 10KB limit: ${sizeKB.toFixed(2)}KB (extensions: ${extensions.join(', ')})`);\n    }\n\n    return code;\n  }\n\n  private loadModule(filename: string): string {\n    const filePath = path.join(this.modulesDir, filename);\n    const content = fs.readFileSync(filePath, 'utf-8');\n\n    return content\n      .replace(/\\/\\*[\\s\\S]*?\\*\\//g, '') // block comments\n      .replace(/^\\s*\\/\\/.*$/gm, '') // line comments (whole-line only)\n      .replace(/^\\s*\\n/gm, '') // blank lines\n      .replace(/function handler\\(event\\) \\{[\\s\\S]*?\\n\\}/g, '')\n      .replace(/async function handler\\(event\\) \\{[\\s\\S]*?\\n\\}/g, '');\n  }\n\n  private generateHandler(checks: string[], config?: ExtensionConfig, composerConfig?: ComposerConfig): string {\n    const hasAuth = checks.includes('auth');\n    const requireMfa = composerConfig?.requireMfa ?? false;\n    const lines: string[] = [\n      '// Generated handler function',\n      hasAuth ? 'async function handler(event) {' : 'function handler(event) {',\n      '  var decodedPayload = null;',\n      '',\n    ];\n\n    // Add TLS check\n    if (checks.includes('tls')) {\n      lines.push(\n        '  // TLS 1.3 enforcement',\n        '  var tlsResult = checkTLS(event);',\n        '  if (tlsResult) return tlsResult;',\n        '',\n      );\n    }\n\n    // Add auth check (with optional role checking built-in)\n    if (hasAuth) {\n      const requiredRoles = config?.requiredRoles ? config.requiredRoles : [];\n      const matchMode = config?.roleMatchMode || RoleMatchMode.OR;\n      const rolesJson = JSON.stringify(requiredRoles);\n\n      lines.push(\n        '  // Authentication check',\n        `  var requiredRoles = ${rolesJson};`,\n        `  var matchMode = '${matchMode}';`,\n        '  var authResult = await checkAuth(event, decodedPayload, requiredRoles, matchMode);',\n        '  if (!authResult.pass) return authResult.response;',\n        '  decodedPayload = authResult.payload;',\n        '',\n        '  // Inject Azure AD JWT for AssumeRoleWithWebIdentity (Azure only)',\n        '  if (typeof injectAzureToken === \\'function\\') {',\n        '    event.request = injectAzureToken(event.request, event.request.cookies);',\n        '  }',\n        '',\n        '  // Inject identity claims as headers for origin (when enabled)',\n        '  if (typeof injectClaimsHeaders === \\'function\\') {',\n        '    event.request = injectClaimsHeaders(event.request, decodedPayload);',\n        '  }',\n        '',\n      );\n\n      // MFA enforcement (defence in depth)\n      if (requireMfa) {\n        lines.push(\n          '  // MFA enforcement',\n          '  if (decodedPayload) {',\n          '    var amr = decodedPayload.amr || [];',\n          '    if (amr.indexOf(\\'mfa\\') === -1) {',\n          '      return {',\n          '        statusCode: 403,',\n          '        statusDescription: \\'Forbidden\\',',\n          '        body: \\'Access denied: MFA required\\'',\n          '      };',\n          '    }',\n          '  }',\n          '',\n        );\n      }\n    }\n\n    // Add URL rewrite after auth so originalPath is saved correctly\n    if (checks.includes('rewrite')) {\n      lines.push(\n        '  rewriteToIndex(event);',\n        '',\n      );\n    }\n\n    lines.push(\n      '  // All checks passed',\n      '  return event.request;',\n      '}',\n    );\n\n    return lines.join('\\n');\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"function-composer.js","sourceRoot":"","sources":["../../../src/cloudfront/cloudfront-functions/function-composer.ts"],"names":[],"mappings":"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","sourcesContent":["import * as fs from 'fs';\nimport * as path from 'path';\nimport { minify_sync } from 'terser';\nimport { Extension, ExtensionConfig, RoleMatchMode } from '../patterns/securedCloudFront';\n\nexport interface ComposerConfig {\n  readonly tenantId?: string;\n  readonly cognitoDomain?: string;\n  readonly clientId?: string;\n  readonly redirectUri?: string;\n  readonly cookieDomain?: string;\n  readonly requireMfa?: boolean;\n  /** Enable header stripping and injection from JWT claims. @default false */\n  readonly enableHeaderInjection?: boolean;\n  /** Map of header name → JWT claim key. e.g. { 'x-customer-id': 'customer_id' } */\n  readonly headerInjectionClaims?: Record<string, string>;\n  /** Enable refresh redirect for expired-but-valid tokens. @default false */\n  readonly enableRefresh?: boolean;\n  /**\n   * Custom-UI mode: first-party path to redirect unauthenticated users to\n   * (e.g. '/login'). When set, the shared auth-check module is used with a\n   * relative redirect instead of an external IdP authorize URL.\n   */\n  readonly loginRedirectPath?: string;\n}\n\n/**\n * Minify CloudFront Function source with terser.\n *\n * CloudFront Functions have a hard 10KB code-size limit. Both the composed\n * (multi-module) path and the standalone auth-check path must minify, using\n * the SAME options, so a function that fits in one path fits in the other.\n *\n * `minify_sync` throws on a parse error and, in its documented failure mode,\n * can return `{ error }` with no `code`. An earlier `minified.code || assembled`\n * fallback caught that second case and silently shipped the UN-minified source,\n * which is how an 11KB function reached CloudFront and 413'd at deploy. This\n * helper never falls back: a thrown error propagates, and a missing `code` is\n * turned into a thrown error too — a minify failure is always a build error.\n *\n * The `reserved` names are the CloudFront-required top-level identifiers that\n * must survive mangling.\n */\nexport function minifyFunctionCode(source: string): string {\n  const result = minify_sync(source, {\n    compress: {\n      dead_code: true,\n      drop_console: false,\n      passes: 2,\n    },\n    mangle: {\n      reserved: ['handler', 'event', 'kvsHandle'],\n    },\n    format: {\n      comments: false,\n    },\n  });\n\n  // `minify_sync` returns `{ error }` (not typed by @types/terser) instead of\n  // throwing; `code` is undefined on failure. Treat a missing `code` as the\n  // failure signal and surface the runtime error if terser attached one.\n  if (result.code === undefined) {\n    const err = (result as { error?: Error }).error;\n    throw new Error(`CloudFront Function minification failed: ${err ?? 'terser produced no output'}`);\n  }\n\n  return result.code;\n}\n\n/**\n * Generates a combined CloudFront Function from modular check functions\n * based on requested extensions\n */\nexport class FunctionComposer {\n  private readonly modulesDir: string;\n\n  constructor() {\n    this.modulesDir = path.join(__dirname, 'modules');\n  }\n\n  /**\n   * Generate combined function code based on requested extensions\n   */\n  public compose(extensions: Extension[], config?: ExtensionConfig, composerConfig?: ComposerConfig): string {\n    const parts: string[] = [];\n\n    // Always include shared utilities\n    parts.push(this.loadModule('shared-utils.js'));\n\n    // Include required check modules\n    const checks: string[] = [];\n\n    if (extensions.includes(Extension.REWRITE_TO_INDEX_HTML)) {\n      parts.push(this.loadModule('url-rewrite.js'));\n      checks.push('rewrite');\n    }\n\n    if (extensions.includes(Extension.REQUIRE_TLS_13)) {\n      parts.push(this.loadModule('tls-check.js'));\n      checks.push('tls');\n    }\n\n    if (extensions.includes(Extension.REQUIRE_AUTH)) {\n      // Custom-UI mode uses the shared auth-check module (header injection +\n      // refresh capable) with a first-party /login redirect, even though the\n      // identity provider is Cognito.\n      const isCustomUi = composerConfig?.loginRedirectPath !== undefined && composerConfig.loginRedirectPath !== '';\n      const isCognito = composerConfig?.cognitoDomain !== undefined && !isCustomUi;\n      let authModule = this.loadModule(isCognito ? 'cognito-auth-check.js' : 'auth-check.js');\n      if (composerConfig) {\n        if (composerConfig.cognitoDomain) {\n          authModule = authModule.replace(/COGNITO_DOMAIN_PLACEHOLDER/g, composerConfig.cognitoDomain);\n        }\n        if (composerConfig.tenantId) {\n          authModule = authModule.replace(/TENANT_ID_PLACEHOLDER/g, composerConfig.tenantId);\n        }\n        if (composerConfig.clientId) {\n          authModule = authModule.replace(/CLIENT_ID_PLACEHOLDER/g, composerConfig.clientId);\n        }\n        if (composerConfig.redirectUri) {\n          authModule = authModule.replace(/REDIRECT_URI_PLACEHOLDER/g, composerConfig.redirectUri);\n        }\n        if (composerConfig.cookieDomain !== undefined) {\n          authModule = authModule.replace(/COOKIE_DOMAIN_PLACEHOLDER/g, composerConfig.cookieDomain);\n        }\n\n        // Header injection placeholders\n        const enableHeaderInjection = composerConfig.enableHeaderInjection ?? false;\n        authModule = authModule.replace(/ENABLE_HEADER_INJECTION_PLACEHOLDER/g, String(enableHeaderInjection));\n\n        if (enableHeaderInjection && composerConfig.headerInjectionClaims) {\n          const map = composerConfig.headerInjectionClaims;\n          authModule = authModule.replace(/HEADER_INJECTION_MAP_PLACEHOLDER/g, JSON.stringify(map));\n          authModule = authModule.replace(/HEADER_INJECTION_KEYS_PLACEHOLDER/g, JSON.stringify(Object.keys(map)));\n        } else {\n          authModule = authModule.replace(/HEADER_INJECTION_MAP_PLACEHOLDER/g, '{}');\n          authModule = authModule.replace(/HEADER_INJECTION_KEYS_PLACEHOLDER/g, '[]');\n        }\n\n        // Refresh redirect placeholder\n        const enableRefresh = composerConfig.enableRefresh ?? false;\n        authModule = authModule.replace(/ENABLE_REFRESH_PLACEHOLDER/g, String(enableRefresh));\n\n        // Custom-UI login-redirect placeholder (empty string => IdP-redirect mode)\n        authModule = authModule.replace(/LOGIN_REDIRECT_PATH_PLACEHOLDER/g, composerConfig.loginRedirectPath ?? '');\n      }\n      parts.push(authModule);\n      checks.push('auth');\n    }\n\n    // Generate handler function\n    parts.push(this.generateHandler(checks, config, composerConfig));\n\n    let assembled = parts.join('\\n\\n');\n\n    // Extract the CloudFront-specific import (terser can't parse ES module imports in script mode).\n    // We'll prepend it back after minification.\n    const cfImport = \"import cf from 'cloudfront';\\n\";\n    assembled = assembled.replace(/import cf from 'cloudfront';\\s*/g, '');\n\n    // Also extract `var crypto = require('crypto');` — terser handles it fine but\n    // CloudFront Functions need it at the top level.\n    const cryptoRequire = \"var crypto = require('crypto');\\n\";\n    assembled = assembled.replace(/var crypto = require\\('crypto'\\);\\s*/g, '');\n\n    // Extract KVS handle declaration (depends on cf import)\n    const kvsDecl = 'const kvsHandle = cf.kvs();\\n';\n    assembled = assembled.replace(/const kvsHandle = cf\\.kvs\\(\\);\\s*/g, '');\n\n    // Minify with terser to stay well under the 10KB CloudFront Function limit.\n    const minified = minifyFunctionCode(assembled);\n\n    // Prepend the CloudFront-specific preamble back\n    const code = cfImport + cryptoRequire + kvsDecl + minified;\n    const sizeKB = Buffer.byteLength(code, 'utf-8') / 1024;\n\n    if (sizeKB > 10) {\n      throw new Error(`CloudFront Function exceeds 10KB limit: ${sizeKB.toFixed(2)}KB (extensions: ${extensions.join(', ')})`);\n    }\n\n    return code;\n  }\n\n  private loadModule(filename: string): string {\n    const filePath = path.join(this.modulesDir, filename);\n    const content = fs.readFileSync(filePath, 'utf-8');\n\n    return content\n      .replace(/\\/\\*[\\s\\S]*?\\*\\//g, '') // block comments\n      .replace(/^\\s*\\/\\/.*$/gm, '') // line comments (whole-line only)\n      .replace(/^\\s*\\n/gm, '') // blank lines\n      .replace(/function handler\\(event\\) \\{[\\s\\S]*?\\n\\}/g, '')\n      .replace(/async function handler\\(event\\) \\{[\\s\\S]*?\\n\\}/g, '');\n  }\n\n  private generateHandler(checks: string[], config?: ExtensionConfig, composerConfig?: ComposerConfig): string {\n    const hasAuth = checks.includes('auth');\n    const requireMfa = composerConfig?.requireMfa ?? false;\n    const lines: string[] = [\n      '// Generated handler function',\n      hasAuth ? 'async function handler(event) {' : 'function handler(event) {',\n      '  var decodedPayload = null;',\n      '',\n    ];\n\n    // Add TLS check\n    if (checks.includes('tls')) {\n      lines.push(\n        '  // TLS 1.3 enforcement',\n        '  var tlsResult = checkTLS(event);',\n        '  if (tlsResult) return tlsResult;',\n        '',\n      );\n    }\n\n    // Add auth check (with optional role checking built-in)\n    if (hasAuth) {\n      const requiredRoles = config?.requiredRoles ? config.requiredRoles : [];\n      const matchMode = config?.roleMatchMode || RoleMatchMode.OR;\n      const rolesJson = JSON.stringify(requiredRoles);\n\n      lines.push(\n        '  // Authentication check',\n        `  var requiredRoles = ${rolesJson};`,\n        `  var matchMode = '${matchMode}';`,\n        '  var authResult = await checkAuth(event, decodedPayload, requiredRoles, matchMode);',\n        '  if (!authResult.pass) return authResult.response;',\n        '  decodedPayload = authResult.payload;',\n        '',\n        '  // Inject Azure AD JWT for AssumeRoleWithWebIdentity (Azure only)',\n        '  if (typeof injectAzureToken === \\'function\\') {',\n        '    event.request = injectAzureToken(event.request, event.request.cookies);',\n        '  }',\n        '',\n        '  // Inject identity claims as headers for origin (when enabled)',\n        '  if (typeof injectClaimsHeaders === \\'function\\') {',\n        '    event.request = injectClaimsHeaders(event.request, decodedPayload);',\n        '  }',\n        '',\n      );\n\n      // MFA enforcement (defence in depth)\n      if (requireMfa) {\n        lines.push(\n          '  // MFA enforcement',\n          '  if (decodedPayload) {',\n          '    var amr = decodedPayload.amr || [];',\n          '    if (amr.indexOf(\\'mfa\\') === -1) {',\n          '      return {',\n          '        statusCode: 403,',\n          '        statusDescription: \\'Forbidden\\',',\n          '        body: \\'Access denied: MFA required\\'',\n          '      };',\n          '    }',\n          '  }',\n          '',\n        );\n      }\n    }\n\n    // Add URL rewrite after auth so originalPath is saved correctly\n    if (checks.includes('rewrite')) {\n      lines.push(\n        '  rewriteToIndex(event);',\n        '',\n      );\n    }\n\n    lines.push(\n      '  // All checks passed',\n      '  return event.request;',\n      '}',\n    );\n\n    return lines.join('\\n');\n  }\n}\n"]}

package/lib/cloudfront/cloudfront-functions/modules/auth-check.js

@@ -140,7 +140,33 @@ function getOriginalPath(request) {
   return request.uri + '?' + qs;
 }
 
-function redirectToAuth(originalPath, host) {
+// A live PKCE sign-in is represented by the pair of cookies (oauth_state +
+// code_verifier) minted on the redirect that started it. The browser drops both
+// at Max-Age=600, so their PRESENCE (with a well-formed, decodable state) is the
+// practical "unexpired flow" signal available to a CloudFront Function — it has
+// no way to read a cookie's own expiry. Reusing an existing pair instead of
+// minting a new one is what stops a redirect provoked mid-sign-in (e.g. a
+// background notification poll from a sibling panel on the shared cookie domain)
+// from overwriting the state the in-flight sign-in carries, which the callback
+// compares strictly and rejects with "400 Invalid state parameter".
+function inflightAuthFlow(cookies) {
+  if (!cookies) { return null; }
+  var stateCookie = cookies.oauth_state;
+  var verifierCookie = cookies.code_verifier;
+  if (!stateCookie || !stateCookie.value || !verifierCookie || !verifierCookie.value) {
+    return null;
+  }
+  // Require the state to be decodable — a malformed value is not a flow we can
+  // reissue against, so fall through to minting a fresh one.
+  try {
+    JSON.parse(base64urlDecode(stateCookie.value));
+  } catch (e) {
+    return null;
+  }
+  return { state: stateCookie.value, codeVerifier: verifierCookie.value };
+}
+
+function redirectToAuth(originalPath, host, cookies) {
   // Custom-UI mode: redirect to a first-party login page. No IdP redirect and
   // no PKCE state/verifier cookies — the login page performs SRP client-side and
   // POSTs the resulting tokens to the session-issuance endpoint.
@@ -153,10 +179,27 @@ function redirectToAuth(originalPath, host) {
       }
     };
   }
+  var domainAttr = COOKIE_DOMAIN ? '; Domain=' + COOKIE_DOMAIN : '';
+
+  // If a sign-in is already in flight, reissue the redirect REUSING its state and
+  // verifier, and set NO cookies — do not clobber the live flow. The challenge is
+  // re-derived from the stored verifier so the authorize URL stays consistent with
+  // the PKCE exchange the callback will perform for whichever flow completes.
+  var inflight = inflightAuthFlow(cookies);
+  if (inflight) {
+    var reusedChallenge = generateCodeChallenge(inflight.codeVerifier);
+    return {
+      statusCode: 302,
+      headers: {
+        location: { value: buildAzureAuthUrl(inflight.state, reusedChallenge, host) },
+        'cache-control': { value: 'no-store' }
+      }
+    };
+  }
+
   var state = generateState(originalPath, host);
   var codeVerifier = generateCodeVerifier();
   var codeChallenge = generateCodeChallenge(codeVerifier);
-  var domainAttr = COOKIE_DOMAIN ? '; Domain=' + COOKIE_DOMAIN : '';
   return {
     statusCode: 302,
     headers: {
@@ -213,14 +256,14 @@ async function checkAuth(event, decodedPayload, requiredRoles, roleMatchMode) {
   if (!sessionCookie) {
     return {
       pass: false,
-      response: redirectToAuth(originalPath, host)
+      response: redirectToAuth(originalPath, host, request.cookies)
     };
   }
   var token = sessionCookie.value;
   if (!token || token.length === 0) {
     return {
       pass: false,
-      response: redirectToAuth(originalPath, host)
+      response: redirectToAuth(originalPath, host, request.cookies)
     };
   }
   try {
@@ -228,14 +271,14 @@ async function checkAuth(event, decodedPayload, requiredRoles, roleMatchMode) {
     if (parts.length !== 3) {
       return {
         pass: false,
-        response: redirectToAuth(originalPath, host)
+        response: redirectToAuth(originalPath, host, request.cookies)
       };
     }
     var isValid = await validateHmacSignature(token);
     if (!isValid) {
       return {
         pass: false,
-        response: redirectToAuth(originalPath, host)
+        response: redirectToAuth(originalPath, host, request.cookies)
       };
     }
     var payload = JSON.parse(base64urlDecode(parts[1]));
@@ -250,7 +293,7 @@ async function checkAuth(event, decodedPayload, requiredRoles, roleMatchMode) {
       }
       return {
         pass: false,
-        response: redirectToAuth(originalPath, host)
+        response: redirectToAuth(originalPath, host, request.cookies)
       };
     }
     var jti = payload.jti;
@@ -260,7 +303,7 @@ async function checkAuth(event, decodedPayload, requiredRoles, roleMatchMode) {
         if (isRevoked) {
           return {
             pass: false,
-            response: redirectToAuth(originalPath, host)
+            response: redirectToAuth(originalPath, host, request.cookies)
           };
         }
       } catch (e) {}
@@ -304,7 +347,7 @@ async function checkAuth(event, decodedPayload, requiredRoles, roleMatchMode) {
   } catch (e) {
     return {
       pass: false,
-      response: redirectToAuth(originalPath, host)
+      response: redirectToAuth(originalPath, host, request.cookies)
     };
   }
 }

package/lib/cloudfront/cloudfront-functions/modules/cognito-auth-check.js

@@ -121,7 +121,47 @@ function getOriginalPath(request) {
   return request.uri + '?' + qs;
 }
 
-function redirectToAuth(originalPath) {
+// A live PKCE sign-in is represented by the pair of cookies (oauth_state +
+// code_verifier) minted on the redirect that started it. The browser drops both
+// at Max-Age=600, so their PRESENCE (with a well-formed, decodable state) is the
+// practical "unexpired flow" signal available to a CloudFront Function — it has
+// no way to read a cookie's own expiry. Reusing an existing pair instead of
+// minting a new one is what stops a redirect provoked mid-sign-in (e.g. a
+// background notification poll from a sibling panel on the shared cookie domain)
+// from overwriting the state the in-flight sign-in carries, which the callback
+// compares strictly and rejects with "400 Invalid state parameter".
+function inflightAuthFlow(cookies) {
+  if (!cookies) { return null; }
+  var stateCookie = cookies.oauth_state;
+  var verifierCookie = cookies.code_verifier;
+  if (!stateCookie || !stateCookie.value || !verifierCookie || !verifierCookie.value) {
+    return null;
+  }
+  try {
+    JSON.parse(base64urlDecode(stateCookie.value));
+  } catch (e) {
+    return null;
+  }
+  return { state: stateCookie.value, codeVerifier: verifierCookie.value };
+}
+
+function redirectToAuth(originalPath, cookies) {
+  // If a sign-in is already in flight, reissue the redirect REUSING its state and
+  // verifier, and set NO cookies — do not clobber the live flow. The challenge is
+  // re-derived from the stored verifier so the authorize URL stays consistent with
+  // the PKCE exchange the callback performs for whichever flow completes.
+  var inflight = inflightAuthFlow(cookies);
+  if (inflight) {
+    var reusedChallenge = generateCodeChallenge(inflight.codeVerifier);
+    return {
+      statusCode: 302,
+      headers: {
+        location: { value: buildCognitoAuthUrl(inflight.state, reusedChallenge) },
+        'cache-control': { value: 'no-store' }
+      }
+    };
+  }
+
   var state = generateState(originalPath);
   var codeVerifier = generateCodeVerifier();
   var codeChallenge = generateCodeChallenge(codeVerifier);
@@ -155,32 +195,32 @@ async function checkAuth(event, decodedPayload, requiredRoles, roleMatchMode) {
   var cookies = request.cookies;
   var originalPath = getOriginalPath(request);
   if (!cookies['__Host-auth_session']) {
-    return { pass: false, response: redirectToAuth(originalPath) };
+    return { pass: false, response: redirectToAuth(originalPath, request.cookies) };
   }
   var token = cookies['__Host-auth_session'].value;
   if (!token || token.length === 0) {
-    return { pass: false, response: redirectToAuth(originalPath) };
+    return { pass: false, response: redirectToAuth(originalPath, request.cookies) };
   }
   try {
     var parts = token.split('.');
     if (parts.length !== 3) {
-      return { pass: false, response: redirectToAuth(originalPath) };
+      return { pass: false, response: redirectToAuth(originalPath, request.cookies) };
     }
     var isValid = await validateHmacSignature(token);
     if (!isValid) {
-      return { pass: false, response: redirectToAuth(originalPath) };
+      return { pass: false, response: redirectToAuth(originalPath, request.cookies) };
     }
     var payload = JSON.parse(base64urlDecode(parts[1]));
     var now = Math.floor(Date.now() / 1000);
     if (payload.exp && payload.exp < now) {
-      return { pass: false, response: redirectToAuth(originalPath) };
+      return { pass: false, response: redirectToAuth(originalPath, request.cookies) };
     }
     var jti = payload.jti;
     if (jti) {
       try {
         var isRevoked = await kvsHandle.get('revoked:' + jti);
         if (isRevoked) {
-          return { pass: false, response: redirectToAuth(originalPath) };
+          return { pass: false, response: redirectToAuth(originalPath, request.cookies) };
         }
       } catch (e) {}
     }
@@ -218,6 +258,6 @@ async function checkAuth(event, decodedPayload, requiredRoles, roleMatchMode) {
 
     return { pass: true, payload: payload };
   } catch (e) {
-    return { pass: false, response: redirectToAuth(originalPath) };
+    return { pass: false, response: redirectToAuth(originalPath, request.cookies) };
   }
 }