Skip to navigation

Threat reportVulnerabilityTL-2026-1115

Claude Cowork Sandbox Escape: RPC Parameter Bypass Enables Root Command Execution

mediumTRACKING

Security research firm Armadin publicly disclosed a two-stage exploit chain against Anthropic's Claude Cowork on Windows: DLL sideloading of a malicious USERENV.dll to gain code execution inside the signed claude.exe process, followed by an RPC parameter-validation bypass (isResume: true) against the CoworkVMService spawn method that returns a root shell inside the product's bubblewrap-isolated Linux VM, with a second allowedDomains wildcard bypass defeating the egress proxy.

Key facts

IdentifiersTL-2026-1115
Also known asClaude Cowork Sandbox Escape, CoworkVMService isResume Bypass
SeverityMEDIUM
Affected productsAnthropic, PBC Claude Cowork (Claude Desktop for Windows)
Weaknesses (CWE)CWE-427, CWE-863, CWE-284
ToolsWinVerifyTrust, bubblewrap (bwrap)
MITRE ATT&CK techniquesT1003 OS Credential Dumping, T1005 Data from Local System, T1057 Process Discovery, T1059 Command and Scripting Interpreter, T1068 Exploitation for Privilege Escalation, T1090 Proxy, T1106 Native API, T1132 Data Encoding, T1518 Software Discovery, T1553 Subvert Trust Controls, T1567 Exfiltration Over Web Service, T1574 Hijack Execution Flow and 3 more in the attack flow
MotivationUNKNOWN
Target sectorstechnology, softwaredevelopment, enterpriseit
Target regionsGlobal
Detection rules9 (1 shown free)
Sources9 cited sources

Detection coverage

As of 2026-07-02, Threadlinqs Intelligence publishes 9 detection rule(s) for TL-2026-1115 across Splunk SPL, Microsoft KQL and Sigma, covering 24 indicator(s) of compromise. The whole corpus is readable without an account. Every threat comes with one complete detection in Splunk SPL, Microsoft KQL and Sigma, free for everyone; a free account adds daily TL Creds to unlock the rest. Paid plans add a larger daily allowance, correlation and the MCP server. Threadlinqs MCP server · View plans.

Free detection: Post-Escape /etc/shadow Read, Base64 Encoding, and Egress-Proxy Wildcard Bypass Exfiltration

Detects the C2/exfiltration stage of the Armadin chain occurring inside the escaped Cowork sandbox VM: a process reading /etc/shadow, followed within a short window by base64 encoding and an outbound curl/HTTP transfer, combined with an allowedDomains:["*"] egress-proxy wildcard bypass that defeats the domain-restricted allowlist otherwise scoping traffic to api.anthropic.com -- activity invisible to host-based EDR because it occurs entirely inside the Hyper-V-isolated Linux guest.

  • Languages: Splunk SPL, Microsoft KQL, Sigma
  • ATT&CK: T1003.008, T1005, T1132.001, T1567, T1090, T1685
  • Data sources: auditd, sysmon_for_linux, linux_process_creation_logs, proxy_logs, netflow
  • Severity: critical
  • Confidence: high

Splunk SPL

index=linux (sourcetype="linux_secure" OR sourcetype="auditd" OR sourcetype="sysmon_linux")
| eval is_shadow_read=if(match(CommandLine, "/etc/shadow"), 1, 0)
| eval is_b64=if(match(CommandLine, "base64"), 1, 0)
| eval is_curl=if(match(Image, "/curl$") OR match(CommandLine, "^curl "), 1, 0)
| eval is_wildcard_egress=if(match(CommandLine, "allowedDomains.?:.?\[.?\"\*\"\]"), 1, 0)
| bin _time span=5m
| stats count(eval(is_shadow_read=1)) as shadow_reads, count(eval(is_b64=1)) as b64_events, count(eval(is_curl=1)) as curl_events, count(eval(is_wildcard_egress=1)) as wildcard_egress by _time, host, User
| where (shadow_reads > 0 AND b64_events > 0 AND curl_events > 0) OR wildcard_egress > 0

Microsoft KQL

let shadowReads = DeviceProcessEvents
| where Timestamp > ago(24h)
| where ProcessCommandLine has "/etc/shadow"
| project Timestamp, DeviceName, AccountName, bin_time = bin(Timestamp, 5m);
let b64Encode = DeviceProcessEvents
| where Timestamp > ago(24h)
| where ProcessCommandLine has "base64"
| project Timestamp, DeviceName, AccountName, bin_time = bin(Timestamp, 5m);
let curlTransfer = DeviceNetworkEvents
| where Timestamp > ago(24h)
| where InitiatingProcessFileName =~ "curl"
| project Timestamp, DeviceName, RemoteIP, RemoteUrl, bin_time = bin(Timestamp, 5m);
shadowReads
| join kind=inner (b64Encode) on DeviceName, bin_time
| join kind=inner (curlTransfer) on DeviceName, bin_time
| project Timestamp, DeviceName, AccountName, RemoteIP, RemoteUrl
| sort by Timestamp desc

Sigma

title: Credential File Read Followed by Encoded Outbound Transfer (Shadow Exfiltration Pattern)
id: b1e6f3b2-2b7b-4e2b-9c3a-1115spl003a3
status: experimental
description: Detects a process reading /etc/shadow followed within a short timeframe by base64 encoding and an outbound curl transfer, and separately an allowedDomains wildcard egress-proxy bypass -- consistent with the Armadin PoC's post-escape credential-file exfiltration from inside the Cowork sandbox VM.
references:
    - https://www.armadin.com/blog-posts/exploiting-root-execution-in-claude-coworks-sandbox
author: Threadlinqs Team
date: 2026-07-05
tags:
    - attack.credential_access
    - attack.exfiltration
    - attack.command_and_control
    - attack.defense_evasion
    - attack.t1003.008
    - attack.t1132.001
    - attack.t1567
    - attack.t1090
    - attack.t1685
logsource:
    category: process_creation
    product: linux
detection:
    selection_read:
        CommandLine|contains: '/etc/shadow'
    selection_encode:
        CommandLine|contains: 'base64'
    selection_transfer:
        Image|endswith: '/curl'
    selection_wildcard_egress:
        CommandLine|contains:
            - 'allowedDomains":["*"]'
            - 'allowedDomains": ["*"]'
    timeframe: 5m
    condition: (selection_read and selection_encode and selection_transfer) or selection_wildcard_egress
falsepositives:
    - Legitimate backup, password-audit, or configuration-management tooling that reads /etc/shadow, base64-encodes data, and transfers it to an authorized internal endpoint
    - Authorized security scanning/compliance tools performing credential-file integrity checks
level: critical

Known false positives:

  • Legitimate backup, password-hygiene audit, or config-management automation reading /etc/shadow and transmitting it (base64-wrapped) to an authorized internal secrets vault or backup endpoint
  • Authorized compliance/security-scanning tools performing scheduled credential-file integrity checks that incidentally match the read+encode+transfer pattern

Tuning notes: Deploy guest-level (in-VM) log forwarding for the Cowork Linux sandbox, since this activity is invisible to host-only Windows EDR by design; tighten the 5-minute correlation window if false positives from legitimate backup jobs occur, and cross-reference destination IPs/domains against the documented api.anthropic.com egress allowlist to flag any destination outside it as high-confidence malicious.

8 more detection rules (Splunk SPL, Microsoft KQL, Sigma) · unlock with TL Creds. Sign up free to unlock the detection rules or query them with the Threadlinqs MCP server (Purple)
  • DLL Search-Order Hijack: Non-System32 [indicator] Load into Signed [indicator] · unlock with TL Creds
  • CoworkVMService Spawn RPC Parameter-Bypass and Root-Privileged Process Anomaly · unlock with TL Creds
  • In-Guest [indicator] Access with Base64 Encoding and Outbound Curl Transfer · unlock with TL Creds
  • Sigma: [indicator] Side-Loading Outside System32 (Claude Cowork DLL Hijack) · unlock with TL Creds
  • Sigma: Nsenter PID-1 Namespace Join for Sandbox/VM Escape · unlock with TL Creds
  • Sigma: Credential File Read Followed by Encoded Outbound Transfer (Shadow Exfiltration Pattern) · unlock with TL Creds
  • Claude Cowork [indicator] Side-Load via Non-System32 Image Load · unlock with TL Creds
  • CoworkVMService Spawn RPC isResume/allowedDomains Parameter Bypass and nsenter Namespace Escape · unlock with TL Creds

Indicators of compromise

As of 2026-07-02, Threadlinqs Intelligence tracks 24 indicators of compromise for TL-2026-1115.

24 indicators of compromise · unlock with TL Creds. Compare plans

Technical analysis

Anthropic disputes the finding as an in-scope security vulnerability because exploitation presupposes an attacker already has local code execution on the Windows host.

Claude Cowork for Windows (packaged as Claude Desktop for Windows, observed at version 1.9255.2.0, installed under the WindowsApps MSIX path) sandboxes agent-executed code inside a Hyper-V Container System (HCS)-isolated Ubuntu Linux VM. Inside that VM, isolation is layered through bubblewrap namespaces, seccomp filtering, per-session unprivileged Linux users, and a domain-restricted egress (MITM) proxy. The host-to-guest control channel is an Authenticode-gated named-pipe RPC service, CoworkVMService, reachable at \\.\pipe\cowork-vm-service, using a simple [4-byte big-endian length][JSON payload] wire framing.

Armadin researcher Nick McClendon first achieved arbitrary code execution inside the legitimately Anthropic-signed claude.exe process via classic DLL search-order hijacking: claude.exe resolves USERENV.dll from its own application directory before falling back to the genuine System32 copy, so a malicious DLL exporting GetUserProfileDirectoryW and named USERENV.dll, dropped alongside claude.exe (found at C:\Program Files\WindowsApps\Claude_1.9255.2.0_x64__pzs8sxrjxfjjc\app\claude.exe), loads and executes inside the trusted, signed process without ever invalidating the running binary's own Authenticode signature.

From that foothold, the researcher used log analysis, JSON fuzzing, and parameter discovery to reverse-engineer the undocumented CoworkVMService RPC protocol, identifying methods including configure, startVM, isGuestConnected, and spawn. CoworkVMService gates pipe connections using WinVerifyTrust to require the connecting process be signed by "Anthropic, PBC" — but this only authenticates the calling binary's publisher, never authorizing or validating the contents of the RPC request itself. The spawn method exposes two undocumented parameters, isResume and allowedDomains. Normally isResume: false forces creation of a fresh unprivileged per-session Linux user for each command; setting isResume: true instead skips the existing-user validation path entirely, letting the daemon execute the requested command as any specified user — including root — with no authorization check. A crafted request such as {"name": "root", "isResume": true} returns an interactive shell with uid=0, full Linux capabilities, and an unconfined AppArmor profile.

From that root shell, still nominally confined by bubblewrap namespaces, the researcher used nsenter targeting PID 1 (nsenter --target 1 --mount --pid --uts --ipc --net) to join the host VM's mount, PID, UTS, IPC, and network namespaces, fully escaping the bwrap sandbox into the broader Hyper-V-isolated Ubuntu guest. A second, independent flaw in the same spawn method allows the allowedDomains parameter to override the VM's network egress allowlist on a per-command basis; while the default proxy configuration returns HTTP 403 for non-allowlisted domains, submitting "allowedDomains": ["*"] grants the sandboxed session unrestricted outbound network connectivity, defeating the domain-restricted egress proxy that is otherwise Cowork's primary control against data exfiltration and untrusted C2 callbacks from agent-executed code.

Claude Cowork itself launched as a research preview on 2026-01-12 as Anthropic's 'computer agent' for non-technical knowledge workers, followed by a wider enterprise rollout in February 2026 adding third-party connectors (Google Drive, Gmail, DocuSign, FactSet). The Windows sandbox architecture Armadin targeted is the same architecture Anthropic later described publicly in its 2026-05-25 engineering post 'How We Contain Claude Across Products,' which documents the VM-based isolation (Apple's Virtualization framework on macOS, HCS on Windows), the bubblewrap/seccomp guest-level layers, and the api.anthropic.com-scoped egress proxy — precisely the control layers Armadin's chain was built to defeat. Inside CoworkVMService, per-session unprivileged-user enforcement is implemented by a backend component the researcher identified as sdk-daemon, which normally invokes useradd to provision a fresh unprivileged Linux account for every non-resumed command; the isResume:true bypass skips this useradd-backed provisioning path entirely, which is the root cause enabling arbitrary-user (including root) command execution. To demonstrate real-world impact beyond a bare root shell, Armadin chained the nsenter host-namespace escape with a live data-exfiltration proof-of-concept: from the escaped VM, the researcher used curl to transmit the contents of /etc/shadow off the sandbox with base64 encoding applied to the payload, showing that both the credential-bearing shadow file and the exfiltration channel itself remained invisible to host-based endpoint defenses because all activity occurred inside the isolated Hyper-V guest rather than on the monitored Windows host.

Armadin reported the full chain to Anthropic on 2026-03-20 under responsible disclosure; Anthropic responded on 2026-03-24 declining to treat it as a qualifying security vulnerability, reasoning that the attack requires the attacker to already possess local code execution on the host — a precondition outside Cowork's stated threat model, which sandboxes agent-generated code rather than defending against an attacker who already owns the host OS. Armadin subsequently published the complete technical write-up and proof-of-concept publicly on 2026-07-01, triggering broad security-press coverage. No CVE has been assigned by MITRE/NVD and the issue does not appear in the CISA Known Exploited Vulnerabilities catalog; there is no evidence of in-the-wild exploitation — this is a disclosed, vendor-disputed, publicly-PoC'd design flaw in Cowork's Windows sandbox rather than an actively exploited campaign. For defenders, the practical exposure is that any local process capable of writing to the Cowork installation directory (e.g., malware already run via other means, a malicious insider, or a supply-chain-compromised auxiliary tool) can pivot local code execution into full root access and full sandbox/VM escape, and separately into unrestricted network egress and credential-file exfiltration from the sandboxed agent session — materially expanding the blast radius of any host that already has some form of local compromise.

MITRE ATT&CK techniques by tactic:

Credential Access

T1003 OS Credential Dumping

Collection

T1005 Data from Local System

Discovery

T1057 Process Discovery; T1518 Software Discovery

Execution

T1059 Command and Scripting Interpreter; T1106 Native API

Privilege Escalation

T1068 Exploitation for Privilege Escalation; T1611 Escape to Host

Command and Control

T1090 Proxy; T1132 Data Encoding

defense-impairment

T1553 Subvert Trust Controls; T1685 Disable or Modify Tools

Exfiltration

T1567 Exfiltration Over Web Service

stealth

T1574 Hijack Execution Flow

Defense Evasion

T1574 Hijack Execution Flow

Resource Development

T1587 Develop Capabilities

privilege-escalation

T1611 Escape to Host

Remediation

Patches

  • No vendor patch has been released as of 2026-07-05; Anthropic disputes the finding as an in-scope security vulnerability, citing the local-code-execution prerequisite

Immediate actions

  • Restrict local write access to the Claude Cowork / Claude Desktop installation directory (e.g., C:\Program Files\WindowsApps\Claude_*) via application allowlisting or Windows Defender Application Control to prevent unauthorized DLL drops alongside claude.exe
  • Deploy Sysmon Event ID 7 monitoring for USERENV.dll (or other system DLL) image loads originating from paths outside C:\Windows\System32
  • Monitor named-pipe connections to \\.\pipe\cowork-vm-service and alert on spawn RPC requests whose JSON payload contains isResume:true or an allowedDomains value of ["*"] or other wildcard
  • Restrict which local users/processes are permitted to open handles to the CoworkVMService named pipe
  • Monitor Cowork sandbox VM session activity for reads of /etc/shadow or other credential files followed by outbound curl/HTTP requests carrying base64-encoded payloads, which indicate post-escape data exfiltration invisible to host-based EDR

Workarounds

  • Enforce code-integrity / application-control policies preventing untrusted binaries from being written into the Cowork install directory
  • Monitor and restrict use of namespace-manipulation tooling (e.g., nsenter) on hosts that run the Cowork Linux VM
  • Consider disabling or restricting Claude Cowork on endpoints where local code execution cannot be tightly controlled, until vendor guidance changes

Longer-term hardening

  • Track Anthropic's public position and any future remediation of the CoworkVMService spawn method's parameter validation (isResume, allowedDomains)
  • Deploy EDR with DLL-sideloading and code-signing-aware execution monitoring on all endpoints running Claude Cowork / Claude Desktop for Windows
  • Apply least-privilege and endpoint hardening baselines to hosts running AI coding-agent desktop tools that spawn local VM/container sandboxes, treating 'attacker already has local code execution' as an in-scope threat-model assumption for enterprise risk purposes even where the vendor does not
  • Incorporate AI-agent sandbox-escape scenarios (DLL sideloading into signed agent binaries, IPC/RPC parameter abuse, egress-proxy bypass, in-VM credential-file exfiltration) into enterprise threat models and red-team scope for any AI coding-agent deployment

Affected and fixed versions

  • Anthropic, PBC — Claude Cowork (Claude Desktop for Windows)
    Vulnerable versions: 1.9255.2.0

Timeline

  • Anthropic launches Claude Cowork as a research preview — a desktop 'computer agent' for non-technical users providing a sandboxed shell and local file-system access on Mac and Windows — establishing the product and Hyper-V/bubblewrap sandbox architecture later targeted by Armadin's exploit chain.
  • Armadin formally reports the full sandbox-escape exploit chain (DLL sideloading + CoworkVMService spawn RPC parameter bypass) to Anthropic under responsible disclosure.
  • Anthropic responds, declining to classify the chain as a qualifying security vulnerability, reasoning that exploitation requires the attacker to already have local code execution on the host.
  • Anthropic publishes the engineering post 'How We Contain Claude Across Products,' publicly documenting the VM-based isolation (Hyper-V/HCS on Windows), bubblewrap/seccomp guest-level layers, and domain-restricted egress proxy that Armadin's chain would later be shown to bypass.
  • SiliconANGLE publishes coverage confirming Armadin's disclosure timeline and Anthropic's dispute of the finding's severity.
  • Armadin publishes the full technical write-up, 'Exploiting Root Execution in Claude Cowork's Sandbox,' detailing the DLL sideloading, RPC spawn method, isResume parameter bypass, nsenter sandbox escape, allowedDomains egress-proxy bypass, and a live locked-ioc-3 exfiltration proof-of-concept via curl and base64 encoding.
  • TL-2026-1115 threat hunt opened under the 'Public PoC available' criterion given the fully published, reproducible attack chain and absence of an assigned CVE.
  • GBHackers and SC Media publish further technical breakdowns of the CoworkVMService RPC exploitation, the isResume/allowedDomains parameters, the sdk-daemon/useradd root cause, and the nsenter-based sandbox escape with locked-ioc-3 exfiltration.
  • Cyber Security News publishes a technical analysis of the exploit chain, syndicating Armadin's findings to a wider security audience.

Sources cited

Previous and next in vulnerability

Drafted by the Threadlinqs research pipeline from 9 sources; published ; last updated —.

Threadlinqs Intelligence — Real-Time Threat Detection Platform

// threat_feed
$ sort --newest
Showing all threats

Live intelligence console

Threat level

Latest Threats