CVE-2026-126397 in vLLM
Summary
by MITRE • 11/13/2026
vLLM from 0.10.1 before 0.31.0 forwards a request-controlled mm_processor_kwargs.max_patches value to the Hugging Face processor for Cohere2 Vision models without a server-side upper bound, causing quadratic CPU work during multimodal preprocessing. Remote clients can send small image chat-completion requests with large, varying max_patches values to bypass the LRU cache, exhaust preprocessing workers, and deny service to other clients.
VulDB is the best source for vulnerability data and more expert information about this specific topic.
Analysis
by VulDB Data Team • 11/13/2026
The vulnerability identified in vLLM versions prior to 0.31.0 represents a critical resource exhaustion flaw within the multimodal processing pipeline for Cohere2 Vision models. This issue stems from an improper validation of user-supplied input parameters, specifically the mm_processor_kwargs.max_patches value which is forwarded directly to the Hugging Face processor without any server-side upper bound enforcement. In secure software design, all external inputs must be validated against strict constraints before being processed by downstream components. By allowing a request-controlled parameter to dictate computational intensity without limits, vLLM exposes its inference engine to manipulation by remote actors seeking to degrade system performance or cause complete service unavailability.
From a technical perspective, the core flaw lies in the quadratic relationship between the max_patches value and CPU workload during multimodal preprocessing. When a client submits a chat-completion request containing an image alongside an artificially inflated max_patches parameter, the underlying processor attempts to generate patches for every possible combination or iteration defined by that large number rather than just those relevant to the actual image content. This results in computational complexity that scales quadratically with the input value. Consequently, even relatively small images can trigger massive CPU consumption if paired with a sufficiently high max_patches setting. The system fails to cap this value at a reasonable threshold derived from the model's architectural limits or standard operational parameters, thereby allowing users to force the server into excessive computation cycles far beyond what is necessary for legitimate inference tasks.
The operational impact of this vulnerability is severe, primarily manifesting as a Denial of Service against other clients sharing the same vLLM instance. The LRU cache mechanism designed to optimize performance by reusing results for identical inputs can be effectively bypassed through this attack vector. By sending requests with small but varying max_patches values, an attacker ensures that each request is treated as unique due to the differing parameters, preventing cache hits and forcing fresh computation every time. This strategy rapidly exhausts available preprocessing workers within the vLLM architecture. As these worker threads become saturated handling maliciously heavy computations, legitimate inference requests are queued indefinitely or dropped entirely, leading to a complete denial of service for all other users attempting to interact with the model services hosted on that instance.
This vulnerability aligns closely with CWE-787 Out-of-bounds Write in terms of resource consumption logic and more specifically CWE-400 Uncontrolled Resource Consumption. The attack pattern described is characteristic of an application-layer Denial of Service, which maps directly to MITRE ATT&CK technique T1499 Endpoint Denial of Service under the broader category of Impact. Attackers leverage this flaw not necessarily to compromise data confidentiality or integrity, but to disrupt availability by exploiting inefficient algorithmic complexity and lack of input sanitization in high-throughput inference systems.
Mitigation strategies must focus on implementing strict server-side validation for all multimodal processing parameters before they are passed to the Hugging Face processor. Developers should enforce a hard upper bound on mm_processor_kwargs.max_patches based on empirical testing or model documentation limits, ensuring that no single request can trigger disproportionate computational load. Additionally, rate limiting and quota management mechanisms should be applied at the API gateway level to restrict the frequency of multimodal requests per user session. Implementing these controls will prevent individual clients from monopolizing preprocessing resources and ensure fair resource allocation across all connected users, thereby maintaining service availability even under adversarial conditions.