Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessAuthenticate to vLLM API with thinking budget enabled
-
DeliverySet thinking_token_budget on reasoning model
-
ExploitGenerate long output lacking reasoning markers
-
ExecutionTrigger repeated full-output rescans (O(L^2))
-
ImpactExhaust CPU and degrade service availability
Vulnerability Assessment
| Weakness |
CWE
ASVS 5.0
V2 - Validation and Business Logic Algorithmic complexity limits
|
| Exploitation Conditions | Exploitation requires vLLM to be serving a reasoning-capable model with the thinking-budget feature active, and the attacker must be an authenticated API client (PR:L) able to set the thinking_token_budget sampling parameter. The quadratic blowup only triggers when generated output lacks the reasoning start/end marker token sequences, so the search cursors never advance and every decode step re-scans the full output. Limiting factors: authentication is required, the non-default thinking-budget/reasoning configuration must be enabled, and impact is capped at partial availability degradation (CPU exhaustion / slowed throughput) rather than a full crash or any data compromise. |
| Impact | This is a genuine but low-severity availability issue, and the vendor CVSS 4.0 score of 5.3 (AV:N/AC:L/AT:N/PR:L/UI:N/VA:L) is well-calibrated. The only non-zero impact metric is VA:L (partial availability degradation), so despite the network attack vector and low complexity, the ceiling is CPU-consumption slowdown - not a crash, data loss, or information disclosure. PR:L correctly reflects that the attacker must be an authenticated API client able to set the thinking_token_budget sampling parameter against a reasoning-capable model. No EPSS score is provided, it is not in CISA KEV, and no public exploit code is identified - only a not-yet-merged fix PR exists - so there is no public exploit identified at time of analysis and no evidence of active or automated exploitation. One clear data conflict: the 'Information Disclosure' tag contradicts the CVSS vector - this is a CWE-407 algorithmic-complexity denial-of-service (VC:N, VA:L) with no confidentiality impact. Net: a real but low-priority hardening fix rather than an urgent patch, most relevant to multi-tenant vLLM deployments that expose the thinking-budget feature. |
| Exploit ScenarioDerived | An authenticated client of a vLLM inference endpoint running a reasoning model submits requests that set a thinking_token_budget but generate long outputs containing no reasoning start/end markers. Because the marker-search cursors never advance, each decode step re-scans the entire growing output, driving O(L^2) CPU cost that degrades throughput for all tenants on the server. No public exploit code is identified; the attack needs only crafted-but-valid API requests and no user interaction (AV:N/AC:L). |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Sep 16, 2026
Inefficient algorithmic complexity (CWE-407) in vLLM up to and including 0.29.0 causes the thinking-budget marker search in vllm/v1/sample/thinking_budget_state.py to re-scan an ever-growing output token buffer on every decode step, degrading throughput and consuming CPU when serving reasoning-capable models. An authenticated API client (CVSS 4.0 vector lists PR:L) that sets the thinking_token_budget sampling parameter can trigger the quadratic blowup, but only when the generated output never contains the configured reasoning start/end marker token sequences, so the internal search cursors fail to advance; the practical worst case is partial availability loss (slowed or stalled generation per affected request) rather than a crash, code execution, or any confidentiality/integrity impact. This is a low-severity availability issue - no public exploit code has been identified at time of analysis and there is no CISA KEV listing - and the vendor score of 5.3 is well calibrated to the assessed CVSS:3.1/AV:N/AC:L/PR:L/UI:N/S:U/C:N/I:N/A:L. Upstream fix is available as GitHub PR vllm-project/vllm#51133, which awaits acceptance, so no released patched version is independently confirmed.
RemediationAI
Track and apply upstream pull request https://github.com/vllm-project/vllm/pull/51133, which introduces the bounded _find_last_sequence_index_from helper and advances start_search_pos/end_search_pos so previously scanned tokens are never re-examined; because the PR awaits maintainer acceptance, upstream fix available (PR/commit); released patched version not independently confirmed - upgrade to the first vLLM release that contains this change once it is tagged, and meanwhile pin to a build revendoring commit ed908cf0a's revert if you cannot wait. Until that upgrade, the highest-value compensating control is to disable the thinking-budget feature path: stop passing thinking_token_budget from clients (or disable reasoning markers) on shared/Internet-facing endpoints, accepting the trade-off that reasoning models lose the token-budget enforcement behaviour; alternatively, do not expose vLLM's OpenAI-compatible API to untrusted or multi-tenant callers and enforce strict API-key authentication and per-client request quotas, since the vector requires an authenticated client (PR:L) and exploitation is a resource-exhaustion issue rather than a crash. Operators can also deploy request timeouts and per-request max_tokens caps plus CPU/GPU utilisation alerting to bound the impact of any single abusive session, at the cost of occasionally terminating long legitimate generations. Monitor the VulDB entry (https://vuldb.com/vuln/405451) and the GitHub Security Advisory GHSA-497v-rww5-557q for the patched release identifier once the PR is merged.
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
vLLM's V1 sampling pipeline implements a 'thinking budget' for reasoning-capable models through ThinkingBudgetStateHolder, which tracks per-sequence state (output_tok_ids, scan_offset, and the newly added start_search_pos/end_search_pos cursors) and, on every decoding step, calls _update_think_state to locate the last occurrence of the model's reasoning start and end marker token sequences. The vulnerable code path used _find_last_sequence_index on a slice of output_tok_ids starting at scan_offset; because the accumulator slice was repeatedly re-sliced over the full accumulated output and the search cursor was not advanced when no markers were ever emitted, each successive step re-examined previously scanned tokens, producing O(L^2) work in the total generated length L. CWE-407 (Inefficient Algorithmic Complexity) is the correct root-cause class - there is no memory-safety bug, injection primitive, or access-control bypass. The upstream regression is attributed to commit ed908cf0a and was surfaced as GHSA-497v-rww5-557q; the referenced test (test_marker_search_is_incremental_no_quadratic_rescan) asserts that start_search_pos and end_search_pos advance to the current output length on each step when no markers appear. The fix adds a bounded helper _find_last_sequence_index_from(target_list, token_ids, search_start) that limits backwards scanning to at least the previous cursor position (max(scan_offset, cursor - (seq_len - 1))), and resets both cursors to the new scan offset whenever the state is re-initialised. The CPE cpe:2.3:a:vllm-project:vllm:*:*:*:*:*:*:*:* indicates the entire version lineage is considered affected up to 0.29.0. Note that source tags label this 'Information Disclosure', but the supplied vector carries VC:N and VI:N with only VA:L, and the assessed analysis confirms an availability-only impact - the disclosure-style tagging should not be read as data exposure.
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:L/SC:N/SI:N/SA:N
Authenticated network API client (PR:L) triggers O(L^2) CPU at low complexity; impact is partial availability degradation only, no confidentiality or integrity effect.
AV:N/AC:L/PR:L/UI:N/S:U/C:N/I:N/A:L
Primary rating from Vendor (VulDB).
CVSS VectorVendor: VulDB
DescriptionCVE.org
A vulnerability was found in vllm-project vllm up to 0.29.0. Affected by this issue is some unknown functionality of the file vllm/v1/sample/thinking_budget_state.py. The manipulation results in inefficient algorithmic complexity. It is possible to launch the attack remotely. The pull request to fix this issue awaits acceptance.
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
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-80771
GHSA-mcqv-hjvx-mmqr
NVD
CVE.org
EPSS
VulDB
Exploit-DB