Learn how to secure a shared Language Model Cache server on Kubernetes.
LMCache 0.5.6 fixes a shared cache bug; Kubernetes operators need network controls, rebuilt images, and restarts before production.
Key Takeaways
- LMCache 0.5.6 fixes CVE-2026-105192, a 9.8-severity unauthenticated remote code execution flaw in multiprocess shared KV-cache servers, where a crafted message could run code as root inside the cache container.
- The risk appears when the cache server listens beyond localhost; affected versions are 0.3.9 through 0.5.5 and 0.5.6 rc1 through rc3, and the official Kubernetes quick-start exposed it by using hostNetwork, 0.0.0.0 listeners, host /dev/shm mounts, and no security context.
- The exploit used Python pickle over ZeroMQ with no authentication, allowing attackers on an exposed setup to reach conversation-derived cache data and potentially access other workloads or node services.
- Version 0.5.6 replaces pickle with typed MessagePack, binds admin endpoints to 127.0.0.1, and gates /run_script, but remote authentication is planned only for 0.5.7, so network controls remain essential until then.
- Operators should treat the shared cache like Redis: keep transport on localhost or a trusted network, apply firewalls or node-level controls, rebuild hardened images, add security contexts, and audit listening ports before production.
Meta description: Learn how the LMCache CVE in version 0.5.6 changed shared KV cache servers and what Kubernetes operators should configure before production today.
Tags: LMCache, vLLM, Kubernetes, key-value cache, CVE-2026-105192
Featured image: A friendly abstract illustration of a locked shared cache drawer on a Kubernetes cluster, no people, no logos, no text.
The LMCache vulnerability fixed in LMCache 0.5.6 in mid-October shows that a shared key-value cache server needs the same care as any network service. The flaw, tracked as CVE-2026-105192, had a severity score of 9.8 out of 10. Anyone who could reach the open cache port could run code as root inside the cache server container. LMCache is an open-source add-on for vLLM, the program many teams use to serve AI models, and most of these setups run on Kubernetes, the system that schedules workloads across machines. The lesson is bigger than one bug: LMCache can now run as a separate server, and a separate server needs the same network controls as any other shared service. The quick-start Kubernetes example is built to get teams running, so hardening it for production is the operator's job. That takes a few configuration changes, a rebuilt image, and one coordinated restart.
The flaw lived in a separate cache service
LMCache stores the key-value cache, the model's working memory for a conversation, so the model does not recompute it on every request. That is what makes long prompts fast, and it is why LMCache appears in vLLM cluster designs. In the normal setup, the cache sits inside the vLLM process. In multiprocess mode, the cache moves into its own server so several vLLM pods can share one set of files. Sharing is useful, but a shared room needs a lock on the door. Remote procedure call authentication is planned for 0.5.7. Until then, the lock is the network setup.
The LMCache documentation describes a DaemonSet plus Deployment pattern: one LMCache server per node through a DaemonSet, shared by multiple vLLM pods through a Deployment. A DaemonSet runs one copy of a program on every node. A Deployment runs as many copies as requested, and each running copy is a pod. vLLM pods connect through LMCacheMPConnector. The cache server holds key-value data for every vLLM pod on that GPU node, one machine in the cluster with GPUs, and it can outlive each of them.
A server that runs for months, holds shared state, and answers on a network port behaves like Redis, the in-memory database many backends use as a cache. It inherits the security checklist Redis operators have followed for years, and the quick-start example leaves that checklist to the operator.
The affected versions were 0.3.9 through 0.5.5, plus the 0.5.6 release candidates rc1 through rc3, which are pre-release test builds. Only multiprocess mode is affected because that mode runs the separate cache server that accepts these messages. Even then, the port listens on 127.0.0.1 by default, meaning this machine only. It becomes exposed when the host address is set to an address other machines can reach. The project's own Kubernetes example set it to 0.0.0.0, which listens on every network interface.
The mechanism is an old one. The cache server decoded one kind of incoming message with Python pickle, a format that can carry instructions as well as data. Python documentation warns that malicious pickle data can execute arbitrary code during unpickling. The server took those messages over ZeroMQ on port 5555, with no authentication. One crafted message ran code as the cache server process. In the official images, that process runs as root.
On an exposed setup, whoever sends that message can run code as root inside the cache server, on a GPU node that is usually among the most expensive machines in the cluster. The cache holds data derived from every conversation served on that node. The container also sits on the host network and mounts the host shared-memory folder, so from there an attacker can reach other workloads' shared memory and any service listening on the node's network, not only the cache. Yuval Moravchick of JFrog reported the bug, and it was disclosed on October 7, before a fix existed.
LMCache 0.5.6 shipped in mid-October and swapped pickle for versioned, typed MessagePack, which carries only data. It also moved the admin web servers from 0.0.0.0 to 127.0.0.1 and gated the POST /run_script endpoint, which before 0.5.6 was served on every interface with no authentication. Before 0.5.6, the admin web servers listened on 0.0.0.0, including the multiprocess frontend on port 8080 with its POST /clear-cache endpoint. Operators can run ss -ltnp inside the container to see what their setup listens on.
Why the Kubernetes example exposed the port
The advisory tells operators to keep the multiprocess transport on localhost, or on a trusted cluster network only. A flat pod network is not a trusted network, and the shipped example cannot use localhost anyway. The configuration shown on the v0.5.6 tag uses hostNetwork true, runs the lmcache/standalone:nightly image, starts the multiprocess server module with --host 0.0.0.0 and --port 6555, mounts /dev/shm from the host as a hostPath volume, and sets no security context at the pod or container level.
hostNetwork true puts the container directly on the node's own network interfaces instead of Kubernetes' private pod network. The vLLM pods live on the pod network, so the cache server has to listen on the node's real interfaces to be reachable. The vLLM Deployment finds the cache through the node address taken from status.hostIP. That means every pod in the cluster, and anything else that can route to the node, can reach port 6555 unless a firewall stops it.
NetworkPolicy is how Kubernetes restricts traffic from one pod to another, and it does not help here. Kubernetes leaves its behavior for hostNetwork pods undefined, and in practice the network plugin treats their traffic as node traffic, so pod selectors never match it.
The pod also fails Pod Security Standards, Kubernetes' built-in security levels, at Baseline. Baseline is the minimum level that blocks the known ways a pod can escalate to the host. It forbids host namespaces like hostNetwork, and it forbids hostPath volumes, which mount a folder straight from the node. This pod does both. The folder is /dev/shm, the shared-memory folder vLLM and the cache use to exchange data on the same machine.
The release post plans a localhost-only example for 0.5.7. If teams adopt it, they should check how their vLLM pods reach the cache, because a pod on the pod network cannot reach the node's own 127.0.0.1.
Borrow the Redis security checklist
The Redis security page says Redis is designed to be accessed by trusted clients inside trusted environments. Swap in LMCache and the sentence still works. Open Redis instances were hijacked through CONFIG SET, the command that rewrites a running server's settings, and protected mode plus later access control lists became part of the answer.
Redis documentation shows binding to 127.0.0.1, and protected mode, added since Redis 3.2, answers only loopback when no bind address and no password are configured. LMCache multiprocess mode 0.5.6 defaults to 127.0.0.1, but the example binds 0.0.0.0 on the host network. The immediate rule is to never bind a reachable address on the host network.
Redis uses access control lists since Redis 6 and legacy requirepass for authentication. LMCache multiprocess mode 0.5.6 has no remote procedure call authentication in the release. Until authentication lands, restrict who can reach the port.
Redis recommends running as an unprivileged redis user. LMCache multiprocess mode 0.5.6 official images run as root. The immediate rule is to build a non-root image and set runAsNonRoot.
Redis protects admin endpoints with access control lists and the bind address. LMCache 0.5.6 binds admin endpoints to 127.0.0.1 and gates the script endpoint. The rule is to keep admin endpoints off reachable addresses.
LMCache has a second way of passing data, the engine-driven path, that still uses pickle. It is off by default and cannot be reached over the network, so it should stay off. Until remote procedure call authentication and non-root images land, controlling who can reach the port is the main lock.
A safer shared cache setup and who should use it
If a team needs one cache server per GPU node shared by several vLLM pods, take it off the host network and give it an ordinary pod IP. Then NetworkPolicy and Pod Security checks apply to it again. The network change needs no new hardware. It costs engineer time, a rebuilt image, and one restart of the cache.
Each vLLM pod should talk only to the cache server on its own machine. A Service gives a group of pods one stable address. Setting internalTrafficPolicy to Local, stable since Kubernetes 1.26, keeps each vLLM pod on its own node's cache server. While that cache server restarts, vLLM pods on the node have nowhere to send cache requests and do not fail over to another node. That is the right behavior for a node-local cache. Operators should confirm that kube-proxy, the component that routes Service traffic on each node, honors the field in their cluster.
A safe setup uses a Service named lmcache in namespace inference, selecting pods labeled app lmcache, with the ZeroMQ port named zmq on port 5555 and target port 5555. It should be paired with a default deny-ingress policy named default-deny-ingress that applies to all pods in the inference namespace, and a policy named lmcache-from-vllm-only that allows only pods labeled app vllm to reach pods labeled app lmcache on port 5555. The policy still allows traffic from the pod's own node so kubelet health probes can pass. That also means a compromised process on that node can bypass the policy.
Moving off the host network clears the hostNetwork violation, but the pod still fails Baseline while it mounts /dev/shm as a hostPath volume. The deployment guide documents --isolated-ipc, which applies to the multiprocess connector only and needs cuda-python. It drops the shared-folder dependency for inter-process communication between vLLM and the cache. That is the route to Baseline and then to Restricted, the strictest level.
If a team does not need sharing across pods, it can run one cache server inside each vLLM pod over localhost. That loses the shared cache, and there is no port the rest of the cluster can reach. A second container would need the same GPU visible and a shared memory volume for inter-process communication.
The target setup should run the cache as an ordinary user with no extra Linux privileges, so a break-in lands with far less power than root. Use a rebuilt image built from the Dockerfile and tagged lmcache-standalone:0.5.6-nonroot, never the nightly image. Set hostNetwork to false, runAsNonRoot to true, runAsUser to 10001, and seccompProfile to RuntimeDefault. For the container, set allowPrivilegeEscalation to false and drop all capabilities. Start the multiprocess server module with --host 0.0.0.0 and --port 5555, because 0.0.0.0 here is the pod IP. Then point vLLM at tcp://lmcache.inference.svc.cluster.local on port 5555 instead of the HOST_IP value.
Without an allow rule, the default-deny policy can cut off the gateway too. Add one for the vLLM serving port, 8000 by default, from the gateway or ingress namespace. Add another for the Prometheus namespace if the cluster scrapes LMCache metrics on port 9090, as the deployment guide does. The labels have to match.
Take the manifests through staging before production and confirm three things: data still passes between vLLM and the cache after the user change, vLLM keeps serving while a node's cache server restarts, and vLLM fails cleanly, with a clear connector error, when the cache server rejects its version.
Who should use this setup: teams running LMCache multiprocess mode across several vLLM pods, teams that can rebuild images, enforce NetworkPolicy, and test the cache restart path. Who should skip the shared-server path for now: teams that cannot control the network, cannot confirm kube-proxy behavior, cannot remove the hostPath dependency, or need remote procedure call authentication before exposing the port. Those teams can wait for 0.5.7 or use the local-cache pattern until authentication and non-root images are available.

Comments (0)