# Hostile Inference: Docker Model Runner Argument Injection and Container Escape Chains in Docker Desktop (CVE-2026-28400, ZDI-26-150/258/451)

> ZDI research shows the unauthenticated Docker Model Runner (DMR) _configure API, reachable from any default container at model-runner.docker.internal, allows llama-server argument injection (CVE-2026-28400). Chained with host file read/write, a macOS Seatbelt sandbox escape (ZDI-26-451) and Docker Extensions abuse (ZDI-26-258), it enables container-to-host escape on Docker Desktop for macOS and Windows (WSL2). No in-the-wild exploitation is stated.

- **Published:** 2026-11-18T17:40:22Z
- **Last reviewed:** 2026-11-18T17:40:22Z
- **Canonical:** https://intel.threadlinqs.com/threat/TL-2026-6357
- **Card image:** https://intel.threadlinqs.com/og/threat/TL-2026-6357.png
- **ID:** TL-2026-6357
- **Severity:** HIGH (CVSS 7.5)
- **Category:** VULNERABILITY
- **Status:** PATCHED
- **Detections:** 9 (1 shown free below) · **IOCs:** 13 (1 shown free below)
- **CVEs:** CVE-2026-28400

## Description

Docker Model Runner (DMR) is a Docker Desktop feature (enabled by default since 4.46.0) that runs llama.cpp's llama-server on the host, as a child of the Docker Backend process, to serve local models. Its REST API is unauthenticated and reachable from any container over HTTP at model-runner.docker.internal. The POST /engines/_configure and /engines/llama.cpp/_configure endpoints accepted runtime flags that were passed to llama-server without adequate validation (CWE-749, argument injection). Injecting the --log-file flag lets a container write or overwrite arbitrary files reachable by the Model Runner process, for example the Docker Desktop VM disk Docker.raw. ZDI-26-150 / CVE-2026-28400 was reported as a denial of service on macOS; ZDI's follow-up research (Nitesh Surana, Trend/TrendAI Research) extended the primitive toward host code execution under non-default configurations. The GitHub advisory GHSA-m456-c56c-hh5c rates it CVSS 7.5 (AV:L/AC:H/PR:L/UI:R/S:C).

Platform sandboxing differs. On macOS, llama-server runs under a Seatbelt profile (sandbox-exec, since Docker Desktop 4.46.0) that starts from (allow default) and denies selected operations, so some user-data paths under the Docker Desktop container directory remain reachable. On Windows, llama-server runs in a Job Object that limits memory, CPU, process count and lifetime but adds no filesystem restrictions beyond the user's own permissions. The post describes certain llama-server options performing host file reads and writes, leaking the Docker Desktop username through UNC-path handling and error output (needed to build user-specific paths), and sinks that put attacker-supplied metadata into inference logs for partial control over written content. Docker Extensions are described as the route to host command execution, since extension UIs can invoke privileged Docker CLI operations and unsandboxed host binaries.

Two related issues complete the chain. ZDI-26-451 (CVSS 8.8, macOS): the Seatbelt profile did not deny the launchservicesd Mach services, so a sandboxed process could launch applications through LaunchServices outside the sandbox (TCC and Gatekeeper still applied); fixed by commit 98038869 denying Mach lookups for com.apple.launchservicesd and com.apple.coreservices.launchservicesd. ZDI-26-258 (CVSS 8.2, Windows/WSL2 0-day): from a compromised Docker Desktop VM, the backend socket /run/host-services/backend.sock exposes an /app/settings API (GET/POST); changing onlyMarketPlaceExtensions re-enables installation of arbitrary extensions, linked to host code execution. Docker rejected this as outside its threat model because a container-to-VM escape is already required; no fix is described.

Remediation for CVE-2026-28400: DMR v1.0.16 (Docker Desktop 4.61.0+) removed then re-added runtime flags with path-safety validation, added a strict per-backend flag allowlist, and removed the allowlisted --trust-remote-code flag that could let vLLM models escape the container. Enhanced Container Isolation (ECI) blocks container access to Model Runner. The ZDI post and sources state no CVSS for the full chain, no in-the-wild exploitation, no attribution and no malicious IOCs; the indicators below are artifacts for hunting and detection rather than attacker infrastructure.

## MITRE ATT&CK

- T1611 Escape to Host
- T1059 Command and Scripting Interpreter
- T1485 Data Destruction
- T1565.001 Stored Data Manipulation
- T1005 Data from Local System
- T1033 System Owner/User Discovery

## Free detection (Splunk SPL, Microsoft KQL, Sigma)

**Docker Model Runner llama-server Argument Injection (CVE-2026-28400) — Exploitation** (`TL-2026-6357-SPL-001`)

Detects the host-side llama.cpp llama-server process (child of the Docker Backend) started with attacker-injected runtime flags delivered through the unauthenticated DMR POST /engines/_configure API: --log-file (arbitrary host file write/overwrite, e.g. Docker.raw), --trust-remote-code (vLLM container-escape flag) or a direct Docker.raw reference. This is the core CVE-2026-28400 / ZDI-26-150 / GHSA-m456-c56c-hh5c exploitation artifact in TL-2026-6357.

- **Languages:** Splunk SPL, Microsoft KQL, Sigma
- **ATT&CK:** T1611, T1068, T1565.001, T1485, T1033
- **Data sources:** sysmon, windows_process_creation, mde_deviceprocessevents
- **Severity:** high
- **Confidence:** high

### Splunk SPL

```spl
index=windows sourcetype="XmlWinEventLog:Microsoft-Windows-Sysmon/Operational" EventCode=1 (Image="*\\llama-server.exe" OR OriginalFileName="llama-server*") (CommandLine="*--log-file*" OR CommandLine="*--trust-remote-code*" OR CommandLine="*Docker.raw*")
| eval cmd_lc=lower(CommandLine)
| eval injected_flag=case(like(cmd_lc,"%--log-file%"),"--log-file", like(cmd_lc,"%--trust-remote-code%"),"--trust-remote-code", true(),"docker.raw")
| eval targets_vm_disk=if(like(cmd_lc,"%docker.raw%"),1,0)
| stats count min(_time) as first_seen max(_time) as last_seen values(CommandLine) as command_lines values(ParentImage) as parent_images by host, User, injected_flag, targets_vm_disk
| convert ctime(first_seen) ctime(last_seen)
```

### Microsoft KQL

```kql
DeviceProcessEvents
| where Timestamp > ago(24h)
| where FileName in~ ("llama-server", "llama-server.exe") or ProcessVersionInfoOriginalFileName startswith "llama-server"
| where ProcessCommandLine has_any ("--log-file", "--trust-remote-code", "Docker.raw")
| extend InjectedFlag = case(ProcessCommandLine has "--log-file", "--log-file", ProcessCommandLine has "--trust-remote-code", "--trust-remote-code", "Docker.raw")
| project Timestamp, DeviceName, AccountName, FileName, ProcessCommandLine, InitiatingProcessFileName, InitiatingProcessCommandLine, InjectedFlag
| order by Timestamp desc
```

### Sigma

```yaml
title: Docker Model Runner llama-server Injected Runtime Flags (CVE-2026-28400)
id: 3f6b1c52-8a4e-4d7b-9c21-5e0a7b8d6f01
status: experimental
description: Detects llama-server (llama.cpp) spawned by Docker Model Runner with injected flags such as --log-file or --trust-remote-code, indicating abuse of the unauthenticated /engines/_configure API (CVE-2026-28400).
references:
    - https://www.thezdi.com/blog/2026/11/17/hostile-inference-exploiting-docker-model-runner-for-container-escapes
    - https://github.com/docker/model-runner/security/advisories/GHSA-m456-c56c-hh5c
    - https://nvd.nist.gov/vuln/detail/CVE-2026-28400
author: Threadlinqs Team
date: 2026/11/18
tags:
    - attack.privilege-escalation
    - attack.t1611
    - attack.t1068
    - attack.impact
    - attack.t1565.001
    - attack.t1485
    - cve.2026-28400
logsource:
    category: process_creation
    product: windows
detection:
    selection_img:
        Image|endswith: '\llama-server.exe'
    selection_flags:
        CommandLine|contains:
            - '--log-file'
            - '--trust-remote-code'
            - 'Docker.raw'
    condition: selection_img and selection_flags
falsepositives:
    - Administrators intentionally running llama-server with --log-file for local debugging
    - Developers testing llama.cpp outside Docker Model Runner
level: high

```

**Known false positives:**

- Developers or admins manually launching llama-server with --log-file for troubleshooting
- Local AI tooling that legitimately passes logging flags to llama-server

**Tuning notes:** Restrict to llama-server instances whose ParentImage is the Docker Desktop Backend to focus on DMR; allow-list known log paths under the Docker Desktop data directory; treat any --log-file value pointing at Docker.raw, a Startup folder, .ssh or another user-data path as critical. After upgrading to Docker Desktop 4.61.0+ (DMR 1.0.16) expect hits only from manual execution.

### 8 more detection rules (Splunk SPL, Microsoft KQL, Sigma), unlock with TL Creds

- Container Tooling Calling Docker Model Runner _configure API (CVE-2026-28400) (locked: unlock with TL Creds)
- llama-server Writing [indicator] or Sensitive Host Paths via --log-file Injection (locked: unlock with TL Creds)
- Docker Extension Installation Outside Marketplace Workflow (ZDI-26-258) (locked: unlock with TL Creds)
- HTTP POST to Docker Model Runner [indicator] Endpoints (locked: unlock with TL Creds)
- llama-server Process Referencing UNC Paths — Username Disclosure and Host File Read Probing (locked: unlock with TL Creds)
- macOS Seatbelt Sandbox Escape — llama-server or sandbox-exec Launching Apps via LaunchServices (ZDI-26-451) (locked: unlock with TL Creds)
- Docker Desktop backend.sock [indicator] Tampering — [indicator] Disabled (ZDI-26-258) (locked: unlock with TL Creds)
- llama-server Spawning Shells or LOLBins on Windows — DMR Host Code Execution (locked: unlock with TL Creds)

Sign up free to unlock the detection rules: https://threadlinqs.com/?modal=signup

## Sample indicators (1 of 13)

Defanged, TLP:CLEAR.

- Domain: `model-runner[.]docker[.]internal`

Full set of 13 indicators unlocks with TL Creds: https://threadlinqs.com/tl-creds

## Sources

- [Hostile Inference: Exploiting Docker Model Runner for Container Escapes (Nitesh Surana, ZDI)](https://www.thezdi.com/blog/2026/11/17/hostile-inference-exploiting-docker-model-runner-for-container-escapes)
- [GHSA-m456-c56c-hh5c: Docker Model Runner Unauthenticated Runtime Flag Injection via _configure Endpoint](https://github.com/docker/model-runner/security/advisories/GHSA-m456-c56c-hh5c)
- [NVD: CVE-2026-28400](https://nvd.nist.gov/vuln/detail/CVE-2026-28400)
- [ZDI-26-150: Docker Desktop for Mac Docker Model Runner](https://www.zerodayinitiative.com/advisories/ZDI-26-150/)
- [ZDI-26-258: (0Day) Docker Desktop extension-manager Exposed Dangerous Function Local Privilege Escalation](https://www.zerodayinitiative.com/advisories/ZDI-26-258/)
- [ZDI-26-451: Docker Desktop for macOS Inference Server Permissive Allow List Sandbox Escape](https://www.zerodayinitiative.com/advisories/ZDI-26-451/)
- [SentinelOne Vulnerability Database: CVE-2026-28400](https://www.sentinelone.com/vulnerability-database/cve-2026-28400/)
- [VulDB: Docker model-runner up to 1.0.15 API /engines/_configure](https://vuldb.com/vuln/348233)

## Full data

The other 8 detection rules (Splunk SPL / Microsoft KQL / Sigma) unlock with TL Creds; a free account includes daily creds: https://threadlinqs.com/?modal=signup
Indicator values unlock with TL Creds, at a lower price on Red and Purple; AI agents can query rules and IOCs through the Threadlinqs MCP server (Purple): https://intel.threadlinqs.com/mcp

Canonical: https://intel.threadlinqs.com/threat/TL-2026-6357
