llamaCVEVulnerability Intelligence
/
Advisory · GitHub · PyPI · vllm

GHSA-58V5-2M8F-94PR

vLLM: GLMGA video sampling permits request-driven CPU and memory exhaustion

Parche disponible
Descargar PNG JSON
CVSS
—
medium
Fuente: —
ExplotaciónSin evidenciaNo figura en CISA KEV
Exploits públicos0Ninguno conocido
Parche1 versiónPrimer parche a -13 d de la divulgación
Exposición44 dDesde la divulgación, 5 oct 2026, 6:42 p. m.
Detección42 dDesde la divulgación hasta su ingreso al índice
Timeline

Ciclo de vida de la vulnerabilidad

Hoy
Divulgación
Publicada
Modificada
Explotación
Remediación
Parche 0.30.0
Monitoreo
Detectada
22 sept 26
5 oct 26
15 oct 26
17 nov 26
19 nov 26
22 sept 26
7 oct 26
21 oct 26
5 nov 26
19 nov 26
FechaFaseEventoDetalle
Remediación Parche 0.30.0 vllm · -13 d desde divulgación
Divulgación Publicada GHSA-58V5-2M8F-94PR divulgada
Divulgación Modificada Última actualización del registro
Monitoreo Detectada Ingresó al índice
Resumen
Descripción del advisory
Texto original · GitHub · en inglés

Summary

The OpenAI-compatible chat endpoint accepts request-level video loader options through `media_io_kwargs`. A caller can select the GLMGA sampler and provide large `fps` and `max_frames` values. GLMGA first constructs an attacker-sized Python index list and then deduplicates it, even when the supplied video contains only a few frames. This work occurs in the shared media-loading executor before frame reads, allowing a tiny valid video and compact JSON options to consume disproportionate CPU time and memory and delay unrelated media requests.

The demonstrated impact is partial denial of service. No memory corruption, data disclosure, or code execution is claimed.

Affected configuration

The server must expose chat completions for a video-capable model and accept request-level `media_io_kwargs`. The model does not need to use GLMGA by default because the request value overrides the model's loader mapping. The proof of concept uses an inline two-frame video and explicitly selects the OpenCV decoder, so no external media host or GPU decoder is required.

The request is reachable without vLLM credentials when no API key is configured. With API-key authentication enabled, any caller holding a valid key can reach the same path.

Attack surface

A remote caller submits a valid chat-completion request with a small video and the following request-level options:

{
  "media_io_kwargs": {
    "video": {
      "video_backend": "glmga",
      "backend": "opencv",
      "fps": 500000,
      "max_frames": 500000
    }
  }
}

Increasing both numeric values increases temporary list construction and deduplication work even when the final decoded frame set remains unchanged.

Root cause

  1. `ChatCompletionRequest` exposes `media_io_kwargs` as request-controlled nested values: `protocol.py#L365-L371` https://github.com/vllm-project/vllm/blob/570735520942b6428ae98f1eb442c6d88adae55e/vllm/entrypoints/openai/chat_completion/protocol.py#L365-L371.
  2. The request options are carried into chat parameters without a numeric work bound on GLMGA's `fps` or `max_frames`: `protocol.py#L571-L599` https://github.com/vllm-project/vllm/blob/570735520942b6428ae98f1eb442c6d88adae55e/vllm/entrypoints/openai/chat_completion/protocol.py#L571-L599.
  3. Media options are merged so request values override configured defaults, including `video_backend`: `connector.py#L577-L605` https://github.com/vllm-project/vllm/blob/570735520942b6428ae98f1eb442c6d88adae55e/vllm/multimodal/media/connector.py#L577-L605.
  4. The connector selects a registered video loader and runs media loading through the shared executor: `video.py#L28-L66` https://github.com/vllm-project/vllm/blob/570735520942b6428ae98f1eb442c6d88adae55e/vllm/multimodal/media/video.py#L28-L66 and `connector.py#L44-L47` https://github.com/vllm-project/vllm/blob/570735520942b6428ae98f1eb442c6d88adae55e/vllm/multimodal/media/connector.py#L44-L47.
  5. GLMGA calculates `extract_t = min(int(duration * fps), max_frames)`, builds a list with that many entries, and deduplicates it before decoding frames: `video.py#L667-L740` https://github.com/vllm-project/vllm/blob/570735520942b6428ae98f1eb442c6d88adae55e/vllm/multimodal/video.py#L667-L740.
  6. The OpenCV decoder receives the already-deduplicated indices, so a two-frame file can trigger a large intermediate allocation while producing only two decoded frames: `opencv.py#L28-L50` https://github.com/vllm-project/vllm/blob/570735520942b6428ae98f1eb442c6d88adae55e/vllm/multimodal/video_decoders/opencv.py#L28-L50.

The missing invariant is a strict upper bound on sampling work before the index list is constructed. Bounding decoded output after deduplication does not bound the vulnerable intermediate computation.

Suggested remediation

Validate request-level video sampling options before dispatching work to the media executor. Enforce conservative absolute limits for `fps`, `max_frames`, and especially the computed candidate count. Reject non-finite, negative, or otherwise invalid numeric values.

Avoid constructing `O(extract_t)` intermediate Python lists. Generate bounded unique frame indices directly from the source frame count and output-frame limit. Apply the limit before list construction and before shared executor submission. Add tests showing that extreme request values are rejected or consume constant memory for a fixed output-frame count.

Workarounds

  • Remove or filter request-level `video_backend`, `fps`, and `max_frames` options at the gateway.
  • Do not allow untrusted callers to select GLMGA.
  • Apply authentication, rate limiting, request concurrency limits, and process memory isolation.
  • Use a separate constrained media-loading worker pool where operationally feasible.
  • Existing media byte, pixel, or decoded-frame limits do not necessarily bound this pre-decode candidate-index allocation.

Related advisory

GHSA-cqm8-jxg6-fqfq https://github.com/vllm-project/vllm/security/advisories/GHSA-cqm8-jxg6-fqfq concerns partial denial of service in the DeepStream video backend through backend confusion and insufficient pixel guarding. This report concerns a different CPU-side GLMGA algorithm: request-controlled sampling values create a large redundant index list before the OpenCV decoder reads a fixed, tiny frame set. The vulnerable backend, resource sink, and required remediation differ.

Incluye detalles técnicos publicados por el investigador. Úselos solo para validar y corregir sus propios sistemas.

Versiones

Rangos afectados

Afectada Corregida Última
vllm≥ 0.23.0rc2 < 0.30.0
0.23.0rc2
0.30.0
0.34.0
Remediación

Estado del parche por paquete

Paquete / productoEstadoCorregida enDesde divulgaciónÚltima versión
pypivllm
Corregida 0.30.0 -13 d 0.34.0 no afectada
Versiones corregidas0.30.0
Explotación

Arsenal público

Sin exploits, módulos ni PoC públicos conocidos a la fecha de verificación.

Referencias
Otrahttps://github.com/vllm-project/vllm/security/advisories/GHSA-58v5-2m8f-94pr
Otrahttps://github.com/vllm-project/vllm/pull/54935
Otrahttps://github.com/vllm-project/vllm/commit/8b6de0eb9a09ef53f20cf06bd4d17ee264b9c2a7
Otrahttps://github.com/vllm-project/vllm
Otrahttps://github.com/vllm-project/vllm/releases/tag/v0.30.0

Las referencias externas se muestran para copiar: cve.llama.ec no lo redirige a otros sitios.