Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessReach exposed vLLM completion endpoint
-
DeliverySend request with oversized tp_size in kv_transfer_params
-
Exploittp_size passes unvalidated into KV-transfer allocation
-
ExecutionUnbounded memory allocation exhausts host RAM
-
ImpactKernel OOM-kills decode worker (service DoS)
Vulnerability Assessment
| Weakness |
CWE
ASVS 5.0
V15 - Secure Coding and Architecture Memory allocation limits
|
| Exploitation Conditions | Requires the vLLM instance to be running in a prefill/decode (P/D) disaggregated deployment, where kv_transfer_params is honored on the OpenAI-compatible completion endpoints (/v1/completions, /v1/chat/completions). The attacker must be able to send requests to that endpoint (no authentication or user interaction is required per PR:N/UI:N), and supplies an arbitrary large tp_size (the fix rejects values ≤0, non-integers, and values above _MAX_KV_TRANSFER_TP_SIZE). What limits exploitation: standard single-node/non-disaggregated vLLM deployments that do not process kv_transfer_params are not affected, and endpoints that are network-restricted or gated behind an authenticating proxy reduce exposure; impact is limited to availability (decode-worker OOM-kill / service disruption), with no data disclosure or code execution. |
| Impact | The vendor-supplied CVSS 4.0 vector (AV:N/AC:L/AT:N/PR:N/UI:N/VC:N/VI:N/VA:H, score 8.7) describes a purely availability-impacting flaw reachable over the network without authentication or user interaction - confidentiality and integrity impacts are explicitly N. This is consistent with CWE-789 (memory allocation with excessive size value) and the description: an unvalidated tp_size drives unbounded allocation that OOM-kills the decode worker. The 'RCE' input tag is contradicted by every other signal - there is no code-execution, integrity, or confidentiality impact anywhere in the vector or description; this is a denial-of-service issue and the tag should be treated as mislabeled. No EPSS score, no CISA KEV entry, and no standalone exploit were provided; the referenced PR #51137 contains the fix plus validation unit tests but not a weaponized POC, so this is 'no public exploit identified at time of analysis.' The high CVSS score is driven by ease of the network-facing DoS, but real-world priority is materially narrowed because exploitation requires a prefill/decode disaggregated deployment (a non-default, advanced serving topology), so this is a high-CVSS/moderate-real-risk issue for most operators and a genuine availability concern only for the subset running P/D disaggregation with exposed completion endpoints. |
| Exploit ScenarioDerived | An attacker who can reach a vLLM OpenAI-compatible /v1/completions or /v1/chat/completions endpoint of a prefill/decode disaggregated deployment sends a normal-looking request whose kv_transfer_params includes an enormous tp_size (e.g. 20,000,000). vLLM fails to validate the value and attempts a correspondingly huge memory allocation, exhausting RAM and causing the kernel to OOM-kill the decode worker, taking down inference. No exploit code is public, but the fix PR's tests demonstrate the exact malicious payload, and the network-facing, unauthenticated, low-complexity nature makes it trivial to reproduce. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Sep 21, 2026
Memory exhaustion in vLLM through 0.29.0 lets remote, unauthenticated attackers crash the inference service by supplying an arbitrary 'tp_size' value inside the 'kv_transfer_params' field of requests to the OpenAI-compatible completion endpoints. Because kv_transfer_params is honored only when the server runs in a prefill/decode (P/D) disaggregated deployment using the NIXL KV-transfer connector, the attacker causes unbounded memory allocation in the decode worker that ends in a kernel OOM-kill and full loss of service availability; confidentiality and integrity are unaffected. No public exploit code was identified at time of analysis and there is no CISA KEV listing, but the flaw is trivially reachable over the network (CVSS 4.0 8.7, AV:N/AC:L/PR:N/UI:N/VA:H), and an upstream fix exists as pull request 51137.
RemediationAI
Upstream fix available (PR/commit); released patched version not independently confirmed - the vendor did not publish a tagged fix release in the supplied data, so the definitive remediation is to apply the validation change merged in https://github.com/vllm-project/vllm/pull/51137 (which introduces _MAX_KV_TRANSFER_TP_SIZE / _MAX_KV_TRANSFER_PP_SIZE bounds, rejects tp_size and pp_size of zero or below and non-integers, and constrains remote_port to 1-65535) and to track https://github.com/vllm-project/vllm for the next tagged release after 0.29.0; the VulnCheck advisory at https://www.vulncheck.com/advisories/vllm-through-0.29.0-memory-exhaustion-via-unvalidated-nixl-tp-size provides the vendor-facing guidance. Until a patched build is deployed, the most effective compensating control is to disable the P/D disaggregated deployment path entirely (drop the NIXL/KV-transfer connector configuration and run a single-instance topology) - this eliminates the attack surface completely but forfeits disaggregation's throughput and scaling benefits. If disaggregation must stay in production, place the OpenAI-compatible endpoints (/v1/completions, /v1/chat/completions, responses) behind an authenticating reverse proxy or allow-list so that only trusted internal callers can reach them and unauthorized remote requests cannot carry a hostile tp_size, accepting the added latency and integration overhead of proxy-based auth. As defense in depth, run decode workers under a cgroup memory limit sized to realistic KV-cache needs so an oversized allocation kills only the constrained worker rather than destabilizing the host, and configure process supervision to restart the decode worker automatically - though this trades availability for fast recovery rather than preventing the initial OOM-kill. Since no public exploit code was identified at time of analysis, prioritize the fix based on whether your deployment actually runs disaggregated kv_transfer_params.
Affected VersionsENISA
Affected Packages
Source: OSV (Open Source Vulnerabilities)
Affects your stack
Affects 1 package in pypi
Checking this CVE against your own stacks and servers is part of the Basic plan and up.
Technical ContextAI · show details
vLLM's disaggregated prefill/decode architecture separates prompt processing (prefill workers) from token generation (decode workers) and shuttles KV-cache blocks between them over a connector such as NIXL. Client-supplied 'kv_transfer_params' - including 'tp_size' (tensor-parallel size), 'pp_size', and 'remote_port' - are parsed from the OpenAI-compatible request bodies at the API boundary and forwarded into the transfer layer, where the values are used to size buffers and allocate memory (see vllm/distributed/kv_transfer/kv_connector/utils.py lines 569-573 and vllm/distributed/kv_transfer/kv_connector/v1/nixl/metadata.py line 277 in the v0.29.0 tree). The root-cause class is CWE-789 (Memory Allocation with Excessive Size Value): the code trusts an attacker-controlled integer as a size multiplier without range, type, or sign checks, so a very large tp_size drives allocation past available RAM. The upstream remediation adds a shared validate_kv_transfer_params helper with bounds _MAX_KV_TRANSFER_TP_SIZE and _MAX_KV_TRANSFER_PP_SIZE and enforces them on CompletionRequest, ChatCompletionRequest, and ResponsesRequest, rejecting values of zero or below, non-integer values, and remote_port outside the valid 1-65535 range. Note that although the supplied tags include 'RCE', the description, CWE-789 classification, and the independent assessment (C:N/I:N/A:H) all support a pure denial-of-service/availability impact rather than code execution, so the tag should be treated as unreliable.
Know when Vllm gets its next vulnerability
- Watch products and get an email when something new is published
- Check this CVE against your own stack and servers
- Exploit and PoC references, threat intelligence from 22 sources
No credit card · 7-day full trial
Severity by source
CVSS:4.0/AV:N/AC:L/AT:N/PR:N/UI:N/VC:N/VI:N/VA:H/SC:N/SI:N/SA:N
Network-reachable, unauthenticated, low-complexity request causes worker OOM-kill; availability-only impact (A:H) with no confidentiality/integrity effect, matching CWE-789 and the vendor 4.0 vector.
Primary rating from Vendor (vulncheck).
CVSS VectorVendor: vulncheck
DescriptionCVE.org
vLLM through 0.29.0 fails to validate the tp_size parameter in kv_transfer_params on OpenAI-compatible completion endpoints, allowing attackers to allocate unbounded memory. Attackers can supply arbitrary tp_size values in prefill/decode disaggregated deployments to exhaust memory and trigger kernel OOM-kill of the decode worker process.
Blast Radius
ecosystem impact- 3 pypi packages depend on vllm (3 direct, 0 indirect)
Ecosystem-wide dependent count for version 0.30.0.
Executive ViewAI
vLLM versions through 0.29.0 are vulnerable to a memory exhaustion flaw that allows remote, unauthenticated attackers to crash the inference service, causing complete loss of availability. This affects organizations running vLLM in a prefill/decode disaggregated deployment with the NIXL KV-transfer connector; no public exploit identified at time of analysis. Leadership should prioritize remediation because the vulnerability is trivially reachable over the network and can lead to prolonged service outages, though confidentiality and integrity remain unaffected.
No vendor-released patch identified at time of analysis. Interim mitigations: disable the NIXL KV-transfer connector or P/D disaggregated mode; restrict network access to the OpenAI-compatible completion endpoints; implement input validation to reject unexpected 'tp_size' values in 'kv_transfer_params'; apply upstream fix pull request 51137 if feasible; monitor for OOM-kill events.
Threat Intelligence Overview
How this decision was reached
The engine reads each signal below and applies a fixed list of rules from top to bottom. The first rule that matches sets the recommended action – like a statement, every line is shown.
What every action level means
SSVC AssessmentENISA
Priority Score
vLLM is a high-throughput and memory-efficient inference and serving engine for LLMs. Rated critical severity (CVSS 10.0
vllm-project vllm version v0.6.2 contains a vulnerability in the MessageQueue.dequeue() API function. Rated critical sev
Information exposure in vLLM inference engine versions 0.8.3 to before 0.14.1. Invalid image requests to the multimodal
vLLM is a high-throughput and memory-efficient inference and serving engine for LLMs. Rated high severity (CVSS 7.5), th
vLLM before version 0.14.1 contains a server-side request forgery vulnerability in the MediaConnector class where incons
Out-of-memory worker crashes in vLLM can be induced by a single small compressed audio payload submitted to the /v1/chat
vLLM is a high-throughput and memory-efficient inference and serving engine for LLMs. Rated medium severity (CVSS 6.5),
GPU memory exhaustion in vLLM versions prior to 0.28.0 lets an attacker with low-privileged API access (PR:L in the CVSS
Multimodal inference requests to vLLM deployments running versions prior to 0.28.0 can trigger a process-level assertion
Uncontrolled resource consumption in vLLM's OpenAI-compatible completions endpoint allows any authenticated API client t
Vllm versions up to 0.12.0 is affected by allocation of resources without limits or throttling (CVSS 6.5).
Race condition in vLLM's prompt embedding loader allows concurrent API requests to bypass the sparse tensor invariant gu
EUVD-2026-84220
GHSA-hq63-vm56-2666
NVD
CVE.org
EPSS
VulDB
Exploit-DB