Description

vLLM through 0.29.0 fetches and fully materializes remote or inline media before enforcing its documented media controls (the VLLM_MAX_AUDIO_CLIP_FILESIZE_MB compressed-audio size cap, default 25 MB, and the per-modality --limit-mm-per-prompt item limits). Across four ingress paths — the shared media-acquisition layer (HTTPConnection.get_bytes()/async_get_bytes()), the chat completions audio_url/base64 path, the batch speech runner, and the Rust frontend POST /tokenize route — the server reads the entire HTTP response body, base64-decodes the inline payload, or spawns one fetch/decode task per media part, and only then applies the limit (or, on some paths, never applies it). A remote attacker can therefore cause the API server or batch-runner process to allocate memory and consume outbound bandwidth proportional to an attacker-chosen body size or media item count before the request is rejected, resulting in pre-inference memory and bandwidth exhaustion (denial of service). The chat and batch surfaces require an API key when one is configured; the Rust frontend /tokenize route is unauthenticated by design. There is no code execution or data disclosure impact.

Executive Summary

Technical Details

Mitigations

References

Additional Metadata

{
  "score": "6.5",
  "pubDate": "2026-09-26T14:16:47.523Z",
  "pubdate": "2026-09-26T14:16:47.523Z",
  "executiveSummary": "vLLM versions up to 0.29.0 are susceptible to a Denial of Service (DoS) vulnerability arising from improper input validation during media processing. The vulnerability exists because the application fully materializes remote and inline media payloads into memory before enforcing configured size or count constraints. This design flaw permits remote attackers to exhaust system memory and network bandwidth by submitting oversized payloads or excessive media items. The vulnerability affects multiple ingress vectors, including HTTP-based chat completions, batch speech runners, and the Rust frontend /tokenize route. Exploitation allows an attacker to cause process termination via resource exhaustion (OOM), impacting service availability. While chat and batch endpoints may require an API key if configured, the /tokenize route is unauthenticated by design, providing an unconstrained vector for remote exploitation. There is no risk of remote code execution or unauthorized data disclosure.",
  "technicalDetails": "The root cause of this vulnerability is a failure to implement 'fail-fast' validation within the media-acquisition layer of vLLM. Specifically, the shared media-acquisition layer (HTTPConnection.get_bytes()/async_get_bytes()) reads the entire HTTP response body into memory before the application evaluates it against defined limits, such as VLLM_MAX_AUDIO_CLIP_FILESIZE_MB or per-modality --limit-mm-per-prompt item limits. Consequently, the enforcement mechanism is invoked post-materialization, rendering the limits ineffective at preventing resource consumption.\nThe exploitation flow proceeds as follows: 1) The attacker initiates a request containing a large remote media URL or a massive base64-encoded inline payload. 2) The server’s media-acquisition layer fetches the remote resource or decodes the inline payload, allocating a buffer proportional to the attacker-supplied size. 3) Because the process allocates memory for the entire payload before validating the configuration limits, the server exhausts its available heap space or triggers OOM-killer intervention. In scenarios involving the Rust frontend /tokenize route, this occurs without any authentication, allowing a remote attacker to repeatedly trigger crashes with minimal effort. Furthermore, the batch speech runner and chat completion surfaces are also impacted, as they exhibit similar behaviors where the server either applies the limit too late or fails to apply it entirely across multiple concurrent media parts.\nThe vulnerability spans several distinct ingress paths: the shared media-acquisition layer, the chat completions (audio_url/base64) path, the batch speech runner, and the Rust frontend /tokenize route. The impact is significant because the server handles these payloads synchronously or spawns one task per media part, multiplying the memory pressure on the host environment. By saturating the outbound bandwidth (for remote fetches) and consuming excessive RAM (for both remote and inline payloads), an attacker can reliably cause a Denial of Service. Because the checks occur after the memory allocation, the application is effectively performing an unconstrained resource acquisition, which is a classic vector for system instability."
}