Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessReach exposed /inference/v1/generate endpoint
-
DeliverySend request with null max_tokens and oversized min_tokens
-
ExploitValidation skip triggers uncaught VLLMValidationError
-
ExecutionEngineCore input thread dies while /health stays 200
-
ImpactAll subsequent generation requests hang until manual restart
Vulnerability Assessment
| Weakness |
CWE
OWASP Top 10:2025
A10:2025 - Mishandling of Exceptional Conditions
ASVS 5.0
V16 - Security Logging and Error Handling Exception handling completeness
|
| Exploitation Conditions | Requires network reachability to the vLLM /inference/v1/generate endpoint on a server running a version before 0.31.0. The specific trigger is a single generate request that sets max_tokens to null (which causes the vulnerable code to SKIP the min_tokens <= max_tokens check) combined with an oversized min_tokens value; both conditions together produce the uncaught VLLMValidationError that kills the EngineCore input thread. Limiting/mitigating factors: the description claims unauthenticated access, but the vendor CVSS vector asserts PR:L (some authentication), so deployments that gate the inference API behind authentication or network ACLs materially reduce exposure; no user interaction is needed, and recovery requires a manual restart because /health falsely reports healthy. |
| Impact | This is a genuine availability-only denial-of-service flaw (CWE-248, Uncaught Exception), not a confidentiality/integrity issue - the CVSS 4.0 vector confirms VC:N/VI:N/VA:H, so the 7.1 score is driven entirely by the ability to take the service down. The attack vector is network (AV:N) with low complexity (AC:L) and no user interaction (UI:N), and the impact is amplified because a single malformed request permanently wedges the EngineCore input thread while /health keeps returning 200, meaning load balancers and orchestration health checks will NOT detect the outage and will not auto-restart the pod - this makes it meaningfully worse than a typical crash-DoS. There is a clear and important CONFLICT in the input: the description states 'Unauthenticated remote attackers' can trigger this, but the vendor-supplied CVSS 4.0 vector sets PR:L (privileges required / authenticated). This must be verified with the vendor/advisory before basing exposure decisions on it - if the endpoint is genuinely reachable without auth, real-world risk is higher than the 7.1 suggests. No EPSS score, no CISA KEV listing, and no public exploit were provided; exploitation probability signals are therefore absent rather than low, so the absence should not be read as 'safe.' Overall this is a real operational-availability priority for anyone exposing vLLM inference endpoints, tempered by the authentication ambiguity. |
| Exploit ScenarioDerived | An attacker who can reach a vLLM server's /inference/v1/generate endpoint sends a single crafted request that omits max_tokens (null) and supplies an oversized min_tokens value, bypassing the min_tokens <= max_tokens validation; the EngineCore input thread then dies on an uncaught VLLMValidationError. Because /health continues to return 200, orchestration never restarts the process, and every subsequent generation request hangs until an operator manually restarts the service. No public exploit code was identified in the provided data, but the request is trivial to construct from the description. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Oct 21, 2026
Crafted /inference/v1/generate requests can permanently stall vLLM before 0.31.0 by killing the EngineCore input thread with an uncaught VLLMValidationError while /health continues to return 200. The trigger is a generate request that sets max_tokens to null-causing the min_tokens <= max_tokens validation to be skipped-together with an oversized min_tokens value, after which all subsequent generation requests hang until a manual restart. This is an availability-only flaw (CWE-248); the supplied CVSS 4.0 vector scores it 7.1 with PR:L, while our independent assessment uses CVSS 3.1 with PR:N, so authentication or network ACLs in front of the inference API materially reduce exposure, and no public exploit identified at time of analysis.
RemediationAI
Upgrade vLLM to version 0.31.0 or later, which is the first release outside the affected range; the vendor advisory is at https://github.com/vllm-project/vllm/security/advisories/GHSA-4xqp-c3mv-qff7 and the VulnCheck advisory is at https://www.vulncheck.com/advisories/vllm-before-0.31.0-denial-of-service-via-min-tokens-in-inference-v1-generate. If immediate upgrade is not possible, place the /inference/v1/generate endpoint behind authentication and network ACLs-the supplied CVSS 4.0 vector requires PR:L, so gated access reduces exposure, but this does not fix the underlying validation bug and may break legitimate API clients. An upstream proxy can also reject or sanitize requests that set max_tokens to null or that supply an oversized min_tokens, with the trade-off of added proxy complexity and possible false positives for valid null max_tokens use cases. Because /health returns 200 after the EngineCore input thread dies, add synthetic generation checks or process-level monitoring rather than relying solely on /health, and restart the service to recover a hung instance.
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 is an open-source LLM inference and serving engine, and the CPE cpe:2.3:a:vllm-project:vllm:*:*:*:*:*:*:*:* with the stated range before 0.31.0 identifies affected deployments. The vulnerable path is the /inference/v1/generate endpoint's input validation: when max_tokens is null, the code skips the min_tokens <= max_tokens check, allowing an oversized min_tokens to reach the EngineCore input thread and raise VLLMValidationError, which is uncaught; that matches CWE-248 (Uncaught Exception) and terminates the thread rather than returning a controlled error. Because the request handler remains alive and /health still returns 200, liveness probes and orchestration systems can falsely report the service as healthy even though generation is dead, forcing manual restart for recovery. The supplied CVSS 4.0 vector (AV:N/AC:L/AT:N/PR:L/UI:N/VC:N/VI:N/VA:H/SC:N/SI:N/SA:N) and our independent CVSS 3.1 vector (AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H) both confirm availability-only impact with no confidentiality or integrity effect; the input tags include 'Information Disclosure', but that label is inconsistent with the assessed VC:N/VI:N/VA:H impact.
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:N
Network-reachable, single malformed request (AC:L, UI:N); availability-only impact (A:H, C/I:N); PR:N follows the description's 'unauthenticated' claim, though the vendor vector states PR:L.
Primary rating from Vendor (VulnCheck).
CVSS VectorVendor: VulnCheck
Lifecycle Timeline
2DescriptionCVE.org
vLLM before 0.31.0 skips the min_tokens <= max_tokens check for /inference/v1/generate requests with a null max_tokens, so the EngineCore input thread later dies on an uncaught VLLMValidationError while /health still returns 200. Unauthenticated remote attackers can send one request with an oversized min_tokens to hang all subsequent generation requests until manual restart.
Technical POC Analysis
CWE-248 (Uncaught Exception), with CWE-754 as the underlying improper-check condition.
Full technical POC analysis - root cause, step-by-step exploitation and patch breakdown - is part of the Pro and Business plans.
Executive ViewAI
vLLM deployments running versions prior to 0.31.0 can be rendered unavailable by a crafted inference request that permanently stalls the engine while health checks continue to report success, requiring manual restart. This affects teams and customers relying on vLLM-hosted AI generation, creating outage risk and operational burden for production inference services. Leadership should prioritize a rapid inventory and access-control review because no vendor-released patch was identified at time of analysis and recovery depends on manual intervention.
No vendor-released patch identified; restrict inference API exposure with authentication and network ACLs, enforce server-side validation to reject null max_tokens or oversized min_tokens, apply rate limiting, monitor generation throughput separately from /health, and maintain a manual restart procedure.
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
Related Vulnerabilities in vLLM Cache and Resource Consumption Vulnerabilities
View all 7vLLM 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
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).
EUVD-2026-107002
GHSA-qwv5-gq8g-3jwj
NVD
CVE.org
EPSS
Exploit-DB