Skip to main content

vLLM EUVDEUVD-2026-107004

| CVE-2026-114053 CRITICAL
Code Injection (CWE-94)
2026-10-21 VulnCheck GHSA-f623-hjm8-5wg5
9.2
CVSS 4.0 · Vendor: VulnCheck
View

Attack ChainAIDerived

Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain

  1. Access
    Locate vLLM with trust_remote_code enabled
  2. Delivery
    Push malicious revision to served model repo
  3. Exploit
    Send multimodal request to /tokenize with code_revision
  4. Execution
    AutoProcessor.from_pretrained imports attacker revision
  5. Impact
    Execute 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.

Act Now Prioritize within 24-48h. Why: CRITICAL severity.
Patch available 0.5% exploitation probability (EPSS)

Get an e-mail when this CVE is exploited, patched or re-scored. Free account.

Alert me

AnalysisAIv1 – 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

vllm 0.7.3 <0.31.0

Affected Packages

euvd vllm fix: 0.31.0

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

Vendor (VulnCheck) PRIMARY 9.2 CRITICAL
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
vuln.today AI 8.1 HIGH

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.

3.1 AV:N/AC:H/PR:N/UI:N/S:U/C:H/I:H/A:H
4.0 AV:N/AC:L/AT:P/PR:N/UI:N/VC:H/VI:H/VA:H/SC:N/SI:N/SA:N

Primary rating from Vendor (VulnCheck).

CVSS VectorVendor: VulnCheck

Attack Vector
Network
Attack Complexity
Low
Attack Requirements
Present
Privileges Required
None
User Interaction
None
Vulnerable system: Confidentiality
High
Vulnerable system: Integrity
High
Vulnerable system: Availability
High
Subsequent system: Confidentiality
None
Subsequent system: Integrity
None
Subsequent system: Availability
None

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.

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

Why It Matters

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.

Business Impact: High
Compensating Controls

Apply vendor patch.

Threat Intelligence Overview

EPSS Score
0.5%
Top 61% exploitable
Prevalence
Medium
dominant self-hosted LLM inference server, but confined to ML-serving deployments
Data Quality
5 sources
Confidence: Medium

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.

SignalValue
Severity CRITICAL
CISA KEV No
Public POC No
EPSS 0.5%
Patch available Yes
Active threat No
Deciding rule
CRITICAL severity
What every action level means
Emergency Immediate action required. Criteria: CRITICAL + in CISA KEV (actively exploited) without patch, OR CRITICAL + EPSS > 30% without patch, OR CRITICAL + active threat signals without patch.
Act Now Prioritize within 24-48h. Criteria: in KEV with patch available, OR CRITICAL + public POC, OR HIGH + EPSS > 10%, OR CRITICAL + active threat, OR any CRITICAL severity.
This Week Schedule remediation this week. Criteria: HIGH severity (CVSS 7.0-8.9). Patch within normal change window.
This Month Plan within 30 days. Criteria: MEDIUM severity (CVSS 4.0-6.9), lower exploitation probability. Include in regular patch cycle.
Monitor Track and reassess. Criteria: LOW severity (CVSS 0.1-3.9), minimal exploitation risk. No immediate action needed.

SSVC AssessmentENISA

SSVC Decision· derived
Scheduled
Exploitation· derived
None
System Exposure· derived
Open
Automatable· derived
Yes
Human Impact
High

Priority Score

46
Low Medium High Critical
KEV: 0
EPSS: 0
CVSS: +46
PoC: 0
Weaponized: 0
Threat intel: 0
Gov advisory: 0

Attack Technique

Code Injection CRITICAL

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.

More in Vllm

View all
CVE-2025-32444 CRITICAL POC
10.0 Apr 30

vLLM is a high-throughput and memory-efficient inference and serving engine for LLMs. Rated critical severity (CVSS 10.0

CVE-2024-11041 CRITICAL POC
9.8 Mar 20

vllm-project vllm version v0.6.2 contains a vulnerability in the MessageQueue.dequeue() API function. Rated critical sev

CVE-2026-22778 CRITICAL POC
9.8 Feb 02

Information exposure in vLLM inference engine versions 0.8.3 to before 0.14.1. Invalid image requests to the multimodal

CVE-2025-59425 HIGH POC
7.5 Oct 07

Timing-based API key recovery in vLLM before 0.11.0rc2 can let remote attackers bypass bearer-token authentication on de

CVE-2025-30202 HIGH POC
7.5 Apr 30

vLLM is a high-throughput and memory-efficient inference and serving engine for LLMs. Rated high severity (CVSS 7.5), th

CVE-2026-24779 HIGH POC
7.1 Jan 27

vLLM before version 0.14.1 contains a server-side request forgery vulnerability in the MediaConnector class where incons

CVE-2026-57173 MEDIUM POC
6.5 Sep 16

Out-of-memory worker crashes in vLLM can be induced by a single small compressed audio payload submitted to the /v1/chat

CVE-2025-46560 MEDIUM POC
6.5 Apr 30

vLLM is a high-throughput and memory-efficient inference and serving engine for LLMs. Rated medium severity (CVSS 6.5),

CVE-2026-69147 MEDIUM POC
6.5 Sep 16

GPU memory exhaustion in vLLM versions prior to 0.28.0 lets an attacker with low-privileged API access (PR:L in the CVSS

CVE-2026-105753 MEDIUM POC
6.5 Oct 05

Multimodal inference requests to vLLM deployments running versions prior to 0.28.0 can trigger a process-level assertion

CVE-2026-73559 MEDIUM POC
6.5 Aug 13

Uncontrolled resource consumption in vLLM's OpenAI-compatible completions endpoint allows any authenticated API client t

CVE-2026-22773 MEDIUM POC
6.5 Jan 10

Vllm versions up to 0.12.0 is affected by allocation of resources without limits or throttling (CVSS 6.5).

This site uses cookies essential for authentication and security. No tracking or analytics cookies are used. Privacy Policy