@oneuptime/common 12.0.7 → 12.0.9

package/Server/Utils/LLM/LLMService.ts

@@ -76,7 +76,14 @@ export interface LLMUsage {
 export interface LLMCompletionResponse {
   content: string;
   toolCalls?: Array<LLMToolCall> | undefined;
-  stopReason?: "stop" | "tool_use" | undefined;
+  /*
+   * "length" means the provider cut generation off at the output-token cap —
+   * the content is incomplete and must not be presented as a finished answer.
+   * Every wire branch maps its provider-specific truncation signal here
+   * (OpenAI-style finish_reason "length", Anthropic stop_reason "max_tokens",
+   * Ollama done_reason "length").
+   */
+  stopReason?: "stop" | "tool_use" | "length" | undefined;
   usage: LLMUsage | undefined;
 }
 
@@ -792,6 +799,24 @@ export default class LLMService {
     const toolCalls: Array<LLMToolCall> | undefined =
       this.parseOpenAIToolCalls(message);
 
+    /*
+     * finish_reason "length" means the model hit the output-token cap, so the
+     * content (or a trailing tool call) is truncated. It takes precedence over
+     * the tool-call heuristic: executing a cut-off tool call or presenting a
+     * cut-off answer as complete would be wrong either way. Otherwise the
+     * presence of tool calls decides — some OpenAI-compatible servers report
+     * finish_reason "stop" even when they emitted tool calls.
+     */
+    const finishReason: string = (choices[0]!["finish_reason"] as string) || "";
+
+    let stopReason: "stop" | "tool_use" | "length" = "stop";
+
+    if (finishReason === "length") {
+      stopReason = "length";
+    } else if (toolCalls && toolCalls.length > 0) {
+      stopReason = "tool_use";
+    }
+
     /*
      * OpenAI (and Azure OpenAI) automatically cache a stable prompt prefix
      * once it is long enough and report the cache hit under
@@ -806,7 +831,7 @@ export default class LLMService {
     return {
       content: (message["content"] as string) || "",
       toolCalls: toolCalls,
-      stopReason: toolCalls && toolCalls.length > 0 ? "tool_use" : "stop",
+      stopReason: stopReason,
       usage: usage
         ? {
             promptTokens: usage["prompt_tokens"] as number,
@@ -960,8 +985,14 @@ export default class LLMService {
       [LlmType.Mistral]: "https://api.mistral.ai/v1",
     };
 
+    /*
+     * gpt-5.1 is a reasoning model: REASONING_MODEL_NAME_REGEX matches it, so
+     * the first request already goes out with max_completion_tokens instead
+     * of the legacy max_tokens, and any sampling params it rejects are
+     * dropped by the error-driven retry.
+     */
     const defaultModels: Record<string, string> = {
-      [LlmType.OpenAI]: "gpt-4o",
+      [LlmType.OpenAI]: "gpt-5.1",
       [LlmType.Groq]: "llama-3.3-70b-versatile",
       [LlmType.Mistral]: "mistral-large-latest",
     };
@@ -971,7 +1002,7 @@ export default class LLMService {
       defaultBaseUrls[config.llmType] ||
       "https://api.openai.com/v1";
     const modelName: string =
-      config.modelName || defaultModels[config.llmType] || "gpt-4o";
+      config.modelName || defaultModels[config.llmType] || "gpt-5.1";
     const response: HTTPErrorResponse | HTTPResponse<JSONObject> =
       await this.postOpenAIChatCompletion({
         requestUrl: this.buildOpenAICompatibleChatCompletionsUrl(baseUrl),
@@ -1049,6 +1080,15 @@ export default class LLMService {
       );
     }
 
+    /*
+     * On Azure the model field is the DEPLOYMENT NAME the operator chose —
+     * not a model id. Keep the long-standing "gpt-4o" guess for tenants who
+     * left it blank: existing deployments named after the old default keep
+     * working, and Azure deployment names cannot contain dots, so a
+     * "gpt-5.1"-style id would never match a real deployment. The
+     * error-driven parameter adaptation corrects token-param mismatches
+     * either way.
+     */
     const modelName: string = config.modelName || "gpt-4o";
     const requestUrl: string = LLMService.buildAzureOpenAIChatCompletionsUrl(
       config.baseUrl,
@@ -1198,7 +1238,11 @@ export default class LLMService {
     }
 
     const baseUrl: string = config.baseUrl || "https://api.anthropic.com/v1";
-    const modelName: string = config.modelName || "claude-sonnet-4-20250514";
+    /*
+     * Current Sonnet alias. The dated claude-sonnet-4-20250514 ID this used to
+     * default to is deprecated and retires in June 2026.
+     */
+    const modelName: string = config.modelName || "claude-sonnet-5";
 
     let systemMessage: string = "";
 
@@ -1321,10 +1365,25 @@ export default class LLMService {
 
     const usage: JSONObject = jsonData["usage"] as JSONObject;
 
+    /*
+     * Anthropic reports truncation as stop_reason "max_tokens" — surface it as
+     * "length" so callers never present a cut-off answer as complete.
+     */
+    const anthropicStopReason: string =
+      (jsonData["stop_reason"] as string) || "";
+
+    let stopReason: "stop" | "tool_use" | "length" = "stop";
+
+    if (anthropicStopReason === "tool_use") {
+      stopReason = "tool_use";
+    } else if (anthropicStopReason === "max_tokens") {
+      stopReason = "length";
+    }
+
     return {
       content: textContent,
       toolCalls: toolCalls.length > 0 ? toolCalls : undefined,
-      stopReason: jsonData["stop_reason"] === "tool_use" ? "tool_use" : "stop",
+      stopReason: stopReason,
       usage: usage
         ? {
             promptTokens: (usage["input_tokens"] as number) || 0,
@@ -1362,7 +1421,8 @@ export default class LLMService {
       throw new BadDataException("Ollama base URL is required");
     }
 
-    const modelName: string = config.modelName || "llama2";
+    // llama2 predates tool calling entirely; llama3.1 is the oldest sane default.
+    const modelName: string = config.modelName || "llama3.1";
 
     const requestData: JSONObject = {
       model: modelName,
@@ -1479,10 +1539,27 @@ export default class LLMService {
     const ollamaCompletionTokens: number =
       (jsonData["eval_count"] as number) || 0;
 
+    /*
+     * Ollama reports why generation ended in done_reason on the final
+     * /api/chat response: "length" when num_predict cut the output off
+     * ("limit" is accepted too for wire-compat variants). Truncation takes
+     * precedence over the tool-call heuristic — a cut-off tool call must not
+     * be executed.
+     */
+    const doneReason: string = (jsonData["done_reason"] as string) || "";
+
+    let stopReason: "stop" | "tool_use" | "length" = "stop";
+
+    if (doneReason === "length" || doneReason === "limit") {
+      stopReason = "length";
+    } else if (toolCalls && toolCalls.length > 0) {
+      stopReason = "tool_use";
+    }
+
     return {
       content: (message["content"] as string) || "",
       toolCalls: toolCalls,
-      stopReason: toolCalls && toolCalls.length > 0 ? "tool_use" : "stop",
+      stopReason: stopReason,
       usage:
         ollamaPromptTokens || ollamaCompletionTokens
           ? {

package/Server/Utils/Monitor/MonitorCriteriaEvaluator.ts

@@ -51,6 +51,13 @@ import Dictionary from "../../../Types/Dictionary";
 import InBetween from "../../../Types/BaseDatabase/InBetween";
 import MetricQueryConfigData from "../../../Types/Metrics/MetricQueryConfigData";
 import MetricExplorerUrl from "../../../Utils/Metrics/MetricExplorerUrl";
+import {
+  CrossSignalQueryParams,
+  TelemetryCrossSignalScope,
+  toLogsExplorerQueryParams,
+  toTracesExplorerQueryParams,
+} from "../../../Utils/Telemetry/CrossSignalScope";
+import ObjectID from "../../../Types/ObjectID";
 import Typeof from "../../../Types/Typeof";
 import ReturnResult from "../../../Types/IsolatedVM/ReturnResult";
 import URL from "../../../Types/API/URL";
@@ -81,6 +88,16 @@ import MonitorStepProxmoxMonitor from "../../../Types/Monitor/MonitorStepProxmox
 import MonitorStepCephMonitor from "../../../Types/Monitor/MonitorStepCephMonitor";
 import MonitorStepDockerSwarmMonitor from "../../../Types/Monitor/MonitorStepDockerSwarmMonitor";
 
+/**
+ * A cross-signal deep link into a telemetry explorer, plus the scope
+ * fields that could not be carried into that explorer's URL grammar
+ * (so consumers can render a "scope partially carried" hint).
+ */
+export interface TelemetryExplorerDeepLink {
+  url: string;
+  dropped: Array<string>;
+}
+
 export default class MonitorCriteriaEvaluator {
   public static async processMonitorStep(input: {
     dataToProcess: DataToProcess;
@@ -924,6 +941,7 @@ ${contextBlock}
       return MonitorCriteriaEvaluator.buildMetricRootCauseContext({
         criteriaInstance: input.criteriaInstance,
         monitor: input.monitor,
+        monitorStep: input.monitorStep,
       });
     }
 
@@ -1038,6 +1056,7 @@ ${contextBlock}
   private static buildMetricRootCauseContext(input: {
     criteriaInstance: MonitorCriteriaInstance;
     monitor: Monitor;
+    monitorStep?: MonitorStep | undefined;
   }): string | null {
     /*
      * Pick the first populated metric context across the instance's filters.
@@ -1147,6 +1166,42 @@ ${contextBlock}
       sections.push(`\n\n[Open metric in dashboard](${deepLink})`);
     }
 
+    /*
+     * Sibling deep links: the same breach window (and, where derivable,
+     * the monitor's service/attribute scope) carried over to the Logs and
+     * Traces explorers, so the on-call engineer can pivot signals without
+     * rebuilding the filter set by hand.
+     */
+    const logsLink: TelemetryExplorerDeepLink | null =
+      MonitorCriteriaEvaluator.buildLogsExplorerDeepLink({
+        monitor: input.monitor,
+        ctx,
+        monitorStep: input.monitorStep,
+      });
+
+    if (logsLink) {
+      sections.push(
+        `\n\n[Open logs in dashboard](${logsLink.url})${MonitorCriteriaEvaluator.formatScopeDroppedHint(
+          logsLink.dropped,
+        )}`,
+      );
+    }
+
+    const tracesLink: TelemetryExplorerDeepLink | null =
+      MonitorCriteriaEvaluator.buildTracesExplorerDeepLink({
+        monitor: input.monitor,
+        ctx,
+        monitorStep: input.monitorStep,
+      });
+
+    if (tracesLink) {
+      sections.push(
+        `\n\n[Open traces in dashboard](${tracesLink.url})${MonitorCriteriaEvaluator.formatScopeDroppedHint(
+          tracesLink.dropped,
+        )}`,
+      );
+    }
+
     return sections.join("\n");
   }
 
@@ -1353,21 +1408,17 @@ ${contextBlock}
       },
     };
 
-    // Time window: breach moment +- 15 minutes (or fall back to last hour).
-    const now: Date = OneUptimeDate.getCurrentDate();
-    const breachTime: Date | undefined = input.ctx.breachingSample?.timestamp;
-    const startTime: Date = breachTime
-      ? OneUptimeDate.addRemoveMinutes(breachTime, -30)
-      : OneUptimeDate.addRemoveHours(now, -1);
-    const endTime: Date = breachTime
-      ? OneUptimeDate.addRemoveMinutes(breachTime, 15)
-      : now;
+    const breachWindow: { startTime: Date; endTime: Date } =
+      MonitorCriteriaEvaluator.getMetricBreachExplorerWindow(input.ctx);
 
     const urlParams: Dictionary<string> =
       MetricExplorerUrl.buildQueryParamsFromMetricViewData({
         queryConfigs: [queryConfig],
         formulaConfigs: [],
-        startAndEndDate: new InBetween(startTime, endTime),
+        startAndEndDate: new InBetween(
+          breachWindow.startTime,
+          breachWindow.endTime,
+        ),
       });
 
     const params: URLSearchParams = new URLSearchParams();
@@ -1383,6 +1434,149 @@ ${contextBlock}
     return `${DashboardClientUrl.toString()}/${projectId}/metrics/view?${params.toString()}`;
   }
 
+  // Time window: breach moment +- 15 minutes (or fall back to last hour).
+  private static getMetricBreachExplorerWindow(ctx: MetricCriteriaContext): {
+    startTime: Date;
+    endTime: Date;
+  } {
+    const now: Date = OneUptimeDate.getCurrentDate();
+    const breachTime: Date | undefined = ctx.breachingSample?.timestamp;
+    const startTime: Date = breachTime
+      ? OneUptimeDate.addRemoveMinutes(breachTime, -30)
+      : OneUptimeDate.addRemoveHours(now, -1);
+    const endTime: Date = breachTime
+      ? OneUptimeDate.addRemoveMinutes(breachTime, 15)
+      : now;
+
+    return { startTime, endTime };
+  }
+
+  /*
+   * The slice of telemetry a metric breach describes, in cross-signal
+   * terms: the breach window, the criteria's metric attribute filters
+   * (overlaid with the per-series labels when per-series alerting
+   * identified a specific series), and the monitor step's telemetry
+   * service scope when one is configured.
+   */
+  private static buildMetricBreachTelemetryScope(input: {
+    ctx: MetricCriteriaContext;
+    monitorStep?: MonitorStep | undefined;
+  }): TelemetryCrossSignalScope {
+    const breachWindow: { startTime: Date; endTime: Date } =
+      MonitorCriteriaEvaluator.getMetricBreachExplorerWindow(input.ctx);
+
+    const attributes: Dictionary<string> = {};
+
+    const attributeSources: Array<JSONObject> = [
+      input.ctx.filterAttributes || {},
+      input.ctx.seriesLabels || {},
+    ];
+
+    for (const source of attributeSources) {
+      for (const key of Object.keys(source)) {
+        const value: unknown = source[key];
+
+        if (
+          typeof value === "string" ||
+          typeof value === "number" ||
+          typeof value === "boolean"
+        ) {
+          attributes[key] = String(value);
+        }
+      }
+    }
+
+    const serviceIds: Array<string> = (
+      input.monitorStep?.data?.metricMonitor?.telemetryServiceIds || []
+    ).map((serviceId: ObjectID): string => {
+      return serviceId.toString();
+    });
+
+    return {
+      ...(serviceIds.length > 0 ? { serviceIds } : {}),
+      ...(Object.keys(attributes).length > 0 ? { attributes } : {}),
+      startTime: breachWindow.startTime,
+      endTime: breachWindow.endTime,
+    };
+  }
+
+  private static buildLogsExplorerDeepLink(input: {
+    monitor: Monitor;
+    ctx: MetricCriteriaContext;
+    monitorStep?: MonitorStep | undefined;
+  }): TelemetryExplorerDeepLink | null {
+    const projectId: string | undefined = input.monitor.projectId?.toString();
+
+    if (!projectId) {
+      return null;
+    }
+
+    const scope: TelemetryCrossSignalScope =
+      MonitorCriteriaEvaluator.buildMetricBreachTelemetryScope({
+        ctx: input.ctx,
+        monitorStep: input.monitorStep,
+      });
+
+    /*
+     * The URL schema is owned by CrossSignalScope — the same grammar the
+     * logs explorer parses — so this link cannot drift from what the
+     * explorer restores.
+     */
+    const queryParams: CrossSignalQueryParams =
+      toLogsExplorerQueryParams(scope);
+
+    const params: URLSearchParams = new URLSearchParams();
+
+    for (const paramName in queryParams.params) {
+      params.set(paramName, queryParams.params[paramName] as string);
+    }
+
+    return {
+      url: `${DashboardClientUrl.toString()}/${projectId}/logs?${params.toString()}`,
+      dropped: queryParams.dropped,
+    };
+  }
+
+  private static buildTracesExplorerDeepLink(input: {
+    monitor: Monitor;
+    ctx: MetricCriteriaContext;
+    monitorStep?: MonitorStep | undefined;
+  }): TelemetryExplorerDeepLink | null {
+    const projectId: string | undefined = input.monitor.projectId?.toString();
+
+    if (!projectId) {
+      return null;
+    }
+
+    const scope: TelemetryCrossSignalScope =
+      MonitorCriteriaEvaluator.buildMetricBreachTelemetryScope({
+        ctx: input.ctx,
+        monitorStep: input.monitorStep,
+      });
+
+    const queryParams: CrossSignalQueryParams =
+      toTracesExplorerQueryParams(scope);
+
+    const params: URLSearchParams = new URLSearchParams();
+
+    for (const paramName in queryParams.params) {
+      params.set(paramName, queryParams.params[paramName] as string);
+    }
+
+    return {
+      url: `${DashboardClientUrl.toString()}/${projectId}/traces?${params.toString()}`,
+      dropped: queryParams.dropped,
+    };
+  }
+
+  private static formatScopeDroppedHint(dropped: Array<string>): string {
+    if (dropped.length === 0) {
+      return "";
+    }
+
+    return ` _(scope partially carried — not applied: ${dropped.join(", ")})_`;
+  }
+
   private static async buildKubernetesRootCauseContext(input: {
     dataToProcess: DataToProcess;
     monitorStep: MonitorStep;

package/Server/Utils/SSRFProtection.ts

@@ -126,10 +126,12 @@ export default class SSRFProtection {
     }
 
     /*
-     * OneUptime's URL parser keeps the port glued to the host (e.g.
-     * "169.254.169.254:80"). Strip it before the checks below, otherwise a
-     * literal-with-port slips past the IPv4 blocklist and, because it contains
-     * a ":", is mistaken for an IP literal and skips DNS resolution entirely.
+     * OneUptime's URL parser hands back the whole authority — userinfo, host
+     * and port glued together ("user:pw@169.254.169.254:80"). Reduce it to the
+     * bare host before the checks below: a literal-with-port otherwise slips
+     * past the IPv4 blocklist and, because it contains a ":", is mistaken for
+     * an IP literal and skips DNS resolution entirely, and userinfo otherwise
+     * gets to nominate the host outright.
      */
     const hostname: string = SSRFProtection.extractHost(rawHost);
 
@@ -137,16 +139,41 @@ export default class SSRFProtection {
       throw new BadDataException("Webhook URL must include a host.");
     }
 
-    if (SSRFProtection.isBlockedHostnameLiteral(hostname)) {
-      throw new BadDataException(
-        "Webhook URL points to a private, loopback, or link-local address and is not allowed.",
-      );
+    /*
+     * Check the host BOTH parsers see, not just ours.
+     *
+     * A guard is only worth something if it reasons about the host the HTTP
+     * client will actually dial, and OneUptime's parser and WHATWG do not
+     * always agree on which substring that is — userinfo was one such
+     * disagreement, and treating it as the only one would be optimistic. So
+     * whenever the two answers differ, both are held to the blocklist and a
+     * verdict of "internal" from either one is enough to refuse. A legitimate
+     * public URL parses to a public host under both, and pays only a string
+     * comparison for the privilege.
+     */
+    const whatwgHostname: string = SSRFProtection.getBareHostname(rawUrl);
+
+    const hostnames: Array<string> =
+      whatwgHostname && whatwgHostname !== hostname
+        ? [hostname, whatwgHostname]
+        : [hostname];
+
+    for (const host of hostnames) {
+      if (SSRFProtection.isBlockedHostnameLiteral(host)) {
+        throw new BadDataException(
+          "Webhook URL points to a private, loopback, or link-local address and is not allowed.",
+        );
+      }
     }
 
-    if (!SSRFProtection.isIpLiteral(hostname)) {
+    for (const host of hostnames) {
+      if (SSRFProtection.isIpLiteral(host)) {
+        continue;
+      }
+
       let resolved: Array<{ address: string }> = [];
       try {
-        resolved = await dns.promises.lookup(hostname, { all: true });
+        resolved = await dns.promises.lookup(host, { all: true });
       } catch {
         throw new BadDataException(
           "Webhook URL hostname could not be resolved via DNS.",
@@ -166,12 +193,34 @@ export default class SSRFProtection {
   }
 
   /*
-   * Extracts the bare host (IPv4, IPv6, or hostname) from a "host[:port]"
-   * string, handling bracketed IPv6 (`[::1]`, `[::1]:8080`) and unbracketed
-   * IPv6 literals (which contain multiple colons and carry no port).
+   * Everything up to and including the LAST "@" is userinfo, never the host.
+   *
+   * This matters because OneUptime's Hostname deliberately KEEPS userinfo in
+   * the string it stores, and a "host:port" split over that string reads the
+   * USERNAME as the host: "example.com:pass@169.254.169.254" holds exactly one
+   * colon, so splitting on it answers "example.com" — which resolves publicly
+   * and sails through the blocklist — while every RFC 3986 client (axios, and
+   * WHATWG before it) dials 169.254.169.254.
+   *
+   * The LAST "@" is the delimiter, which is how WHATWG resolves an authority
+   * carrying more than one and therefore where the HTTP client will split it.
+   * Hostname's own validation happens to reject a second "@" before this runs,
+   * so the choice only shows up on hosts reaching us by another route — but
+   * splitting on the first "@" would be a bypass the day that changes.
+   */
+  private static stripUserInfo(authority: string): string {
+    const atIndex: number = authority.lastIndexOf("@");
+    return atIndex === -1 ? authority : authority.substring(atIndex + 1);
+  }
+
+  /*
+   * Extracts the bare host (IPv4, IPv6, or hostname) from a
+   * "[userinfo@]host[:port]" string, handling bracketed IPv6 (`[::1]`,
+   * `[::1]:8080`) and unbracketed IPv6 literals (which contain multiple colons
+   * and carry no port).
    */
   private static extractHost(hostWithPort: string): string {
-    const host: string = hostWithPort.trim();
+    const host: string = SSRFProtection.stripUserInfo(hostWithPort.trim());
 
     if (host.startsWith("[")) {
       const closingBracketIndex: number = host.indexOf("]");
@@ -296,9 +345,9 @@ export default class SSRFProtection {
    * True when an IPv6 literal points somewhere the server must never be made
    * to reach. Ranges, not spellings: loopback, unspecified, link-local
    * (fe80::/10), unique-local (fc00::/7) and multicast (ff00::/8), plus the
-   * three ways IPv6 can carry an IPv4 destination - IPv4-mapped
-   * (::ffff:0:0/96), IPv4-compatible (::/96) and the NAT64 well-known prefix
-   * (64:ff9b::/96) - which are handed to the IPv4 blocklist.
+   * ways IPv6 can embed IPv4 routing endpoints - IPv4-mapped (::ffff:0:0/96),
+   * IPv4-compatible (::/96), NAT64 (64:ff9b::/96), 6to4 (2002::/16), and
+   * Teredo (2001:0000::/32) - which are handed to the IPv4 blocklist.
    */
   private static isBlockedIpv6(address: string): boolean {
     const groups: Array<number> | null = SSRFProtection.expandIpv6(address);
@@ -316,9 +365,19 @@ export default class SSRFProtection {
       });
     };
 
-    const embeddedIpv4: () => string = (): string => {
-      const high: number = groups[6] as number;
-      const low: number = groups[7] as number;
+    const embeddedIpv4: (highGroupIndex: number, invert?: boolean) => string = (
+      highGroupIndex: number,
+      invert: boolean = false,
+    ): string => {
+      let high: number = groups[highGroupIndex] as number;
+      let low: number = groups[highGroupIndex + 1] as number;
+
+      // Teredo conceals the client IPv4 address by flipping all 32 bits.
+      if (invert) {
+        high ^= 0xffff;
+        low ^= 0xffff;
+      }
+
       return `${high >> 8}.${high & 0xff}.${low >> 8}.${low & 0xff}`;
     };
 
@@ -334,7 +393,7 @@ export default class SSRFProtection {
 
     // ::ffff:0:0/96 — IPv4-mapped.
     if (isZeroThrough(5) && groups[5] === 0xffff) {
-      return SSRFProtection.isBlockedIpv4(embeddedIpv4());
+      return SSRFProtection.isBlockedIpv4(embeddedIpv4(6));
     }
 
     // 64:ff9b::/96 — NAT64 well-known prefix.
@@ -346,12 +405,28 @@ export default class SSRFProtection {
       groups[4] === 0 &&
       groups[5] === 0
     ) {
-      return SSRFProtection.isBlockedIpv4(embeddedIpv4());
+      return SSRFProtection.isBlockedIpv4(embeddedIpv4(6));
     }
 
     // ::/96 — IPv4-compatible (deprecated, still routable by some stacks).
     if (isZeroThrough(6)) {
-      return SSRFProtection.isBlockedIpv4(embeddedIpv4());
+      return SSRFProtection.isBlockedIpv4(embeddedIpv4(6));
+    }
+
+    // 2002::/16 — 6to4 stores the IPv4 gateway in bits 16-48.
+    if (groups[0] === 0x2002) {
+      return SSRFProtection.isBlockedIpv4(embeddedIpv4(1));
+    }
+
+    /*
+     * 2001:0000::/32 — Teredo stores its server IPv4 in bits 32-64 and
+     * an inverted client IPv4 in the last 32 bits.
+     */
+    if (groups[0] === 0x2001 && groups[1] === 0) {
+      return (
+        SSRFProtection.isBlockedIpv4(embeddedIpv4(2)) ||
+        SSRFProtection.isBlockedIpv4(embeddedIpv4(6, true))
+      );
     }
 
     const first: number = groups[0] as number;

package/Server/Utils/StartServer.ts

@@ -4,6 +4,7 @@ import { StatusAPIOptions } from "../API/StatusAPI";
 import {
   AppVersion,
   IsBillingEnabled,
+  TrustedProxyHops,
   getFrontendEnvVars,
 } from "../EnvironmentConfig";
 import LocalCache from "../Infrastructure/LocalCache";
@@ -61,10 +62,18 @@ app.disable("x-powered-by");
 app.set("port", process.env["PORT"]);
 app.set("view engine", "ejs");
 /*
- * Enable trust proxy to correctly interpret X-Forwarded-* headers from reverse proxies
- * This is needed for req.protocol, req.ip to be correct when behind nginx/load balancers
+ * Trust exactly the proxies we run, and no more, so req.protocol and req.ip
+ * are correct behind our Nginx gateway.
+ *
+ * This was `true`, meaning "trust every hop". Under that setting Express
+ * resolves req.ip to the LEFTMOST X-Forwarded-For entry -- the end of the
+ * header the caller writes -- so req.ip was whatever the caller said it was.
+ * A number instead means "the nth hop in from the right is the client", which
+ * is the entry one of our own proxies wrote. Express's numeric semantics and
+ * resolveClientIp's hop counting are the same count, so req.ip and
+ * getClientIp() agree.
  */
-app.set("trust proxy", true);
+app.set("trust proxy", TrustedProxyHops);
 app.use(CookieParser());
 
 const jsonBodyParserMiddleware: RequestHandler = ExpressJson({