Severity:

CRITICAL RISK

(9.9)

Server-Side Request Forgery (CWE-918) in FlowIntel External Reference URL Probe

CVE-2026-9813

Analyzed

Vulnerability type

Category:

Server-Side Request Forgery (SSRF)

CWE:

CWE-918

Impact:

Internal Network Access and Potential Metadata/Service Compromise

Severity:

CRITICAL RISK

(9.9)

CVSS version:

3.1

Catch this CVE while code is being written

Detect vulnerable code directly in pull requests, so CVEs are fixed before merge.

Summary

FlowIntel up to version 3.3.0 contains a server-side request forgery (SSRF) flaw in the external reference URL probe feature that lets attackers direct the application server to send HTTP HEAD requests to arbitrary destinations.

When an attacker can supply or control the external reference URL, insufficient validation of URL schemes and resolved IP addresses may allow access to loopback, link-local, private, reserved, or other restricted network resources, including internal services and cloud metadata endpoints.

Affected context

This vulnerability exists in FlowIntel deployments where:

  • Users can create or modify cases/tasks that include an "external reference URL" field.
  • The server automatically performs an HTTP HEAD probe to the supplied URL from its own network context.
  • URL and DNS resolution checks do not sufficiently block internal, loopback, link-local, or reserved address ranges.

The risk is greatest when the FlowIntel server has access to sensitive internal services, instance metadata endpoints, or management interfaces that are not otherwise exposed externally.

Exploit preconditions

  • Attack surface: Application HTTP interface(s) that accept or process external reference URLs (e.g., case/task creation or update endpoints).
  • Required access: Ability to submit or influence the external reference URL parameter (via authenticated user roles, integrations, or any exposed API).
  • Trigger point: The backend logic that performs an HTTP HEAD request to the provided URL as part of probing or validation.
  • Why exploitation is possible:
  • URL scheme validation is incomplete, allowing HTTP(S) requests to unintended targets.
  • Destination validation relies on insufficient checks, failing to block IPs in loopback (127.0.0.0/8, ::1), link-local, private (RFC1918), or other reserved ranges.
  • DNS-based hostnames that resolve to internal IPs are not properly rejected, enabling SSRF via DNS rebinding or internal hostnames.

Why this happens

The core issue aligns with CWE-918: Server-Side Request Forgery (SSRF), where server-side HTTP logic trusts attacker-controlled URLs without enforcing strict outbound access controls.

In this case, the URL probe feature in app/case/task.py performs HTTP HEAD requests based on user-supplied input:

  • It accepts arbitrary URLs and relies on weak or incomplete validation of scheme and destination.
  • It does not robustly restrict which IP ranges or hostnames the server can contact.

Conceptually, this is an insecure pattern where a backend component acts as a proxy to arbitrary network endpoints, using its privileged network position and exposing internal network surfaces that were never intended to be directly reachable by users.

Potential impact

  • Access to internal web services that are otherwise not exposed externally.
  • Interaction with cloud instance metadata endpoints, which could lead to disclosure of credentials, tokens, or configuration data.
  • Port scanning and service discovery on internal or management networks from the server's vantage point.
  • Potential pivot into sensitive administrative interfaces (e.g., database consoles, internal dashboards, message queues) if they speak HTTP or HTTP-like protocols.
  • Abuse of internal APIs to modify configuration, exfiltrate data, or trigger additional vulnerabilities (e.g., chained with deserialization or injection flaws).
  • Circumvention of network segmentation controls by using the application server as a trusted relay.

General mitigation guidance

Effective mitigation focuses on constraining outbound requests and treating user-supplied URLs as untrusted:

  • Harden URL validation:
  • Restrict allowed schemes to a minimal, expected set (e.g., https only where possible).
  • Enforce strict, canonical hostname and path patterns if the feature is meant to talk only to specific domains.
  • Enforce network-level egress controls:
  • Use firewall rules, security groups, or service mesh policies to prevent the application server from contacting loopback, link-local, private, or metadata address ranges.
  • Prefer a default-deny egress policy, explicitly permitting only known-safe destinations.
  • Perform robust destination checks:
  • Resolve hostnames and validate the resulting IPs against allow/deny lists before making any outbound request.
  • Re-validate after DNS resolution to guard against DNS rebinding, and treat multiple A/AAAA records conservatively.
  • Isolate the probing component:
  • Run URL probing logic in a sandboxed service or worker with minimal network permissions instead of from the main application server.
  • Apply least-privilege network and system permissions so that even if SSRF occurs, reachable assets are substantially limited.
  • Reduce reliance on dynamic external probes:
  • Where feasible, avoid automatic server-side fetching of arbitrary URLs and consider alternative designs (e.g., client-side checks, curated allowlists).

How teams detect issues like this

Detection typically combines code-centric review and runtime monitoring:

  • Static analysis and code review:
  • Search for HTTP client usage (e.g., requests, urllib, or framework-specific HTTP clients) that consume request parameters or form fields as URLs.
  • Flag patterns where user-controlled strings are passed directly into outbound HTTP calls without allowlist or network checks.
  • Review URL validation utilities to ensure they include IP range checks, scheme restrictions, and safe DNS resolution behavior.
  • Security testing and fuzzing:
  • Perform targeted SSRF tests in staging environments using internal and metadata endpoint patterns (e.g., loopback and RFC1918 addresses).
  • Use DAST tools or custom scripts to attempt accessing known-blocked IP ranges via user-supplied URL fields.
  • Operational monitoring:
  • Monitor outbound HTTP traffic from application servers for unexpected destinations, especially to local/metadata addresses or non-business domains.
  • Implement network-level logging (e.g., flow logs) and configure alerts for requests to restricted IP ranges.
  • Policy enforcement in CI/CD:
  • Integrate automated checks to block new code that introduces generic URL fetchers without appropriate validation and egress constraints.
  • Use security linters or SAST tools configured with SSRF-specific rules.

Sources

SourceLink
github.comgithub.com/flowintel/flowintel/commit/68b523b47854c54bf36fd706c0fd5353063b5409

Frequently asked

questions

Yes. If an attacker can remotely supply or influence the external reference URL field (for example via a web form or API), they can trigger the server to make HTTP requests to attacker-chosen destinations. The extent of impact depends on what internal resources the server can reach.

It depends on how the external reference URL feature is exposed. In many deployments, a valid user account or integration may be required to create or update cases/tasks. Any role or integration that can control this URL is in a position to attempt SSRF.

The most robust approach is to avoid allowing arbitrary outbound requests altogether. Constrain the probe to a strict allowlist of domains or disable generic URL probing where it is not essential. Combine this with network-level egress controls to block internal and metadata address ranges, and enforce strict scheme and IP validation before any request is sent.

Treat any URL or network target derived from user input as untrusted. Adopt a design where backend services do not act as open proxies: implement allowlists for outbound destinations, apply default-deny egress policies, validate resolved IPs against safe ranges, and include SSRF-specific checks in security reviews, coding standards, and automated analysis tools.

Find out what's already
exploitable in your codebase.