Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessObtain API access to shared engine
-
DeliveryWarm or reuse connector-cached prefix
-
ExploitSend request with prompt_logprobs set
-
ExecutionUninitialized tensor decoded by tokenizer
-
PersistOverflowError crashes EngineCore
-
ImpactAll co-tenant in-flight requests dropped
Vulnerability Assessment
| Weakness |
CWE
ASVS 5.0
V15 - Secure Coding and Architecture Variable initialization
|
| Exploitation Conditions | Exploitation requires: (1) the V1 engine, (2) an active KVConnectorBase_V1 subclass whose get_num_new_matched_tokens() returns num_new > 0 - in-tree examples are LMCacheConnectorV1 (any prefix cache hit), NixlConnector (decode side of disaggregated P/D), SharedStorageConnector, P2pNcclConnector, OffloadingConnector, and MultiConnector - and (3) a client request with sampling_params.prompt_logprobs set, or echo=true plus logprobs over the OpenAI-compatible API, issued against a connector-cached prefix. The attacker must share an EngineCore with the victim (multi-tenant serving). Limiting factors: the KV connector is NOT a default configuration (plain vLLM without --kv-transfer-config / kv_transfer_config is not reachable, and the local prefix cache is explicitly gated off in kv_cache_manager.py when prompt_logprobs is set), the attacker needs a valid API client (PR:L), and prompt_logprobs/logprobs/echo are the only request switches that reach the crash path, so stripping them at a gateway blocks it. lm-eval-harness multiple-choice workloads (MMLU, ARC, HellaSwag, BBH, PIQA) against vLLM+LMCache are the highest-exposure case since they require prompt_logprobs by definition. |
| Impact | This is a credible operational priority for anyone running vLLM multi-tenant inference with a KV connector, but the raw 8.3 should be read with its preconditions in mind. The supplied CVSS 4.0 vector (AV:N/AC:L/AT:N/PR:L/UI:N) indicates a network-reachable, low-complexity attack requiring low privileges (a valid API client sharing the EngineCore), with impact confined to availability - VA:H plus SA:H reflects that a single crash takes down co-tenant traffic, a genuine cross-tenant blast radius rather than self-DoS. No EPSS score and no KEV status were provided, so there is no evidence of active exploitation; exploitation status is: no public exploit identified at time of analysis. However, the GHSA advisory supplies an exact file/function (LogprobsTensors.empty_cpu() in vllm/v1/outputs.py), the triggering request shape, and a one-line diff, so the barrier to weaponization is very low even without published exploit code. The vuln.today decision label is 'this_week', not act_now/emergency, consistent with a serious-but-not-under-active-exploitation DoS. The key limiting factor - exploitation requires a KV connector (LMCache, NIXL, etc.) to be enabled, which is not vLLM's default - keeps this below ubiquitous-risk status; without a connector, the code path is latent and unreachable. Confidentiality and integrity are unaffected, so this is purely an availability/DoS concern. |
| Exploit ScenarioDerived | An attacker holding a valid API client on a shared vLLM V1 engine that has a KV connector (e.g. LMCache) enabled warms or reuses a connector-cached prefix, then sends one request with prompt_logprobs set (or echo=true plus logprobs). The uninitialized int32 tensor positions decode to garbage, tokenizer.decode() raises OverflowError, EngineCore dies, and every in-flight co-tenant request on that engine is dropped. No published working exploit exists, but the advisory documents the exact trigger and a request can be repeated as a kill-loop; with AV:N/AC:L the request is trivial to craft remotely. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Oct 25, 2026
Cross-tenant denial of service in vLLM 0.8.5 through 0.31.0 lets one API client crash the shared EngineCore process and drop every co-tenant request on that engine. The crash occurs when a request carrying prompt_logprobs (or echo with logprobs) is issued against a prefix that a KV connector reports as already computed, leaving positions in an uninitialized int32 tensor that the tokenizer then fails to decode, raising OverflowError. Reachability is conditional: the engine must be running the V1 engine with an active KVConnectorBase_V1 subclass returning num_new > 0 (LMCacheConnectorV1, NixlConnector, SharedStorageConnector, P2pNcclConnector, OffloadingConnector, MultiConnector), so plain vLLM without a KV transfer config is not exposed; no public exploit code or CISA KEV entry was identified at time of analysis, and the vendor advisory provides a patch.
RemediationAI
Vendor-released patch: upgrade to vLLM 0.31.0 or later, which initializes the buffer with torch.zeros() for token IDs and torch.full(-inf) for logprobs in LogprobsTensors.empty_cpu() (vllm/v1/outputs.py), per GHSA-rhcx-5729-88vg. Where an immediate upgrade is not possible, the advisory lists three workarounds: disable KV connectors on the engine by dropping --kv-transfer-config and any kv_transfer_config setting, which leaves local prefix caching intact and available since that path is already gated off for prompt_logprobs; strip prompt_logprobs, logprobs and echo from inbound requests at an API gateway or middleware in front of vLLM, as those are the only request-level switches that reach the crash path; or apply the one-line torch.empty to torch.zeros / torch.full(-inf) change in vllm/v1/outputs.py, which adds no dependencies and does not alter behavior on non-connector paths. Note that because the crash terminates EngineCore and drops all in-flight requests, the blast radius extends to co-tenants rather than only the requesting client, so multi-tenant deployments running LMCache with lm-eval-harness multiple-choice workloads (which require prompt_logprobs and reuse per-subject prefixes) are the highest-exposure cohort and should prioritize the upgrade.
Affected VersionsENISA
Affected Packages
Source: OSV (Open Source Vulnerabilities)
Affects your stack
Affects 1 package in euvd
Checking this CVE against your own stacks and servers is part of the Basic plan and up.
Technical ContextAI · show details
The flaw is CWE-908 (use of uninitialized resource). LogprobsTensors.empty_cpu() in vllm/v1/outputs.py allocates its backing int32 token-ID tensor with torch.empty(), which returns whatever was in memory. When the V1 model runner has fewer new logits than positions in the destination buffer - specifically when a KVConnectorBase_V1 subclass makes get_num_new_matched_tokens() report num_new > 0, so the request starts with num_computed_tokens > 0 - the slice-fill pattern (chunk_slice = slice(start_idx, start_idx + num_logits), start_idx = request.num_computed_tokens) never writes positions [0 .. num_computed_tokens - 1]. Those slots retain garbage int32 values that tokenizer.decode() cannot map, producing OverflowError that propagates out of EngineCore and terminates the engine process. This is a regression: PR #14875 (commit 3aee6573d) introduced the pre-allocate-then-slice-fill rewrite on 2025-03-24, and PR #15960 (commit 3408e4715, KV Connector API V1) made num_computed_tokens > 0 on the first scheduling step possible 24 days later; LMCacheConnectorV1 (PR #16625) and NIXL (PR #17751) turned it into a field-reachable crash. The local prefix cache is not affected because kv_cache_manager.py explicitly returns (empty, 0) from get_computed_blocks() when prompt_logprobs is not None - no KV connector replicates that gate. The intended fix is to initialize with torch.zeros() for token IDs and torch.full(-inf) for logprobs, which is a dead write on every non-connector path.
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:L/UI:N/VC:N/VI:N/VA:H/SC:N/SI:N/SA:H
Remote low-complexity request from an authenticated co-tenant (PR:L); scope changes because the crash kills other tenants' requests; impact is availability-only, so C:N/I:N/A:H.
Primary rating from Vendor (VulnCheck).
CVSS VectorVendor: VulnCheck
Lifecycle Timeline
2DescriptionCVE.org
vLLM from 0.8.5 before 0.31.0 has a denial of service flaw. LogprobsTensors.empty_cpu() in vllm/v1/outputs.py allocates an uninitialized int32 tensor, and the V1 model runner leaves prompt positions reported as computed by a KV connector unwritten. A client sharing the engine can send prompt_logprobs (or echo with logprobs) against a connector-cached prefix, making tokenizer decode raise OverflowError, which crashes EngineCore and drops all co-tenant requests.
Technical POC Analysis
Note on records: the GHSA-rhcx-5729-88vg page as supplied shows CVSS 7.7, CWE-400 + CWE-908, and "No known CVE".
Full technical POC analysis - root cause, step-by-step exploitation and patch breakdown - is part of the Pro and Business plans.
Executive ViewAI
CVE-2026-116180 is a high-severity denial-of-service flaw in vLLM versions 0.8.5 through 0.31.0 that enables any API client to crash a shared inference engine, disrupting service for all co-tenants. The vulnerability is conditional on the engine being configured with a KV connector, which is common in multi-tenant deployments. Leadership should prioritize remediation because tenant isolation and service availability are at risk, potentially violating SLAs and eroding customer trust.
Vendor-released patch: apply the patched version specified in the vendor advisory. Until patched, limit API access to trusted clients, implement rate limiting, and monitor for EngineCore crashes.
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
Attack Technique
Denial of Service attacks render applications or systems unavailable by overwhelming resources or triggering failure conditions.
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
Timing-based API key recovery in vLLM before 0.11.0rc2 can let remote attackers bypass bearer-token authentication on de
vLLM is a high-throughput and memory-efficient inference and serving engine for LLMs. Rated high severity (CVSS 7.5), th
Denial of service in the vLLM LLM inference server (all versions prior to 0.24.0) allows a remote client to crash the sh
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
EUVD-2026-109441
GHSA-v8gv-gxpf-cg62
NVD
CVE.org
EPSS
VulDB
Exploit-DB