/

CVE-2026-24779

Severity:

HIGH RISK

(7.1)

SSRF in vLLM MediaConnector Host Validation

CVE-2026-24779

Modified

Vulnerability type

Category:

Server-Side Request Forgery (SSRF)

CWE:

CWE-918

Impact:

Unauthorized access to internal network resources via SSRF

Severity:

HIGH RISK

(7.1)

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

A Server-Side Request Forgery (SSRF) flaw in vLLM's multimodal MediaConnector allows attackers to bypass host restrictions when loading media from user-provided URLs.

Due to inconsistent URL parsing between two Python libraries, an attacker can coerce the vLLM server into issuing arbitrary HTTP requests to internal services, which is especially dangerous in containerized deployments that expose internal management or data endpoints.

Affected context

The vulnerability affects vLLM deployments that:

  • Enable multimodal features using the MediaConnector class, and
  • Accept user-controlled URLs in load_from_url or load_from_url_async, and
  • Rely on host-based restrictions to prevent access to internal or sensitive endpoints.

It is particularly relevant in containerized or orchestrated environments (e.g., llm-d pods in a Kubernetes cluster) where the vLLM pod has network visibility into internal services, management APIs, or other workloads that are not directly exposed to the public internet.

Exploit preconditions

  • Attack surface: HTTP(S) or API endpoints that accept user-controlled URLs for media loading through vLLM's multimodal APIs.
  • Required access: Ability to submit or influence URL parameters processed by MediaConnector.load_from_url or load_from_url_async (e.g., via an API client, integration, or upstream application).
  • Trigger point: Invocation of the MediaConnector methods that:
  • Parse the supplied URL, and
  • Apply host restrictions using one parser while the actual request or validation uses another, allowing inconsistent interpretation of the URL.
  • Why exploitation is possible: Two different Python parsing libraries interpret backslashes in URLs differently. The host validation step and the actual request target can diverge, enabling a crafted URL to:
  • Pass the host restriction checks, yet
  • Be resolved by the HTTP client to an attacker-chosen internal host or endpoint.

Why this happens

The core issue is improper enforcement of network access controls when fetching external resources, aligning with CWE-918: Server-Side Request Forgery (SSRF).

At an implementation level, the MediaConnector class relies on URL parsing for host validation, but mixes different Python parsing libraries that each treat backslashes and other URL components differently. Host restrictions are checked against one interpretation of the URL, while the actual request may be formed using another interpretation, breaking the assumption that validation and use share the same canonical representation.

Conceptually, this is an inconsistent normalization and validation bug: security decisions (which hosts are allowed) are made on a differently-parsed version of the input than the one used for the network request. This enables attackers to craft specially formatted URLs that circumvent intended host allowlists and cause the server to initiate arbitrary outbound connections.

Potential impact

  • vLLM server may issue arbitrary HTTP requests to internal network services that are not directly internet-accessible.
  • Attackers could scan internal IP ranges or service endpoints reachable from the vLLM pod.
  • Internal management APIs (such as llm-d control or metrics endpoints) may be abused to:
  • Report false telemetry (e.g., KV cache state),
  • Destabilize scheduling or resource allocation,
  • Trigger unexpected administrative actions.
  • Access to internal-only APIs or databases could lead to exposure of sensitive data, configuration, or secrets.
  • Misuse of internal endpoints might contribute to denial of service against other pods or shared infrastructure.

General mitigation guidance

Addressing SSRF in this context typically involves tightening URL validation, minimizing outbound network trust, and segregating network privileges rather than relying on ad hoc checks.

Recommended defensive patterns include:

  • Single, canonical URL parsing: Use one well-defined parsing library for both validation and request construction. Ensure that host, scheme, and port are derived from a single canonical representation, with consistent treatment of backslashes and other delimiters.
  • Strict host and scheme allowlists: Instead of trying to block internal hosts, define a narrow set of allowed domains and schemes (e.g., https only, specific CDN or asset domains) for media loading.
  • Prohibit ambiguous URLs: Reject URLs containing backslashes, mixed encodings, unusual schemes, embedded credentials, or other suspicious patterns that complicate parsing and validation.
  • Network-level egress controls: Configure the runtime environment (e.g., Kubernetes NetworkPolicies, service mesh rules, firewall rules) so that the vLLM pod can only reach explicitly-approved external destinations needed for normal operation.
  • Least-privilege pod design: Limit the vLLM container's network visibility and avoid co-locating sensitive management endpoints on addresses directly reachable from inference pods.
  • Safe defaults in APIs: Prefer design choices where multimodal URL fetching is disabled or highly restricted by default and must be consciously enabled with explicit security configuration.

How teams detect issues like this

Effective detection combines code-centric and environment-centric approaches:

  • Static analysis and code review:
  • Flag code paths that accept user-controlled URLs and initiate outbound HTTP requests.
  • Look for multiple URL parsing libraries in the same validation/request flow, especially when host checks are performed separately from actual network calls.
  • Review for ad hoc host-based "blocklists" or "internal IP" checks that are not backed by canonical parsing or robust normalization.
  • Automated security testing:
  • Incorporate SSRF test cases into API security testing, using crafted URLs with backslashes, mixed schemes, encoded characters, and internal hostnames/IPs to probe for bypasses.
  • Use fuzzers or security scanners that specialize in SSRF to exercise multimodal endpoints.
  • Runtime monitoring:
  • Monitor outbound traffic from vLLM pods using network telemetry or service mesh observability.
  • Define alerts for unexpected egress patterns, such as connections to non-approved domains, internal IP ranges, or management endpoints.
  • Policy enforcement:
  • Apply cluster-wide policies (e.g., admission controllers, network policies) that restrict what destinations workloads like vLLM can contact, reducing impact even if SSRF-like behavior appears in code.

Sources

SourceLink
github.comgithub.com/vllm-project/vllm/commit/f46d576c54fb8aeec5fc70560e850bed38ef17d7
github.comgithub.com/vllm-project/vllm/pull/32746
github.comgithub.com/vllm-project/vllm/security/advisories/GHSA-qh4c-xf7m-gxfc
access.redhat.comaccess.redhat.com/errata/RHSA-2026:10184
access.redhat.comaccess.redhat.com/errata/RHSA-2026:19712
access.redhat.comaccess.redhat.com/errata/RHSA-2026:30087
access.redhat.comaccess.redhat.com/errata/RHSA-2026:30088
access.redhat.comaccess.redhat.com/errata/RHSA-2026:30089
access.redhat.comaccess.redhat.com/errata/RHSA-2026:3461
access.redhat.comaccess.redhat.com/errata/RHSA-2026:3462
access.redhat.comaccess.redhat.com/errata/RHSA-2026:3782
access.redhat.comaccess.redhat.com/errata/RHSA-2026:42644
access.redhat.comaccess.redhat.com/security/cve/CVE-2026-24779
bugzilla.redhat.combugzilla.redhat.com/show_bug.cgi?id=2433624
security.access.redhat.comsecurity.access.redhat.com/data/csaf/v2/vex/2026/cve-2026-24779.json

Frequently asked

questions

Exploitability depends on exposure of the multimodal endpoints that accept user-provided URLs. In many deployments, these endpoints are reachable by untrusted clients (e.g., external applications, API consumers), which makes the issue broadly exploitable whenever users can supply arbitrary URLs to vLLM.

Not necessarily. If the vLLM API or any upstream service allows untrusted users to submit URLs to MediaConnector, an attacker only needs that level of access. The SSRF effect then allows them to leverage the vLLM pod's internal network position, even if they themselves have no direct access to those internal resources.

The most robust pattern is to enforce a strict allowlist of permitted destinations and schemes, combined with a single canonical URL parsing routine that is used consistently for both validation and the outbound request. Complementary controls at the network layer should prevent the pod from reaching internal or sensitive endpoints that are not explicitly required.

Treat any feature that fetches data from user-supplied URLs as high risk, and design it with:

  • Canonical, centralized URL normalization and validation,
  • Tight destination allowlists instead of broad "deny internal" logic,
  • Separation of concerns between public-facing inference components and internal management services,
  • Network egress restrictions and continuous monitoring for anomalous outbound requests.
Find out what's already
exploitable in your codebase.