Vulnerabilities in pkg:pypi/vllm

PACKAGE
Advisory Identifier: GHSA-ph3r-5jfg-f84f
Advisory Summary

CVE-2026-105753 is a MODERATE (CVSS 6.5) mirrored multimodal ipc caches desync vulnerability (CWE-617: Reachable Assertion) affecting vLLM libraries in the PyPI ecosystem. The issue involves mirrored multimodal ipc caches desync after a rejected request — a later request reusing the same media hash trips a receiver assertion in the engine core. Remediation is available by upgrading affected packages to version 0.28.0.

80 Known Advisory Record(s)
Package Vulnerability Intelligence

pkg:pypi/vllm

80 Known Advisory Record(s)

Vulnerability advisories affecting package pkg:pypi/vllm. Select an advisory below to view technical details or fixes.

Advisory ID CVE / NVD Severity Summary
GHSA-ph3r-5jfg-f84f CVE-2026-105753 MODERATE vLLM: Mirrored multimodal IPC caches desync after a rejected request — a later request reusing the same media hash trips a receiver assertion in the engine core
GHSA-935w-9g4m-p28p CVE-2026-105752 LOW vLLM: Harmony tool continuations drop `cache_salt` — restoring a cross-tenant prefix-cache membership oracle
GHSA-x6mc-67gf-chw4 CVE-2026-105758 MODERATE vLLM: Qwen2-VL / Qwen3-VL video samplers bound on request-controlled max_frames, which the num_frames ceiling does not reach
GHSA-58v5-2m8f-94pr CVE-2026-105760 MODERATE vLLM: GLMGA video sampling permits request-driven CPU and memory exhaustion
GHSA-ph72-cqr5-qpp7 CVE-2026-105754 MODERATE vLLM: Scale-out disaggregated multimodal transport trusts caller-supplied features
GHSA-85xf-c7hm-whqw CVE-2026-105757 MODERATE vLLM: Structured-output request errors escape the request boundary and terminate the shared EngineCore — engine-fatal denial of service (3 sites)
GHSA-2phq-3phc-84px CVE-2026-105755 MODERATE vLLM: Flash late-interaction scoring caches query embeddings under a caller-controlled request id — cross-request integrity break and induced errors on `/score` and `/rerank`
GHSA-2823-qmq8-rwvj CVE-2026-105756 MODERATE vLLM: Loose `cache_salt` validation lets a single request kill EngineCore on LMCache-MP deployments — uncaught downstream `ValueError` denial of service
GHSA-8pw2-6jv3-mj5j CVE-2026-69147 MODERATE vLLM: Request-selected PyNvVideoCodec GPU decode bypasses static VRAM reservation
GHSA-hcwq-8wjf-3gcr CVE-2026-57173 MODERATE vLLM: Unauthenticated audio decompression-bomb DoS in /v1/chat/completions
GHSA-mcmc-2m55-j8jj CVE-2026-56340 HIGH vLLM introduced enhanced protection for CVE-2025-62164
GHSA-78fp-cf4h-g36p - HIGH Duplicate Advisory: vLLM introduced enhanced protection for CVE-2025-62164
GHSA-vfm7-4h43-gp6m - MODERATE Duplicate Advisory: vLLM Vulnerable to Regular Expression Denial of Service
GHSA-4hhp-h66f-j5j7 CVE-2026-73560 MODERATE vLLM: SSRF + arbitrary local file read in MiMoV2OmniMultiModalProcessor `_fetch_image` and audio loader bypass MediaConnector protections
GHSA-7m6h-x95x-82q5 CVE-2026-73558 MODERATE vLLM: Cross-User Data Leak Vulnerability
GHSA-pr7f-p5mw-fc87 CVE-2026-73557 MODERATE vLLM: Incomplete CVE-2025-62164 remediation can be bypassed by concurrent prompt parts
GHSA-48jh-3gj7-fg8v CVE-2026-73556 MODERATE vLLM: ReDoS via structured_outputs.regex in the lm-format-enforcer backend (no compile timeout) — missed sibling of GHSA-rwxx-mrjm-wc2m
GHSA-hwrm-c4cx-rf4j CVE-2026-73555 MODERATE vLLM: Unauthenticated Internal Path and Username Disclosure via Validation Error Messages
GHSA-8737-qx52-hjff CVE-2026-71486 MODERATE vLLM: Derender endpoints decode caller-supplied GenerateResponse token IDs without output bounds
GHSA-q8gq-377p-jq3r CVE-2026-41523 HIGH vLLM: Security Check Bypass via assert Statement in Activation Function Loading Allows Arbitrary Code Execution
GHSA-94f4-hr76-p5j6 CVE-2026-48746 CRITICAL vLLM: OpenAI auth bypass
GHSA-pq5c-rjhq-qp7p CVE-2026-34755 MODERATE vLLM: Denial of Service via Unbounded Frame Count in video/jpeg Base64 Processing
GHSA-wcwg-c5fc-9vrc CVE-2026-5497 HIGH vLLM is vulnerable to an Out-of-Memory (OOM) Denial of Service (DoS) attack due to unbounded frame count processing in the `VideoMediaIO.load_base64()` method
GHSA-87x5-vmc3-756j CVE-2026-73559 MODERATE vLLM: Completion prompt lists fan out into unbounded engine requests
GHSA-qh4c-xf7m-gxfc CVE-2026-24779 HIGH vLLM vulnerable to Server-Side Request Forgery (SSRF) through MediaConnector
GHSA-2pc9-4j83-qjmr CVE-2026-22807 HIGH vLLM affected by RCE via auto_map dynamic module loading during model initialization
GHSA-33cg-gxv8-3p8g CVE-2026-55514 HIGH vLLM denial of service via prompt embeds on M-RoPE models
GHSA-hgg8-fqqc-vfmw CVE-2026-54236 MODERATE vLLM: incomplete CVE-2026-22778 fix leaks PIL repr addresses via Anthropic router
GHSA-v82g-2437-67m2 CVE-2026-55646 MODERATE vLLM: Speech-to-text upload size limit is enforced after full UploadFile read
GHSA-rwxx-mrjm-wc2m CVE-2026-55574 HIGH vLLM: ReDoS via structured_outputs.regex compiled without timeout in xgrammar and outlines backends
GHSA-8wr5-jm2h-8r4f CVE-2026-54234 HIGH vLLM has Remote DoS via Invalid Recovered Token Reinjection
GHSA-6c4r-fmh3-7rh8 CVE-2026-34760 MODERATE vLLM: Processing differential in multi-channel audio downmixing enables hidden-input/moderation bypass for audio models
GHSA-7h4p-rffg-7823 CVE-2026-54235 MODERATE vLLM: temperature=NaN and temperature=Infinity bypass validation and propagate to GPU kernels
GHSA-6pr9-rp53-2pmc CVE-2026-54233 MODERATE vLLM: OOM Denial of Service via Audio Decompression Bomb
GHSA-8jr5-v98p-w75m CVE-2026-12491 MODERATE vLLM: image EXIF Rotation & PNG tRNS Transparency Not Normalized, Causing Mismatch Between Model Input and Expectations
GHSA-3ww4-5jv9-j5gm CVE-2026-47155 MODERATE vLLM's Artifact Pin Decay allows pinned deployments to load unpinned code, weights, and processors
GHSA-hpv8-x276-m59f CVE-2026-44222 MODERATE vLLM Vulnerable to Remote DoS via Special-Token Placeholders
GHSA-5jv2-g5wq-cmr4 CVE-2026-53923 MODERATE vLLM: GGUF dequantize kernel int truncation exposes uninitialized GPU memory in multi-tenant serving
GHSA-3mwp-wvh9-7528 CVE-2026-34756 MODERATE vLLM: Unauthenticated OOM Denial of Service via Unbounded `n` Parameter in OpenAI API Server
GHSA-pf3h-qjgv-vcpr CVE-2026-34753 MODERATE vLLM: Server-Side Request Forgery (SSRF) in `download_bytes_from_url `
GHSA-7972-pg2x-xr59 CVE-2026-27893 HIGH vLLM has Hardcoded Trust Override in Model Files Enables RCE Despite Explicit User Opt-Out
GHSA-v359-jj2v-j536 CVE-2026-25960 MODERATE vLLM has SSRF Protection Bypass
GHSA-4r2x-xpjr-7cvv CVE-2026-22778 CRITICAL vLLM has RCE In Video Processing
GHSA-8fr4-5q9j-m8gm CVE-2025-66448 HIGH vLLM vulnerable to remote code execution via transformers_utils/get_config
GHSA-69j4-grxj-j64p CVE-2025-62426 MODERATE vLLM vulnerable to DoS via large Chat Completion or Tokenization requests with specially crafted `chat_template_kwargs`
GHSA-pmqf-x6x8-p7qw CVE-2025-62372 HIGH vLLM vulnerable to DoS with incorrect shape of multimodal embedding inputs
GHSA-mrw7-hf4f-83pf CVE-2025-62164 HIGH vLLM deserialization vulnerability leading to DoS and potential RCE
GHSA-wr9h-g72x-mwhm CVE-2025-59425 HIGH vLLM is vulnerable to timing attack at bearer auth
GHSA-rxc4-3w6r-4v47 CVE-2025-48956 HIGH vllm API endpoints vulnerable to Denial of Service Attacks
GHSA-vrq3-r879-7m65 CVE-2025-48944 MODERATE vLLM Tool Schema allows DoS via Malformed pattern and type Fields
GHSA-hjq4-87xh-g4fv CVE-2025-47277 CRITICAL vLLM Allows Remote Code Execution via PyNcclPipe Communication Service
GHSA-vc6m-hm49-g9qg CVE-2025-46560 MODERATE vLLM: Quadratic Time Complexity in Input Token Processing​ leads to denial of service
GHSA-9f8f-2vmf-885j CVE-2025-30202 HIGH Data exposure via ZeroMQ on multi-node vLLM deployment
GHSA-9pcc-gvx5-r5wm CVE-2025-30165 HIGH Remote Code Execution Vulnerability in vLLM Multi-Node Cluster Configuration
GHSA-98f3-hwg4-4rf7 CVE-2026-9540 MODERATE vllm has Improper Resource Shutdown or Release
GHSA-x8xr-mj9x-6h7w - MODERATE Duplicate Advisory: image EXIF Rotation & PNG tRNS Transparency Not Normalized, Causing Mismatch Between Model Input and Expectations
GHSA-83vm-p52w-f9pw CVE-2026-44223 MODERATE vLLM: extract_hidden_states speculative decoding crashes server on any request with penalty parameters
GHSA-grg2-63fw-f2qr CVE-2026-22773 MODERATE vLLM is vulnerable to DoS in Idefics3 vision models via image payload with ambiguous dimensions
GHSA-cj47-qj6g-x7r4 CVE-2024-9053 CRITICAL vLLM allows Remote Code Execution by Pickle Deserialization via AsyncEngineRPCServer() RPC server entrypoints
GHSA-mgrm-fgjv-mhv8 CVE-2025-29770 MODERATE vLLM denial of service via outlines unbounded cache on disk
GHSA-x368-4g9h-fvv4 CVE-2026-7141 LOW vLLM makes Use of Uninitialized Resource
GHSA-3f6c-7fw2-ppm4 CVE-2025-6242 HIGH vLLM is vulnerable to Server-Side Request Forgery (SSRF) through `MediaConnector` class
GHSA-6fvq-23cw-5628 CVE-2025-61620 MODERATE vLLM: Resource-Exhaustion (DoS) through Malicious Jinja Template in OpenAI-Compatible Server
GHSA-79j6-g2m3-jgfw CVE-2025-9141 HIGH vLLM has remote code execution vulnerability in the tool call parser for Qwen3-Coder
GHSA-x3m8-f7g5-qhm7 CVE-2025-29783 CRITICAL vLLM Allows Remote Code Execution via Mooncake Integration
GHSA-rm76-4mrf-v9r8 CVE-2025-25183 LOW vLLM uses Python 3.12 built-in hash() which leads to predictable hash collisions in prefix cache
GHSA-rh4j-5rhw-hr54 CVE-2025-24357 HIGH vllm: Malicious model to RCE by torch.load in hf_model_weights_iterator
GHSA-9hcf-v7m4-6m2j CVE-2025-48943 MODERATE vLLM allows clients to crash the openai server with invalid regex
GHSA-6qc9-v4r8-22xg CVE-2025-48942 MODERATE vLLM DOS: Remotely kill vllm over http with invalid JSON schema
GHSA-4qjh-9fv9-r85r CVE-2025-46570 LOW Potential Timing Side-Channel Vulnerability in vLLM’s Chunk-Based Prefix Caching
GHSA-w6q7-j642-7c25 CVE-2025-48887 MODERATE vLLM has a Regular Expression Denial of Service (ReDoS, Exponential Complexity) Vulnerability in `pythonic_tool_parser.py`
GHSA-c65p-x677-fgj6 CVE-2025-46722 MODERATE vLLM has a Weakness in MultiModalHasher Image Hashing Implementation
GHSA-hj4w-hm2g-p6w5 CVE-2025-32444 CRITICAL vLLM Vulnerable to Remote Code Execution via Mooncake Integration
GHSA-j828-28rj-hfhp - MODERATE vLLM vulnerable to Regular Expression Denial of Service
GHSA-ggpf-24jw-3fcw - CRITICAL CVE-2025-24357 Malicious model remote code execution fix bypass with PyTorch < 2.6.0
GHSA-hf3c-wxg2-49q9 - MODERATE vLLM vulnerable to Denial of Service by abusing xgrammar cache
GHSA-pgr7-mhp5-fgjp CVE-2024-9052 CRITICAL vLLM deserialization vulnerability in vllm.distributed.GroupCoordinator.recv_object
GHSA-5vqr-wprc-cpp7 CVE-2024-11041 CRITICAL vLLM Deserialization of Untrusted Data vulnerability
GHSA-wc36-9694-f9rf CVE-2024-8939 MODERATE vLLM Denial of Service via the best_of parameter
GHSA-w2r7-9579-27hf CVE-2024-8768 HIGH vLLM denial of service vulnerability

CVE-2026-105753 at a Glance

CVE Identifier CVE-2026-105753
GHSA Identifier GHSA-ph3r-5jfg-f84f
Severity MODERATE
CVSS v3.1 Base Score 6.5
CWE Classification CWE-617: Reachable Assertion
Affected Product vLLM
Package Ecosystem PyPI
Published Date
Last Updated

Security Impact

CVSS: 6.5

The security impact metrics below are parsed directly from the CVSS v3.1 vector string (CVSS:3.1/AV:N/AC:L/PR:L/UI:N/S:U/C:N/I:N/A:H).

Attack Vector Network (AV:N)
Attack Complexity Low (AC:L)
Privileges Required Low (PR:L)
User Interaction None (UI:N)
Scope Unchanged (S:U)
Confidentiality None (C:N)
Integrity None (I:N)
Availability High (A:H)

How to Fix CVE-2026-105753

To remediate this vulnerability, upgrade all affected vLLM dependencies to a patched release. Both direct and transitive dependencies should be checked, as frameworks or security libraries may pull in vulnerable versions transitively.

vllm fixed: 0.28.0
pip install vllm>=0.28.0
Verify Direct and Transitive Dependencies

Run the following command in your project directory to verify that all resolved dependencies use the patched release:

pip show vllm

How to Check if You Are Affected

To determine whether your Python environment is affected by CVE-2026-105753, inspect your installed packages using pip:

pip show vllm

Analyze the terminal output to locate any version of vLLM in your dependency tree. If any resolved version matches the vulnerable ranges listed in the table below (for example, versions earlier than 0.28.0), your application is affected.

Note: The pip show vllm command checks currently installed packages in your active Python environment.

Technical Details

Vulnerability Mechanism & Technical Analysis

This vulnerability is classified under CWE-617: Reachable Assertion, where the product contains an assert() or similar statement that can be triggered by an attacker, which leads to an application exit or other behavior that is more severe than necessary. In vLLM, software state validation or input boundaries are circumvented during processing. Review the official source advisory statement below for specific affected components, classes, and reproduction details.

Source Advisory Statement

## Affected - **Ecosystem / package:** pip / `vllm` - **Affected versions:** vLLM ≤ 0.25.1 (confirmed on 0.25.1, commit [`752a3a504485`](https://github.com/vllm-project/vllm/tree/752a3a504485790a2e8491cacbb35c137339ad34)). The lower bound predates 0.25.1; maintainers can confirm how far back the mirrored sender/receiver cache protocol reaches. ## Summary vLLM's default multimodal cache (`mm_processor_cache_type="lru"`) mirrors state across two processes: the frontend (P0) holds only metadata (`MultiModalProcessorSenderCache`) while the engine core (P1) holds the real payload (`MultiModalReceiverCache`). The design invariant is that `get_and_update()` runs on P0 and P1 in lockstep for every request, so eviction order stays mirrored and P0 can answer "is this cached in P1?" without talking to P1. That invariant breaks when a request is **rejected after P0 has rendered and hashed the multimodal input** (populating the P0 cache) **but before P1 receives the item** — for example, an oversized chat prompt rejected on `max_model_len` *after* rendering. P0 now believes the media is cached while P1 never got it. A later request reusing the same media hash gets a P0 hit, so P0 sends `None` instead of the payload, and P1 — which has nothing cached — trips `assert mm_item is not None, f"Expected a cached item for {mm_hash=}"`. This is a remotely reachable, request-controlled cache-mirroring desync on the standard multimodal inference path. It requires only the default cache configuration. ## Affected code Links pinned to the confirmed commit [`752a3a504485`](https://github.com/vllm-project/vllm/tree/752a3a504485790a2e8491cacbb35c137339ad34) (v0.25.1): - **P0 metadata cache** — `MultiModalProcessorSenderCache` at [`vllm/multimodal/cache.py#L379`](https://github.com/vllm-project/vllm/blob/752a3a504485790a2e8491cacbb35c137339ad34/vllm/multimodal/cache.py#L379); `get_and_update_item` at [`#L410-L421`](https://github.com/vllm-project/vllm/blob/752a3a504485790a2e8491cacbb35c137339ad34/vllm/multimodal/cache.py#L410-L421), commit assertion at [`#L418`](https://github.com/vllm-project/vllm/blob/752a3a504485790a2e8491cacbb35c137339ad34/vllm/multimodal/cache.py#L418). - **P1 payload cache (the actual sink)** — `MultiModalReceiverCache` at [`vllm/multimodal/cache.py#L630`](https://github.com/vllm-project/vllm/blob/752a3a504485790a2e8491cacbb35c137339ad34/vllm/multimodal/cache.py#L630); `get_and_update_item` at [`#L652-L663`](https://github.com/vllm-project/vllm/blob/752a3a504485790a2e8491cacbb35c137339ad34/vllm/multimodal/cache.py#L652-L663), with the failing `assert mm_item is not None, f"Expected a cached item for {mm_hash=}"` at [`#L660`](https://github.com/vllm-project/vllm/blob/752a3a504485790a2e8491cacbb35c137339ad34/vllm/multimodal/cache.py#L660). - **Default `mm_processor_cache_type = "lru"`** at [`vllm/config/multimodal.py#L132`](https://github.com/vllm-project/vllm/blob/752a3a504485790a2e8491cacbb35c137339ad34/vllm/config/multimodal.py#L132); dispatch in [`vllm/multimodal/registry.py#L294-L307`](https://github.com/vllm-project/vllm/blob/752a3a504485790a2e8491cacbb35c137339ad34/vllm/multimodal/registry.py#L294-L307) (sender) and [`#L322-L331`](https://github.com/vllm-project/vllm/blob/752a3a504485790a2e8491cacbb35c137339ad34/vllm/multimodal/registry.py#L322-L331) (receiver). The `processor_only`, disabled-caching, and `shm` paths are not affected. - **Rejection-after-render window** — rendering happens before length validation in [`vllm/entrypoints/openai/chat_completion/serving.py#L206-L231`](https://github.com/vllm-project/vllm/blob/752a3a504485790a2e8491cacbb35c137339ad34/vllm/entrypoints/openai/chat_completion/serving.py#L206-L231) (`render_chat_request`), and the length check raises after the render in [`vllm/entrypoints/serve/utils/api_utils.py#L171-L189`](https://github.com/vllm-project/vllm/blob/752a3a504485790a2e8491cacbb35c137339ad34/vllm/entrypoints/serve/utils/api_utils.py#L171-L189). - **Cache-commit call site** — [`vllm/multimodal/processing/processor.py#L1347`](https://github.com/vllm-project/vllm/blob/752a3a504485790a2e8491cacbb35c137339ad34/vllm/multimodal/processing/processor.py#L1347) (`_merge_mm_kwargs`) commits the P0 sender entry during render. - The separate stale-order eviction hang is already fixed via [`vllm/utils/cache.py#L120-L121`](https://github.com/vllm-project/vllm/blob/752a3a504485790a2e8491cacbb35c137339ad34/vllm/utils/cache.py#L120-L121) (`LRUCache.touch()` guarding `if key in self:`) — a different mechanism that does not touch the sender/receiver commit-ordering protocol and does not remediate this assertion. The P1 receiver sink — the assertion that fires when P1 receives `None` for a hash it never cached: ```python # vllm/multimodal/cache.py Lines 651-663 @override def get_and_update_item( self, mm_item: MultiModalKwargsItem | None, mm_hash: str, ) -> MultiModalKwargsItem: if (cached_item := self._cache.get(mm_hash)) is not None: return cached_item assert mm_item is not None, f"Expected a cached item for {mm_hash=}" self._cache[mm_hash] = mm_item return mm_item ``` The P0 sender — on a hit it drops the payload (returns `None`) and, on a miss during render, unconditionally commits the metadata entry with no rollback tied to admission: ```python # vllm/multimodal/cache.py Lines 409-422 @override def get_and_update_item( self, mm_item: MultiModalProcessorCacheInItem, mm_hash: str, ) -> MultiModalProcessorCacheOutItem: if (cached_item := self._cache.get(mm_hash)) is not None: return None, cached_item.prompt_updates assert mm_item is not None, f"Expected a cached item for {mm_hash=}" self._cache[mm_hash] = MultiModalProcessorCacheItemMetadata(*mm_item) return mm_item ``` ## Impact A remote client submitting multimodal requests can poison a cache identity — render a media item successfully, then have that request rejected — so a **later** request reusing the same media hash fails on the P1 receiver assertion. This is an availability failure against a shared serving instance. No code execution, memory corruption, or data disclosure is claimed. On this revision the failure is scoped as a request-level preprocessing error (the engine core catches around `preprocess_add_request`); public reports show the same assertion cascading into further engine-loop assertions on other revisions. It applies to multimodal models running the default mirrored `lru` cache. ## Suggested Fix Two complementary changes: 1. **Make the mirrored commit atomic with admission** — insert into the P0 sender cache only after the request has passed all admission checks (length, limits) and P1 has acknowledged the item, or roll back the P0 insert on rejection. 2. **Defense in depth** — convert the P1 receiver `assert mm_item is not None` into a checked, request-scoped error (fetch-on-miss from P0) so a desync degrades a single request rather than asserting in the engine loop. The core of the rollback half: wrap the post-render length check so a `ValueError` rejection discards the P0 entries the render just committed, before re-raising. Add a `discard_sender_cache_item()` on the processor cache (no-op default, `pop` on the sender) and a `Renderer.discard_mm_cache_entries()` that walks a rendered request's `mm_hashes`: ```python # vllm/entrypoints/openai/chat_completion/serving.py (_create_chat_completion) - max_tokens = get_max_tokens( - max_model_len, - ..., - truncate_prompt_tokens=request.truncate_prompt_tokens, - ) + try: + max_tokens = get_max_tokens( + max_model_len, + ..., + truncate_prompt_tokens=request.truncate_prompt_tokens, + ) + except ValueError: + for rendered_input in engine_inputs: + if mm_hashes := rendered_input.get("mm_hashes"): + self.renderer.discard_mm_cache_entries(mm_hashes) + raise ``` ```python # vllm/multimodal/cache.py (MultiModalProcessorSenderCache) + @override + def discard_sender_cache_item(self, mm_hash: str) -> None: + self._cache.pop(mm_hash, None) ``` This closes the `max_model_len` rejection path; because any other rejection-after-render path reopens the same window, pairing it with the defense-in-depth change above (making the P1 `assert` a checked, request-scoped error) is recommended. ## Credit **Reported by:** Patch the Planet (Trail of Bits + OpenAI collaboration) This vulnerability was discovered using GPT-5.5-Cyber as part of the Patch the Planet security initiative. --- **Proposed fix:** a fix for this issue is proposed in a public pull request: https://github.com/vllm-project/vllm/pull/51897

CVE-2026-105753 Affected vLLM Versions

1 component(s)
Fixed Versions:
0.28.0
Product / Package Ecosystem Affected Versions Fixed Version
vllm
PyPI
< 0.28.0
0.28.0

References

Frequently Asked Questions

What is CVE-2026-105753?
CVE-2026-105753 is a security vulnerability in vLLM involving Mirrored multimodal IPC caches desync after a rejected request — a later request reusing the same media hash trips a receiver assertion in the engine core under CWE-617: Reachable Assertion.
Which vLLM versions are affected?
Affected versions include releases prior to 0.28.0 across affected packages: vllm.
What version fixes CVE-2026-105753?
Upgrading to 0.28.0 (or the latest patched release for your respective branch) resolves the vulnerability.
Is vllm affected?
Yes, vllm is affected in releases prior to 0.28.0. Upgrade your dependency to 0.28.0 or later.
What is the CVSS score of CVE-2026-105753?
CVE-2026-105753 has a CVSS v3.1 base score of 6.5 (MODERATE) with vector string CVSS:3.1/AV:N/AC:L/PR:L/UI:N/S:U/C:N/I:N/A:H.
What CWE is associated with CVE-2026-105753?
CVE-2026-105753 is classified under CWE-617: Reachable Assertion (The product contains an assert() or similar statement that can be triggered by an attacker, which leads to an application exit or other behavior that is more severe than necessary.).
How can I check PyPI dependencies for CVE-2026-105753?
Run the dependency tree command: 'pip show vllm'. This command lists direct and transitive dependencies in your build configuration so you can verify if a vulnerable version is resolved.
Machine-readable OSV JSON OSV v1.5 Schema
Normalized schema output
{
  "schema_version" : "1.4.0",
  "id" : "GHSA-ph3r-5jfg-f84f",
  "modified" : "2026-10-06T00:02:06Z",
  "published" : "2026-10-06T00:02:05Z",
  "aliases" : [ "CVE-2026-105753" ],
  "summary" : "vLLM: Mirrored multimodal IPC caches desync after a rejected request — a later request reusing the same media hash trips a receiver assertion in the engine core",
  "details" : "## Affected\n\n- **Ecosystem / package:** pip / `vllm`\n- **Affected versions:** vLLM ≤ 0.25.1 (confirmed on 0.25.1, commit [`752a3a504485`](https://github.com/vllm-project/vllm/tree/752a3a504485790a2e8491cacbb35c137339ad34)). The lower bound predates 0.25.1; maintainers can confirm how far back the mirrored sender/receiver cache protocol reaches.\n\n## Summary\n\nvLLM's default multimodal cache (`mm_processor_cache_type=\"lru\"`) mirrors state across two processes: the frontend (P0) holds only metadata (`MultiModalProcessorSenderCache`) while the engine core (P1) holds the real payload (`MultiModalReceiverCache`). The design invariant is that `get_and_update()` runs on P0 and P1 in lockstep for every request, so eviction order stays mirrored and P0 can answer \"is this cached in P1?\" without talking to P1.\n\nThat invariant breaks when a request is **rejected after P0 has rendered and hashed the multimodal input** (populating the P0 cache) **but before P1 receives the item** — for example, an oversized chat prompt rejected on `max_model_len` *after* rendering. P0 now believes the media is cached while P1 never got it. A later request reusing the same media hash gets a P0 hit, so P0 sends `None` instead of the payload, and P1 — which has nothing cached — trips `assert mm_item is not None, f\"Expected a cached item for {mm_hash=}\"`.\n\nThis is a remotely reachable, request-controlled cache-mirroring desync on the standard multimodal inference path. It requires only the default cache configuration.\n\n## Affected code\n\nLinks pinned to the confirmed commit [`752a3a504485`](https://github.com/vllm-project/vllm/tree/752a3a504485790a2e8491cacbb35c137339ad34) (v0.25.1):\n\n- **P0 metadata cache** — `MultiModalProcessorSenderCache` at [`vllm/multimodal/cache.py#L379`](https://github.com/vllm-project/vllm/blob/752a3a504485790a2e8491cacbb35c137339ad34/vllm/multimodal/cache.py#L379); `get_and_update_item` at [`#L410-L421`](https://github.com/vllm-project/vllm/blob/752a3a504485790a2e8491cacbb35c137339ad34/vllm/multimodal/cache.py#L410-L421), commit assertion at [`#L418`](https://github.com/vllm-project/vllm/blob/752a3a504485790a2e8491cacbb35c137339ad34/vllm/multimodal/cache.py#L418).\n- **P1 payload cache (the actual sink)** — `MultiModalReceiverCache` at [`vllm/multimodal/cache.py#L630`](https://github.com/vllm-project/vllm/blob/752a3a504485790a2e8491cacbb35c137339ad34/vllm/multimodal/cache.py#L630); `get_and_update_item` at [`#L652-L663`](https://github.com/vllm-project/vllm/blob/752a3a504485790a2e8491cacbb35c137339ad34/vllm/multimodal/cache.py#L652-L663), with the failing `assert mm_item is not None, f\"Expected a cached item for {mm_hash=}\"` at [`#L660`](https://github.com/vllm-project/vllm/blob/752a3a504485790a2e8491cacbb35c137339ad34/vllm/multimodal/cache.py#L660).\n- **Default `mm_processor_cache_type = \"lru\"`** at [`vllm/config/multimodal.py#L132`](https://github.com/vllm-project/vllm/blob/752a3a504485790a2e8491cacbb35c137339ad34/vllm/config/multimodal.py#L132); dispatch in [`vllm/multimodal/registry.py#L294-L307`](https://github.com/vllm-project/vllm/blob/752a3a504485790a2e8491cacbb35c137339ad34/vllm/multimodal/registry.py#L294-L307) (sender) and [`#L322-L331`](https://github.com/vllm-project/vllm/blob/752a3a504485790a2e8491cacbb35c137339ad34/vllm/multimodal/registry.py#L322-L331) (receiver). The `processor_only`, disabled-caching, and `shm` paths are not affected.\n- **Rejection-after-render window** — rendering happens before length validation in [`vllm/entrypoints/openai/chat_completion/serving.py#L206-L231`](https://github.com/vllm-project/vllm/blob/752a3a504485790a2e8491cacbb35c137339ad34/vllm/entrypoints/openai/chat_completion/serving.py#L206-L231) (`render_chat_request`), and the length check raises after the render in [`vllm/entrypoints/serve/utils/api_utils.py#L171-L189`](https://github.com/vllm-project/vllm/blob/752a3a504485790a2e8491cacbb35c137339ad34/vllm/entrypoints/serve/utils/api_utils.py#L171-L189).\n- **Cache-commit call site** — [`vllm/multimodal/processing/processor.py#L1347`](https://github.com/vllm-project/vllm/blob/752a3a504485790a2e8491cacbb35c137339ad34/vllm/multimodal/processing/processor.py#L1347) (`_merge_mm_kwargs`) commits the P0 sender entry during render.\n- The separate stale-order eviction hang is already fixed via [`vllm/utils/cache.py#L120-L121`](https://github.com/vllm-project/vllm/blob/752a3a504485790a2e8491cacbb35c137339ad34/vllm/utils/cache.py#L120-L121) (`LRUCache.touch()` guarding `if key in self:`) — a different mechanism that does not touch the sender/receiver commit-ordering protocol and does not remediate this assertion.\n\nThe P1 receiver sink — the assertion that fires when P1 receives `None` for a hash it never cached:\n\n```python\n# vllm/multimodal/cache.py Lines 651-663\n    @override\n    def get_and_update_item(\n        self,\n        mm_item: MultiModalKwargsItem | None,\n        mm_hash: str,\n    ) -> MultiModalKwargsItem:\n        if (cached_item := self._cache.get(mm_hash)) is not None:\n            return cached_item\n\n        assert mm_item is not None, f\"Expected a cached item for {mm_hash=}\"\n\n        self._cache[mm_hash] = mm_item\n        return mm_item\n```\n\nThe P0 sender — on a hit it drops the payload (returns `None`) and, on a miss during render, unconditionally commits the metadata entry with no rollback tied to admission:\n\n```python\n# vllm/multimodal/cache.py Lines 409-422\n    @override\n    def get_and_update_item(\n        self,\n        mm_item: MultiModalProcessorCacheInItem,\n        mm_hash: str,\n    ) -> MultiModalProcessorCacheOutItem:\n        if (cached_item := self._cache.get(mm_hash)) is not None:\n            return None, cached_item.prompt_updates\n\n        assert mm_item is not None, f\"Expected a cached item for {mm_hash=}\"\n\n        self._cache[mm_hash] = MultiModalProcessorCacheItemMetadata(*mm_item)\n\n        return mm_item\n```\n\n## Impact\n\nA remote client submitting multimodal requests can poison a cache identity — render a media item successfully, then have that request rejected — so a **later** request reusing the same media hash fails on the P1 receiver assertion. This is an availability failure against a shared serving instance. No code execution, memory corruption, or data disclosure is claimed.\n\nOn this revision the failure is scoped as a request-level preprocessing error (the engine core catches around `preprocess_add_request`); public reports show the same assertion cascading into further engine-loop assertions on other revisions. It applies to multimodal models running the default mirrored `lru` cache.\n\n\n## Suggested Fix\n\nTwo complementary changes:\n\n1. **Make the mirrored commit atomic with admission** — insert into the P0 sender cache only after the request has passed all admission checks (length, limits) and P1 has acknowledged the item, or roll back the P0 insert on rejection.\n2. **Defense in depth** — convert the P1 receiver `assert mm_item is not None` into a checked, request-scoped error (fetch-on-miss from P0) so a desync degrades a single request rather than asserting in the engine loop.\n\nThe core of the rollback half: wrap the post-render length check so a `ValueError` rejection discards the P0 entries the render just committed, before re-raising. Add a `discard_sender_cache_item()` on the processor cache (no-op default, `pop` on the sender) and a `Renderer.discard_mm_cache_entries()` that walks a rendered request's `mm_hashes`:\n\n```python\n# vllm/entrypoints/openai/chat_completion/serving.py (_create_chat_completion)\n-            max_tokens = get_max_tokens(\n-                max_model_len,\n-                ...,\n-                truncate_prompt_tokens=request.truncate_prompt_tokens,\n-            )\n+            try:\n+                max_tokens = get_max_tokens(\n+                    max_model_len,\n+                    ...,\n+                    truncate_prompt_tokens=request.truncate_prompt_tokens,\n+                )\n+            except ValueError:\n+                for rendered_input in engine_inputs:\n+                    if mm_hashes := rendered_input.get(\"mm_hashes\"):\n+                        self.renderer.discard_mm_cache_entries(mm_hashes)\n+                raise\n```\n\n```python\n# vllm/multimodal/cache.py (MultiModalProcessorSenderCache)\n+    @override\n+    def discard_sender_cache_item(self, mm_hash: str) -> None:\n+        self._cache.pop(mm_hash, None)\n```\n\nThis closes the `max_model_len` rejection path; because any other rejection-after-render path reopens the same window, pairing it with the defense-in-depth change above (making the P1 `assert` a checked, request-scoped error) is recommended.\n\n## Credit\n\n**Reported by:** Patch the Planet (Trail of Bits + OpenAI collaboration)\n\nThis vulnerability was discovered using GPT-5.5-Cyber as part of the Patch the Planet security initiative.\n\n---\n\n**Proposed fix:** a fix for this issue is proposed in a public pull request: https://github.com/vllm-project/vllm/pull/51897",
  "severity" : [ {
    "type" : "CVSS_V3",
    "score" : "CVSS:3.1/AV:N/AC:L/PR:L/UI:N/S:U/C:N/I:N/A:H"
  } ],
  "affected" : [ {
    "package" : {
      "ecosystem" : "PyPI",
      "name" : "vllm"
    },
    "ranges" : [ {
      "type" : "ECOSYSTEM",
      "events" : [ {
        "introduced" : "0"
      }, {
        "fixed" : "0.28.0"
      } ]
    } ]
  } ],
  "references" : [ {
    "type" : "WEB",
    "url" : "https://github.com/vllm-project/vllm/security/advisories/GHSA-ph3r-5jfg-f84f"
  }, {
    "type" : "WEB",
    "url" : "https://github.com/vllm-project/vllm/pull/46747"
  }, {
    "type" : "WEB",
    "url" : "https://github.com/vllm-project/vllm/pull/51897"
  }, {
    "type" : "WEB",
    "url" : "https://github.com/vllm-project/vllm/commit/396204230423b7cc6798300926b8fa30190d26a9"
  }, {
    "type" : "PACKAGE",
    "url" : "https://github.com/vllm-project/vllm"
  }, {
    "type" : "WEB",
    "url" : "https://github.com/vllm-project/vllm/releases/tag/v0.28.0"
  } ],
  "database_specific" : {
    "cwe_ids" : [ "CWE-617" ],
    "severity" : "MODERATE",
    "github_reviewed" : true,
    "github_reviewed_at" : "2026-10-06T00:02:05Z",
    "nvd_published_at" : null
  }
}