PT-2026-6363 — Heap Based Buffer Overflow in Pypi Vllm

PT-2026-6363 · Pypi · Vllm

Published

2026-02-02

Updated

2026-02-02

CVSS v3.1

9.8

Critical

Vector

AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:H

Summary

A chain of vulnerabilities in vLLM allow Remote Code Execution (RCE):

Info Leak - PIL error messages expose memory addresses, bypassing ASLR
Heap Overflow - JPEG2000 decoder in OpenCV/FFmpeg has a heap overflow that lets us hijack code execution

Result: Send a malicious video URL to vLLM Completions or Invocations for a video model -> Execute arbitrary commands on the server

Completely default vLLM instance directly from pip, or docker, does not have authentication so "None" privileges are required, but even with non-default api-key enabled configuration this exploit is feasible through invocations route that allows payload to execute pre-auth.

Example heap target is provided, other heap targets can be exploited as well to achieve rce. Leak allows for simple ASLR bypass. Leak + heap overflow achieves RCE on versions prior to 0.14.1.

Deployments not serving a video model are not affected.

1. Vulnerability Overview

1.1 The Bug: JPEG2000 cdef Box Heap Overflow

The JPEG2000 decoder used by OpenCV (cv2) honors a cdef box that can remap color channels. When Y (luma) is mapped into the U (chroma) plane buffer, the decoder writes a large Y plane into the smaller U buffer, causing a heap overflow.

Root Cause

cdef allows channel remapping (e.g., Y→U, U→Y).
Y plane size: W×H; U plane size: (W/2)×(H/2).
Overflow size = W×H - (W/2×H/2) = 0.75 × W × H bytes.

Example (150×64)

Y plane: 150×64 = 9,600 bytes
U plane: 75×32 = 2,400 bytes
Overflow: 7,200 bytes past the U buffer

1.2 Malicious cdef Box

Offset Size Field      Value
0    4   Box Length   0x00000016 (22 bytes)
4    4   Box Type    'cdef'
8    2   N (channels)  0x0003
10   2   Channel 0 Cn  0x0000 (Y channel)
12   2   Channel 0 Typ  0x0000 (color)
14   2   Channel 0 Asoc 0x0002 (→ maps Y into U plane)
16   2   Channel 1 Cn  0x0001 (U channel)
18   2   Channel 1 Typ  0x0000 (color)
20   2   Channel 1 Asoc 0x0001 (→ maps U into Y plane)
22   2   Channel 2 Cn  0x0002 (V channel)
24   2   Channel 2 Typ  0x0000 (color)
26   2   Channel 2 Asoc 0x0003 (→ maps V plane)

Key control: Asoc=2 for channel 0 forces Y data into the U buffer, triggering the overflow.

Vulnerable Code Chain

1) Entry: vLLM accepts a remote `video url` and downloads raw bytes

vLLM’s OpenAI-compatible API supports a video url content part:

python

class VideoURL(TypedDict, total=False):
  url: Required[str]

class ChatCompletionContentPartVideoParam(TypedDict, total=False):
  video url: Required[VideoURL]
  type: Required[Literal["video url"]]

Source: src/vllm/entrypoints/chat utils.py.

When the URL is HTTP(S), vLLM downloads it as raw bytes and passes the bytes into the modality loader:

python

if url spec.scheme.startswith("http"):
  data = connection.get bytes(url, timeout=fetch timeout, allow redirects=...)
  return media io.load bytes(data)

Source: src/vllm/multimodal/utils.py (MediaConnector.load from url).

2) Decode: vLLM uses OpenCV (cv2) VideoCapture on an in-memory byte stream

The default video backend is OpenCV, and it constructs cv2.VideoCapture over a BytesIO buffer containing the downloaded bytes:

python

backend = cls().get cv2 video api()
cap = cv2.VideoCapture(BytesIO(data), backend, [])
if not cap.isOpened():
  raise ValueError("Could not open video stream")

Source: src/vllm/multimodal/video.py (OpenCVVideoBackend.load bytes).

The backend is selected from OpenCV’s stream-buffered backends registry:

python

import cv2.videoio registry as vr
for backend in vr.getStreamBufferedBackends():
  if vr.hasBackend(backend) and ...:
    api pref = backend
    break
return api pref

Source: src/vllm/multimodal/video.py (OpenCVVideoBackend.get cv2 video api).

Implication: vLLM is delegating container parsing + codec decode to OpenCV’s Video I/O stack (which, in typical builds, is backed by FFmpeg for MOV/MP4 and codecs like JPEG2000).

3) The actual overflow: Y (full-res) written into U (quarter-res)

When the decoder honors the remap and writes Y into the U-plane buffer, it writes too many bytes:

Y plane bytes: (W times H)
U plane bytes: ((W/2) times (H/2))
Overflow bytes: (W times H - (W/2 times H/2) = 0.75 times W times H)

Concrete example tried (150×64):

Y: (150 times 64 = 9600) bytes
U: (75 times 32 = 2400) bytes
Overflow: (9600 - 2400 = 7200) bytes past the end of the U allocation

This is a heap buffer overflow into whatever allocations follow the U-plane buffer in the decoder’s heap layout (structures, metadata, other buffers, etc.). The exact victims depend on build + runtime allocator layout.

The Exploit Chain

Vuln 1: PIL BytesIO Address Leak (ASLR Bypass)

When you send an invalid image to vLLM's multimodal endpoint, PIL throws an error like:

cannot identify image file < io.BytesIO object at 0x7a95e299e750>
                          ^^^^^^^^^^^^^^^^
                          LEAKED ADDRESS!

vLLM returns this error to the client, leaking a heap address. This address is ~10.33 GB before libc in memory. With this leak, we reduce ASLR from 4 billion guesses to ~8 guesses.

Vuln 2: JPEG2000 cdef Heap Overflow (RCE)

vLLM uses OpenCV (cv2) to decode videos. OpenCV bundles FFmpeg 5.1.x which has a heap overflow in the JPEG2000 decoder. The OpenCV is used for video decoding so if we build a video from JPEG2000 frames it will reach the vuln:

vLLM API Request to Completions/Invocation
   ↓
OpenCV cv2.VideoCapture()
   ↓
FFmpeg 5.1 (bundled in OpenCV)
   ↓
JPEG2000 decoder (libopenjp2)
   ↓
HEAP OVERFLOW via malicious "cdef" box
   ↓
Overwrite function pointer → RCE!

How the overflow works:

JPEG2000 has a cdef box that remaps color channels
We remap Y (luma) into the U (chroma) buffer
Y plane = 9,600 bytes, U plane = 2,400 bytes
On small geometry like 150x64 pixel image we get 7,200 bytes overflow past the U buffer. We can grow that exponentially by making bigger images.
This overwrites an AVBuffer structure containing a free() function pointer. This could be any function pointer or other targets.
We set free = system() and opaque = "command string"
When the buffer is freed → system("our command") executes

vLLM Attack Surface

Affected Endpoints

Both multimodal endpoints are vulnerable:

POST /v1/chat/completions   (with video url in content)
POST /v1/invocations     (with video url in content)

Request Flow

1. Attacker sends request with video url pointing to malicious .mov file
2. vLLM fetches the video from the URL
3. vLLM passes video bytes to cv2.VideoCapture()
4. OpenCV's bundled FFmpeg decodes JPEG2000 frames
5. Malicious cdef box triggers heap overflow
6. AVBuffer.free pointer overwritten with system()
7. When buffer is released → system("attacker command") executes

Versions Affected

Component	Version	Notes
vLLM	>= 0.8.3, < 0.14.1	Default config vulnerable when serving a video model
OpenCV (cv2)	4.x with FFmpeg bundle	Bundled FFmpeg is vulnerable
FFmpeg	5.1.x (bundled)	JPEG2000 cdef overflow
libopenjp2	2.x	Honors malicious cdef box

Fixes

Fix

Heap Based Buffer Overflow

Insertion into Log File

Found an issue in the description? Have something to add? Feel free to write us 👾

dbugs@ptsecurity.com

Weakness Enumeration

CWE-122CWE-532

Related Identifiers

GHSA-4R2X-XPJR-7CVV

Affected Products

Vllm

PT-2026-6363 · Pypi · Vllm

Summary

1. Vulnerability Overview

1.1 The Bug: JPEG2000 cdef Box Heap Overflow

1.2 Malicious cdef Box

Vulnerable Code Chain

1) Entry: vLLM accepts a remote video url and downloads raw bytes

2) Decode: vLLM uses OpenCV (cv2) VideoCapture on an in-memory byte stream

3) The actual overflow: Y (full-res) written into U (quarter-res)

The Exploit Chain

Vuln 1: PIL BytesIO Address Leak (ASLR Bypass)

Vuln 2: JPEG2000 cdef Heap Overflow (RCE)

vLLM Attack Surface

Affected Endpoints

Request Flow

Versions Affected

Fixes

Weakness Enumeration

Related Identifiers

Affected Products

References · 7

1) Entry: vLLM accepts a remote `video url` and downloads raw bytes