Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessLocate vLLM with trust_remote_code enabled
-
DeliveryPush malicious revision to served model repo
-
ExploitSend multimodal request to /tokenize with code_revision
-
ExecutionAutoProcessor.from_pretrained imports attacker revision
-
ImpactExecute arbitrary Python in API process
Vulnerability Assessment
| Weakness |
CWE
OWASP Top 10:2025
A05:2025 - Injection
ASVS 5.0
V1 - Encoding and Sanitization Code injection prevention, sandbox exec
MITRE ATT&CK
2 techniques across 2 tactics: Execution, Initial Access The technique list with ATT&CK links and the kill-chain view is part of the Basic plan and up. |
| Exploitation Conditions | Two concrete prerequisites, both drawn from the description: (1) the vLLM server must be started with trust_remote_code enabled (a non-default, explicitly security-sensitive option), and (2) the attacker must control a revision in the model repository being served, since mm_processor_kwargs.code_revision selects which revision of the dynamic processor code AutoProcessor.from_pretrained imports. Given those, exploitation is remote and unauthenticated against the /tokenize endpoint via a crafted multimodal request. Limiting factors: default deployments (trust_remote_code disabled) are not exploitable, and the attacker needs write/revision control over the served repo - so the realistic risk centers on setups serving attacker-influenceable or third-party model repos with remote code trusted. |
| Impact | This is a genuine high-priority issue, but with a real precondition that tempers raw-score panic. The CVSS 4.0 vector (AV:N/AC:L/AT:P/PR:N/UI:N, VC:H/VI:H/VA:H, score 9.2) scores arbitrary code execution reached over the network against the unauthenticated /tokenize endpoint, which is why confidentiality, integrity and availability are all High. The decisive nuance is AT:P (Attack Requirements: Present): per the description, exploitation is only possible when trust_remote_code is enabled AND the attacker can control a revision in the served model repository - this is not a drive-by against any default vLLM install. No EPSS score was provided, and there is no KEV listing and no POC in the supplied data, so exploitation status is 'no public exploit identified at time of analysis' - the 9.2 reflects worst-case impact, not demonstrated widespread exploitation. Signals are therefore consistent rather than conflicting: high impact plus a meaningful enabling condition. One important data caveat: the referenced patch commit diff (570735...) contains only MLA sparse-attention kernel changes and is unrelated to mm_processor_kwargs/code_revision, so the supplied source evidence does not corroborate the described fix - verify the actual remediation in the GHSA advisory. |
| Exploit ScenarioDerived | A vLLM deployment serves a multimodal model with trust_remote_code enabled, and the attacker has push access to a revision of that served model repository. The attacker places malicious dynamic processor code in a revision, then sends an unauthenticated multimodal request to /tokenize with mm_processor_kwargs.code_revision pointing at that revision, causing AutoProcessor.from_pretrained to import and execute the attacker's Python inside the vLLM API process. No public POC was identified in the provided data. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Oct 21, 2026
Remote code execution in vLLM 0.7.3 through 0.30.x lets remote, unauthenticated clients run arbitrary Python inside the API server process when a multimodal request to the /tokenize endpoint supplies a crafted mm_processor_kwargs.code_revision value, which vLLM forwards to Transformers AutoProcessor.from_pretrained and uses to select which revision of the model repository's dynamic processor code gets imported. Exploitation requires two non-default preconditions: the server must be running with trust_remote_code enabled, and the attacker must control (or be able to write) a revision in the model repository being served, so default hardened deployments with remote code disabled are not exposed. No public exploit code or confirmed active exploitation was identified at time of analysis, but the impact for exposed configurations is full confidentiality, integrity and availability loss (vendor CVSS 4.0 score 9.2; our independent CVSS 3.1 assessment of 8.1 reflects the high attack complexity created by the prerequisites).
RemediationAI
Upgrade to vLLM 0.31.0 or later (vendor-released patch: 0.31.0); the advisory GHSA-h3rc-6mm3-gc2m and the referenced upstream commit 570735520942b6428ae98f1eb442c6d88adae55e track the fix, which should be validated against the advisory since the visible diff covers unrelated sparse-attention code. If an immediate upgrade is not possible, the highest-value control is to stop starting the server with trust_remote_code (or its equivalent engine/model flag) - this removes the code-import path entirely, at the cost that models genuinely requiring custom remote code will fail to load and must have their processor code vendored and reviewed locally. Second, do not let untrusted parties supply the served repository: pin the model to an operator-controlled, immutable revision and reject or overwrite client-supplied mm_processor_kwargs.code_revision server-side (for example with a reverse proxy or request-rewriting middleware that strips the field), which neutralizes the revision-selection primitive without touching model behavior. Third, restrict network access to the /tokenize endpoint - place the vLLM API behind authentication and allowlist only trusted inference clients - acknowledging that this is compensating for a missing auth boundary rather than fixing the root cause. Finally, run the vLLM process as an unprivileged user with no access to model cache credentials or cloud metadata endpoints, and audit model repositories pulled from third parties or public hubs for unexpected revisions, since those are the realistic delivery vectors for the malicious processor code.
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 multimodal input pipeline accepts per-request processor configuration through mm_processor_kwargs and passes entries such as code_revision directly into Transformers' AutoProcessor.from_pretrained, which resolves a specific git revision of the model repository's processor code. When the server is started with trust_remote_code=True - an opt-in flag vLLM disables by default precisely because it permits model repositories to ship executable Python - the selected revision's processing_*.py / *.py modules are imported and executed inside the vLLM API process. Because /tokenize is an unauthenticated endpoint in the OpenAI-compatible server surface, a client that is also able to publish a malicious revision in the served repository closes the loop and achieves code execution as the vLLM service account, mapped to CWE-94 (Improper Control of Generation of Code). The trust boundary failure is that a request-level parameter (code_revision) is allowed to influence which executable code is loaded, rather than the revision being fixed at model load time by the operator. Note for verification: the linked upstream commit 570735520942b6428ae98f1eb442c6d88adae55e, as visible in the supplied diff, changes MLA sparse-attention kernel block-stride handling (flashinfer_mla_sparse.py, sparse_utils.py, deepseek_v32 kernels) and does not itself show the mm_processor_kwargs/code_revision validation change, so the authoritative fix content should be confirmed against the GitHub security advisory GHSA-h3rc-6mm3-gc2m before relying on that commit alone.
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:P/PR:N/UI:N/VC:H/VI:H/VA:H/SC:N/SI:N/SA:N
PR:N because /tokenize is unauthenticated and AV:N over the API; AC:H reflects the required trust_remote_code config plus attacker control of a served model revision; C/I/A:H from arbitrary Python execution in-process.
Primary rating from Vendor (VulnCheck).
CVSS VectorVendor: VulnCheck
DescriptionCVE.org
vLLM from 0.7.3 before 0.31.0 forwards the request-supplied mm_processor_kwargs.code_revision to Transformers AutoProcessor.from_pretrained, letting clients select which revision of a model's dynamic processor code is imported when trust_remote_code is enabled. An attacker controlling a revision in the served model repository can send a multimodal request to the unauthenticated /tokenize endpoint to execute arbitrary Python in the vLLM API process.
Articles & Coverage 1
Technical POC Analysis
CWE-94, Improper Control of Generation of Code.
Full technical POC analysis - root cause, step-by-step exploitation and patch breakdown - is part of the Pro and Business plans.
Executive ViewAI
A critical remote code execution flaw in vLLM (versions 0.7.3 through 0.30.x) would allow an attacker to run arbitrary Python inside the model-serving API process, handing over full control of the affected host, its model assets, and any data it can reach. Real-world exposure is narrow but serious: only deployments that enable trust_remote_code and serve a model repository an outside party can write to are at risk, so hardened default configurations are not affected. Because vLLM typically sits in front of production AI workloads, leadership should confirm which teams run it in those configurations and drive remediation before attackers begin probing for it.
Apply vendor patch.
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
Code injection occurs when an application accepts user input and passes it directly into a language interpreter or evaluator without proper sanitization.
Remote Code Execution represents the critical moment when an attacker successfully runs arbitrary code on a target system without physical access.
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-107004
GHSA-f623-hjm8-5wg5
NVD
CVE.org
EPSS
Exploit-DB