Hostile Inference: Exploiting Docker Model Runner for Container Escapes Researchers disclosed CVE-2026-28400 (ZDI-26-150), an unauthenticated argument-injection vulnerability in Docker Model Runner (DMR) that was first reported in November 2025 as a macOS denial of service but can be escalated under non-default configurations to arbitrary code execution on the host on both macOS and Windows. DMR, compiled into the Docker Backend, runs the llama.cpp llama-server inference process on the host rather than inside the LinuxKit VM, and its unauthenticated REST API is reachable from any container at model-runner.docker.internal over HTTP. The researchers also found two further escapes: one from an overly permissive Seatbelt sandbox configuration on macOS and one that pivots the WSL2 VM-to-host boundary through Docker Extensions. Blog Hostile Inference: Exploiting Docker Model Runner for Container Escapes Local LLM inference is seeing adoption in default developer workflows, and the tooling that serves those models now ships inside products developers already trust. One of those is Docker Model Runner DMR , the feature in Docker Desktop that pulls, runs, and serves models locally. In November 2025, we reported ZDI-26-150 https://www.zerodayinitiative.com/advisories/ZDI-26-150/ / CVE-2026-28400 https://www.cve.org/CVERecord?id=CVE-2026-28400 , a denial-of-service on macOS stemming from an unauthenticated argument-injection vulnerability in DMR. A container created with the default set of privileges could overwrite and corrupt the Docker Desktop VM’s data disk. Further analysis, under non-default configurations, turned the same primitive into arbitrary code execution on the host, on both macOS and Windows. In this post, we walk through the full chain: the argument-injection primitive, the host file read/write foothold it grants, how we take partial control of what gets written, and the payoff that turns a constrained file write into arbitrary code execution on the host through Docker Extensions. We then cover two further escapes we found along the way: one from an overly permissive Seatbelt sandbox configuration on macOS, and one that pivots the WSL2 VM-to-host boundary through Docker Extensions. Background: Docker Model Runner and the host boundary Docker Desktop https://www.docker.com/products/docker-desktop/ helps run Docker containers on macOS, Windows, and Linux. Docker Desktop for Windows with Windows containers and Docker Desktop for Linux are out of scope for this blog. Since macOS and Windows don’t come with a Linux kernel to run Linux containers, Docker Desktop ships a LinuxKit https://github.com/linuxkit/linuxkit VM that hosts the container runtime; on macOS the VM runs using the Apple Virtualization Framework https://docs.docker.com/desktop/features/vmm/ apple-virtualization-framework , while on Windows it runs under WSL2 https://docs.docker.com/desktop/features/wsl/ by default. Linux containers and the Docker Engine components runc, containerd, dockerd run in the Linux VM. Bridging the gap between the host OS and the VM is a daemon called Docker Backend: com.docker.backend macOS or com.docker.backend.exe Windows . This process is responsible for managing the execution environment and brokering all inter-process communication IPC across the VM–OS boundary. DMR https://docs.docker.com/ai/model-runner/ lets users pull, run, and serve models over OpenAI-compatible APIs using the same idioms as running containers docker model pull , docker model run . Models are distributed as OCI artifacts through OCI-compliant registries and stored on the host. At the time of our research, DMR would create an instance of llama.cpp’s llama-server for inference tasks. DMR is compiled into the Docker Backend. The detail that makes this interesting: on macOS and Windows the inference process does not run inside the VM; it runs on the host, as a child of the Docker Backend, with the privileges of the user running Docker Desktop. Because models are, correctly, treated as untrusted input, the inference process is wrapped in an OS-native sandbox using Seatbelt on macOS and Job Objects on Windows. These are not equivalent boundaries, and that difference carries much of the weight on Windows, as we will see in a bit. The DMR REST API is unauthenticated and reachable from any container at the container-internal DNS name model-runner.docker.internal over HTTP. The question we set out to answer was whether a stock container, created with no additional capabilities, flags, mounts, or privileges, could lead to a container-to-host compromise. The Primitive: Argument Injection in configure We refer throughout to the DMR repository at docker/model-runner@38a800 https://github.com/docker/model-runner/tree/38a800e02582964de7591aaf74953b55935e2a2a . The API is split by two prefixes, both served over model-runner.docker.internal : Backed by the ConfigureRequest https://github.com/docker/model-runner/blob/38a800e02582964de7591aaf74953b55935e2a2a/pkg/inference/scheduling/api.go L88-L93 struct, the configure endpoint accepts two JSON properties whose values are appended as command-line arguments for llama-server. It calls the “Configure” method of the scheduler. 1 - The body of the incoming /engines/ configure request is unmarshalled. 2.1 & 2.2 - If the body of the POST request has runtime-flags populated, the value is saved to runtimeFlags as-is. If the body has raw-runtime-flags populated, the value is tokenized through shellwords.Parse . 3 & 4 - runnerConfig stores the inference server s backend configuration. 5 - The POST request's model property is used to fetch the model ID for which the config will be modified. 6 - setRunnerConfig persists the modified configuration per model and mode embedding or non-embedding . At this point, the altered configuration will be applied to the runner's next spawn. Using the chat-completions endpoint /v1/chat/completions , we can load the model that would run the inference server with the altered configuration. Let's see how the arguments propagate. 1 - The backend mode is deduced from the URL path suffix /v1/chat/completions or /v1/completions for completion mode; /v1/embeddings for embedding mode. 2 - The chat completion request's model property contains the model for which chat completion is being invoked. 3 - The scheduler asks the loader using load to execute the request. 4 - If an existing runner for {backend, modelID, mode} is alive, it is reused as-is. Altered configuration is ignored if a runner already exists. 5 - Otherwise, the persisted flags from configure endpoint are retrieved into runnerConfig . 6 - The runner is created via the package-level run ... in pkg/scheduling/runner.go, passing the retrieved configuration. 7 - run calls backend.Run inside a goroutine, populated with the slot's Unix socket path, the model ID, the request-deduced mode, and the attacker-controlled runnerConfig retrieved from configure . backend.Run invokes the inference.Backend interface; the registered and default implementation is llama.cpp s llama-server. 8, 8.1 - GetArgs constructs llama-server’s final command line: hardcoded performance flags, model path, socket host, mode, context-size arguments, followed by the caller-supplied runtime flags appended as-is. 9 - The final set of arguments is supplied to sandbox.Create 10 , which starts com.docker.llama-server in a macOS Seatbelt sandbox sandbox-exec -p