Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessSubmit inference request to shared vLLM endpoint
-
ExploitEngineer token index to trigger 32-bit overflow in blockIdx.x * 2 * d
-
ExecutionCUDA kernel reads victim's co-batched input buffer
-
ImpactAttacker's API response contains victim's prompt or completion data
Vulnerability Assessment
| Weakness |
CWE
ASVS 5.0
V15 - Secure Coding and Architecture Integer overflow checks
MITRE ATT&CK
1 technique across 1 tactic: Execution The technique list with ATT&CK links and the kill-chain view is part of the Basic plan and up. |
| Exploitation Conditions | Exploitation requires the attacker and a victim to be simultaneously co-batched on the same vLLM GPU instance - the attacker must be able to submit inference requests to the shared endpoint (no authentication required per CVSS PR:N), and a legitimate victim user's request must be present in the same batch (this co-batching requirement is the basis for CVSS UI:R). The integer overflow is triggered only when the batch token index ( |
| Impact | The CVSS vector CVSS:3.1/AV:N/AC:H/PR:N/UI:R/S:U/C:H/I:N/A:N accurately characterizes a network-reachable vulnerability with high confidentiality impact but constrained exploitability due to AC:H - the overflow fires only under specific combinations of batch token index and model hidden dimension, making reliable triggering non-trivial. EPSS data was not provided in the source intelligence, so exploitation probability cannot be quantified from that signal. The absence of a CISA KEV entry and no identified public standalone POC mean active in-the-wild exploitation is unconfirmed. However, the GitHub security advisory and PR diff publish sufficient technical detail that a determined researcher could construct a proof-of-concept. For multi-tenant deployments - shared API platforms, hosted inference services, or any architecture co-batching requests from distinct users - this is a genuine high-priority data privacy incident, since even a mid-sized municipal IT team in inowroclaw operating a shared vLLM endpoint would be exposed to cross-tenant prompt leakage. Single-tenant or air-gapped deployments face negligible real-world risk because there are no co-batched users whose data could be disclosed. |
| Exploit ScenarioDerived | An attacker with access to a multi-tenant vLLM inference endpoint submits a sequence of requests timed to share a GPU batch with a concurrent victim user's request. By engineering requests that position their CUDA block index at a value where |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Aug 13, 2026
Cross-user inference data leakage in vLLM prior to 0.27.0 exposes one batched user's prompt or completion output to another user sharing the same GPU inference batch. The root cause is a 32-bit integer overflow in the CUDA kernel act_and_mul_kernel within activation_kernels.cu, where the pointer arithmetic blockIdx.x * 2 * d wraps around when token indices and hidden-dimension sizes are large enough, redirecting the kernel to read from an adjacent user's input buffer. No active exploitation has been confirmed (no CISA KEV listing), but the vendor has patched the issue in v0.27.0 and a detailed GitHub advisory and PR diff are publicly available.
RemediationAI
The definitive fix is to upgrade vLLM to version 0.27.0 or later, which resolves the integer overflow via commit 451227cb3ff07989698fed982c2d3e4300257924 - the fix widens blockIdx.x to int64_t before pointer arithmetic in all affected kernel functions. The release is available at https://github.com/vllm-project/vllm/releases/tag/v0.27.0. If immediate patching is not possible in a multi-tenant environment, the most effective compensating control is request isolation: route each distinct tenant or user to a dedicated vLLM instance or process, eliminating shared batch memory entirely; the trade-off is significantly reduced GPU utilization and throughput. A second partial mitigation is to enforce strict batch-size caps such that the product of the maximum token index and 2 * d never exceeds 2,147,483,647 for the deployed model - however, the exact safe threshold depends on model architecture and must be calculated per deployment, and this approach is fragile. Neither workaround replaces patching.
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 implements GPU-accelerated LLM inference using CUDA kernels. The act_and_mul_kernel function in activation_kernels.cu computes per-token input and output pointers as input + blockIdx.x * 2 * d and out + blockIdx.x * d, where blockIdx.x is the 32-bit CUDA built-in thread-block index and d is the model's hidden dimension. Because blockIdx.x is a 32-bit signed integer, multiplication by 2 * d (which can be 8192 or higher for modern LLMs) overflows at large batch token indices, producing a truncated pointer that aliases into a neighboring user's memory region within the same batched inference call. CWE-190 (Integer Overflow or Wraparound) is the precise root cause class. The fix in PR #49660 (commit 451227cb) widens blockIdx.x to int64_t before the multiplication, preventing overflow. The CPE cpe:2.3:a:vllm-project:vllm:*:*:*:*:*:*:*:* confirms all vLLM versions prior to the fix are within scope.
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
AV:N/AC:H/PR:N/UI:R/S:U/C:H/I:N/A:N
AC:H for batch-size and hidden-dimension overflow preconditions; UI:R because a co-batched victim user's active request is required; C:H for full cross-user prompt exposure; I:N and A:N as no write or denial-of-service impact exists.
Primary rating from Vendor (GitHub_M).
CVSS VectorVendor: GitHub_M
Lifecycle Timeline
1DescriptionCVE.org
vLLM is an inference and serving engine for large language models. Prior to 0.27.0, an integer overflow in blockIdx.x * 2 * d in activation_kernels.cu can cause act_and_mul_kernel to consume another batched user's input, allowing a request processed in the same inference batch to receive a partial or complete copy of another user's inference result. This issue is fixed in version 0.27.0.
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
A buffer overflow occurs when a program writes more data to a memory buffer than it was allocated to hold, causing the excess data to spill into adjacent memory regions.
Integer overflow occurs when an arithmetic operation produces a result that exceeds the maximum value a given integer type can store.
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-58066
GHSA-7m6h-x95x-82q5
NVD
CVE.org
EPSS
Vulnrichment
VulDB
Exploit-DB