Skip to content
CVE-2026-105192 Splunk · SPL

Detect LMCache Unsafe Pickle Deserialization RCE over Multiprocess ZMQ Transport (CVE-2026-105192) in Splunk

Detects exploitation of CVE-2026-105192, an unauthenticated remote code execution vulnerability in LMCache (>= 0.3.9, < 0.5.6). The LMCache multiprocess IPC/ZMQ transport deserializes attacker-controlled messages with Python pickle without authentication (CWE-306: Missing Authentication for Critical Function). An attacker able to reach the LMCache ZMQ socket (default bound TCP/IPC endpoint used by the vLLM-integrated KV-cache worker) can send a crafted pickle payload whose __reduce__ executes arbitrary code in the context of the LMCache/vLLM process. Detection focuses on the LMCache/vLLM Python process spawning unexpected child processes, inbound connections to the LMCache ZMQ port from non-loopback hosts, and vulnerable package versions present on hosts.

MITRE ATT&CK

Tactic
Initial Access Execution

SPL Detection Query

Splunk (SPL)
spl
``` df00tech DF00-50f53208bf · https://df00tech.com/detections/CVE-2026-105192 · licence: https://df00tech.com/detections/licence ```
index=linux OR index=edr sourcetype IN ("linux:process","sysmon","XmlWinEventLog:Microsoft-Windows-Sysmon/Operational")
| search (parent_process_name IN ("python","python3","vllm") OR parent_process="*lmcache*" OR parent_process="*vllm*")
| where match(process_name, "^(sh|bash|dash|zsh|nc|ncat|curl|wget|powershell\.exe|cmd\.exe)$")
| stats count min(_time) as firstTime max(_time) as lastTime values(process) as process by host parent_process_name process_name user
| convert ctime(firstTime) ctime(lastTime)
| sort - count
high severity medium confidence

Identifies child processes (shells, network clients) spawned by an LMCache/vLLM Python parent, consistent with code execution through the unsafe pickle deserialization path.

Data Sources

Linux process telemetrySysmon

Required Sourcetypes

linux:processsysmonXmlWinEventLog:Microsoft-Windows-Sysmon/Operational

False Positives & Tuning

  • Service startup wrappers launching subprocesses from the Python parent
  • Model/weight download helpers invoking curl or wget
  • Monitoring agents executing shell health probes under the service user

Other platforms for CVE-2026-105192


Testing Methodology

Validate this detection against 3 adversary techniques from Atomic Red Team. Each test below lists the behaviour to exercise and the telemetry you should expect to see. Executable commands and cleanup steps are further down this page.

  1. Test 1 Simulate pickle RCE child-process spawn from vLLM/LMCache worker

    Expected signal: Process-start event with a python3 parent (command line referencing lmcache) spawning /bin/bash which runs `id`.

  2. Test 2 Deliver crafted pickle to local ZMQ endpoint (lab)

    Expected signal: python3 process invoking os.system -> sh -> touch, creating /tmp/lmcache_pickle_poc.

  3. Test 3 Detect vulnerable lmcache version installed

    Expected signal: Command execution reading package metadata; version string in output.


Response Playbook

Triage

  1. Confirm the affected host runs LMCache in the vulnerable range (>= 0.3.9, < 0.5.6): run `pip show lmcache` or inspect the container image to obtain the installed version.
  2. Determine whether the LMCache multiprocess ZMQ transport endpoint is network-exposed: check listening sockets (`ss -tlnp | grep -i python`) and whether the bind address is loopback-only or reachable from other hosts/pods.
  3. Review process ancestry for the alerting event — confirm the shell/network child genuinely descends from the LMCache/vLLM worker rather than from a legitimate startup wrapper.
  4. Correlate the alert time with any inbound connections to the ZMQ port from non-loopback source IPs.

Containment

  1. Isolate or network-segment the affected host/pod so the LMCache ZMQ endpoint is no longer reachable from untrusted networks; restrict the socket to loopback or an authenticated internal network.
  2. Stop the compromised LMCache/vLLM service and kill any unexpected child processes spawned by it.
  3. Block the attacker source IP(s) at the host/network firewall and rotate any credentials or tokens accessible from the service process.

Evidence Collection

  1. Capture the full process tree, command lines, and environment of the LMCache/vLLM worker and all child processes for the alert window.
  2. Preserve network connection logs/pcap for the ZMQ port showing the inbound source and payload timing.
  3. Collect the LMCache/vLLM application logs and any core dumps, plus the on-disk package version metadata (`pip show lmcache`).

Escalation Criteria

  • !Escalate to incident response if a child process performed outbound C2, credential access, lateral movement, or persistence after the suspicious spawn.
  • !Escalate if the ZMQ endpoint was confirmed reachable from an untrusted network AND the installed version is in the vulnerable range, regardless of whether code execution is yet confirmed.

Investigation Guide

Forensic Artifacts

  • >Process-creation records showing LMCache/vLLM Python as parent of an unexpected shell/network child
  • >Listening-socket and network-connection logs for the LMCache ZMQ endpoint
  • >Installed lmcache package version metadata (pip/site-packages RECORD)

Tuning Guidance

Baseline the legitimate subprocesses that your LMCache/vLLM deployment spawns at startup (entrypoint shells, model-download curl/wget) and exclude those specific parent/child command-line patterns and service accounts. Tighten the ZMQ-exposure checks to your known bind address so loopback-only deployments are deprioritized. After patching to >= 0.5.6, reduce severity and keep the hunt as a regression guard.


Hunting Queries

Hunt for shell or network-tool children of LMCache/vLLM workers across the fleet to surface post-exploitation activity.

Hunting — KQL
kql
// df00tech DF00-50f53208bf · https://df00tech.com/detections/CVE-2026-105192 · licence: https://df00tech.com/detections/licence
DeviceProcessEvents | where InitiatingProcessCommandLine has_any ("lmcache","vllm") | where FileName in~ ("sh","bash","nc","curl","wget","python3") | project Timestamp, DeviceName, InitiatingProcessCommandLine, FileName, ProcessCommandLine
Hunting — SPL
spl
``` df00tech DF00-50f53208bf · https://df00tech.com/detections/CVE-2026-105192 · licence: https://df00tech.com/detections/licence ```
index=* (parent_process="*lmcache*" OR parent_process="*vllm*") process_name IN ("sh","bash","nc","curl","wget") | stats count by host, parent_process, process_name, user

Atomic Red Team Tests

Test 1 Simulate pickle RCE child-process spawn from vLLM/LMCache worker
linux

In a lab, a Python process mimicking the LMCache worker spawns a shell, reproducing the process-ancestry telemetry generated when a pickle __reduce__ payload executes.

Command

bash
python3 -c "import subprocess,sys; sys.argv[0]='lmcache_worker'; subprocess.run(['/bin/bash','-c','id > /tmp/lmcache_rce_poc.txt'])"

Cleanup

bash
rm -f /tmp/lmcache_rce_poc.txt

Expected Telemetry

Process-start event with a python3 parent (command line referencing lmcache) spawning /bin/bash which runs `id`.

Expected Detection

KQL/SPL/EQL rules fire on the LMCache/vLLM Python parent spawning a bash child.

Test 2 Deliver crafted pickle to local ZMQ endpoint (lab)
linux

Send a malicious pickle whose __reduce__ touches a file to a locally bound REP socket emulating the LMCache multiprocess transport, demonstrating unauthenticated deserialization.

Command

bash
python3 - <<'EOF'
import pickle, os, socket, struct
class E:
    def __reduce__(self):
        return (os.system, ('touch /tmp/lmcache_pickle_poc',))
payload = pickle.dumps(E())
# In a real test, send `payload` to the LMCache ZMQ REP endpoint; here we just deserialize locally to mimic the sink.
pickle.loads(payload)
EOF

Cleanup

bash
rm -f /tmp/lmcache_pickle_poc

Expected Telemetry

python3 process invoking os.system -> sh -> touch, creating /tmp/lmcache_pickle_poc.

Expected Detection

Process rules detect the Python-to-shell child spawn; file-creation telemetry shows the dropped marker file.

Test 3 Detect vulnerable lmcache version installed
linux

Enumerate the installed lmcache package version to confirm exposure to CVE-2026-105192 (vulnerable if >= 0.3.9 and < 0.5.6).

Command

bash
pip show lmcache 2>/dev/null | grep -i version || echo 'lmcache not installed'

Cleanup

bash
true

Expected Telemetry

Command execution reading package metadata; version string in output.

Expected Detection

Vulnerability management / inventory hunt flags any version in [0.3.9, 0.5.6) as affected.

Related Detections