ARTEX and the Agentic Offensive Frameworks: Machine-Speed Intrusions Built on Stolen Credentials and Unhardened Basics

ARTEX agentic attack framework turning one stolen cloud credential into a full intrusion chain across Azure, AWS and Active Directory, Phoenix Security threat analysis

Executive 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

LabelContent
What it isOpen-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 bitesCloud 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 mattersMachine-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 statusNot applicable. Nothing to patch on the attacker side. Your fix is configuration, identity and segmentation hardening, plus detection.
Immediate actionHunt 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

FieldValue
Threat classAgentic offensive framework abuse (AI-orchestrated intrusion)
Frameworks observedARTEX (plus forks ScopeWeaver and ARTEX PRO), PentAGI, CAIRN, HexStrike AI
OriginARTEX: 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 / CVSSNone. No software defect; abuse of dual-use tooling against existing weaknesses
Commonly chained weaknessesCWE-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 availableNo. Mitigation is hardening and detection
Active exploitationConfirmed (GTIG, Mandiant, Microsoft, CrowdStrike)
Tracked actorsUNC7228 (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 hitGovernment, 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.

StageDescriptionGTIG timeframe
1Prompt-based LLM use: code help, phishing drafts, light reconEnd 2025 to early 2026
2LLM capabilities embedded in malware (HONESTCUE, PROMPTSPY)Early 2026
3LLM-enabled automation alongside human operators, LLM proxy services for OPSECEarly 2026 to Sept 2026
4Development and experimentation with autonomous frameworksMid 2026 to Sept 2026
5Multiple lifecycle stages run by LLM tooling in the wild, noisy but successfulCurrent
6Multi-agent, unsophisticated attacks with little or no human interactionNear term (1 to 3 months)
7Sophisticated, stealthy, fully autonomous operations on self-hosted modelsMedium 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

  1. 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/validate dry-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.
  2. 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 writable is_admin flag on account creation, Kerberoastable SPNs, a DCSync-capable path to domain credentials, or a notification API with no recipient limit.
  3. Execution impact. Code execution on application and database servers, theft of the domain krbtgt key, 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

PhaseWhat ARTEX didSpeed / volume markers
Phase 1: Initial footholdPermission 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 URLsBlob write/delete in ~330 to 400 ms; 27 events in 23 s of AWS probing
Phase 2: ExpansionKerberoasting, 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 targetsAdmin accounts created with is_admin=true within minutes
Phase 3: Infrastructure targetingLateral 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 collectionNew 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” errorAccount 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

TacticTechniqueARTEX observation
Initial AccessT1078.004 Valid Accounts: Cloud AccountsOperator-supplied SAS tokens, service principals, IAM keys
Initial AccessT1190 Exploit Public-Facing ApplicationSQL API abuse on internet-facing Weaver OA server
DiscoveryT1580 Cloud Infrastructure DiscoveryARM validate sweeps, EC2/EBS DryRun probing
DiscoveryT1087.002 / T1069.002 Domain Account and Group Discovery110,000+ AD objects enumerated, Domain Admins retrieved
ExecutionT1059.001 PowerShellGenerated enumeration and staging scripts
PersistenceT1505.003 Web ShellMySQL general log poisoned into JSP files
PersistenceT1136 Create Account / T1098 Account Manipulationis_admin=true accounts, password resets
Credential AccessT1558.003 KerberoastingService ticket harvesting across domains
Credential AccessT1003.006 DCSynckrbtgt, AD-sync and DC machine hashes
Lateral MovementT1550.002 / T1550.003 Pass the Hash / Pass the TicketAttempted against domain controllers
Defense Evasion / PersistenceT1578 Modify Cloud Compute InfrastructureKeyless EC2 instances, snapshot mounts, volume expansion
Command and ControlT1102 Web ServiceRotating webhook.site endpoints
Lateral MovementT1534 Internal SpearphishingNotification API used to mail 1,300+ internal users
ExfiltrationT1567 Exfiltration Over Web ServiceCommand 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.

PackageVulnerable VersionsFixed VersionNotes
ARTEX (Autumn-27 original)All releases since July 2026 public releaseNot applicableRepository withdrawn October 2026 over abuse; copies keep circulating
ARTEX forks (ScopeWeaver and others)AllNot applicableLocalized variants observed by GTIG
ARTEX PROAllNot applicableCommercial edition
PentAGI (VXControl)Open-source and commercial editionsNot applicableKali sandbox execution; customized builds used against Asian telcos and system integrators; chained with proxy services against aerospace
CAIRNAllNot applicableNamed by GTIG in IR engagements
HexStrike AIAllNot applicableConnects models to 150+ security tools
Abused surfaceAbuse observedHardened state to reach
Azure App Service Kudu/SCMCommand execution, script staging, artifact cleanupSCM access restricted to deployment networks; basic publishing auth disabled; run-from-package
Azure Storage Shared Key / SASCapability checks, mass blob readsallowSharedKeyAccess=false; Entra ID auth with Conditional Access
AWS IAM users with static keysDryRun probing, EC2/EBS/snapshot abuse, instance profile escalationRoles and temporary credentials only; iam:PassRole scoped with iam:PassedToService
MySQL application accountsSET GLOBAL general_log_file webshell pivotNo SYSTEM_VARIABLES_ADMIN/SUPER/FILE; secure_file_priv set; MySQL process cannot write to web roots
Active DirectoryKerberoasting, DCSync, AD CS template auditgMSA instead of password SPNs; AES-only; DCSync rights audited; ENROLLEE_SUPPLIES_SUBJECT removed
Internal business APIsWritable is_admin, mass notification to 1,300+ usersServer-side authorization on privileged fields; recipient and rate limits
Server egresscurl to 491 rotating webhook.site URLsDefault-deny egress; OAST, webhook and tunneling domains blocked

Exposure Analysis

EnvironmentRisk LevelReason
Cloud control planes (ARM, IAM, Kudu/SCM, management APIs)CriticalHighest-value target for stolen credentials; ARTEX tests permissions at sub-second speed
Identity infrastructure (AD, Entra, AD CS, federation)CriticalDCSync and Kerberoasting yield domain-wide persistence
Internet-exposed servicesCriticalDirect entry; detailed error responses steer agent iteration
Internal business applicationsHighUndocumented APIs are now enumerable; legitimate features become attack primitives
CI/CD pipelinesHighLong-lived deployment tokens and publishing credentials feed the entry step
Cloud workloadsHighAttached identities, embedded secrets and flat egress enable lateral movement and exfiltration staging
Developer environments and coding agentsMedium to HighInsider-equivalent access; agent configs are a persistence target (Miasma, Shai-Hulud lineage)

Scale indicators from public reporting:

SignalValueSource
Exposed ARTEX consoles1,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 reach200+ organizations in under two weeks, from Oct 17CrowdStrike via iTnews
South Korean finance incidentsAt 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 unconfirmedCrowdStrike, Yonhap, Deutsche Welle
Time to detection at three Korean banks~15 to ~68 hoursAkamai

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

IndicatorTelemetry sourceWhat to look for
Permission probing burstAWS CloudTrailMany Client.DryRunOperation / UnauthorizedOperation responses from one identity within seconds, often with placeholder resource IDs
ARM validation sweepAzure Activity LogMicrosoft.Resources/deployments/validate/action across many resource types in under 10 seconds
Write-then-delete blobsAzure Storage diagnostic logsPutBlob followed by DeleteBlob on the same tiny object within ~1 second
Kudu command executionApp Service / SCM logsPOST /api/command or /api/zip from IPs outside deployment infrastructure
MySQL log redirectionMySQL general/audit logSET GLOBAL general_log_file pointing at any path ending .jsp, .php, .aspx or inside a web root
Web path fuzzingWeb server / WAFHundreds of requests per minute alternating 200/403 across extensions
New script files in web rootsEDR / FIM.jsp files with short incremental names; files matching artex-probe-*
Webhook C2Proxy / DNS / NetFlowServer-originated HTTPS to webhook.site (or similar OAST/webhook services) across many unique URLs
Directory services burstsDomain controller logsEvent 4769 with RC4 tickets for many SPNs in a short window; 4662 with DS-Replication-Get-Changes(-All) from non-DC hosts
Account lifecycle burstsApp and IdP audit logsMultiple accounts created with admin flags or password resets within minutes, incrementing numeric suffixes
Notification abuseApplication logsOne application identity emailing hundreds or thousands of internal recipients outside baseline

Indicators of Compromise

TypeIndicatorContextConfidence
Filename patternartex-probe-NNNNN.* (five-digit, roughly incremental)Access-probing artifactsGTIG
Account name patternContains ArtexProbe, plaintext passwords setPersistence accountsGTIG
Filenamescl1217.jsp, f1219a.jsp, z1219.jspMySQL log-poisoned webshellsGTIG (names will vary per run)
Domainwebhook[.]site (491 rotating URLs in one case)C2 and output exfiltrationGTIG
IP38.244.50[.]120Hosted the ARTEX instance likely used in the South Korean finance campaignCrowdStrike
Behavioral markerIncrementing numeric suffixes in file names, account names, passwords and email subjectsARTEX run artifactGTIG

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

  1. Run the IOC hunts above across file systems, IdP, application and database audit logs for the last 90 days.
  2. 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.
  3. Enumerate application database accounts with server-level privileges and confirm whether the DB process can write to any web-served path.
  4. 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.
  5. List internet-reachable admin and publishing endpoints from your external attack surface inventory, including *.scm.azurewebsites.net.
  6. Review production server egress for connections to webhook, OAST, tunneling and file-transfer services.
  7. 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

  1. 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.
  2. Set allowSharedKeyAccess=false on storage accounts and move to Entra ID authorization behind Conditional Access.
  3. Restrict Kudu/SCM to deployment networks with separate SCM access restrictions, disable basic publishing authentication, and repeat for the ftp policy:

bash

az resource update --resource-group <rg> --name scm \
  --namespace Microsoft.Web \
  --resource-type basicPublishingCredentialsPolicies \
  --parent sites/<app> --set properties.allow=false
  1. Scope iam:PassRole to named roles with an iam:PassedToService condition; deny ec2:RunInstances with arbitrary instance profiles from human or CI identities.
  2. Revoke server-level privileges from application database accounts, then set secure_file_priv to 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'@'%';
  1. If DCSync is suspected, reset krbtgt twice with replication between resets, rotate AD-sync service credentials, and convert SPN-bearing user accounts to gMSAs with AES-only encryption.
  2. Default-deny egress from production servers and block webhook.site and comparable OAST and tunneling services at proxy and DNS.
  3. 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)

  1. Scan your external surface with Phoenix Purple Pentest.
  2. Put WAF rules in front of SCM and admin endpoints that allow only deployment IP ranges.
  3. Rate-limit and alert on 403/200 alternation bursts from a single client.
  4. Disable JSP/PHP execution in upload and log directories at the servlet container or web server level.
  5. Deploy the hunting queries above as scheduled detections with paging, not dashboards.
  6. Strip stack traces, SQL errors, and compiler output from external responses; keep them in internal logs only.
  7. Add Conditional Access location and device conditions to service principals and admin roles you cannot convert this week.
  8. Start scanning for secrets in CI, and use Phoenix Purple hooks and PR review to block pull requests that add them.
  9. 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

  1. 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.
  2. Export guardrail packs for the repositories those services live in, and enable the pipelineless PR check on the same repositories.
  3. 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

  1. Google Threat Intelligence Group and Mandiant, “ARTEX and Friends: Enter Agentic Offensive Frameworks,” October 30, 2026.
  2. Google Threat Intelligence Group, From Prompting to Autonomy (September 2026), coverage via Help Net Security
  3. CrowdStrike, Unknown Threat Actor Uses ARTEX to Target South Korean Finance
  4. iTnews, ARTEX AI hacking framework spreads to another China-linked group (VAPOR PANDA)
  5. Censys, ARTEX: Agentic Asbestos (exposed console research)
  6. TechCrunch, Hundreds of ARTEX AI hacking tools found publicly exposed to the web, November 6, 2026
  7. Cloud Security Alliance AI Safety Initiative, ARTEX: Open-Source Agentic Pentest Tool Turned on Korean Banks, October 10, 2026
  8. BleepingComputer, Hacker used ARTEX AI and Claude agents to target South Korean banks
  9. Security Affairs, Inside ARTEX: AI Hacking Tools, Exposed Servers and South Korean Bank Breaches (Hunt.io research)
  10. Akamai, What ARTEX reveals about overlooked attack surfaces
  11. SOC Prime, ARTEX Leads a New Wave of Agentic Offensive Frameworks (detection content)
  12. VXControl, PentAGI project
  13. MITRE ATT&CK Enterprise Matrix
  14. Phoenix Security, Phoenix Security Launches the Exploit Hunt
  15. Phoenix Security, Phoenix Security Launches Phoenix Purple
  16. Phoenix Security, Miasma: The Worm That Lives Inside Your AI Tools
  17. Phoenix Security, Agentic SDLC Security control framework

Francesco is an internationally renowned public speaker, with multiple interviews in high-profile publications (eg. Forbes), and an author of numerous books and articles, who utilises his platform to evangelize the importance of Cloud security and cutting-edge technologies on a global scale.

Discuss this blog with our community on Slack

Join our AppSec Phoenix community on Slack to discuss this blog and other news with our professional security team

From our Blog

Threat intelligence tells you what a vulnerability is. Your open findings tell you what it means for you. Using Log4Shell as the example, Francesco Cipollone explains why the two rarely sit on one screen, what Phoenix is building to join them, and five checks to run on Monday morning.
Marcus Webb
Frontier models made vulnerability discovery cheap: 948 Linux privilege escalations at about $1,280 each. Fixing didn’t speed up. Only 1 in 8 disclosed AI findings has a known upstream patch, and AI-found bugs are exploited at 1.3%, the historical norm. The bottleneck is verified remediation, owned by a team and proven by the next scan.
Francesco Cipollone
Derek

Derek Fisher

Head of product security at a global fintech

Derek Fisher – Head of product security at a global fintech. Speaker, instructor, and author in application security.

Derek is an award winning author of a children’s book series in cybersecurity as well as the author of “The Application Security Handbook.” He is a university instructor at Temple University where he teaches software development security to undergraduate and graduate students. He is a speaker on topics in the cybersecurity space and has led teams, large and small, at organizations in the healthcare and financial industries. He has built and matured information security teams as well as implemented organizational information security strategies to reduce the organizations risk.

Derek got his start in the hardware engineering space where he learned about designing circuits and building assemblies for commercial and military applications. He later pursued a computer science degree in order to advance a career in software development. This is where Derek was introduced to cybersecurity and soon caught the bug. He found a mentor to help him grow in cybersecurity and then pursued a graduate degree in the subject.

Since then Derek has worked in the product security space as an architect and leader. He has led teams to deliver more secure software in organizations from multiple industries. His focus has been to raise the security awareness of the engineering organization while maintaining a practice of secure code development, delivery, and operations.

In his role, Jeevan handles a range of tasks, from architecting security solutions to collaborating with Engineering Leadership to address security vulnerabilities at scale and embed security into the fabric of the organization.

Jeevan Singh

Jeevan Singh

Founder of Manicode Security

Jeevan Singh is the Director of Security Engineering at Rippling, with a background spanning various Engineering and Security leadership roles over the course of his career. He’s dedicated to the integration of security practices into software development, working to create a security-aware culture within organizations and imparting security best practices to the team.
In his role, Jeevan handles a range of tasks, from architecting security solutions to collaborating with Engineering Leadership to address security vulnerabilities at scale and embed security into the fabric of the organization.

James

James Berthoty

Founder of Latio Tech

James Berthoty has over ten years of experience across product and security domains. He founded Latio Tech to help companies find the right security tools for their needs without vendor bias.

christophe

Christophe Parisel

Senior Cloud Security Architect

Senior Cloud Security Architect

Chris

Chris Romeo

Co-Founder
Security Journey

Chris Romeo is a leading voice and thinker in application security, threat modeling, and security champions and the CEO of Devici and General Partner at Kerr Ventures. Chris hosts the award-winning “Application Security Podcast,” “The Security Table,” and “The Threat Modeling Podcast” and is a highly rated industry speaker and trainer, featured at the RSA Conference, the AppSec Village @ DefCon, OWASP Global AppSec, ISC2 Security Congress, InfoSec World and All Day DevOps. Chris founded Security Journey, a security education company, leading to an exit in 2022. Chris was the Chief Security Advocate at Cisco, spreading security knowledge through education and champion programs. Chris has twenty-six years of security experience, holding positions across the gamut, including application security, security engineering, incident response, and various Executive roles. Chris holds the CISSP and CSSLP certifications.

jim

Jim Manico

Founder of Manicode Security

Jim Manico is the founder of Manicode Security, where he trains software developers on secure coding and security engineering. Jim is also the founder of Brakeman Security, Inc. and an investor/advisor for Signal Sciences. He is the author of Iron-Clad Java: Building Secure Web Applications (McGraw-Hill), a frequent speaker on secure software practices, and a member of the JavaOne Rockstar speaker community. Jim is also a volunteer for and former board member of the OWASP foundation.

Join our Mailing list!

Get all the latest news, exclusive deals, and feature updates.

The IKIGAI concept
Protected By
Shield Security PRO