On Thursday, Anthropic disclosed that it disrupted an operation by a Russian state-sponsored threat actor it tracks as GTG-20006 — the "GTG" prefix standing for Generative Threat Group — that abused the Claude AI model to build an AI-assisted malware development workflow. Reporting on this cluster aligns it with the activity set more broadly known as Midnight Blizzard (also tracked as APT29, Cozy Bear, and Nobelium), the espionage arm attributed to Russia's SVR.
The headline is not that an APT used an LLM. It is how they used it: as a regeneration engine. When their tooling was detected and burned — by endpoint defenses, by AV signature updates, or by incident responders — the actor fed the detection feedback back into Claude and produced rebuilt variants of the same malicious software, retooled to get ahead of the detection curve. This collapses the traditional defender advantage of "detect once, block forever" into something much shorter: a detection is now a starting gun for an adversary race, not a finish line.
If you run a SOC, hunt team, or IR practice, this campaign is a forcing function. Signature-only defenses, static IOC lists, and hash-based blocking are structurally mismatched against an adversary who can regenerate a functionally equivalent binary in hours. This post breaks down the campaign from a defender's perspective and gives you concrete detection logic — Sigma, KQL, and VQL — tuned for the observable behaviors this workflow leaves behind, regardless of how many times the payload is rewritten.
Technical Analysis
Who and what is involved
- Threat actor: GTG-20006 (Anthropic designation), assessed to align with Midnight Blizzard / APT29 / Cozy Bear — Russian SVR cyber espionage.
- Abused platform: Anthropic's Claude, used as an AI-assisted development workflow to iteratively rewrite and rebuild malicious software after detection events.
- No CVE is associated with this campaign. This is not a vulnerability story; it is a tradecraft story. There is no patch — there is only detection engineering and behavioral hunting.
- Exploitation/abuse status: Confirmed in-the-wild operational use, disrupted by the vendor. This is not theoretical.
How the AI-assisted regeneration workflow works (defender's view)
Traditional malware development has a slow feedback loop: a campaign gets detected, the developers manually analyze what triggered detection, rewrite the code, recompile, retest, and redeploy. That cycle takes days to weeks, which is why signature and IOC-based defenses, while imperfect, have remained useful.
The GTG-20006 workflow compresses that loop:
- Payload deployment — an initial implant or loader is delivered through the actor's usual espionage tradecraft (for Midnight Blizzard historically: spear-phishing, token theft, OAuth abuse, and supply-chain or trusted-relationship access).
- Detection event — an EDR, AV, or YARA/signature control burns the payload.
- LLM-assisted rebuild — the actor uses Claude to regenerate the malicious code: renaming functions and strings, restructuring control flow, swapping API call sequences, changing obfuscation layers, or porting the same capability to a different language or loader stub. Critically, the code changes but the behavior does not.
- Redeployment — a functionally identical but cryptographically and structurally distinct binary is pushed back out, often within a window far shorter than a human development cycle.
The defensive implication
Every regeneration preserves the mission: the payload still has to execute, persist, communicate, and act on objectives. Those behavioral constants are your detection surface:
- On-host compilation/toolchain abuse. AI-assisted rebuild cycles often involve compiling or packing on or near the target environment — compilers and build tools (
cl.exe,link.exe,gcc,go.exe,rustc.exe,pyinstaller,csc.exe) invoked from script interpreters, user-writable paths, or machines that are not developer workstations. - Rapid variant churn. Multiple low-prevalence, unsigned, first-seen executables appearing in user profiles,
%TEMP%,%AppData%, orC:\ProgramDatain quick succession — especially files that are created and then executed within minutes. - Behavioral persistence and C2 constants. Scheduled tasks, registry Run keys, and COM/service persistence that survive recompilation; outbound beaconing patterns (periodicity, JA3/JA4 fingerprints, rare FQDNs) that persist even when the binary hash changes weekly.
- Identity tradecraft. Midnight Blizzard's hallmark is identity-based access: token theft, illicit consent grants, and abuse of legitimate cloud services for C2. Payload regeneration is the endpoint half of a campaign whose identity half is equally detectable.
The strategic lesson: your detections must anchor to behavior, lineage, and identity — not hashes. Every rule below is written with that principle.
Detection & Response
The detections below target the observable residue of a regenerate-and-redeploy workflow: on-host build toolchains, freshly-dropped-and-executed payloads, and persistence that outlives any single binary variant. They are written to be tuned, not to be dropped in blind.
Sigma Rules
---
title: Build Toolchain Execution from Script Interpreter or Non-Developer Context
id: 4c2a8f61-9d3b-4e7a-b5c2-1a6f9d0e8b34
status: experimental
description: Detects compilers and build tools spawned by script interpreters or Office applications, or running from user-writable/temp paths — consistent with AI-assisted malware rebuild-and-recompile workflows where payloads are regenerated after detection.
references:
- https://thehackernews.com/2026/09/russian-state-sponsored-hackers-use.html
- https://attack.mitre.org/techniques/T1027/
- https://attack.mitre.org/techniques/T1059/
author: Security Arsenal
date: 2026/09/04
tags:
- attack.defense_evasion
- attack.t1027
- attack.execution
logsource:
category: process_creation
product: windows
detection:
selection_img:
Image|endswith:
- '\cl.exe'
- '\link.exe'
- '\csc.exe'
- '\msbuild.exe'
- '\go.exe'
- '\gcc.exe'
- '\rustc.exe'
- '\pyinstaller.exe'
selection_parent:
ParentImage|endswith:
- '\powershell.exe'
- '\pwsh.exe'
- '\cmd.exe'
- '\wscript.exe'
- '\cscript.exe'
- '\mshta.exe'
- '\winword.exe'
- '\excel.exe'
condition: selection_img and selection_parent
falsepositives:
- Developer workstations where builds are legitimately scripted — baseline and exclude build servers and engineering endpoints by host, not globally
- Software packaging/Intune content prep on admin endpoints
level: high
---
title: Newly Created Executable Launched from User-Writable Path
id: 8e1b3c47-6a2d-4f95-a8e0-3c7b2d914f56
status: experimental
description: Detects execution of executables or DLL loads from user-writable staging paths commonly used for rapidly regenerated payloads (AppData, Temp, ProgramData). Designed to catch variant churn where hashes and filenames change but staging behavior does not.
references:
- https://thehackernews.com/2026/09/russian-state-sponsored-hackers-use.html
- https://attack.mitre.org/techniques/T1204/
- https://attack.mitre.org/techniques/T1036/
author: Security Arsenal
date: 2026/09/04
tags:
- attack.execution
- attack.defense_evasion
- attack.t1036
logsource:
category: process_creation
product: windows
detection:
selection_path:
Image|contains:
- '\AppData\Local\Temp\'
- '\AppData\Roaming\'
- '\Users\Public\'
- '\ProgramData\'
selection_ext:
Image|endswith:
- '.exe'
- '.dll'
- '.scr'
filter_signed_system:
Image|contains:
- '\AppData\Local\Microsoft\'
- '\AppData\Local\Google\'
- '\AppData\Local\Mozilla\'
- '\AppData\Local\Programs\'
- '\AppData\Roaming\Microsoft\'
condition: selection_path and selection_ext and not filter_signed_system
falsepositives:
- Legitimate per-user application installs (Teams, Slack updaters) — tune with signer/prevalence enrichment in your EDR rather than removing the rule
level: medium
---
title: Persistence Registration Shortly Following Payload Staging in ProgramData or AppData
id: 2f7d5a19-4c8e-4b63-9a17-6e0c3f845d21
status: experimental
description: Detects scheduled task creation or Run key persistence pointing at payloads staged in user-writable paths. Persistence is the behavioral constant that survives AI-assisted payload regeneration — the binary changes, the persistence mechanism points at the new variant.
references:
- https://thehackernews.com/2026/09/russian-state-sponsored-hackers-use.html
- https://attack.mitre.org/techniques/T1053/005/
- https://attack.mitre.org/techniques/T1547/001/
author: Security Arsenal
date: 2026/09/04
tags:
- attack.persistence
- attack.t1053.005
- attack.t1547.001
logsource:
category: process_creation
product: windows
detection:
selection_schtasks:
Image|endswith: '\schtasks.exe'
CommandLine|contains:
- '/create'
- 'AppData'
selection_reg:
Image|endswith: '\reg.exe'
CommandLine|contains:
- '\CurrentVersion\Run'
- 'add'
condition: 1 of selection_*
falsepositives:
- Enterprise software deployment tooling (SCCM/Intune) — exclude known management service accounts and source hosts
level: high
KQL — Microsoft Sentinel / Defender
This query hunts the core signature of the GTG-20006 workflow: payload variant churn. It finds unsigned or low-reputation executables created in user-writable paths and executed within 30 minutes of creation — the pattern you get when an adversary pushes a freshly regenerated binary and immediately launches it. Hash rotation defeats hash blocking; this query doesn't care about hashes.
let lookback = 7d;
let staging_paths = dynamic(["\\AppData\\Local\\Temp\\", "\\AppData\\Roaming\\", "\\Users\\Public\\", "\\ProgramData\\"]);
let recent_drops =
DeviceFileEvents
| where TimeGenerated > ago(lookback)
| where ActionType == "FileCreated"
| where FolderPath has_any (staging_paths)
| where FileName endswith ".exe" or FileName endswith ".dll" or FileName endswith ".scr"
| project DropTime=TimeGenerated, DeviceId, DeviceName, FolderPath, FileName, SHA256;
DeviceProcessEvents
| where TimeGenerated > ago(lookback)
| where FileName endswith ".exe" or FileName endswith ".dll"
| project ExecTime=TimeGenerated, DeviceId, ProcessName=FileName, ProcessPath=FolderPath,
ProcessSHA256=SHA256, ProcessCommandLine, InitiatingProcessFileName, InitiatingProcessCommandLine, AccountName
| join kind=inner recent_drops on DeviceId, $left.ProcessSHA256 == $right.SHA256
| extend MinutesBetweenDropAndExec = datetime_diff('minute', ExecTime, DropTime)
| where MinutesBetweenDropAndExec between (0 .. 30)
| summarize VariantsOnHost=dcount(SHA256), FirstSeen=min(DropTime), LastSeen=max(ExecTime),
make_set(FileName), make_set(FolderPath), make_set(ProcessCommandLine)
by DeviceName, AccountName
| order by VariantsOnHost desc;
Pivot on VariantsOnHost — a host that has executed multiple distinct hashes of staged payloads in a week is either a developer machine or a regeneration target. Pair this with an identity-side query for Midnight Blizzard's cloud tradecraft: rare OAuth consent grants, new service principal credentials, and token replay from unfamiliar ASNs against M365 workloads in SigninLogs and AuditLogs.
Velociraptor VQL
Use this hunt artifact for rapid fleet-wide triage when you suspect a regenerate-and-redeploy campaign: it enumerates recently created executables in staging paths and correlates them with live processes and network connections, so a burned-and-rebuilt implant can be caught by its execution lineage and sockets rather than its name.
-- Hunt: freshly staged executables in user-writable paths, enriched with process and network lineage
LET staged = SELECT FullPath, Size, Mtime, Btime
FROM glob(globs=['C:/Users/*/AppData/Local/Temp/**/*.exe',
'C:/Users/*/AppData/Roaming/**/*.exe',
'C:/Users/Public/**/*.exe',
'C:/ProgramData/**/*.exe'])
WHERE Mtime > now() - 604800 -- created/modified in the last 7 days
ORDER BY Mtime DESC;
SELECT FullPath AS StagedBinary,
Size,
Mtime AS Modified,
proc.Pid AS RunningPid,
proc.CommandLine AS ProcessCmdline,
proc.Username AS ProcessUser,
net.RemoteAddr AS C2RemoteIP,
net.RemotePort AS C2RemotePort,
net.Status AS ConnState
FROM staged
LEFT JOIN (
SELECT Pid, Name, Exe, CommandLine, Username
FROM pslist()
) AS proc ON proc.Exe = staged.FullPath
LEFT JOIN (
SELECT Pid AS NetPid, RemoteAddr, RemotePort, Status
FROM netstat()
WHERE Status =~ 'ESTABLISHED|LISTEN'
) AS net ON net.NetPid = proc.Pid
Rows where RunningPid is populated and a C2RemoteIP exists are your highest-priority triage targets: a recently staged binary in a user-writable path that is currently running with an established outbound connection is the regenerated implant doing its job. Acquire it, hash it, and pivot on the remote infrastructure.
Remediation & Hardening Script
The following PowerShell is built for the two things that actually blunt this campaign: (1) confirming Microsoft Defender's cloud-delivered and behavior-based protections are enabled (these are what force the adversary into the regeneration loop in the first place), and (2) auditing your fleet for build toolchains on machines that should never compile anything — your early-warning tripwire for on-host rebuild activity.
# GTG-20006 / Midnight Blizzard regeneration-workflow hardening and audit
# Run elevated. Test in a lab ring before broad deployment.
# --- 1. Verify behavior-based and cloud-delivered Defender protections ---
$mp = Get-MpPreference
$status = [PSCustomObject]@{
RealTimeMonitoring = -not $mp.DisableRealtimeMonitoring
BehaviorMonitoring = -not $mp.DisableBehaviorMonitoring
CloudProtectionLevel = (Get-MpComputerStatus).MAPSReporting
CloudBlockLevel = $mp.MpCloudBlockLevel # 0=default, 1=moderate, 2=high, 3=zero-tolerance
PUAProtection = $mp.PUAProtection # 1 = enabled
}
$status | Format-List
# --- 2. Harden: raise cloud block level and enable PUA protection ---
Set-MpPreference -MAPSReporting Advanced
Set-MpPreference -MpCloudBlockLevel High
Set-MpPreference -PUAProtection Enabled
Set-MpPreference -DisableBehaviorMonitoring $false
Set-MpPreference -DisableRealtimeMonitoring $false
# --- 3. Enable ASR rules that break payload staging/execution from user paths ---
# Block executable content from email client and webmail
Add-MpPreference -AttackSurfaceReductionRules_Ids "BE9BA2D9-53EA-4CDC-84E5-9B1EEEE46550" -AttackSurfaceReductionRules_Actions Enabled
# Block Office applications from creating child processes
Add-MpPreference -AttackSurfaceReductionRules_Ids "D4F940AB-401B-4EFC-AADC-AD5F3C50688A" -AttackSurfaceReductionRules_Actions Enabled
# Block execution of potentially obfuscated scripts
Add-MpPreference -AttackSurfaceReductionRules_Ids "5BEB7EFE-FD9A-4556-801D-275E5FFC04CC" -AttackSurfaceReductionRules_Actions Enabled
# Block untrusted/unsigned processes from running from USB
Add-MpPreference -AttackSurfaceReductionRules_Ids "b2b3f03d-6a65-4f7b-a9c7-1c7ef74a9ba4" -AttackSurfaceReductionRules_Actions Enabled
# --- 4. Audit: find compilers/build tools on endpoints that shouldn't have them ---
$toolchains = @("cl.exe","link.exe","csc.exe","MSBuild.exe","go.exe","gcc.exe","rustc.exe","pyinstaller.exe")
$hits = foreach ($t in $toolchains) {
Get-ChildItem -Path "C:\Users","C:\ProgramData" -Filter $t -Recurse -ErrorAction SilentlyContinue |
Select-Object FullName, LastWriteTime
}
if ($hits) {
Write-Warning "Build toolchain binaries found in user-writable paths — investigate for on-host payload rebuild activity:"
$hits | Format-Table -AutoSize
} else {
Write-Host "[OK] No toolchain binaries found in audited user-writable paths."
}
# --- 5. Audit persistence constants: tasks and Run keys pointing into staging paths ---
Get-ScheduledTask | ForEach-Object {
$actions = $_.Actions | Where-Object { $_.Execute -match 'AppData|ProgramData|Users\\Public' }
if ($actions) { [PSCustomObject]@{ TaskName=$_.TaskName; Path=$_.TaskPath; Execute=($actions.Execute -join ';') } }
} | Format-Table -AutoSize
Get-ItemProperty "HKLM:\SOFTWARE\Microsoft\Windows\CurrentVersion\Run",
"HKCU:\SOFTWARE\Microsoft\Windows\CurrentVersion\Run" -ErrorAction SilentlyContinue |
ForEach-Object { $_.PSObject.Properties } |
Where-Object { $_.Value -match 'AppData|ProgramData|Users\\Public' } |
Select-Object Name, Value | Format-Table -AutoSize
Remediation
There is no patch for this campaign — remediation is architectural. Prioritized actions:
-
Kill your dependency on hash-based blocking. Retire or demote static IOC feeds as a primary control. They have a shelf life of hours against this adversary. Redirect that effort into behavioral detections like the ones above.
-
Shorten your detection-to-containment loop. If an adversary can regenerate in hours, your mean time to contain must be faster than their rebuild cycle. Automate host isolation on high-confidence behavioral verdicts; do not wait for analyst approval chains on confirmed Midnight Blizzard-class activity.
-
Harden the identity plane. Midnight Blizzard's campaigns pair endpoint implants with token theft, illicit OAuth consent grants, and abuse of trusted cloud services. Audit app consent policies (disable user consent by default), alert on new service principal credentials and rare grant types, and enforce phishing-resistant MFA (FIDO2) — regenerated malware can't help an actor whose initial access is identity-based and blocked.
-
Baseline build toolchains. Know which hosts in your fleet legitimately have compilers and build tools. Everything else with
cl.exe,go.exe, orpyinstallerin a user-writable path is a lead, not an anomaly to ignore. -
Treat LLM-platform abuse reporting as an intel source. Anthropic disrupted this campaign at the platform level and published the attribution. Track vendor threat-intel disclosures from AI providers (Anthropic, OpenAI, Google) as a standing feed — they are becoming a primary early-warning channel for state-sponsored tooling development.
-
Exercise against regeneration. In your next purple team or tabletop, simulate the scenario: "EDR burned the implant at 09:00; a functionally identical variant was live by 13:00." If your playbook assumes a detection is the end of an incident, it will fail this test. The incident ends when the behavioral path is closed, not when a hash is blocked.
Related Resources
Security Arsenal Penetration Testing Services AlertMonitor Platform Book a SOC Assessment vulnerability-management Intel Hub
Is your security operations ready?
Get a free SOC assessment or see how AlertMonitor cuts through alert noise with automated triage.