Darktrace Signal Labs demonstrated on November 12, 2026 that stolen Claude Console credentials can turn Claude Code into a covert command-and-control implant using memory stores—with traffic that stays on api.anthropic.com and looks like ordinary agent work. The primary write-up, Living off the AI: Shared Memories as a Covert C2 Channel, stresses this is not a Claude vulnerability and has not been observed in the wild—only in Darktrace’s simulated corporate Active Directory lab.
If you run Claude Code on Linux workstations with API keys in environment files or OAuth caches, the lesson is behavioral: allowlisting the vendor API is not enough when the same channel carries attacker-queued jobs and Files API uploads.
| Question | Short answer |
|---|---|
| Am I affected? | Potentially yes if a developer machine is compromised and Claude Console credentials are present—common on agent-heavy laptops |
| Is there a fix? | No patch—rotate keys, audit memory stores, monitor harness process trees, limit key scope |
| Does data leave my machine? | Yes, by design—the PoC exfiltrated via Claude’s Files API, blending theft into allowed egress |
| What should I do today? | Review Console workspaces for unknown stores, protect API keys, correlate claude processes with nmap/smbclient |
explainx.ai covered the same GTIG theme week on settings.json backdoors; Darktrace shows a cloud-native variant that needs no repo commit once keys are stolen.
Living off the AI
“Living off the land” meant abusing PowerShell, WMI, or RMM tools already on the endpoint. Darktrace argues enterprise AI agents are the next LOTL layer: trusted insiders that accept natural-language orders, run bash and network tools, and already hold API routes to the vendor.
Prior public reporting named stealers such as QUIETVAULT that task local models to hunt secrets. Those flows lack interactive operator feedback. Darktrace’s memory-store loop adds real-time tasking without maintaining a separate malware C2 domain on the host—after initial credential theft, systemd-run can keep spawning non-interactive Claude Code children that poll cloud memory files.
Memory store mechanics
Anthropic’s memory stores are workspace-scoped collections of text “memory” files, manageable from platform.claude.com or api.anthropic.com. They are marketed for cross-session learning on managed agents, but Darktrace notes stores can be created without enrolling in Claude Managed Agents—anyone with stolen API credentials for a user’s Console assignment can add stores and files.
The C2 mapping uses three files:
- Heartbeat — harness check-in timestamps the operator watches.
- Input — natural-language jobs the operator overwrites between runs.
- Output — agent results the operator reads before queuing the next job.
Because reads and writes go through the same REST API as inference, egress controls see vendor TLS, not a novel C2 domain.
Image: Darktrace Signal Labs
Darktrace lists the per-process loop: check in on launch, pull queued work, execute via model-chosen bash tool calls, post results, wait for the next harness instance.
Why natural-language C2 changes operator economics
Traditional operators script each stage: download tools, parse output, craft the next command. Darktrace notes that objectives in plain language offload planning to the model—“spray this password against the domain controller” becomes a generated SMB script, username list, and results parsing without the attacker hand-writing every flag. That is the same productivity promise enterprises buy when they adopt agents; here it accelerates post-compromise movement after one credential theft event.
The stealth property is separate: once systemd-run keeps spawning harnesses, the host may not need a persistent reverse shell to the operator. Jobs and results round-trip through Anthropic’s cloud, which defenders already permit for legitimate coding sessions.
Attack chain step by step
Darktrace modeled a Linux Claude Code host, SMB server, and domain controller at 192.168.1.2 in lab addressing (defanged in their indicators table).
Initial access and credential theft
A dash interpreter ran a curl-delivered shell payload from a staging server. Commands discovered the Claude harness, collected API and OAuth credentials, and exfiltrated them back to staging—classic pre-AI staging, unchanged from many intrusions.
Memory store registration
With API access, the operator created a memory store and three files, then returned store and file identifiers to the host script.
Persistence without a traditional implant
The payload used systemd-run to define a transient unit that repeatedly spawns Claude Code with arguments to:
- Write heartbeat messages.
- Invoke Claude Sonnet 4.5 in non-interactive mode.
- Read jobs from the input memory and write outputs.
After that, the operator could discard the staging channel and run nine jobs entirely through memory files.
Operator job sequence (summarized)
Darktrace’s narrative includes:
- Bounded network reconnaissance —
ip,ss,ncdiscovered FTP, SMB, SSH on 192.168.1.2. - Targeted
nmap— OS and service detail plus anonymous FTP directory listings. - Anonymous FTP harvest — employee details and a password in exposed files.
- Username corpus generation — 190 candidate usernames written to
/tmp/usernames.txtvia heredoc. - Password spray —
pa55wordagainst the DC via generated SMB scripts; hit fictional usergreg.simon. - SMB share enumeration and listing — identified a 1 GB object.
- Download and exfiltration — smbclient retrieval, local split, upload to
https://api.anthropic.com/v1/files.
Each step used plain-language job text in the input memory—lowering operator skill at the cost of verbose, auditable agent behavior if you collect process trees.
What Darktrace’s telemetry figures emphasize
The primary post embeds Advanced Search and Process Tree screenshots for nearly every stage—useful context for SOC playbooks even when you do not run Darktrace. Recurring patterns in those figures include:
curlchildren ofdashfor staging retrieval and credential upload—early-chain LOTL before any Claude invocation.systemd-runcreating a transient service that becomes the parent of repeatedclaude(or harness) processes—persistence without a classic.servicefile left on disk indefinitely.- Single harness processes spawning long chains of
nmap,nc,smbclient, andbashheredocs while maintaining concurrent HTTPS to api.anthropic.com—the correlation Darktrace argues is essential.
Darktrace also published fictional lab indicators (defanged) tying the narrative to concrete observables:
| Type | Lab indicator (defanged) | Role in PoC |
|---|---|---|
| IP | 192.168.1.2 | Lab DC/SMB/FTP target |
| Domain | api[.]anthropic.com | Memory store + inference |
| Domain | platform[.]claude.com | Console administration |
| URL | api[.]anthropic.com/v1/files | 1 GB upload split into three parts |
| Path | /tmp/usernames.txt | Generated spray list (190 lines) |
| Account | greg.simon | Fictional spray success |
| Password | pa55word | Fictional spray password |
| Process | dash | Initial payload interpreter |
| Process | systemd-run | Transient harness launcher |
Re-fang only inside controlled intel platforms, as Darktrace warns—do not paste live credentials from the table into production hunts.
Detection and response
Darktrace’s defensive thesis: you cannot realistically block the Claude API on developer machines. Instead:
- Baseline Claude Code process behavior — tool children, argument shapes, cadence.
- Correlate process creation with network volume to api.anthropic.com — sprays, large uploads, and off-hours bursts are abnormal even when the domain is allowed.
- Protect Console credentials — least privilege, rotation after compromise suspicion, hardware-bound secret storage where possible.
- Audit workspaces for unknown memory stores on platform.claude.com.
- Treat non-interactive harness loops spawned by
systemd-runfrom adashparent as high priority—Darktrace’s own figures show that lineage explicitly.
The technique parallels developer-credential targeting in supply-chain incidents—except the exfiltration rail is your AI vendor, not a malicious npm package.
Workspace hygiene on Claude Console
Because memory stores are Console workspace objects, incident response should include account-side steps even when the laptop is reimaged:
- Inventory memory stores per workspace; delete unrecognized stores and rotate keys tied to the compromised user.
- Review Files API objects uploaded during the incident window—large artifacts may remain in vendor storage after local deletion.
- Separate personal and employer workspaces so a gaming-machine infostealer does not cross into production Console tenants.
- Restrict API key scopes where Anthropic’s console allows role separation; prefer short-lived OAuth where available over long-lived files on disk.
None of those steps are substitutes for EDR on the host, but they close the cloud half of the channel Darktrace demonstrated.
Threat modeling alongside prompt injection
Memory-store C2 is orthogonal to prompt injection: the operator does not need to poison CLAUDE.md or a fetched webpage if they already control the input memory file through stolen API credentials. Conversely, prompt injection defenses in the IDE do not stop operator-authored jobs the model is designed to execute. Your control stack needs identity and egress monitoring layers, not only content filters—similar to how MCP tool misbinding failures are configuration problems rather than model bugs.
How Beam handles this
Beam is local observability and hook policy for coding agents—not a network NDR and not a Claude Console admin console.
Where Beam helps: PreToolUse hooks on Claude Code can deny or flag unexpected nmap, smbclient, or mass curl uploads when workspace policy is in enforce; skill and MCP scanning catches malicious instructions in repo-local automation; on-device event history preserves tool-call evidence for incident review. See agent runtime security and /#watches.
Where Beam does not help: Beam does not read memory store contents, block Files API uploads, or see operator-side Console changes. Those require vendor account controls plus EDR/NDR correlation. Hooks are heuristic and fail-open when cached policy is missing—complement, not replace, Darktrace-style behavioral analytics.
What this means if you run AI coding agents
Concrete checks grounded in Darktrace’s lab (adapt addresses to your environment):
# Recent Claude-related processes (Linux)
ps aux | grep -i claude | grep -v grep
# Unexpected systemd transient units touching claude
systemctl list-units --type=service --all | grep -i claude
# Local credential files agents commonly read (inspect permissions)
ls -la ~/.config/claude 2>/dev/null
ls -la ~/.claude 2>/dev/null
Console-side (human): sign in to platform.claude.com, list memory stores, delete anything not created by your team, and rotate API keys after any infostealer or RAT finding on a developer laptop—consistent with Socradar’s Phantom53/Xaocmail malware reporting on Claude-oriented stealers.
Policy-side: separate production keys from personal Console workspaces; never store keys in repos agents can commit; pair vendor trust with local deny rules for destructive tools.
When to escalate
Treat the following as P1 hunt triggers on developer endpoints, even without Darktrace-specific detections:
- New systemd transient units whose command line references claude or anthropic but were not installed by your standard agent installer.
- Claude harness processes with non-interactive flags looping on a timer while smbclient, nmap, or mass curl uploads appear in the same process tree.
- Sudden growth in outbound bytes to api.anthropic.com from a host that previously showed only chat-sized sessions.
- Console alerts (if available) for memory store creation by a user who did not open a ticket for agent automation.
Document API key rotation time, Console store deletions, and local tool-call exports in the same incident record—auditors will ask whether you proved data did or did not reach vendor storage.
Frequently asked questions
See front matter FAQ entries for indexed questions on vulnerability status, detection, and Beam limits.
Related reading
- GTIG SOMBERMEME settings.json backdoor
- Phantom53 malware targeting Claude Code users
- MCP security practical guide
- What is AI agent monitoring
- F-Secure AI harms taxonomy for agent layers
Primary sources: Darktrace Signal Labs post (November 12, 2026). Secondary context only: Help Net Security summary.
Indicators, product names, and API paths are accurate as of November 17, 2026 per Darktrace’s publication. Lab IP addresses and credentials are fictitious; do not treat them as live threat data.

