Products / vllm
vllm
89 records.
- vLLM has Hardcoded Trust Override in Model Files Enables RCE Despite Explicit User Opt-Out Two model implementation files hardcode trust_remote_code=True for sub-component loads, so a malicious model repository runs Python even when the user disabled remote code.
- vLLM has SSRF Protection Bypass vLLM's URL check parses backslash-containing URLs differently from the aiohttp client that fetches them, letting a request reach an attacker host.
- vLLM has RCE In Video Processing A crafted video URL sent to a video model makes the server's image decoder overflow the heap, after an info leak reveals memory layout, letting the attacker run commands.
- vLLM vulnerable to Server-Side Request Forgery (SSRF) through MediaConnector Host restrictions in the media loader parse backslashes differently in two libraries, so a crafted URL can reach internal hosts.
- vLLM affected by RCE via auto_map dynamic module loading during model initialization A model repository's auto_map entry makes vLLM import attacker Python during model resolution, even with trust_remote_code disabled.
- vLLM is vulnerable to DoS in Idefics3 vision models via image payload with ambiguous dimensions A 1x1 image is misread as channel-first, causing a tensor split mismatch in the Idefics3 vision path that crashes the engine process.
- vLLM introduced enhanced protection for CVE-2025-62164 Crafted sparse prompt embeddings reach PyTorch without index validation, so enabling the feature lets a user crash or stall the serving process.
- vLLM vulnerable to remote code execution via transformers_utils/get_config Loading a model config whose auto_map points to another repository imports and runs that repository's Python even when remote code is disabled.
- vLLM vulnerable to DoS via large Chat Completion or Tokenization requests with specially crafted `chat_template_kwargs` Caller-supplied chat template keyword arguments can flip the tokenize default, forcing blocking tokenisation of huge inputs that stalls the API server.
- vLLM deserialization vulnerability leading to DoS and potential RCE The Completions endpoint loads user-supplied tensor embeddings with torch.load, where disabled sparse checks let crafted tensors cause out-of-bounds writes.
- vLLM vulnerable to DoS with incorrect shape of multimodal embedding inputs Multimodal embedding inputs with the right number of dimensions but a wrong hidden size pass validation and crash the engine during embedding scatter.
- vLLM is vulnerable to Server-Side Request Forgery (SSRF) through `MediaConnector` class The media loader fetches any http, https or file URL supplied in a multimodal request without host restrictions, so the server can be made to reach internal addresses.
- vLLM: Resource-Exhaustion (DoS) through Malicious Jinja Template in OpenAI-Compatible Server Malicious Jinja templates, or keyword arguments that overwrite the template key, exhaust CPU and memory during rendering, bypassing the chat_template restriction.
- vLLM is vulnerable to timing attack at bearer auth The API key is checked with a non-constant-time string comparison, so response timing reveals correct characters and the key can be recovered incrementally.
- vLLM has remote code execution vulnerability in the tool call parser for Qwen3-Coder The Qwen3-Coder tool-call parser calls eval() on tool parameters of unrecognised type, so model-generated arguments containing Python code run on the server.
- vllm API endpoints vulnerable to Denial of Service Attacks An oversized HTTP header on a GET request makes the server buffer the entire value in memory, exhausting available RAM.
- Potential Timing Side-Channel Vulnerability in vLLM’s Chunk-Based Prefix Caching Response timing differs when a prompt prefix is already cached, so a co-tenant can infer whether a guessed prompt matches a victim's.
- vLLM DOS: Remotely kill vllm over http with invalid JSON schema An invalid JSON schema in a guided decoding request causes an unhandled exception in the grammar compiler that crashes the engine.
- vLLM allows clients to crash the openai server with invalid regex A client-supplied invalid regex in structured output makes the vLLM OpenAI server crash.
- vLLM has a Weakness in MultiModalHasher Image Hashing Implementation The image hash uses only raw pixel bytes without dimensions or mode, so different images can share a hash and receive each other's cached results.
- vLLM vulnerable to Regular Expression Denial of Service Several regular expressions in vLLM backtrack catastrophically on crafted input, so a single request can stall processing.
- vLLM Tool Schema allows DoS via Malformed pattern and type Fields Malformed type and pattern fields in a tool schema reach the grammar and regex converters unvalidated, crashing the inference worker until it is restarted.
- vLLM has a Regular Expression Denial of Service (ReDoS, Exponential Complexity) Vulnerability in `pythonic_tool_parser.py` A nested regex used to detect tool calls in generated text backtracks catastrophically on crafted output, stalling the serving process.
- vLLM Allows Remote Code Execution via PyNcclPipe Communication Service The PyNcclPipe KV transfer service accepts pickled messages from a TCP store bound to all interfaces, so remote senders can execute code on the server.
- Remote Code Execution Vulnerability in vLLM Multi-Node Cluster Configuration Secondary vLLM hosts unpickle messages received over ZeroMQ, so anyone who controls the primary host or its network can run code on them.
- Data exposure via ZeroMQ on multi-node vLLM deployment A multi-node vLLM host binds an internal publish socket to all interfaces, so any reachable client receives broadcast internal state.
- vLLM Vulnerable to Remote Code Execution via Mooncake Integration The Mooncake KV transfer integration calls recv_pyobj over a ZeroMQ socket listening on all interfaces, so attacker-sent pickle data runs code when deserialised.
- vLLM: Quadratic Time Complexity in Input Token Processing leads to denial of service Repeated placeholder token expansion rebuilds the input list each time, so crafted inputs with many placeholders consume quadratic CPU time.
- CVE-2025-24357 Malicious model remote code execution fix bypass with PyTorch < 2.6.0 A malicious checkpoint still executes code when loaded with weights-only mode on PyTorch versions before 2.6, so the vLLM safeguard is ineffective.
- vLLM vulnerable to Denial of Service by abusing xgrammar cache Repeated short structured-output requests with unique schemas fill the grammar cache until the server runs out of memory.
- vLLM Deserialization of Untrusted Data vulnerability The message queue dequeue path unpickles data received from sockets, so a crafted network message runs code on the receiving machine.
- vLLM allows Remote Code Execution by Pickle Deserialization via AsyncEngineRPCServer() RPC server entrypoints The RPC server passes incoming network messages directly to cloudpickle loads, so a crafted message executes code when it is deserialised.
- vLLM deserialization vulnerability in vllm.distributed.GroupCoordinator.recv_object A distributed communication helper unpickles received network bytes without checks, so a crafted message runs code on the receiving host.
- vLLM denial of service via outlines unbounded cache on disk Many short requests with unique structured-output schemas make vLLM's outlines backend grow an on-disk grammar cache until the disk fills.
- vLLM Allows Remote Code Execution via Mooncake Integration vLLM's Mooncake KV-transfer pipe unpickles data received over a network socket, so a crafted payload sent to it runs code.
- vLLM uses Python 3.12 built-in hash() which leads to predictable hash collisions in prefix cache Predictable Python 3.12 hash values let crafted prompts collide with cached prefixes, so a request can reuse cached state built from different content.
- vllm: Malicious model to RCE by torch.load in hf_model_weights_iterator Loading a malicious checkpoint through torch.load with default settings runs attacker pickle code during model load.
- vLLM denial of service vulnerability A completions API request with an empty prompt crashes the serving process.
- vLLM Denial of Service via the best_of parameter Very large best_of values in vLLM completion requests consume excessive resources without timeouts, leaving the API unresponsive to other users.