Vulnerability DatabaseCVE-2026-112269

CVE-2026-112269: 
SGLang vulnerability analysis and mitigation

Overview

CVE-2026-112269 is a denial-of-service vulnerability in SGLang's Mooncake prefill-decode (PD) disaggregation backend caused by unauthenticated decode registration messages being accepted on the Prefill rank ZMQ PULL socket. It affects SGLang versions through 0.5.22 (inclusive) when the Mooncake disaggregation backend is enabled. The vulnerability was disclosed on October 18, 2026 via a GitHub issue and published to the NVD and GitHub Advisory Database on October 19, 2026. It carries a CVSS v3.1 base score of 6.5 (Medium) and a CVSS v4.0 base score of 7.1 (High) (Github Advisory, Feedly).

Technical details

The root cause is CWE-770 (Allocation of Resources Without Limits or Throttling). The Prefill rank's bootstrap_thread() in MooncakeKVManager receives multipart ZMQ messages on an unauthenticated PULL socket. When frame 0 contains "None", the message is parsed as a Decode registration and stored in decode_kv_args_table keyed by the attacker-supplied mooncake_session_id (frame 3). Frame 6 is passed to unpack_int_lists(), where the first integer controls the number of nested buffers — a 400,004-byte frame can declare 100,000 empty child buffers, causing the parser to materialize 100,000 Python list objects per message. There is no sender authentication, Decode identity binding, nested-buffer count limit, table size limit, or entry expiry, so each unique session ID permanently retains its parsed objects in memory (SGLang Issue #45012, conn.py L889-L909, utils.py L47-L69).

Impact

Successful exploitation causes the Prefill scheduler process to be OOM-killed, rendering all routed inference completions unavailable until the full stack is restarted. In a documented test, 12,620 unique registrations raised Prefill cgroup memory from ~3.72 GB to 16.69 GB, triggering an OOM kill (oom_kill=1); all 11 monitored in-flight completions and 5 post-OOM completions timed out. The Router and Decode processes remain alive but cannot serve requests without a functioning Prefill. There is no confidentiality or integrity impact — the vulnerability is purely an availability attack against AI inference infrastructure (SGLang Issue #45012).

Exploitability

A public proof-of-concept exploit (a self-contained Python script using only zmq and standard library modules) is available in the GitHub issue report, with detailed step-by-step reproduction instructions (SGLang Issue #45012). The NVD SSVC assessment classifies exploitation as "poc" with no evidence of in-the-wild exploitation at time of publication. No threat actor attribution is available. The EPSS score is approximately 0.487% (42nd percentile), indicating a relatively low but non-negligible probability of exploitation within 30 days. The vulnerability is not listed in the CISA KEV catalog (Github Advisory, Feedly).

Exploitation steps

  1. Reconnaissance: Identify a target host running SGLang with the Mooncake PD disaggregation backend enabled, where the Prefill bootstrap HTTP port (e.g., 32498) is reachable from an adjacent network segment.
  2. Discover ZMQ rank endpoint: Send an unauthenticated HTTP GET request to the Prefill bootstrap /route endpoint (e.g., GET http://192.168.55.134:32498/route?prefill_dp_rank=0&prefill_cp_rank=0&target_tp_rank=0&target_pp_rank=0) to obtain the Prefill rank's IP address and dynamic ZMQ PULL socket port number — no credentials are required.
  3. Connect to ZMQ PULL socket: Using a ZMQ PUSH socket (e.g., via pyzmq), connect to the returned tcp://<rank_ip>:<rank_port> endpoint.
  4. Craft malicious registration messages: Construct multipart ZMQ messages where frame 0 is b"None" (triggering the Decode registration path), frame 3 is a unique mooncake_session_id (e.g., a UUID), and frame 6 is a 400,004-byte nested-buffer payload declaring 100,000 empty child buffers (packed as struct.pack(f"<{100001}I", 100000, *([0]*100000))).
  5. Flood with unique registrations: Send thousands of such messages, each with a distinct session ID, in a tight loop. Each message causes the Prefill process to materialize ~100,000 Python list objects and permanently retain them in decode_kv_args_table with no eviction.
  6. Trigger OOM kill: After approximately 12,620 registrations (delivering ~5 GB of application-frame payload), the Prefill cgroup memory is exhausted, the Linux OOM killer terminates the Prefill scheduler, and all routed inference requests begin timing out until the stack is manually restarted (SGLang Issue #45012).

Indicators of compromise

  • Network: Unexpected inbound TCP connections to the Prefill bootstrap HTTP port (e.g., 32498) from hosts that are not configured Decode workers; high-volume TCP connections from a single adjacent host to the dynamic ZMQ rank port (e.g., 44437); large volumes of ZMQ PUSH traffic originating from an unexpected source IP.
  • Process: Rapid, sustained growth in the Prefill scheduler process's RSS/PSS memory (e.g., >100 MB/minute); Linux OOM killer events (oom_kill=1) in cgroup memory event counters (/sys/fs/cgroup/.../memory.events); absence of the Prefill scheduler process while the launcher and detokenizer remain running.
  • Logs: SGLang Prefill health endpoint (/health) returning timeouts or connection refused; router health returning HTTP 200 while routed completions time out; memory.peak in the Prefill cgroup approaching or exceeding memory.max.
  • File System / cgroup: cat /sys/fs/cgroup/<prefill-scope>/memory.events showing oom=1 and oom_kill=1; memory.peak at or above the configured MemoryMax limit (SGLang Issue #45012).

Mitigation and workarounds

The primary remediation is to upgrade SGLang to a version newer than 0.5.22, which addresses this vulnerability (Github Advisory). As an immediate workaround, implement network segmentation to restrict access to the Prefill bootstrap HTTP port and the dynamic ZMQ PULL socket port to only trusted Decode worker hosts using firewall rules or network ACLs — the Prefill should not be bound to 0.0.0.0 in production unless access is strictly controlled. Additionally, monitor Prefill rank memory consumption and configure alerting for abnormal growth patterns; placing the Prefill process in a memory-limited cgroup can contain the blast radius but does not prevent the OOM kill (Feedly).

Additional resources


Source: This report was generated using AI

Related SGLang vulnerabilities:

CVE ID

Severity

Score

Technologies

Component name

CISA KEV exploit

Has fix

Published date

CVE-2026-112266HIGH8.2
  • SGLang logoSGLang
  • cpe:2.3:a:lmsys:sglang
NoYesOct 19, 2026
CVE-2026-112270HIGH7.1
  • SGLang logoSGLang
  • cpe:2.3:a:lmsys:sglang
NoYesOct 19, 2026
CVE-2026-112269HIGH7.1
  • SGLang logoSGLang
  • cpe:2.3:a:lmsys:sglang
NoYesOct 19, 2026
CVE-2026-112267MEDIUM6.9
  • SGLang logoSGLang
  • cpe:2.3:a:lmsys:sglang
NoYesOct 19, 2026
CVE-2026-111392MEDIUM6.3
  • SGLang logoSGLang
  • cpe:2.3:a:lmsys:sglang
NoNoOct 16, 2026

Free Vulnerability Assessment

Benchmark your Cloud Security Posture

Evaluate your cloud security practices across 9 security domains to benchmark your risk level and identify gaps in your defenses.

Request assessment

Additional Wiz resources

Get a personalized demo

Ready to see Wiz in action?

"Best User Experience I have ever seen, provides full visibility to cloud workloads."
David EstlickCISO
"Wiz provides a single pane of glass to see what is going on in our cloud environments."
Adam FletcherChief Security Officer
"We know that if Wiz identifies something as critical, it actually is."
Greg PoniatowskiHead of Threat and Vulnerability Management