/

CVE-2026-25960

Severity:

HIGH RISK

(7.1)

SSRF in vLLM load_from_url_async

CVE-2026-25960

Modified

Vulnerability type

Category:

Server-Side Request Forgery (SSRF)

CWE:

CWE-918, CWE-474

Impact:

Unauthorized backend network access via forged server-side HTTP requests

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) vulnerability in vLLM allows attackers to bypass previously added network access controls by exploiting inconsistent URL parsing between the validation layer and the HTTP client.

By crafting specially formatted URLs, an attacker can trick vLLM's load_from_url_async method into making unauthorized backend requests despite hostname checks, potentially reaching internal services or metadata endpoints.

Affected context

This vulnerability affects deployments of vLLM that:

  • Expose functionality allowing users to supply arbitrary or semi-arbitrary URLs to load data or models (e.g., load_from_url_async).
  • Rely on hostname validation based on urllib3.util.parse_url() for SSRF protection.
  • Perform the actual HTTP requests with aiohttp, which uses yarl for URL parsing.

The issue arises specifically when URL validation and request execution use different parsing logic, creating discrepancies that an attacker can abuse.

Exploit preconditions

  • Attack surface: Any vLLM feature or API endpoint that accepts user-controlled URLs and routes them to load_from_url_async.
  • Required access: Ability to submit or influence the URL parameter (e.g., via API calls, UI fields, configuration options, or plugin interfaces).
  • Trigger point: Invocation of load_from_url_async with a crafted URL that passes urllib3-based validation but is interpreted differently by aiohttp/yarl.
  • Why exploitation is possible: The validation logic and the HTTP client parse URLs differently. An attacker can construct edge-case URLs (using encodings, unusual schemes, or delimiter tricks) that appear safe to the validator but resolve to restricted targets when processed by aiohttp.

Why this happens

The underlying bug belongs to the class of inconsistent validation and enforcement issues, captured by CWE-918: Server-Side Request Forgery (SSRF).

Instead of validating and using a single, canonical URL representation throughout the entire request flow, vLLM validates user-supplied URLs with urllib3.util.parse_url() but delegates the actual HTTP request to aiohttp, which relies on yarl for parsing.

Because these two parsers do not handle all URL edge cases identically, the hostname and target extracted during validation can differ from the hostname and target used during request execution.

This mismatch breaks the assumption that hostname checks fully constrain the eventual network request, enabling forged requests to internal or otherwise restricted endpoints.

Potential impact

  • May allow access to internal network services that should not be directly reachable from external users.
  • Could be used to query cloud instance metadata endpoints, potentially disclosing credentials or configuration secrets.
  • Can enable port scanning or service discovery within the server's network environment.
  • Might allow interaction with internal admin panels or management APIs, depending on network topology and ACLs.
  • Could facilitate chained attacks where data retrieved via SSRF is used to further compromise infrastructure or exfiltrate sensitive information.

General mitigation guidance

Effective mitigation focuses on consistent URL handling, strict network egress controls, and defense-in-depth around URL-based features:

  • Use a single, authoritative URL parser for both validation and request execution, or derive the effective target (hostname, port, scheme) directly from the same parsed object that will be used by the HTTP client.
  • Perform allowlist-based hostname and scheme validation (e.g., only permit https and explicitly approved domains) rather than relying on deny lists of "bad" hosts.
  • Normalize and canonicalize URLs before validation to reduce ambiguity (e.g., resolve encodings, redundant delimiters, and edge-case constructs before applying checks).
  • Introduce network-layer egress restrictions (e.g., firewall rules, container network policies) so that the application process cannot freely connect to internal control planes or metadata services.
  • Treat user-supplied URLs as untrusted input and avoid granting them access to privileged credentials; prefer scoped, limited-privilege credentials for outbound HTTP requests when possible.

How teams detect issues like this

Organizations can detect and manage this class of SSRF risks by combining code-level and infrastructure-level approaches:

  • Static analysis and linters: Flag patterns where URL validation and HTTP request execution rely on different parsing libraries or code paths. Rules can specifically look for urllib3-based validation followed by aiohttp-based requests.
  • Code review practices: Require reviewers to verify that all URL-based features perform canonicalization and reuse the same parsed representation for both validation and enforcement. Look for manual string-based hostname checks that might be bypassed by encoding tricks.
  • Security testing and fuzzing: Use SSRF-focused test suites and URL fuzzers to generate edge-case URLs (with mixed encodings, userinfo components, IPv6 literals, and unusual schemes) and observe whether they bypass existing validation.
  • Network monitoring and policy enforcement: Configure outbound traffic controls (e.g., egress firewalls, Kubernetes NetworkPolicies, service mesh policies) and alert on unexpected HTTP requests to internal or metadata endpoints originating from vLLM services.
  • Automated review tools: Integrate SAST/DAST tools that include SSRF checks into CI/CD pipelines, ensuring regressions are caught when SSRF defenses are modified or expanded.

Sources

SourceLink
github.comgithub.com/vllm-project/vllm/commit/6f3b2047abd4a748e3db4a68543f8221358002c0
github.comgithub.com/vllm-project/vllm/pull/34743
github.comgithub.com/vllm-project/vllm/security/advisories/GHSA-qh4c-xf7m-gxfc
github.comgithub.com/vllm-project/vllm/security/advisories/GHSA-v359-jj2v-j536
access.redhat.comaccess.redhat.com/errata/RHSA-2026:24977
access.redhat.comaccess.redhat.com/errata/RHSA-2026:42644
access.redhat.comaccess.redhat.com/security/cve/CVE-2026-25960
bugzilla.redhat.combugzilla.redhat.com/show_bug.cgi?id=2445892
security.access.redhat.comsecurity.access.redhat.com/data/csaf/v2/vex/2026/cve-2026-25960.json

Frequently asked

questions

Yes, if a vLLM deployment exposes APIs or interfaces where remote users can provide URLs that are subsequently passed into load_from_url_async. In that case, an external attacker may be able to trigger SSRF without direct access to the internal network.

The attacker needs the ability to control or significantly influence the URL parameter used by vLLM, such as through an API endpoint, a configuration field, or an integration plugin. No direct shell or filesystem access on the server is required.

The safest approach is to make URL validation and request execution share the same canonical parsing logic, apply strict allowlist-based hostname and scheme checks, and ensure that the final request target is derived from that validated representation. Combining this with network egress restrictions provides robust protection.

Adopt a design pattern where:

  • All URL inputs are normalized and parsed once, using a single library.
  • The parsed result is the sole source of truth for both validation and HTTP client configuration.
  • SSRF protections are backed by network-level controls and regular security testing.

Embedding these checks into shared utilities and enforcing their use through code review and automated tooling helps prevent future inconsistencies.

Find out what's already
exploitable in your codebase.