Contents
ToggleExecutive Summary
On October 30, 2026, Google Threat Intelligence Group (GTIG) and Mandiant published incident response evidence that threat actors are running open-source, multi-agent pentesting frameworks in live intrusions. ARTEX is the headline name, with PentAGI, CAIRN and HexStrike AI in the same category. Since late August 2026, these frameworks have carried out reconnaissance, privilege escalation, lateral movement, database exploitation and exfiltration staging inside victim environments. In several cases the human operator did little more than pick a target, paste in compromised credentials and set an objective.
None of the techniques are new. Valid accounts, long-lived cloud keys, admin APIs reachable from the internet, Kerberoastable service accounts and database accounts allowed to rewrite server-wide settings have been on every pentest report for a decade. What changed is the cost of chaining them. GTIG puts the typical UNC7228 path from first compromised account to deep system access at around four hours, with one case at 15 minutes. ARTEX executes in bursts of 2 to 25 seconds, reads its own error messages, rewrites its payload and tries again until something returns clean output. The original repository was pulled by its author in October. Censys still counted 1,465 hosts exposing an ARTEX console on November 4, about 815 of them distinct deployments.
My read for engineering and security teams is blunt: the attacker now tests your attack paths faster and more often than your annual pentest does. Defenses that rely on attackers getting bored, or on a human operator taking a weekend off, are already obsolete. The counter is to run the same chaining logic against yourself on a schedule you control, and to break chains before anyone walks them. That means hooks and guardrails where code and agents act, toxic-combination detection across code, identity and cloud, and blast-radius analysis for every credential and workload. That model works the same whether the operator is an outside crew holding a stolen service principal or an insider with legitimate access and an LLM subscription.
Key Takeaways
- Run attack-path testing against your own code and applications continuously, using the same chaining logic attackers use. Annual pentests sample a surface that agents probe every day.
- Require every confirmed finding to carry a file, a line, a correct fix and a regression test before it counts as remediated.
- Turn confirmed findings into rules your AI coding agents load every session, so the same vulnerability class stops being generated.
- Put a server-side check on every pull request. Local hooks help, but a developer or an agent can remove them.
- Treat valid credentials driven by an agent as a single threat model, whether the holder is an outside crew or an insider.
TL;DR for Engineering Teams
| Label | Content |
|---|---|
| What it is | Open-source, multi-agent LLM pentest frameworks (ARTEX, PentAGI, CAIRN, HexStrike AI) abused by espionage and extortion actors to automate most of the intrusion lifecycle. No CVE, no CVSS: this is tool abuse against existing weaknesses. |
| Where it bites | Cloud control planes (Azure Kudu/SCM, ARM, AWS IAM/EC2/EBS), Active Directory (Kerberoasting, DCSync, AD CS), internet-facing apps with exposed APIs, over-privileged database accounts, internal business APIs (mass notification, account creation). |
| Why it matters | Machine-speed chaining: 27 events in 23 seconds of AWS permission probing; first account to deep access in 15 minutes in one UNC7228 case; 200+ organizations targeted by VAPOR PANDA in under two weeks (CrowdStrike). Forks and a commercial ARTEX PRO keep circulating after the takedown. |
| Patch status | Not applicable. Nothing to patch on the attacker side. Your fix is configuration, identity and segmentation hardening, plus detection. |
| Immediate action | Hunt for artex-probe-* files and ArtexProbe accounts. Rotate and convert static cloud keys and service principal secrets. Restrict Kudu/SCM and admin APIs to trusted networks. Revoke SYSTEM_VARIABLES_ADMIN/SUPER from application MySQL accounts. Block webhook.site and OAST egress from servers. Alert on DryRun and ARM validate bursts. |

Threat Overview
| Field | Value |
|---|---|
| Threat class | Agentic offensive framework abuse (AI-orchestrated intrusion) |
| Frameworks observed | ARTEX (plus forks ScopeWeaver and ARTEX PRO), PentAGI, CAIRN, HexStrike AI |
| Origin | ARTEX: GitHub user Autumn-27, written in Go with an embedded Next.js console, public since July 2026, withdrawn October 2026. PentAGI: VXControl, open-source and commercial editions |
| CVE / CVSS | None. No software defect; abuse of dual-use tooling against existing weaknesses |
| Commonly chained weaknesses | CWE-522 (insufficiently protected credentials), CWE-269 (improper privilege management), CWE-306 (missing authentication for critical function), CWE-209 (error messages exposing internals), CWE-1188 (insecure defaults) |
| Patch available | No. Mitigation is hardening and detection |
| Active exploitation | Confirmed (GTIG, Mandiant, Microsoft, CrowdStrike) |
| Tracked actors | UNC7228 (GTIG; overlaps Microsoft Storm-0940, PRC-nexus), VAPOR PANDA (CrowdStrike, PRC-linked), unattributed actor targeting South Korean finance (CrowdStrike), multiple financially motivated extortion crews (GTIG) |
| Sectors hit | Government, technology, enterprise software, industrial automation, semiconductor, telecom, chemicals and materials, manufacturing, aerospace, financial services |
Why This Is Spreading Now
GTIG frames adversarial LLM use as a seven-stage maturity curve. The useful part for defenders is where we sit on it today and how short the gaps between stages have been.
| Stage | Description | GTIG timeframe |
|---|---|---|
| 1 | Prompt-based LLM use: code help, phishing drafts, light recon | End 2025 to early 2026 |
| 2 | LLM capabilities embedded in malware (HONESTCUE, PROMPTSPY) | Early 2026 |
| 3 | LLM-enabled automation alongside human operators, LLM proxy services for OPSEC | Early 2026 to Sept 2026 |
| 4 | Development and experimentation with autonomous frameworks | Mid 2026 to Sept 2026 |
| 5 | Multiple lifecycle stages run by LLM tooling in the wild, noisy but successful | Current |
| 6 | Multi-agent, unsophisticated attacks with little or no human interaction | Near term (1 to 3 months) |
| 7 | Sophisticated, stealthy, fully autonomous operations on self-hosted models | Medium term (3 to 6 months) |
Three things push adoption. The barrier to entry is close to zero: PentAGI asks for a target and a goal, and ARTEX turns high-level tactical intent into commands through six specialized sub-agents. The model layer is swappable. CrowdStrike reports VAPOR PANDA running ARTEX mainly on DeepSeek alongside a second, unidentified commercial model. The South Korean finance actor reached models through an API reseller. Blocking one AI vendor does not stop the framework. And the economics favor volume. GTIG assesses with high confidence that cybercrime actors will keep adopting these tools because wider reach compensates for lower per-target success rates.
We have watched the same curve in the supply chain data at Phoenix. Through 2026 the campaigns we track moved from hand-crafted packages to self-propagating worms. Then they moved to persistence planted inside AI agent configuration (.claude/, CLAUDE.md, .cursorrules, MCP config), as documented in our Miasma and Shai-Hulud analyses. ARTEX is the same industrialization applied to post-compromise tradecraft. The attacker’s marginal cost per attack path tested is now a few cents of tokens.
Technical Anatomy
Architecture
ARTEX is an autonomous multi-agent pentest and command-and-control platform. A Go backend orchestrates six sub-agents, each responsible for part of the lifecycle. The Next.js console is where the operator sets scope, objectives and credentials. The framework does not ship a model. It calls frontier or open-weight models through APIs, which is why operators have been seen pairing it with DeepSeek, Grok and Claude Code in different campaigns. CrowdStrike measured ARTEX planning agents consuming roughly 1.4 billion input tokens during a single intrusion. That number tells you how much trial and error the framework is willing to burn on one target.
PentAGI follows a similar pattern with stronger isolation. Tasks are broken into “Flows,” executed by specialized agents inside Kali Linux sandboxes, using stock tooling such as nmap, sqlmap and Metasploit. HexStrike AI connects models to more than 150 security tools.
Root Cause
There is no single bug here, and that is the uncomfortable part. The root cause is the attack-path graph that already exists in most environments. It is a set of individually “medium” findings connected by credentials, trust relationships and legitimate features. For example: an exposed management API, a storage key that works from any IP, an application database account with server-level privileges, a service account with a crackable SPN. Each sits in a different team’s backlog with a different severity label.
Two properties of LLM agents make that graph walkable at speed. First, error-driven iteration is free. Every stack trace, SQL error, compiler message or 403 is a steering signal, and the agent rewrites and retries in seconds. CWE-209 used to be a hygiene finding; against an agent it is navigation data. Second, agents read undocumented internal applications well. Custom APIs that only made sense to insiders are now enumerated, understood and repurposed in minutes. That is how ARTEX turned a legitimate notification feature into a mass internal mailer.
Exploit Path: Three Steps
- Entry point. The operator supplies valid credentials (SAS tokens, service principals, Kudu publishing credentials, storage account keys, IAM user keys or application accounts). ARTEX maps effective permissions with sub-second capability checks: a test blob written and deleted in roughly 330 to 400 ms, an 8-second ARM
deployments/validatedry-run sweep across 11 Azure resource types, EC2/EBS/snapshot calls with DryRun flags and placeholder IDs, and 500+ web requests fuzzing paths for 200 versus 403. - Vulnerability trigger. The agent finds a legitimate feature that crosses a trust boundary and abuses it: Kudu SCM command execution, a MySQL account allowed to set
general_log_file, a writableis_adminflag on account creation, Kerberoastable SPNs, a DCSync-capable path to domain credentials, or a notification API with no recipient limit. - Execution impact. Code execution on application and database servers, theft of the domain
krbtgtkey, cloud AD-sync credentials and DC machine hashes, enumeration of 110,000+ AD objects, mass blob reads and SQL extraction, EBS snapshot harvesting via keyless EC2 instances, persistent jump hosts on Elastic IPs, and 1,300+ internal users hit with test emails from a trusted application.
Worked Example: MySQL Log Poisoning to a JSP Webshell
This sequence from the GTIG report shows how ARTEX pivots from database context to OS context using nothing but an application SQL API the supplied credential could already reach. Annotated for defenders, webshell body omitted:
-- Step 1: redirect the general query log into a web-served path
SET GLOBAL general_log_file = '/<webroot>/cl1217.jsp';
-- Step 2: turn on the general log; every subsequent statement is written to that file
SET GLOBAL general_log = 1;
-- Step 3: a SELECT whose literal contains JSP scriptlet tags lands in the log file
SELECT '<% /* JSP payload omitted */ %>';
-- The servlet container compiles the .jsp on request, executing the embedded Java
The precondition is the finding most teams under-price. An application database account holds SYSTEM_VARIABLES_ADMIN (MySQL 8) or SUPER (legacy), and the MySQL process is able to write into a directory the web tier serves. ARTEX produced several iterations with incrementing names (cl1217.jsp, f1219a.jsp, z1219.jsp). Early attempts failed on Java compile errors such as variable 't' is already defined. The framework rewrote the payload until a shell returned valid output. The run generated 240 log events, some apparently caused by sub-agents overwriting each other’s work. Noisy, yes. Still successful.

Campaign Phases
| Phase | What ARTEX did | Speed / volume markers |
|---|---|---|
| Phase 1: Initial foothold | Permission mapping of Azure and AWS credentials; Kudu API command execution; staging of Python, C# and PowerShell; C2 via native curl posting results to 491 rotating webhook.site URLs | Blob write/delete in ~330 to 400 ms; 27 events in 23 s of AWS probing |
| Phase 2: Expansion | Kerberoasting, SQL injection to dump DB credentials, DCSync for krbtgt, AD-sync credentials and DC hashes; generated PowerShell enumeration of GMSAs, AD CS templates, cross-forest principals, Exchange and PasswordState targets | Admin accounts created with is_admin=true within minutes |
| Phase 3: Infrastructure targeting | Lateral movement attempts via Pass-the-Ticket, WinRM, Kerberos relay, Pass-the-Hash; attempts to launch EC2 instances with high-value instance profiles (failed on invalid ARNs) | Blocked by EDR before DC compromise in one case |
| Phase 4: Persistence and collection | New SSH key pair, Elastic IP, t3.micro jump hosts; password resets and new accounts; 100 GB volume and 60 GB root expansion for staging; ~400 KB of SQL results across ~20 queries; 17-snapshot instance deployed in ~10 s after self-correcting a “script too large” error | Account names and files carry ArtexProbe / artex-probe-NNNNN markers |
Attack Chain
[Stolen credential: SAS / SP secret / Kudu creds / IAM key / app account]
|
v
[Sub-second permission mapping: DryRun, ARM validate, blob write+delete, path fuzzing]
|
+--> [Kudu SCM cmd exec] --> [curl + PowerShell staging] --> [webhook.site C2 (491 URLs)]
|
+--> [App SQL API] --> [SET GLOBAL general_log_file -> .jsp] --> [JSP webshell on app server]
|
v
[AD recon: GMSA, AD CS, cross-forest] --> [Kerberoast] --> [offline crack] --> [DCSync: krbtgt, AD-sync creds]
|
v
[Persistence: new admin accounts, SSH keys, Elastic IP jump host]
|
v
[Collection: SQL dumps, blob reads, EBS snapshot harvesting, mass internal email via notification API]
MITRE ATT&CK Mapping
| Tactic | Technique | ARTEX observation |
|---|---|---|
| Initial Access | T1078.004 Valid Accounts: Cloud Accounts | Operator-supplied SAS tokens, service principals, IAM keys |
| Initial Access | T1190 Exploit Public-Facing Application | SQL API abuse on internet-facing Weaver OA server |
| Discovery | T1580 Cloud Infrastructure Discovery | ARM validate sweeps, EC2/EBS DryRun probing |
| Discovery | T1087.002 / T1069.002 Domain Account and Group Discovery | 110,000+ AD objects enumerated, Domain Admins retrieved |
| Execution | T1059.001 PowerShell | Generated enumeration and staging scripts |
| Persistence | T1505.003 Web Shell | MySQL general log poisoned into JSP files |
| Persistence | T1136 Create Account / T1098 Account Manipulation | is_admin=true accounts, password resets |
| Credential Access | T1558.003 Kerberoasting | Service ticket harvesting across domains |
| Credential Access | T1003.006 DCSync | krbtgt, AD-sync and DC machine hashes |
| Lateral Movement | T1550.002 / T1550.003 Pass the Hash / Pass the Ticket | Attempted against domain controllers |
| Defense Evasion / Persistence | T1578 Modify Cloud Compute Infrastructure | Keyless EC2 instances, snapshot mounts, volume expansion |
| Command and Control | T1102 Web Service | Rotating webhook.site endpoints |
| Lateral Movement | T1534 Internal Spearphishing | Notification API used to mail 1,300+ internal users |
| Exfiltration | T1567 Exfiltration Over Web Service | Command output posted to webhook endpoints |
Affected Frameworks and Abused Surfaces
There are no vulnerable package versions in the usual sense. The first table tracks the tooling; the second tracks the parts of your environment the tooling consumes.
| Package | Vulnerable Versions | Fixed Version | Notes |
|---|---|---|---|
| ARTEX (Autumn-27 original) | All releases since July 2026 public release | Not applicable | Repository withdrawn October 2026 over abuse; copies keep circulating |
| ARTEX forks (ScopeWeaver and others) | All | Not applicable | Localized variants observed by GTIG |
| ARTEX PRO | All | Not applicable | Commercial edition |
| PentAGI (VXControl) | Open-source and commercial editions | Not applicable | Kali sandbox execution; customized builds used against Asian telcos and system integrators; chained with proxy services against aerospace |
| CAIRN | All | Not applicable | Named by GTIG in IR engagements |
| HexStrike AI | All | Not applicable | Connects models to 150+ security tools |
| Abused surface | Abuse observed | Hardened state to reach |
|---|---|---|
| Azure App Service Kudu/SCM | Command execution, script staging, artifact cleanup | SCM access restricted to deployment networks; basic publishing auth disabled; run-from-package |
| Azure Storage Shared Key / SAS | Capability checks, mass blob reads | allowSharedKeyAccess=false; Entra ID auth with Conditional Access |
| AWS IAM users with static keys | DryRun probing, EC2/EBS/snapshot abuse, instance profile escalation | Roles and temporary credentials only; iam:PassRole scoped with iam:PassedToService |
| MySQL application accounts | SET GLOBAL general_log_file webshell pivot | No SYSTEM_VARIABLES_ADMIN/SUPER/FILE; secure_file_priv set; MySQL process cannot write to web roots |
| Active Directory | Kerberoasting, DCSync, AD CS template audit | gMSA instead of password SPNs; AES-only; DCSync rights audited; ENROLLEE_SUPPLIES_SUBJECT removed |
| Internal business APIs | Writable is_admin, mass notification to 1,300+ users | Server-side authorization on privileged fields; recipient and rate limits |
| Server egress | curl to 491 rotating webhook.site URLs | Default-deny egress; OAST, webhook and tunneling domains blocked |
Exposure Analysis
| Environment | Risk Level | Reason |
|---|---|---|
| Cloud control planes (ARM, IAM, Kudu/SCM, management APIs) | Critical | Highest-value target for stolen credentials; ARTEX tests permissions at sub-second speed |
| Identity infrastructure (AD, Entra, AD CS, federation) | Critical | DCSync and Kerberoasting yield domain-wide persistence |
| Internet-exposed services | Critical | Direct entry; detailed error responses steer agent iteration |
| Internal business applications | High | Undocumented APIs are now enumerable; legitimate features become attack primitives |
| CI/CD pipelines | High | Long-lived deployment tokens and publishing credentials feed the entry step |
| Cloud workloads | High | Attached identities, embedded secrets and flat egress enable lateral movement and exfiltration staging |
| Developer environments and coding agents | Medium to High | Insider-equivalent access; agent configs are a persistence target (Miasma, Shai-Hulud lineage) |
Scale indicators from public reporting:
| Signal | Value | Source |
|---|---|---|
| Exposed ARTEX consoles | 1,465 hosts as of Nov 4, 2026, about 815 of them distinct deployments (the rest sit in two cloned hosting blocks) | Censys, “ARTEX: Agentic Asbestos” |
| ARTEX hosts seen by AhnLab | ~600 IPs hosting ARTEX instances (hosting, not confirmed attacks) | AhnLab via Yonhap |
| VAPOR PANDA reach | 200+ organizations in under two weeks, from Oct 17 | CrowdStrike via iTnews |
| South Korean finance incidents | At least seven institutions breached late Sept to early Oct; data of about 68,000 people exposed. CrowdStrike notes the total number of affected organizations is unconfirmed | CrowdStrike, Yonhap, Deutsche Welle |
| Time to detection at three Korean banks | ~15 to ~68 hours | Akamai |
A note on that last row. If an agent moves from first account to deep access in 15 minutes and you detect in 15 hours, the detection told you what happened. It did not change the outcome. GTIG makes the same point: detection and disruption are separate functions.
Real-World Impact
The realistic scenarios are already documented. A stolen Azure storage key becomes bulk blob reads before the SOC queue refreshes. A Kudu credential becomes code execution on an internal Windows database server with results streamed out through hundreds of webhook URLs. A single application account with a writable admin flag becomes a set of persistent admin accounts. A legitimate notification service becomes an internal mass mailer trusted by every recipient. On the identity side, Kerberoasting plus offline cracking plus DCSync hands over the domain.
The insider version of the same attack
Every ARTEX case GTIG describes in detail starts with valid credentials. From the defender’s telemetry, that is indistinguishable from an insider: authenticated, using supported APIs, touching resources the identity can reach. Strip away the attribution label and the control problem is identical.
Insider risk shows up in concrete ways. A malicious or disgruntled employee no longer needs offensive skills; a framework plus their own access is enough to enumerate and chain everything their identity touches. A compromised developer workstation hands the attacker that developer’s cloud, Git and CI credentials, which is exactly the entry step ARTEX wants. And the coding agents running inside your own SDLC are themselves agents with credentials. If their permissions, hooks and configuration files are not governed, a poisoned instruction file or MCP server gets the same chaining power for free. Our analysis of Miasma showed attackers already hiding persistence in exactly those settings and hook files.
The conclusion for program design: model “valid credential in the wrong hands, driven by an agent” as a first-class threat, whoever holds it.
Phoenix Purple runs the same chaining logic against your own code and apps. It traces each finding to the line that fixes it. Then it turns the fix into a rule your coding agents follow.
Protect yourself with Phoenix Purple – find TRUE critical chainable vulnerabilities with exploits
Detection Guidance
ARTEX trades stealth for velocity, which gives defenders a window. The signals sit in sequence, timing and volume rather than in any single event.
Log Indicators
| Indicator | Telemetry source | What to look for |
|---|---|---|
| Permission probing burst | AWS CloudTrail | Many Client.DryRunOperation / UnauthorizedOperation responses from one identity within seconds, often with placeholder resource IDs |
| ARM validation sweep | Azure Activity Log | Microsoft.Resources/deployments/validate/action across many resource types in under 10 seconds |
| Write-then-delete blobs | Azure Storage diagnostic logs | PutBlob followed by DeleteBlob on the same tiny object within ~1 second |
| Kudu command execution | App Service / SCM logs | POST /api/command or /api/zip from IPs outside deployment infrastructure |
| MySQL log redirection | MySQL general/audit log | SET GLOBAL general_log_file pointing at any path ending .jsp, .php, .aspx or inside a web root |
| Web path fuzzing | Web server / WAF | Hundreds of requests per minute alternating 200/403 across extensions |
| New script files in web roots | EDR / FIM | .jsp files with short incremental names; files matching artex-probe-* |
| Webhook C2 | Proxy / DNS / NetFlow | Server-originated HTTPS to webhook.site (or similar OAST/webhook services) across many unique URLs |
| Directory services bursts | Domain controller logs | Event 4769 with RC4 tickets for many SPNs in a short window; 4662 with DS-Replication-Get-Changes(-All) from non-DC hosts |
| Account lifecycle bursts | App and IdP audit logs | Multiple accounts created with admin flags or password resets within minutes, incrementing numeric suffixes |
| Notification abuse | Application logs | One application identity emailing hundreds or thousands of internal recipients outside baseline |
Indicators of Compromise
| Type | Indicator | Context | Confidence |
|---|---|---|---|
| Filename pattern | artex-probe-NNNNN.* (five-digit, roughly incremental) | Access-probing artifacts | GTIG |
| Account name pattern | Contains ArtexProbe, plaintext passwords set | Persistence accounts | GTIG |
| Filenames | cl1217.jsp, f1219a.jsp, z1219.jsp | MySQL log-poisoned webshells | GTIG (names will vary per run) |
| Domain | webhook[.]site (491 rotating URLs in one case) | C2 and output exfiltration | GTIG |
| IP | 38.244.50[.]120 | Hosted the ARTEX instance likely used in the South Korean finance campaign | CrowdStrike |
| Behavioral marker | Incrementing numeric suffixes in file names, account names, passwords and email subjects | ARTEX run artifact | GTIG |
Treat the static IOCs as a bonus. Forks will rename the markers, and the ScopeWeaver and PRO variants may already have.
Hunting Queries
AWS CloudTrail via Athena, DryRun bursts per identity:
SELECT useridentity.arn,
sourceipaddress,
date_trunc('minute', from_iso8601_timestamp(eventtime)) AS minute,
count(*) AS dryrun_calls,
count(DISTINCT eventname) AS distinct_apis
FROM cloudtrail_logs
WHERE errorcode IN ('Client.DryRunOperation', 'Client.UnauthorizedOperation')
AND from_iso8601_timestamp(eventtime) > current_timestamp - interval '30' day
GROUP BY 1, 2, 3
HAVING count(*) >= 15
ORDER BY dryrun_calls DESC;
Scanner References
Phoenix Purple Exploit Hunt and Phoenix Red Vision for chainable attack-path validation against code and exposed surfaces. Phoenix Orange attack surface management for internet-exposed admin interfaces and services. Phoenix Blue for threat intelligence and campaign IOCs.
Complement with CSPM checks for Shared Key auth, static IAM keys and iam:PassRole scope. Add secret scanning across repositories, images and pipelines, AD tooling for Kerberoastable accounts and AD CS template misconfiguration, and SBOM-backed inventory of which applications expose management APIs.
Verification Steps for Teams
- Run the IOC hunts above across file systems, IdP, application and database audit logs for the last 90 days.
- Inventory every static cloud credential (IAM user keys, SP client secrets, storage account keys, SAS tokens, Kudu publishing profiles) and record owner, age, scope and allowed source networks.
- Enumerate application database accounts with server-level privileges and confirm whether the DB process can write to any web-served path.
- Query AD for user accounts with SPNs and RC4 support, accounts with replication rights, and AD CS templates allowing requester-supplied subjects with client auth.
- List internet-reachable admin and publishing endpoints from your external attack surface inventory, including
*.scm.azurewebsites.net. - Review production server egress for connections to webhook, OAST, tunneling and file-transfer services.
- Identify internal APIs that can send mass messages, create users or set privilege flags, and confirm server-side authorization and rate limits exist.
Remediation Guidance
There is no version to upgrade to. Every action below targets a link ARTEX was seen using.
Immediate Actions
- Rotate every static credential found in step 2 above, then replace it: IAM users with roles and temporary credentials, SP client secrets with Managed Identities or workload identity federation, GitHub classic PATs with fine-grained PATs or Actions OIDC.
- Set
allowSharedKeyAccess=falseon storage accounts and move to Entra ID authorization behind Conditional Access. - Restrict Kudu/SCM to deployment networks with separate SCM access restrictions, disable basic publishing authentication, and repeat for the
ftppolicy:
bash
az resource update --resource-group <rg> --name scm \
--namespace Microsoft.Web \
--resource-type basicPublishingCredentialsPolicies \
--parent sites/<app> --set properties.allow=false
- Scope
iam:PassRoleto named roles with aniam:PassedToServicecondition; denyec2:RunInstanceswith arbitrary instance profiles from human or CI identities. - Revoke server-level privileges from application database accounts, then set
secure_file_privto a non-web directory and confirm the MySQL OS user has no write access to web roots:
sql
REVOKE SYSTEM_VARIABLES_ADMIN, SUPER, FILE ON *.* FROM 'app'@'%';
- If DCSync is suspected, reset
krbtgttwice with replication between resets, rotate AD-sync service credentials, and convert SPN-bearing user accounts to gMSAs with AES-only encryption. - Default-deny egress from production servers and block webhook.site and comparable OAST and tunneling services at proxy and DNS.
- Add recipient caps and rate limits to notification and email APIs; enforce server-side authorization for privileged fields such as
is_admin.
Temporary Mitigations (if hardening is delayed)
- Scan your external surface with Phoenix Purple Pentest.
- Put WAF rules in front of SCM and admin endpoints that allow only deployment IP ranges.
- Rate-limit and alert on 403/200 alternation bursts from a single client.
- Disable JSP/PHP execution in upload and log directories at the servlet container or web server level.
- Deploy the hunting queries above as scheduled detections with paging, not dashboards.
- Strip stack traces, SQL errors, and compiler output from external responses; keep them in internal logs only.
- Add Conditional Access location and device conditions to service principals and admin roles you cannot convert this week.
- Start scanning for secrets in CI, and use Phoenix Purple hooks and PR review to block pull requests that add them.
- Simulate this attack with Phoenix Purple Hunt.
Phoenix Security Recommendations
ARTEX proves the attacker side of an idea we built Phoenix Purple around: findings matter when they chain, and chains are only real when someone walks them. The defensive answer has two halves. Test the chains the way the attacker will, continuously. Then prevent the chains from forming, at the point where code, identities and agents make changes.

Test the chain the way ARTEX walks it
Phoenix Purple Exploit Hunt runs inside the code knowledge graph Phoenix builds for each repository (call graph, taint and cross-file relationships). It takes its targets from a live STRIDE threat model, including trust boundaries and attack-path chains. It runs adversarial personas (attacker, skeptic, exploit developer) that must disagree before anything becomes a finding. A finding ships with a runnable proof of concept, which is the same standard ARTEX applies when it keeps retrying until the webshell answers. Phoenix Red Vision extends that loop to the running estate: OSINT, DAST, exploitation and remediation chained together. It validates findings from Purple and Blue and maps attack paths against compensating controls.
The point is ownership of the schedule. ARTEX tests your paths whenever an operator feeds it a credential. You can test the same paths every sprint, on every merge to main, with results that name the chain, the proof and the owner.
Find in code: Hunt Path A
Hunt starts from the code knowledge graph (files, functions, calls, imports) and the threat model’s trust boundaries, and picks the files most likely to hold a reachable vulnerability. Deep Hunt models each hypothesis as an ordered chain from source to hops to sink. It joins confirmed findings that share a file into a deeper chain rooted at a trust-boundary crossing. That is how two mediums become one attack path on the screen, before an attacker finds them. A finding reads Exploit confirmed only when a working proof of concept was stored, and Not exploitable stays separate from False positive. Hunt and Deep Hunt are available today. Live DAST validation of hunt findings is in preview for Enterprise.
Find at runtime: Hunt Path B and Purple Pentest
Path B starts where ARTEX starts, at the running application. Purple Pentest runs in three tiers. Quick is a multi-tool scanner pipeline. Standard is the same pipeline with an AI judge on each result. Pentest Deep is an autonomous agent loop that discovers endpoints, picks tools and chains steps inside a declared, owned scope. On Enterprise, Pentest Deep gets read-only access to the code graph through a single-scan, short-lived token. So it can read the handler behind an endpoint to aim its next test. The tiers are in preview. The next step, now being built, traces each runtime finding back into code. It uses the graph to list every other entry point that reaches the same flaw: the blast radius of one finding, measured before an attacker measures it.
Fix right
A pentest finding that says “this URL is vulnerable” costs a developer days of searching. Purple’s remediation output ties each finding to its file and line and proposes fixes grouped by breaking change. It also adds a regression test and a one-line reproduction command per finding. The regression test is what keeps the fix fixed. AI-suggested fixes are labeled as unverified suggestions, never change a verdict, and a person approves them.
Prevent the chain before it exists
Testing finds chains; prevention stops new ones from being shipped. Phoenix Purple’s preventative controls sit where engineering work happens, including inside coding agents (Purplephx integrations for Cursor, VS Code, Claude Code and Windsurf), before the pull request.
Hooks and guardrails block the moves that feed ARTEX at creation time. For example: a new static cloud key committed to config, a database grant that adds SUPER, an admin endpoint exposed publicly in IaC, an agent configuration or MCP server change nobody reviewed. The same hooks govern your own coding agents, which closes the insider and poisoned-agent path described above.
Guardrails
Phoenix turns a repository’s own confirmed High and Critical findings into rule files the coding agent loads every session. They are exported natively for Claude Code, Cursor, Codex CLI and Gemini CLI. Rules are fingerprinted, so a repeated mistake produces one rule. The same generation is exposed through MCP, so the agent can refresh its own rules. A scanner finds the bug after it is written. A guardrail is in context before the next line is written. Agent Config Certification, in preview, checks the agent’s own configuration for injected commands, embedded credentials, removed safety checks and hidden instructions before a session starts.
Hook policies inside the session
Purple hooks run at fixed moments in a Claude Code, Cursor or Codex session: commit, push, PR creation. They return three lists to the agent: blocking findings, findings to fix with remedies, and waived findings. Each comes with file, lines and remedy text, so the agent starts at the fix. Administrators set policy per organization and workspace, and a workspace can be stricter but never looser without an audited exception. Hooks are in early access.
Gate: pipelineless PR review
A developer can remove a local hook. The pull request check runs server-side from the source-control webhook, with no CI workflow file and no runner. Phoenix overlays the changed files on its code graph, runs reachability and taint analysis, and uses baseline diffing to show only the risk that change introduced. It is available on GitHub, GitLab, Bitbucket and Azure DevOps.
Toxic combinations and blast radius
Toxic combinations analysis correlates weaknesses that look medium in isolation and critical together. An internet-reachable SCM endpoint, a publishing credential that works from any IP and an app identity with storage write access are three tickets in three backlogs. In ARTEX terms they are one path, and Phoenix scores and routes them as one.
Security blast radius analysis answers the question every ARTEX incident forces: if this credential, workload or agent is compromised, what can it reach next? Mapping each identity and workload to its reachable resources lets you shrink the radius before an attacker measures it with DryRun calls.

Breaking the ARTEX chain
Run the Weaver OA sequence through the loop.
Hunt Path A reads the application code and flags the SQL API handler that concatenates request input into a query. Deep Hunt joins it with the connection configuration that uses a privileged database account, and models the chain from the HTTP entry point to a server-level SQL statement. The proof of concept lands and the finding reads Exploit confirmed. The developer gets the file, the line and the fix: parameterized queries in the handler, plus a separate least-privilege account without SYSTEM_VARIABLES_ADMIN.
Purple Pentest Deep, run against the same application, finds the verbose error responses and the path-fuzzing surface from outside. Tracing back into code shows the same handler sits behind three other endpoints. One finding becomes four fix locations.
The fix ships with a regression test. The finding becomes a guardrail rule: in this repository, never build SQL from request input in this module; use the query builder. The next time an agent touches that service, the rule is already in its context. If the agent writes the pattern anyway, the session hook returns it as blocking before the pull request exists. If someone removed the hook, the pipelineless PR check catches it.
What changes is the shape of the backlog. Each confirmed finding produces a fix and a rule instead of a ticket that reappears. Noise drops because proof replaces pattern, and because one issue reported by pentest, hunt and code scan is linked to one code location instead of counted three times. That is the same reduction logic behind ClearBank’s 98% reduction in container findings, from 467,000 to about 8,000.
Insider and outsider, one model
Because both halves start from “valid access plus automation,” they cover the external crew with a stolen service principal and the insider with legitimate access in the same way. You stop arguing about attribution and start measuring reachable impact.
Close the loop in Phoenix Orange
Contextual deduplication collapses identical exposure reported by CSPM, secret scanners, SAST and pentest tools into one finding per chain link. Reachability analysis separates exposures that sit on a live, reachable path from ones that do not. Remediation campaigns turn an ARTEX response into tracked work: create the campaign, assign owners per application and identity, track fixes, and verify runtime exposure has closed. Ownership attribution makes sure the iam:PassRole fix lands on the platform team and the MySQL grant fix lands on the application team. Attack surface management continuously flags internet-exposed admin and publishing interfaces, the first thing ARTEX goes looking for.
Phoenix Security correlates vulnerable components and over-privileged identities with runtime workloads, proves which chains are exploitable, blocks new links at the point of change, and assigns remediation ownership. That shrinks an agentic attacker’s playground into an owned, trackable backlog.
Practical guidance
Start Monday with an inventory of the chains, not the findings. List internet-reachable admin and publishing endpoints, static cloud credentials with their source restrictions, and application database accounts with server-level privileges. Any service that appears in two of those lists is a chain candidate.
Point continuous chain testing at those services first. Code-side hunting finds the path before deployment; runtime testing confirms what an outsider can actually reach. Run both, and make the results land with a named owner.
Change your definition of done. A finding is remediated when it has a merged fix, a regression test and a prevention rule in the agent configuration for that repository. Closing the ticket is not the same thing.
Govern your coding agents as privileged identities. Version-control their rules, hooks and MCP configuration, review changes to them like infrastructure code, and keep a server-side PR gate that does not depend on any local setting.
Next Steps
- Map your top 20 internet-facing services against the three chain lists above within two weeks, and pick five for continuous Hunt and Pentest coverage.
- Export guardrail packs for the repositories those services live in, and enable the pipelineless PR check on the same repositories.
- Add “fix, regression test, guardrail rule” to the remediation definition of done in your vulnerability management policy this quarter.
Regulatory hooks
In the US, an ARTEX-style incident that reaches material systems starts the SEC Form 8-K Item 1.05 four-business-day clock. CISA’s Secure by Design guidance already pushes vendors toward the default-deny, short-lived-credential posture described above. In the UK and EU, DORA’s threat-led penetration testing requirement for financial entities and NIS2’s risk-management obligations make continuous attack-path validation an easier case to put in front of the board. The South Korean bank incidents, with emergency regulator response, are the preview.
External References
- Google Threat Intelligence Group and Mandiant, “ARTEX and Friends: Enter Agentic Offensive Frameworks,” October 30, 2026.
- Google Threat Intelligence Group, From Prompting to Autonomy (September 2026), coverage via Help Net Security
- CrowdStrike, Unknown Threat Actor Uses ARTEX to Target South Korean Finance
- iTnews, ARTEX AI hacking framework spreads to another China-linked group (VAPOR PANDA)
- Censys, ARTEX: Agentic Asbestos (exposed console research)
- TechCrunch, Hundreds of ARTEX AI hacking tools found publicly exposed to the web, November 6, 2026
- Cloud Security Alliance AI Safety Initiative, ARTEX: Open-Source Agentic Pentest Tool Turned on Korean Banks, October 10, 2026
- BleepingComputer, Hacker used ARTEX AI and Claude agents to target South Korean banks
- Security Affairs, Inside ARTEX: AI Hacking Tools, Exposed Servers and South Korean Bank Breaches (Hunt.io research)
- Akamai, What ARTEX reveals about overlooked attack surfaces
- SOC Prime, ARTEX Leads a New Wave of Agentic Offensive Frameworks (detection content)
- VXControl, PentAGI project
- MITRE ATT&CK Enterprise Matrix
- Phoenix Security, Phoenix Security Launches the Exploit Hunt
- Phoenix Security, Phoenix Security Launches Phoenix Purple
- Phoenix Security, Miasma: The Worm That Lives Inside Your AI Tools
- Phoenix Security, Agentic SDLC Security control framework
















