Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessReach OpenAI-compatible OCR API
-
DeliverySubmit legal zero-sum PNG image
-
Exploitembed_multimodal returns None
-
ExecutionTrip encoder-output sanity assertion
-
ImpactCrash EngineCore, full service DoS
Vulnerability Assessment
| Weakness |
CWE
ASVS 5.0
V16 - Security Logging and Error Handling Reachable assertion handling
|
| Exploitation Conditions | The deployment must be serving a DeepSeek-OCR-family model (deepseek-ai/DeepSeek-OCR, deepseek-ai/DeepSeek-OCR-2, or baidu/Unlimited-OCR via UnlimitedOCRForCausalLM) on vLLM 0.11.1 through before 0.32.0, with the OpenAI-compatible API reachable by the client. The attacker submits a schema-valid image whose normalized pixels sum to exactly 0.0 - e.g. a 1024×1024 half-black/half-white PNG that yields equal counts of -1.0 and +1.0 after Normalize(0.5,0.5), well under the default VLLM_MAX_IMAGE_PIXELS cap. No special server flags, malformed input, or resource exhaustion are needed; it works on default configuration (cudagraph_mm_encoder=False, fault tolerance off). The single limiting factor is that the trigger image must be alone in its per-step encoder batch, which holds on an idle instance and is otherwise achieved by retrying. Scope is limited strictly to deployments serving these OCR models; instances not running them are unaffected. Note the advisory describes default-config unauthenticated reach, which conflicts with the NVD vector's PR:L. |
| Impact | This is a deterministic, single-request denial-of-service (CWE-617 reachable assertion) against vLLM instances serving the DeepSeek-OCR model family. The supplied CVSS 3.1 vector (AV:N/AC:L/PR:L/UI:N/S:U/C:N/I:N/A:H, 6.5) agrees on network reach, low complexity and high-availability-only impact, but its PR:L (authenticated) directly CONFLICTS with the GHSA advisory, which states repeatedly that a single UNAUTHENTICATED request against a DEFAULT configuration kills the engine - this discrepancy should be resolved with the vendor, and the realistic exposure is closer to PR:N. No EPSS score and no KEV status were provided in the input, so there is no signal of active or widespread exploitation; status is 'no public exploit identified' in the strict sense, though a highly detailed public PoC reference (exact trigger image, end-to-end reproduction on vllm/vllm-openai:v0.30.0) exists in the advisory and lowers the bar to weaponize considerably. No SSVC decision record was supplied; the only priority signal is the vuln.today 'this_month' label, consistent with a serious-but-not-emergency DoS that has no confirmed in-the-wild use. Net: this is a genuine, trivially reproducible availability risk for the specific deployments that serve these OCR models (impact is total service outage requiring manual restart), but it is not a confidentiality/integrity issue and shows no evidence of mass exploitation - prioritize patching for affected OCR deployments within the vendor's and advisory's timeframe rather than as a drop-everything emergency. |
| Exploit ScenarioDerived | An attacker who can reach the OpenAI-compatible chat API of a vLLM server running DeepSeek-OCR, DeepSeek-OCR-2, or Unlimited-OCR sends one schema-valid request containing an ordinary 1024×1024 PNG that is half pure black and half pure white. After ToTensor+Normalize(0.5,0.5) the pixels sum to exactly zero, so _parse_and_validate_image_input returns None, embed_multimodal propagates it, and sanity_check_mm_encoder_outputs fires a fatal AssertionError that kills EngineCore and the API server for all users. The attack is ~0.1s, needs no special flags, costs one request, and a detailed reproduction PoC is published in the GHSA advisory; given AV:N/AC:L the only practical caveat is that the trigger image be alone in its encoder batch, which is trivially true on an idle instance and otherwise simply retried. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Oct 26, 2026
Denial of service in vLLM: any deployment serving the DeepSeek-OCR model family (deepseek-ai/DeepSeek-OCR, DeepSeek-OCR-2, or baidu/Unlimited-OCR) can be permanently killed by a single schema-valid chat request containing an ordinary half-black/half-white 1024x1024 PNG, whose pixel values cancel to exactly zero after normalization. That zero sum makes the image parser return no embedding, which trips a fatal encoder-output assertion inside the EngineCore worker; the API server raises EngineDeadError and exits, taking down every in-flight and future request until a manual restart. Affected versions run from 0.11.1 through before 0.32.0 on default configuration, the vendor advisory documents a verified end-to-end reproduction, but there is no CISA KEV listing and no public exploit code identified at time of analysis; the priority rating places remediation in the this-month window rather than emergency response.
RemediationAI
Vendor-released patch: upgrade vLLM to 0.32.0 (https://github.com/vllm-project/vllm/releases/tag/v0.32.0), which removes the 'torch.sum(pixel_values) == 0 -> return None' shortcut from _parse_and_validate_image_input in deepseek_ocr.py and narrows the deepseek_ocr2.py check to a None-only test (PR https://github.com/vllm-project/vllm/pull/59417, commit c15672cfb49152ebf65cfd188e71b84593ec5686), with regression tests confirming balanced half-black/half-white pixels now parse as normal image input. The advisory states there is no mitigation short of patching for affected deployments, so the realistic compensating controls are exposure-reduction rather than fixes: because only instances serving these three OCR checkpoints are vulnerable, placing the OpenAI-compatible API behind an authenticating gateway or taking the OCR model off the public listener eliminates the attack path at the cost of client access, and running the engine under a supervisor that restarts it only shortens downtime since a single retried request can kill it again. Detection can rely on the characteristic AssertionError at v1/worker/utils.py:512 followed by 'EngineCore encountered a fatal error' and an EngineDeadError in the API server log.
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
The flaw is a CWE-617 reachable assertion, not a memory-safety or resource-exhaustion issue. DeepSeek-OCR input validation inherited a shortcut from the upstream research code: if torch.sum(pixel_values).item() == 0, _parse_and_validate_image_input returns None instead of an embedding tensor. In vLLM's serving path that condition is exactly reachable by legitimate data, because DeepseekOCRProcessor applies ToTensor plus Normalize(0.5, 0.5), mapping pure black (0) to exactly -1.0 and pure white (255) to exactly +1.0 in float32; a 1024x1024 image that is half black and half white therefore produces equal counts of -1.0 and +1.0 and a pairwise-reduced sum of exactly 0.0, well inside float32 exactness bounds and far below the default VLLM_MAX_IMAGE_PIXELS cap of 178,956,970. The None propagates through embed_multimodal into sanity_check_mm_encoder_outputs (vllm/v1/worker/utils.py:512), whose assert fires inside the encoder runner with no per-request containment; the exception escapes to the EngineCore busy loop's top-level handler (core.py:1368), engine fault tolerance is off by default, and the API server shuts down via EngineDeadError (async_llm.py:843). The same check exists in deepseek_ocr2.py:339 and is inherited unmodified by UnlimitedOCRForCausalLM (unlimited_ocr.py:244). The CPE cpe:2.3:a:vllm-project:vllm records the package scope; the only practical precondition beyond reachable API access is that the trigger image be alone in its per-step encoder batch, which holds on an idle instance and is otherwise achieved by retrying. Note that NVD's published vector scores PR:L while the advisory and our assessment describe unauthenticated reach against a default deployment.
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:L/PR:L/UI:N/S:U/C:N/I:N/A:H
Advisory confirms unauthenticated default-config reach (PR:N, not PR:L) and a deterministic one-request trigger (AC:L, batch-alone condition is retryable); availability-only total outage, no C/I impact.
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. From 0.11.1 until 0.32.0, the DeepSeek-OCR, DeepSeek-OCR-2, and Unlimited-OCR image path allows a remote client that can reach the OpenAI-compatible API to submit a legal image whose normalized pixels sum to zero when that image is alone in its per-step encoder batch. _parse_and_validate_image_input returns no embedding, embed_multimodal propagates that value, and sanity_check_mm_encoder_outputs triggers a fatal assertion that shuts down the engine for all users. This issue is fixed in version 0.32.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
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-110032
GHSA-gq5q-89c7-vhvx
NVD
CVE.org
EPSS
Exploit-DB