CVE-2026-94624: vllm p2p never connected zmq_exhaustion
vLLM servers that use the `OffloadingConnector` with `TieringOffloadingSpec` and a P2P secondary tier can be crashed by an API client. Each request with a unique, non-listening peer in `kv_transfer_params.prefill` leaks ZeroMQ sockets. About 341 requests exhaust the default quota and terminate EngineCore. Upgrade to vLLM 0.32.0.
Published Oct 27, 2026 · Analysis Oct 27, 2026
What an attacker can do
P2PSecondaryTierManager.on_new_request() reads remote_host and remote_port from the request's kv_transfer_params.prefill. It calls _get_or_create_session(), which opens a ZeroMQ DEALER, a monitor and a PAIR socket, and stores the session before any connection is established. The monitor subscribes only to EVENT_DISCONNECTED. A peer that never answers never fires it, so mark_dead() is never called. Finishing the request does not close the session, and nothing limits or expires pending peers.
Each retained peer costs about three sockets. With the default MAX_SOCKETS=1023, 340 peers fit. The next peer raises an uncaught ZMQError ("Too many open files") that escapes into the EngineCore loop. EngineCore dies with EngineDeadError and the API server shuts down. This was reproduced on 0.26.0 with a normal API key and without access to the internal P2P ports. Raising MAX_SOCKETS to 2,048 moved the ceiling to 682 peers, which confirms the quota is the exhausted resource.
Only deployments that explicitly enable the offloading connector, tiering spec and P2P tier are affected. The result is availability loss only: all inference stops until a restart. Confidentiality and integrity are not affected. Anyone with a valid API key, or network access when --api-key is unset, can trigger it with cheap one-token requests.
Who is affected
vLLM versions before 0.32.0 are affected, but only with the OffloadingConnector, TieringOffloadingSpec and a P2P secondary tier enabled. Standard deployments without that KV-offloading setup do not take this path. In testing, 512 requests without P2P parameters left no active peers.
Check the version:
pip show vllmThen check your --kv-transfer-config or equivalent settings for the offloading connector and a P2P tier.
vllm
- Ecosystem
- PyPI
- Affected
- < 0.32.0
- Fixed in
- 0.32.0
- Check
pip show vllm
How to fix it
Upgrade to vllm 0.32.0:
pip install --upgrade "vllm>=0.32.0"The fix is pull request 51504. The advisory names no configuration workaround. Based on the attack conditions, turning off the P2P secondary tier removes the path, and restricting API access to trusted clients limits who can trigger it. The advisory also mentions an open proposal, pull request 47843, for sanitizing peer addresses and adding an allowlist. It notes that proposal would block this trigger but not add capacity limits.
How to tell if you were hit
Look in vLLM logs for zmq.error.ZMQError: Too many open files raised from _open_connection or _get_or_create_session, followed by EngineDeadError and API server shutdown. A burst of HTTP 500 responses before the exit is typical.
In request logs, look for many chat or completion calls whose kv_transfer_params.prefill has a different remote_host or remote_port each time. Watch the EngineCore file descriptor count: it climbs by about three per unique peer and never drops.
Original advisory
From the GitHub Advisory Database (CC BY 4.0).
Summary
When the OffloadingConnector uses TieringOffloadingSpec with a P2P secondary tier, an API client can submit many unique non-listening peer addresses through kv_transfer_params.prefill. vLLM keeps every never-established P2P session and its ZeroMQ sockets after the request finishes. On vLLM 0.26.0, 340 such peers filled the default ZeroMQ context socket quota; creating the next peer raised an uncaught ZMQError, terminated EngineCore, and shut down the API server. The path was reproduced with a normal API key and no access to the internal P2P listener.
Details
Root cause
In vLLM 0.26.0, P2PSecondaryTierManager.on_new_request() reads the following request-controlled fields:
{
"kv_transfer_params": {
"prefill": {
"kv_request_id": "id",
"remote_host": "127.0.0.1",
"remote_port": 49101
}
}
}on_new_request() calls _get_or_create_session(peer_id). This calls ZmqTransport.connect(), creates a P2PSession, and stores it in _sessions before the asynchronous ZeroMQ connection has been established.
ZmqTransport._open_connection() creates a DEALER, enables a libzmq monitor, creates a PAIR socket for that monitor, calls dealer.connect(), and immediately stores the resulting ZmqConnection in _connections. Returning from dealer.connect() does not prove that the peer is reachable.
The monitor subscribes only to zmq.EVENT_DISCONNECTED. A peer that never accepts the initial connection produced EVENT_CONNECT_DELAYED, EVENT_CONNECT_RETRIED, and EVENT_CLOSED, but no EVENT_DISCONNECTED during a 60-second observation. The production monitor therefore never calls mark_dead(), and ZmqConnection.alive remains true.
Request completion calls session.finish_request(), but does not close or remove the peer session. The manager reaps only a session for which session.connected and not session.alive is true. A never-established peer remains connected=True, alive=True, and ready=False. There is no establishment deadline, idle eviction, or limit on pending or total peers.
Each unique retained peer uses about three sockets in the same ZeroMQ context: the DEALER, the monitor endpoint created by libzmq, and the PAIR monitor client. With the measured default MAX_SOCKETS=1023, 340 peers use approximately 1,020 sockets in addition to the local ROUTER. The next peer fails while creating its monitor PAIR. The exception escapes through on_new_request() and the scheduler into the EngineCore loop:
P2PSecondaryTierManager._get_or_create_session()
-> ZmqTransport.connect()
-> ZmqTransport._open_connection()
-> monitor_sock = self._zmq_ctx.socket(zmq.PAIR)
-> zmq.error.ZMQError: Too many open files
-> EngineDeadErrorThe process open-files limit was 65,536. The EngineCore had about 1,215 file descriptors at the failure point, so the failure was not the operating-system FD limit.
Boundary and controls
Each row below used a fresh vLLM process and pre-generated unique non-listening loopback ports.
| Test | Result | | Default `MAX_SOCKETS=1023`, 340 unique peers | 340 HTTP 200 responses; 340 active peers; service healthy | | Default limit, 344 unique peers, concurrency 4 | 340 HTTP 200 and 4 HTTP 500 responses; EngineCore and API exited | | Default limit, 344 unique peers, concurrency 1 | Same 340-peer ceiling and service exit | | Same endpoint repeated 512 times | 512 HTTP 200 responses; one active peer; service healthy | | 512 requests without P2P parameters | 512 HTTP 200 responses; no active peers; service healthy |
A diagnostic A/B changed only the context MAX_SOCKETS value. Raising it from 1,023 to 2,048 moved the last fully successful point from 340 to 682 peers. The 683rd peer then raised the same ZMQError and terminated the service. The approximately 2.01x movement in the boundary identifies the ZeroMQ context quota as the exhausted resource.
The failure runs used logging-only instrumentation around _open_connection() to record the context limit, peer count, and process FD count. It did not add or close any ZeroMQ socket and re-raised the original exception.
Related public work
PR #47843 is an open, unmerged proposal that identifies client-supplied P2P peer addresses as an SSRF risk and proposes API sanitization plus a configured peer allowlist. Those changes would block this public API trigger, but the PR does not add a connection deadline, session cleanup, or a capacity limit for never-established peers. This report adds the deterministic resource-exhaustion and service-exit impact of the retained state.
PR #49823 fixes cleanup and reconnection after a connection has been marked dead. A peer that never establishes does not receive the subscribed EVENT_DISCONNECTED event, so it never enters that dead-state cleanup path.
Impact
This is uncontrolled resource consumption leading to denial of service. An attacker needs network access to an OpenAI-compatible inference endpoint and a normal API key when --api-key is enabled. The attacker does not need access to the internal P2P control or data ports and does not need any peer to answer.
Only deployments that explicitly enable OffloadingConnector, TieringOffloadingSpec, and a P2P secondary tier are affected. Repeating a cheap one-token request with unique non-listening endpoints steadily consumes scheduler and ZeroMQ resources. In the tested default context, about 341 requests were enough to terminate EngineCore and stop all inference on the instance until restart. Confidentiality and integrity were not affected; the demonstrated impact is availability loss.
This advisory was fixed in MR51504.
Credited to yyymk, jperezdealgaba.
Questions
- Is every vLLM server vulnerable to this ZeroMQ exhaustion?
No. Only deployments that enable
OffloadingConnector,TieringOffloadingSpecand a P2P secondary tier. The advisory's control runs with no P2P parameters showed no leak.- Does the attacker need access to the internal P2P ports?
No. The attacker needs only network access to the OpenAI-compatible endpoint and a normal API key if
--api-keyis on. No peer has to answer.- How many requests does it take to crash the server?
About 341 with unique non-listening peers on the default context in the advisory's tests. 340 worked, and the next peers raised the error that ended EngineCore and the API server.
References
Read for this analysis:
- https://github.com/vllm-project/vllm/security/advisories/GHSA-frvg-qw88-hww9
- https://github.com/vllm-project/vllm/pull/51504
- https://nvd.nist.gov/vuln/detail/CVE-2026-94624
- https://github.com/vllm-project/vllm/commit/93d2cab35e8ae66bbaa1dea1c077986d5a79eb80
- https://github.com/pypa/advisory-database/tree/main/vulns/vllm/PYSEC-2026-4006.yaml
- https://github.com/vllm-project/vllm/blob/v0.29.0/vllm/v1/kv_offload/tiering/p2p/control/zmq.py#L240-L260
- https://github.com/vllm-project/vllm/blob/v0.29.0/vllm/v1/kv_offload/tiering/p2p/manager.py#L667-L677
- https://github.com/vllm-project/vllm/releases/tag/v0.32.0
- https://www.vulncheck.com/advisories/vllm-through-0.29.0-denial-of-service-via-unbounded-p2p-kv-offloading-sessions
- https://github.com/advisories/GHSA-frvg-qw88-hww9
How this page is made: the data panel comes from the GitHub Advisory Database, CISA’s KEV catalog, the NVD and FIRST EPSS, and updates twice a day. The analysis is written by an AI model from the sources listed above and checked by automated rules before it is published. Check versions against the vendor's advisory before you act. Methodology
Coverage on the Beam blog
More vLLM vulnerabilities
All vLLM entriesCVE-2026-115911
vLLM: DoS via unbounded chat_template Jinja2 rendering exhausts the renderer thread pool
medium6.5Oct 28, 2026CVE-2026-115912
vLLM: Public multimodal SHM handle forgery reaches worker-side `pickle.loads()` with insecure serialization disabled
high7.5Oct 28, 2026CVE-2026-115913
vLLM: Phi-4 multimodal audio encoder materializes and retains full attention matrices: a single max-length audio OOM-crashes the vLLM engine
medium6.5Oct 28, 2026CVE-2026-115914
vLLM DeepSeek-OCR image processing vulnerable to denial of service
medium6.5Oct 28, 2026CVE-2026-115915
vLLM: Untrusted EPS inputs can trigger denial of service or Ghostscript RCE
high8.1Oct 28, 2026CVE-2026-115916
vLLM: Out-of-vocabulary prompt token id passes input validation and triggers a CUDA device-side assert (engine crash / DoS)
medium6.5Oct 28, 2026
