Detect LMCache Unsafe Pickle Deserialization RCE over Multiprocess ZMQ Transport (CVE-2026-105192) in Google Chronicle
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
YARA-L Detection Query
// df00tech DF00-50f53208bf · https://df00tech.com/detections/CVE-2026-105192 · licence: https://df00tech.com/detections/licence
rule lmcache_pickle_rce_child_process {
meta:
author = "Argus"
description = "LMCache/vLLM Python worker spawning shell/network child (CVE-2026-105192)"
severity = "HIGH"
events:
$e.metadata.event_type = "PROCESS_LAUNCH"
re.regex($e.principal.process.parent_process.file.full_path, `(?i)(python3?|vllm)$`)
(re.regex($e.principal.process.command_line, `(?i)(lmcache|vllm|ipc_wrapper)`) or re.regex($e.principal.process.parent_process.command_line, `(?i)(lmcache|vllm)`))
re.regex($e.target.process.file.full_path, `(?i)/(sh|bash|dash|zsh|nc|ncat|curl|wget)$`)
condition:
$e
} YARA-L rule matching LMCache/vLLM Python parents launching shell or network-tool child processes, indicative of deserialization code execution.
Data Sources
Required Tables
False Positives & Tuning
- Legitimate service startup subprocess launches
- Model download helpers running curl/wget
- Shell-based liveness probes under the service account
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.
- 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`.
- Test 2 Deliver crafted pickle to local ZMQ endpoint (lab)
Expected signal: python3 process invoking os.system -> sh -> touch, creating /tmp/lmcache_pickle_poc.
- Test 3 Detect vulnerable lmcache version installed
Expected signal: Command execution reading package metadata; version string in output.
References (9)
- https://github.com/LMCache/LMCache/security/advisories/GHSA-w5f2-9q9c-ff4h
- https://nvd.nist.gov/vuln/detail/CVE-2026-105192
- https://github.com/LMCache/LMCache/pull/5644
- https://github.com/LMCache/LMCache/pull/5684
- https://github.com/LMCache/LMCache/pull/5685
- https://github.com/LMCache/LMCache/commit/160b6dec469edb765efd1fad42aca5a438b08bb5
- https://blog.lmcache.ai/en/2026/10/13/an-update-on-cve-2026-105192
- https://research.jfrog.com/vulnerabilities/lmcache-is-vulnerable-to-unauthenticated-remote-code-execution-via-pickle-deserialization-on-the-multiprocess-zmq-transport-cve-2026-105192-jfsa-2026-001694382
- https://github.com/advisories/GHSA-w5f2-9q9c-ff4h
Response Playbook
Triage
- 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.
- 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.
- 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.
- Correlate the alert time with any inbound connections to the ZMQ port from non-loopback source IPs.
Containment
- 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.
- Stop the compromised LMCache/vLLM service and kill any unexpected child processes spawned by it.
- Block the attacker source IP(s) at the host/network firewall and rotate any credentials or tokens accessible from the service process.
Evidence Collection
- Capture the full process tree, command lines, and environment of the LMCache/vLLM worker and all child processes for the alert window.
- Preserve network connection logs/pcap for the ZMQ port showing the inbound source and payload timing.
- 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.
// 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 ``` 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
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
python3 -c "import subprocess,sys; sys.argv[0]='lmcache_worker'; subprocess.run(['/bin/bash','-c','id > /tmp/lmcache_rce_poc.txt'])" Cleanup
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.
Send a malicious pickle whose __reduce__ touches a file to a locally bound REP socket emulating the LMCache multiprocess transport, demonstrating unauthenticated deserialization.
Command
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
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.
Enumerate the installed lmcache package version to confirm exposure to CVE-2026-105192 (vulnerable if >= 0.3.9 and < 0.5.6).
Command
pip show lmcache 2>/dev/null | grep -i version || echo 'lmcache not installed' Cleanup
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.