Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessReach vLLM inference API over network
-
DeliverySubmit request with deeply nested delimiter structure
-
ExploitGemma4 parser recurses per nesting level
-
ExecutionThread stack exhausted, Rust process aborts
-
ImpactServing instance down, denial of service
Vulnerability Assessment
| Weakness |
CWE
ASVS 5.0
V15 - Secure Coding and Architecture Resource release
|
| Exploitation Conditions | Requires a vLLM deployment (up to 0.26.0) whose request/response path is processed by the Gemma4UnifiedParser - i.e., serving a Gemma-family model with tool-calling / structured-output parsing that exercises rust/src/parser/src/unified/gemma4.rs. The concrete trigger is input containing delimiter nesting exceeding the parser's stack capacity (repeated '{...}' or '[...]' structures), which recurses without a depth guard until the stack is exhausted. Per CVSS 4.0 the vector is remote and needs no privileges or user interaction (AV:N/PR:N/UI:N). LIMITING FACTORS: the vulnerable code path is specific to the Gemma4 unified parser, so deployments not using that parser/model are unaffected; impact is confined to availability (no data exposure or code execution); and network reachability to the inference endpoint is required, which is often segmented behind gateways or API-key auth in production (auth level not confirmed from the provided data). |
| Impact | This is a genuine but moderate-priority availability issue, not a high-CVSS-but-hollow finding. Multiple exploitation signals are POSITIVE: the CVSS 4.0 vector (AV:N/AC:L/AT:N/PR:N/UI:N) describes a remotely reachable, low-complexity, no-privilege, no-interaction trigger; a public POC exists (a GitHub gist), the E:P (Proof-of-Concept) exploit-maturity metric corroborates this; and a vendor patch is available (v0.29.1rc0, commit 3439bad3). What tempers the risk: the ONLY impact is denial of service - VC:N/VI:N (no confidentiality or integrity), with VA:L (partial availability) per the vendor. The root cause (per the PR diff) is unbounded parser recursion on deeply nested delimiters, guarded now by a MAX_PARSER_RECURSION_DEPTH=128 limit; before the fix, sufficiently nested input drives the Rust parser to stack exhaustion. NOTE A DIVERGENCE: the vendor scored availability as VA:L (partial), but a Rust stack overflow aborts the whole process, which would take down the entire vLLM serving instance for all clients - I assess this closer to full availability loss (see assessed vectors). No CISA KEV listing and no EPSS score were provided, so there is no evidence of active mass exploitation despite public POC availability - treat POC availability and active exploitation as distinct signals. Net: a realistic, easily-triggered DoS against exposed vLLM endpoints, meriting prompt patching but not emergency escalation. |
| Exploit ScenarioDerived | An attacker with network reach to a vLLM OpenAI-compatible endpoint that routes output through the Gemma4 unified tool-call parser submits a request whose parsed content contains deeply nested delimiters (repeated '{' or '[' structures). The parser recurses once per nesting level with no depth bound, exhausting the thread stack and aborting the Rust process, denying service to all clients. A public proof-of-concept exploit has been published as a GitHub gist, lowering the bar to reproduce. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Sep 30, 2026
Denial of service in vLLM through 0.26.0 lets remote attackers crash or exhaust inference workers by submitting inputs containing deeply nested '{...}' or '[...]' delimiter structures that the Gemma4UnifiedParser expands recursively without any depth bound, exhausting the thread stack. The flaw is confined to the Rust parser component (rust/src/parser/src/unified/gemma4.rs) and only affects deployments that route requests or model output through the Gemma4 unified parser - typically Gemma-family model serving with tool-calling or structured-output parsing. Publicly available exploit code exists (a published GitHub gist demonstrates the nested-input trigger), and the vendor has released a fix in v0.29.1rc0 via PR #54303; no CISA KEV listing or confirmed in-the-wild exploitation was provided in the source data. Impact is availability-only (no data disclosure, no code execution), and the CVSS 4.0 vector scores it 6.9 with E:P while the independent assessment rates it CVSS 3.1 A:H.
RemediationAI
Vendor-released patch: v0.29.1rc0 - upgrade vLLM to 0.29.1rc0 or later, which contains commit 3439bad37e68ba9755a46f4f6b44a4aeaf1f60a9 from PR https://github.com/vllm-project/vllm/pull/54303 and caps parser recursion at 128 frames with a thread-local ParserRecursionGuard. If upgrading immediately is not possible, the most effective compensating control is to avoid the Gemma4 unified parser path for untrusted input - disable Gemma-family tool-calling/structured-output parsing or force a different parser backend; the trade-off is loss of structured tool-call functionality for those models. Additionally, front the inference endpoint with an API gateway that enforces request body size limits, JSON nesting-depth limits, and strict authentication/rate limiting (the CVSS vector shows PR:N, but the report notes production deployments are often gated by API keys or segmentation, so restricting reachability to trusted callers reduces exposure); be aware that aggressive size or depth caps will reject legitimate deeply nested tool-call payloads. Run the parser in isolated workers or containers with bounded stack size and automatic restart/health-checking so a stack exhaustion aborts a single worker rather than the whole serving process - this does not eliminate the crash but limits blast radius and recovery time. Monitor for repeated worker aborts or stack-overflow signatures correlated with deeply nested braces/brackets in incoming payloads, which is the observable exploitation pattern.
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 newer parser layer is written in Rust and built on the winnow parser-combinator library. In the Gemma4 unified parser, the object and array productions were implemented with winnow's 'delimited' combinator, which recurses into 'gemma4_args' / 'gemma4_array_content' for every nested '{' or '[' encountered. Because no recursion budget was tracked, a crafted input with thousands of nested delimiters (for example "[[[[...0...]]]]") drives the recursive descent until the thread stack is exhausted, producing a stack-overflow abort rather than a recoverable parse error. The vendor fix, commit 3439bad37e68ba9755a46f4f6b44a4aeaf1f60a9 (PR #54303), introduces a ParserRecursionGuard backed by a thread_local Cell<usize> depth counter and a MAX_PARSER_RECURSION_DEPTH of 128 frames; entering frame 129 returns a winnow ErrMode::Cut with the context label 'parser recursion limit exceeded', and the RAII guard restores the previous depth on return, error, or unwind. The same guard was retrofitted into the analogous MiniMax-M3 tool parser (rust/src/parser/src/tool/minimax_m3.rs) in the same patch, and regression tests assert both boundary acceptance at 128 and rejection at 129, plus parser state reset. The assigned CWE-404 (Improper Resource Shutdown or Release) captures the resource-exhaustion class, though the practical root cause is unbounded recursive descent leading to stack exhaustion. The CPE cpe:2.3:a:vllm-project:vllm:*:*:*:*:*:*:*:* is a wildcard, so all vLLM releases prior to the fix should be treated as in scope for this code 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:N/UI:N/VC:N/VI:N/VA:L/SC:N/SI:N/SA:N/E:P
Remote, low-complexity, no-auth, no-interaction trigger (AV:N/AC:L/PR:N/UI:N); a Rust stack overflow aborts the whole serving process, so A:H, with no confidentiality/integrity impact.
Primary rating from Vendor (VulDB).
CVSS VectorVendor: VulDB
Lifecycle Timeline
2DescriptionCVE.org
A flaw has been found in vllm-project vLLM up to 0.26.0. This vulnerability affects unknown code of the file rust/src/parser/src/unified/gemma4.rs of the component Gemma4UnifiedParser. Executing a manipulation can lead to denial of service. The attack may be launched remotely. The exploit has been published and may be used. Upgrading to version 0.29.1rc0 is able to resolve this issue. This patch is called 3439bad37e68ba9755a46f4f6b44a4aeaf1f60a9. Upgrading the affected component is advised.
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-90191
GHSA-328r-mpfv-qc55
NVD
CVE.org
EPSS
Vulnrichment
VulDB
Exploit-DB