fixup! fix(@angular/ssr): introduce trustProxyHeaders option to safely validate and sanitize proxy headers

Author: alan-agius4

packages/angular/ssr/node/src/request.ts

@@ -8,7 +8,7 @@
 
 import type { IncomingHttpHeaders, IncomingMessage } from 'node:http';
 import type { Http2ServerRequest } from 'node:http2';
-import { getFirstHeaderValue } from '../../src/utils/validation';
+import { getFirstHeaderValue, normalizeTrustProxyHeaders } from '../../src/utils/validation';
 
 /**
  * A set containing all the pseudo-headers defined in the HTTP/2 specification.
@@ -33,7 +33,7 @@ const HTTP2_PSEUDO_HEADERS: ReadonlySet<string> = new Set([
  * be used by web platform APIs.
  *
  * @param nodeRequest - The Node.js request object (`IncomingMessage` or `Http2ServerRequest`) to convert.
- * @param trustProxyHeaders - A boolean or an array of allowed proxy headers.
+ * @param trustProxyHeaders - A boolean or an array of proxy headers to trust when constructing the request URL.
  *
  * @remarks
  * When `trustProxyHeaders` is enabled, headers such as `X-Forwarded-Host` and
@@ -46,18 +46,14 @@ export function createWebRequestFromNodeRequest(
   nodeRequest: IncomingMessage | Http2ServerRequest,
   trustProxyHeaders?: boolean | readonly string[],
 ): Request {
-  const trustProxyHeadersNormalized =
-    trustProxyHeaders && typeof trustProxyHeaders !== 'boolean'
-      ? new Set(trustProxyHeaders.map((h) => h.toLowerCase()))
-      : trustProxyHeaders;
-
+  const trustProxyHeadersNormalized = normalizeTrustProxyHeaders(trustProxyHeaders);
   const { headers, method = 'GET' } = nodeRequest;
   const withBody = method !== 'GET' && method !== 'HEAD';
   const referrer = headers.referer && URL.canParse(headers.referer) ? headers.referer : undefined;
 
   return new Request(createRequestUrl(nodeRequest, trustProxyHeadersNormalized), {
     method,
-    headers: createRequestHeaders(headers, trustProxyHeadersNormalized),
+    headers: createRequestHeaders(headers),
     body: withBody ? nodeRequest : undefined,
     duplex: withBody ? 'half' : undefined,
     referrer,
@@ -68,27 +64,16 @@ export function createWebRequestFromNodeRequest(
  * Creates a `Headers` object from Node.js `IncomingHttpHeaders`.
  *
  * @param nodeHeaders - The Node.js `IncomingHttpHeaders` object to convert.
- * @param trustProxyHeaders - A boolean or a set of allowed proxy headers.
  * @returns A `Headers` object containing the converted headers.
  */
-function createRequestHeaders(
-  nodeHeaders: IncomingHttpHeaders,
-  trustProxyHeaders: boolean | ReadonlySet<string> | undefined,
-): Headers {
+function createRequestHeaders(nodeHeaders: IncomingHttpHeaders): Headers {
   const headers = new Headers();
 
   for (const [name, value] of Object.entries(nodeHeaders)) {
     if (HTTP2_PSEUDO_HEADERS.has(name)) {
       continue;
     }
 
-    if (
-      name.toLowerCase().startsWith('x-forwarded-') &&
-      !isProxyHeaderAllowed(name.toLowerCase(), trustProxyHeaders)
-    ) {
-      continue;
-    }
-
     if (typeof value === 'string') {
       headers.append(name, value);
     } else if (Array.isArray(value)) {
@@ -105,7 +90,7 @@ function createRequestHeaders(
  * Creates a `URL` object from a Node.js `IncomingMessage`, taking into account the protocol, host, and port.
  *
  * @param nodeRequest - The Node.js `IncomingMessage` or `Http2ServerRequest` object to extract URL information from.
- * @param trustProxyHeaders - A boolean or a set of allowed proxy headers.
+ * @param trustProxyHeaders - A set of allowed proxy headers.
  *
  * @remarks
  * When `trustProxyHeaders` is enabled, headers such as `X-Forwarded-Host` and
@@ -116,7 +101,7 @@ function createRequestHeaders(
  */
 export function createRequestUrl(
   nodeRequest: IncomingMessage | Http2ServerRequest,
-  trustProxyHeaders?: boolean | ReadonlySet<string>,
+  trustProxyHeaders: ReadonlySet<string>,
 ): URL {
   const {
     headers,
@@ -154,13 +139,13 @@ export function createRequestUrl(
  *
  * @param headers - The Node.js incoming HTTP headers.
  * @param headerName - The name of the proxy header to retrieve.
- * @param trustProxyHeaders - A boolean or a set of allowed proxy headers.
+ * @param trustProxyHeaders - A set of allowed proxy headers.
  * @returns The value of the allowed proxy header, or `undefined` if not allowed or not present.
  */
 function getAllowedProxyHeaderValue(
   headers: IncomingHttpHeaders,
   headerName: string,
-  trustProxyHeaders: boolean | ReadonlySet<string> | undefined,
+  trustProxyHeaders: ReadonlySet<string>,
 ): string | undefined {
   return isProxyHeaderAllowed(headerName, trustProxyHeaders)
     ? getFirstHeaderValue(headers[headerName])
@@ -171,26 +156,9 @@ function getAllowedProxyHeaderValue(
  * Checks if a specific proxy header is allowed.
  *
  * @param headerName - The name of the proxy header to check.
- * @param allowedProxyHeaders - A boolean or a set of allowed proxy headers.
+ * @param allowedProxyHeaders - A set of allowed proxy headers.
  * @returns `true` if the header is allowed, `false` otherwise.
  */
-function isProxyHeaderAllowed(
-  headerName: string,
-  trustProxyHeaders: boolean | ReadonlySet<string> | undefined,
-): boolean {
-  if (trustProxyHeaders === undefined) {
-    const lower = headerName.toLowerCase();
-
-    return lower === 'x-forwarded-host' || lower === 'x-forwarded-proto';
-  }
-
-  if (trustProxyHeaders === false) {
-    return false;
-  }
-
-  if (trustProxyHeaders === true) {
-    return true;
-  }
-
+function isProxyHeaderAllowed(headerName: string, trustProxyHeaders: ReadonlySet<string>): boolean {
   return trustProxyHeaders.has(headerName.toLowerCase());
 }

packages/angular/ssr/src/app-engine.ts

@@ -12,7 +12,11 @@ import { getPotentialLocaleIdFromUrl, getPreferredLocale } from './i18n';
 import { EntryPointExports, getAngularAppEngineManifest } from './manifest';
 import { createRedirectResponse } from './utils/redirect';
 import { joinUrlParts } from './utils/url';
-import { sanitizeRequestHeaders, validateRequest } from './utils/validation';
+import {
+  normalizeTrustProxyHeaders,
+  sanitizeRequestHeaders,
+  validateRequest,
+} from './utils/validation';
 
 /**
  * Options for the Angular server application engine.
@@ -97,7 +101,7 @@ export class AngularAppEngine {
   /**
    * The normalized allowed proxy headers.
    */
-  private readonly trustProxyHeaders: ReadonlySet<string> | boolean | undefined;
+  private readonly trustProxyHeaders: ReadonlySet<string>;
 
   /**
    * A cache that holds entry points, keyed by their potential locale string.
@@ -110,14 +114,7 @@ export class AngularAppEngine {
    */
   constructor(options?: AngularAppEngineOptions) {
     this.allowedHosts = this.getAllowedHosts(options);
-
-    const trustProxyHeaders = options?.trustProxyHeaders;
-    this.trustProxyHeaders =
-      trustProxyHeaders === undefined
-        ? undefined
-        : typeof trustProxyHeaders === 'boolean'
-          ? trustProxyHeaders
-          : new Set(trustProxyHeaders.map((h) => h.toLowerCase()));
+    this.trustProxyHeaders = normalizeTrustProxyHeaders(options?.trustProxyHeaders);
   }
 
   private getAllowedHosts(options: AngularAppEngineOptions | undefined): ReadonlySet<string> {
@@ -160,7 +157,10 @@ export class AngularAppEngine {
    */
   async handle(request: Request, requestContext?: unknown): Promise<Response | null> {
     const allowedHost = this.allowedHosts;
-    const securedRequest = sanitizeRequestHeaders(request, this.trustProxyHeaders);
+    const { request: securedRequest, deoptToCSR } = sanitizeRequestHeaders(
+      request,
+      this.trustProxyHeaders,
+    );
 
     try {
       validateRequest(securedRequest, allowedHost, AngularAppEngine.ɵdisableAllowedHostsCheck);
@@ -170,6 +170,10 @@ export class AngularAppEngine {
 
     const serverApp = await this.getAngularServerAppForRequest(securedRequest);
     if (serverApp) {
+      if (deoptToCSR) {
+        return serverApp.serveClientSidePage();
+      }
+
       return serverApp.handle(securedRequest, requestContext);
     }
 

packages/angular/ssr/src/app.ts

@@ -191,20 +191,6 @@ export class AngularServerApp {
     }
 
     const { redirectTo, status, renderMode, headers, preload } = matchedRoute;
-
-    if (request.headers.get('x-angular-deopt-csr') === 'true') {
-      let html = await this.assets.getServerAsset('index.csr.html').text();
-      html = await this.runTransformsOnHtml(html, url, preload);
-
-      return new Response(html, {
-        status: 200,
-        headers: new Headers({
-          'Content-Type': 'text/html;charset=UTF-8',
-          ...headers,
-        }),
-      });
-    }
-
     if (redirectTo !== undefined) {
       return createRedirectResponse(
         joinUrlParts(

packages/angular/ssr/src/utils/validation.ts

@@ -6,6 +6,17 @@
  * found in the LICENSE file at https://angular.dev/license
  */
 
+/**
+ * Common X-Forwarded-* headers.
+ */
+const X_FORWARDED_HEADERS = new Set([
+  'x-forwarded-for',
+  'x-forwarded-host',
+  'x-forwarded-port',
+  'x-forwarded-proto',
+  'x-forwarded-prefix',
+]);
+
 /**
  * The set of headers that should be validated for host header injection attacks.
  */
@@ -85,49 +96,31 @@ export function validateUrl(url: URL, allowedHosts: ReadonlySet<string>): void {
  * If no headers need to be removed, the original request is returned without cloning.
  *
  * @param request - The incoming `Request` object to sanitize.
- * @param trustProxyHeaders - A set of allowed proxy headers or a boolean indicating whether all are allowed.
- * @returns The sanitized request, or the original request if no changes were needed.
+ * @param trustProxyHeaders - A set of allowed proxy headers.
+ * @returns An object containing the sanitized request, or the original request if no changes were needed.
  */
 export function sanitizeRequestHeaders(
   request: Request,
-  trustProxyHeaders: boolean | ReadonlySet<string> | undefined,
-): Request {
-  let receivedXForwarded = false;
+  trustProxyHeaders: ReadonlySet<string>,
+): { request: Request; deoptToCSR: boolean } {
   const keysToDelete: string[] = [];
   let deoptToCSR = false;
 
   for (const [key] of request.headers) {
     const lowerKey = key.toLowerCase();
-    if (lowerKey.startsWith('x-forwarded-')) {
-      receivedXForwarded = true;
-
-      if (trustProxyHeaders === true) {
-        continue;
-      }
-
-      if (trustProxyHeaders === undefined) {
-        if (lowerKey === 'x-forwarded-host' || lowerKey === 'x-forwarded-proto') {
-          continue;
-        }
-        if (lowerKey === 'x-forwarded-prefix') {
-          deoptToCSR = true;
-          continue;
-        }
-      } else if (trustProxyHeaders !== false && trustProxyHeaders.has(lowerKey)) {
-        continue;
-      }
-
+    if (lowerKey.startsWith('x-forwarded-') && !isProxyHeaderAllowed(lowerKey, trustProxyHeaders)) {
+      // eslint-disable-next-line no-console
+      console.warn(
+        `Received "${key}" header but "trustProxyHeaders" was not set up to allow it.\n` +
+          `For more information, see https://angular.dev/best-practices/security#configuring-trusted-proxy-headers`,
+      );
+      deoptToCSR = true;
       keysToDelete.push(key);
     }
   }
 
-  if (trustProxyHeaders === undefined && receivedXForwarded) {
-    // eslint-disable-next-line no-console
-    console.warn('Received "X-Forwarded-*" headers but "trustProxyHeaders" was not configured.');
-  }
-
-  if (keysToDelete.length === 0 && !deoptToCSR) {
-    return request;
+  if (keysToDelete.length === 0) {
+    return { request, deoptToCSR };
   }
 
   const clonedReq = new Request(request.clone(), {
@@ -139,11 +132,7 @@ export function sanitizeRequestHeaders(
     headers.delete(key);
   }
 
-  if (deoptToCSR) {
-    headers.set('x-angular-deopt-csr', 'true');
-  }
-
-  return clonedReq;
+  return { request: clonedReq, deoptToCSR };
 }
 
 /**
@@ -240,3 +229,40 @@ function validateHeaders(
     );
   }
 }
+
+/**
+ * Checks if a specific proxy header is allowed.
+ *
+ * @param headerName - The name of the proxy header to check.
+ * @param trustProxyHeaders - A set of allowed proxy headers.
+ * @returns `true` if the header is allowed, `false` otherwise.
+ */
+export function isProxyHeaderAllowed(
+  headerName: string,
+  trustProxyHeaders: ReadonlySet<string>,
+): boolean {
+  return trustProxyHeaders.has(headerName.toLowerCase());
+}
+
+/**
+ * Normalizes the `trustProxyHeaders` option to a consistent representation.
+ * @param trustProxyHeaders The input `trustProxyHeaders` value.
+ * @returns A `Set<string>` of normalized header names.
+ */
+export function normalizeTrustProxyHeaders(
+  trustProxyHeaders: boolean | readonly string[] | undefined,
+): ReadonlySet<string> {
+  if (trustProxyHeaders === undefined) {
+    return new Set(['x-forwarded-host', 'x-forwarded-proto']);
+  }
+
+  if (trustProxyHeaders === false) {
+    return new Set();
+  }
+
+  if (trustProxyHeaders === true) {
+    return X_FORWARDED_HEADERS;
+  }
+
+  return new Set(trustProxyHeaders.map((h) => h.toLowerCase()));
+}