A penetration-testing tool published on GitHub in July is now turning up in intrusion reports from Microsoft, CERT-EU and CrowdStrike. ARTEX lets a team of LLM agents scan, exploit and move through a target on its own, and it has been picked up by actors ranging from financially motivated crews to a China-nexus espionage group.

Nothing it does is new. It scans, sprays passwords, drops web shells and dumps databases, all things your detections already know about. What changes is the clock: Microsoft saw one agent go from scanning GitHub for secrets to pulling data out of an Azure Key Vault in five minutes.

This post covers what ARTEX is, who is using it and how its behaviour maps to ATT&CK. It then gives you KQL hunts organised by attack stage and a short list of hardening steps. If you are short on time, skip to the hunts and the hardening section.

What ARTEX is

ARTEX is an open-source, multi-agent penetration-testing platform that takes a goal in plain language and has LLM-driven workers carry it out with real tools. An independent developer published it to GitHub in July 2026 as a Go backend with a Next.js dashboard. The operator sets scope and watches progress, but CERT-EU notes there is no hard technical enforcement of scope or of avoiding destructive actions.

The original author withdrew the repository in October 2026 after reports of misuse. Independent forks remain, and their capabilities differ.

Three properties matter for defenders:

  • No built-in model. Operators bring their own LLM. Reporting names DeepSeek, Zhipu AI and xAI, alongside Claude Code.
  • Commodity tooling. By default it uses Nmap, curl, wget, Python HTTP clients, Norma SDK WebFetch and headless Chromium through Playwright, so it has no unique network signature.
  • Scale and persistence. It can test large numbers of low-complexity misconfigurations, work through long attack chains without fatigue, and craft tailored payloads that a time-limited human tester might skip.

The ecosystem is already broader than one tool. GitGuardian has catalogued 45 “sibling” agentic attack frameworks, and Censys has observed more than 1,400 internet-exposed ARTEX console deployments.

Who is using it

The reported users range from financially motivated crews to a China-nexus espionage actor, and the targets span banks, identity providers and software supply chains.

Activity Reported targets What was observed Source
Storm-3358 (Cambodia-based, financially motivated), from October 2026 Financial organisations in Southeast Asia, plus a smaller number of large global ones ARTEX combined with conventional tools to scan, exploit anonymous file upload and SSRF, and install WISP, vshell and AdaptixC2 RATs Microsoft
Storm-0940 ConnectWise supply-chain compromise Agentic AI used to automate attacks, including cloud identity abuse and supply-chain compromise Microsoft
China-nexus actor reported by CrowdStrike Multiple targets worldwide, including Microsoft 365 tenants ARTEX run alongside DeepSeek in an espionage campaign Cybersecurity Dive
Unattributed, likely financially motivated, from late September 2026 Seven South Korean financial institutions ARTEX with DeepSeek and Claude Code; about 67,000 customer and loan records stolen; an exposed attacker directory held Chinese-language agent instructions SOC Prime
Unattributed, October 2026 Dozens of Japanese companies ARTEX, Claude Code and several LLM APIs; agent configurations and session histories found on attacker servers SOC Prime
Identity-provider attacks Okta, Cognito and Microsoft Entra ARTEX-driven activity reported by Wiz Cybersecurity Dive
Secrets hunting GitHub-exposed secrets, Azure Key Vault An agent moved from scanning GitHub for secrets to exfiltrating Key Vault data in five minutes; OAuth app secrets were a specific target Dark Reading, Microsoft

The Korea, Japan and identity-provider details come from secondary reporting on CrowdStrike, GMO Cybersecurity, JPCERT/CC and Wiz research, not the primary reports.

TTP map

The behaviours reported across ARTEX campaigns map to well-known ATT&CK techniques; what is new is the speed and the automation of the whole chain. CERT-EU published the first three IDs. The rest are SHQ Adversary Labs mappings of behaviour described in Microsoft and other reporting, so validate them against your own taxonomy.

Stage Observed behaviour ATT&CK Basis
Reconnaissance Active scanning of exposed services with Nmap, curl and headless browsers T1595 CERT-EU
Resource development Obtaining an open-source offensive framework T1588.002 CERT-EU
Initial access Exploiting public-facing applications, including anonymous file upload and SSRF T1190 CERT-EU
Initial access Searching public code repositories for secrets; password spraying and brute force T1593.003, T1110.003, T1552 SHQ mapping
Execution and tooling Shell commands, with curl and netcat used to pull RATs onto hosts T1059.004, T1105 SHQ mapping
Persistence Web shells, cron jobs, open-source RATs (WISP, vshell, AdaptixC2), new cloud credentials T1505.003, T1053.003, T1219, T1098.001 SHQ mapping
Credential access Compromised public and local credentials; Key Vault secret retrieval T1078.004, T1555.006 SHQ mapping
Discovery and lateral movement Rapid network and host discovery; RDP and RAT-based movement T1046, T1021.001 SHQ mapping
Collection and exfiltration API enumeration and abuse, database dumping, archiving and upload T1213, T1560, T1041 SHQ mapping

How to detect an agent

Detect the pattern of the chain, because no single step is unique to ARTEX.

  • Speed and breadth. Agentic scanners send a wide variety of requests in a short time, retry variations of one technique, and move to next-stage actions at machine speed.
  • Tool fingerprints. Stock tools carry default user-agent strings and command lines. Blocking them will not stop an agent, but spotting them gives an early alert.
  • Chains over single events. Minor misconfigurations get chained into high-impact paths, so alert on sequences (scan, exploit, stage, persist) rather than single events.
  • Identity and cloud, not just endpoints. Spraying, leaked app secrets, Key Vault reads and Graph activity are part of the same campaigns.

A note on the queries below. Device* queries use Defender XDR advanced hunting (Timestamp); in Microsoft Sentinel replace it with TimeGenerated. Several sources must be enabled first, including IIS or WAF logs, Entra sign-in and audit logs, and Defender for Cloud alerts. Thresholds are starting points: baseline them, add allow-lists for your own scanners and admin tooling, and check field names against your schema before alerting.

Hunt: scanning and reconnaissance

An agent scanning your web tier looks like a single source sending hundreds of requests to many distinct URLs within minutes. These queries find that burst, the tools behind it, and unauthorised ARTEX deployments inside your own estate.

High-volume, high-variety web requests from one source (IIS logs)

W3CIISLog
| where TimeGenerated > ago(1d)
| summarize Requests = count(),
            DistinctUris = dcount(csUriStem),
            DistinctMethods = dcount(csMethod),
            DistinctUA = dcount(csUserAgent),
            Errors = countif(tostring(scStatus) in ("400","401","403","404","405","500")),
            Statuses = make_set(tostring(scStatus), 10)
    by cIP, bin(TimeGenerated, 5m)
| extend ErrorRatio = round(todouble(Errors) / Requests, 2)
| where Requests > 300 and DistinctUris > 100
| order by Requests desc

The same pattern from a WAF or reverse proxy (CEF)

CommonSecurityLog
| where TimeGenerated > ago(1d)
| where isnotempty(RequestURL)
| summarize Requests = count(),
            DistinctUrls = dcount(RequestURL),
            Blocked = countif(DeviceAction in~ ("blocked","block","deny","drop")),
            DistinctUA = dcount(RequestClientApplication)
    by SourceIP, bin(TimeGenerated, 5m)
| where Requests > 300 and DistinctUrls > 100
| order by Requests desc

Scanner binaries, ARTEX strings and ARTEX default listeners (Defender XDR)

SOC Prime notes that an ARTEX string in process telemetry can trigger a rule. The documented start flags use ports 8787 (frontend and API) and 8788 (traffic-recording proxy), which helps find unauthorised deployments.

let scanTools = dynamic(["nmap","masscan","nuclei","ffuf","gobuster","feroxbuster","sqlmap","nikto","naabu","zgrab2","dirsearch","katana","subfinder"]);
union
(
    DeviceProcessEvents
    | where Timestamp > ago(14d)
    | where FileName has_any (scanTools)
        or FileName has "artex"
        or ProcessCommandLine has_any ("artex", "start.sh -addr", "-proxy :8788")
    | project Timestamp, DeviceName, Signal = "Process", Detail = ProcessCommandLine,
              Account = AccountName, Parent = InitiatingProcessFileName
),
(
    DeviceNetworkEvents
    | where Timestamp > ago(14d)
    | where ActionType == "ListeningConnectionCreated" and LocalPort in (8787, 8788)
    | project Timestamp, DeviceName, Signal = "Listener",
              Detail = strcat(InitiatingProcessFileName, " listening on ", tostring(LocalPort)),
              Account = InitiatingProcessAccountName, Parent = InitiatingProcessParentFileName
)
| order by Timestamp desc

Headless-browser automation on servers

Playwright-driven Chromium is part of ARTEX’s default toolset and is rarely expected on a production server.

DeviceProcessEvents
| where Timestamp > ago(7d)
| where ProcessCommandLine has "--headless"
    and (ProcessCommandLine has_any ("--remote-debugging","playwright","puppeteer") or FolderPath has "ms-playwright")
| project Timestamp, DeviceName, AccountName, InitiatingProcessFileName, FileName, ProcessCommandLine
| order by Timestamp desc

Hunt: exploitation, execution and installation

After a foothold, ARTEX agents stage RATs with curl, wget and netcat, so the strongest signals are web processes spawning shells and payloads that are downloaded, made executable and run in quick succession.

Web server process spawns a shell, then downloads a payload within 30 minutes (Linux)

let webParents = dynamic(["php", "php-fpm", "php-cgi", "php-fpm7", "php-fpm8", "apache2", "httpd", "nginx"]);
let shells = dynamic(["sh", "bash", "dash"]);
let webShellSpawn = DeviceProcessEvents
    | where Timestamp > ago(7d)
    | where FileName in~ (shells)
    | where InitiatingProcessFileName has_any (webParents)
    | project DeviceId, DeviceName, ShellTime = Timestamp, ShellCommandLine = ProcessCommandLine, WebParent = InitiatingProcessFileName, ShellPid = ProcessId, ShellCreation = ProcessCreationTime;
let downloads = DeviceProcessEvents
    | where Timestamp > ago(7d)
    | where FileName in~ ("curl", "wget")
    | where ProcessCommandLine has_any ("http://", "https://")
    | where ProcessCommandLine has_any ("-o", "-O", "--output", "/tmp/")
    | project DeviceId, DlTime = Timestamp, DlCommandLine = ProcessCommandLine, DlParent = InitiatingProcessFileName, DlParentCmd = InitiatingProcessCommandLine;
webShellSpawn
| join kind=inner hint.strategy=broadcast (downloads) on DeviceId
| where DlTime between (ShellTime .. ShellTime + 30m)
| project ShellTime, DlTime, DeviceName, WebParent, ShellCommandLine, DlCommandLine, DlParent, DlParentCmd

Download-and-chmod chain within 10 minutes (RAT staging via curl or wget)

let downloads = DeviceProcessEvents
    | where Timestamp > ago(7d)
    | where FileName in~ ("curl","wget")
    | where ProcessCommandLine has_any ("/tmp/","/dev/shm/","/var/tmp/"," -o "," -O ","--output")
    | project DeviceId, DeviceName, DlTime = Timestamp, DlCmd = ProcessCommandLine, DlParent = InitiatingProcessFileName;
let chmods = DeviceProcessEvents
    | where Timestamp > ago(7d)
    | where FileName =~ "chmod" and ProcessCommandLine has_any ("+x","755","777")
    | project DeviceId, ChmodTime = Timestamp, ChmodCmd = ProcessCommandLine;
downloads
| join kind=inner chmods on DeviceId
| where ChmodTime between (DlTime .. (DlTime + 10m))
| project DlTime, ChmodTime, DeviceName, DlParent, DlCmd, ChmodCmd
| order by DlTime desc

Hidden download, chmod and execute sequence on one Linux device

This chains three steps within an hour each: a download into a dot-prefixed file, a chmod on it, then execution of a hidden file from a world-writable directory.

let window = 1h;
let hidden_download = DeviceProcessEvents
    | where Timestamp > ago(1d)
    | where FileName in~ ("curl", "wget")
    | where ProcessCommandLine has_any ("-o", "-O", "--output")
    | where ProcessCommandLine matches regex @"(-o|-O|--output)\s+['""]?(/tmp/|/var/tmp/|/dev/shm/)?\.[A-Za-z0-9_]+"
    | project DeviceId, DeviceName, DlTime = Timestamp, DlCommand = ProcessCommandLine, DlUser = AccountName;
let chmod_exec = DeviceProcessEvents
    | where Timestamp > ago(1d)
    | where FileName =~ "chmod"
    | where ProcessCommandLine has_any ("+x", "755", "777", "700")
    | where ProcessCommandLine matches regex @"(/tmp/|/var/tmp/|/dev/shm/|\s)\.[A-Za-z0-9_]+"
    | project DeviceId, ChmodTime = Timestamp, ChmodCommand = ProcessCommandLine;
let hidden_exec = DeviceProcessEvents
    | where Timestamp > ago(1d)
    | where FolderPath matches regex @"^(/tmp/|/var/tmp/|/dev/shm/)([^/]+/)*\.[A-Za-z0-9_]+$"
    | project DeviceId, ExecTime = Timestamp, ExecPath = FolderPath, ExecCommand = ProcessCommandLine, ExecParent = InitiatingProcessFileName;
hidden_download
| join kind=inner hint.strategy=broadcast (chmod_exec) on DeviceId
| where ChmodTime between (DlTime .. DlTime + window)
| join kind=inner (hidden_exec) on DeviceId
| where ExecTime between (ChmodTime .. ChmodTime + window)
| project DeviceName, DlTime, DlCommand, ChmodTime, ChmodCommand, ExecTime, ExecPath, ExecCommand, ExecParent, DlUser

Execution from world-writable directories

DeviceProcessEvents
| where Timestamp > ago(7d)
| where FolderPath startswith "/tmp/" or FolderPath startswith "/dev/shm/" or FolderPath startswith "/var/tmp/"
| where InitiatingProcessFileName in~ ("sh","bash","dash","curl","wget","php","python","python3","java","w3wp.exe","httpd","nginx")
| project Timestamp, DeviceName, AccountName, FolderPath, FileName, ProcessCommandLine,
          InitiatingProcessFileName, InitiatingProcessCommandLine
| order by Timestamp desc

Reverse shell patterns

DeviceProcessEvents
| where Timestamp > ago(7d)
| where ProcessCommandLine matches regex @"(?i)(bash\s+-i\s+>&\s*/dev/tcp/|/dev/tcp/\d{1,3}\.|\bnc(at)?\b.*\s-(e|c)\s|mkfifo\s+/tmp/|socat\s+.*exec:|python[0-9.]*\s+-c\s+.*socket.*(connect|subprocess|pty))"
| project Timestamp, DeviceName, AccountName, InitiatingProcessFileName, ProcessCommandLine
| order by Timestamp desc

curl reaching a destination not seen in the previous week

This catches RAT staging, C2 and exfiltration over curl by comparing the last day with a seven-day baseline. It is noisy on build servers, so scope it to production hosts.

let baseline = materialize(
    DeviceNetworkEvents
    | where Timestamp between (ago(8d) .. ago(1d))
    | where InitiatingProcessFileName =~ "curl" or InitiatingProcessFileName =~ "curl.exe"
    | extend Remote = coalesce(RemoteUrl, RemoteIP)
    | where isnotempty(Remote)
    | distinct Remote
);
let baselineList = toscalar(baseline | summarize make_set(Remote, 100000));
DeviceNetworkEvents
| where Timestamp > ago(1d)
| where InitiatingProcessFileName in~ ("curl", "curl.exe")
| extend Remote = coalesce(RemoteUrl, RemoteIP)
| where isnotempty(Remote)
| where not(set_has_element(baselineList, Remote))
| summarize FirstSeen = min(Timestamp), LastSeen = max(Timestamp), Connections = count(), RemotePorts = make_set(RemotePort, 20), CommandLines = make_set(InitiatingProcessCommandLine, 10) by DeviceName, DeviceId, Remote, InitiatingProcessAccountName
| order by FirstSeen desc

Hunt: persistence

Observed ARTEX intrusions persist through web shells, scheduled jobs and open-source RATs, so watch the places a non-admin process should never write.

Crontab commands containing download or staging content

DeviceProcessEvents
| where Timestamp > ago(7d)
| where ProcessCommandLine has_any ("crontab","/etc/cron")
| where ProcessCommandLine matches regex @"(?i)(curl|wget|/tmp/|/dev/shm/|base64|bash -i|\bnc\b)"
| project Timestamp, DeviceName, AccountName, InitiatingProcessFileName, ProcessCommandLine
| order by Timestamp desc

Other Linux and Windows persistence locations

union
(
    DeviceFileEvents
    | where Timestamp > ago(7d)
    | where ActionType in ("FileCreated","FileModified")
    | where FolderPath matches regex @"(?i)(/etc/systemd/system/.*\.service|/usr/lib/systemd/system/.*\.service|/etc/rc\.local|/etc/init\.d/.*|\.ssh/authorized_keys|/etc/ld\.so\.preload|\.bashrc|\.profile)$"
    | where InitiatingProcessFileName !in~ ("dpkg","apt","apt-get","yum","dnf","rpm","ansible","puppet","chef-client","salt-minion","sshd")
    | project Timestamp, DeviceName, Signal = "LinuxPersistFile",
              Detail = strcat(FolderPath, "/", FileName), Actor = InitiatingProcessFileName
),
(
    DeviceProcessEvents
    | where Timestamp > ago(7d)
    | where (FileName =~ "schtasks.exe" and ProcessCommandLine has "/create")
        or (FileName =~ "sc.exe" and ProcessCommandLine has "create")
        or (FileName =~ "reg.exe" and ProcessCommandLine has_any ("CurrentVersion\\Run","Winlogon"))
    | where InitiatingProcessFileName in~ ("w3wp.exe","cmd.exe","powershell.exe","pwsh.exe","curl.exe","java.exe","php.exe")
    | project Timestamp, DeviceName, Signal = "WindowsPersistCmd",
              Detail = ProcessCommandLine, Actor = InitiatingProcessFileName
)
| order by Timestamp desc

Hunt: credential access and identity

Spraying, brute force and leaked secrets are how ARTEX operators reach cloud identities, so correlate failed-then-successful sign-ins and identity-risk signals with cloud alerts.

Successful sign-in from an IP that is spraying many accounts

let lookback = 1h;
let failureCodes = dynamic(["50126", "50053", "50057"]);
let sprayers = SigninLogs
    | where TimeGenerated > ago(lookback)
    | where ResultType in (failureCodes)
    | summarize FailedAttempts = count(), TargetedUsers = dcount(UserPrincipalName), FirstFail = min(TimeGenerated), LastFail = max(TimeGenerated) by IPAddress
    | where TargetedUsers >= 10 and FailedAttempts >= 20;
SigninLogs
| where TimeGenerated > ago(lookback)
| where ResultType == "0"
| join kind=inner hint.strategy=broadcast (sprayers) on IPAddress
| where TimeGenerated >= FirstFail
| project TimeGenerated, UserPrincipalName, IPAddress, AppDisplayName, FailedAttempts, TargetedUsers, FirstFail, LastFail

Successful Entra sign-ins from tool-default user agents

A successful sign-in whose user agent is a scripting library or headless browser deserves a look, because ARTEX defaults to the stock user agents of its tools. No source documents a user agent literally named ARTEX, so the artex and norma terms below are a speculative catch for forks. Libraries such as python-requests, axios and okhttp are common in legitimate automation, so allow-list your own service accounts and apps.

let toolUA = @"(?i)(python-requests|python-httpx|aiohttp|go-http-client|^curl/|^wget/|headlesschrome|playwright|puppeteer|nmap|nuclei|sqlmap|artex|norma|okhttp|node-fetch|axios)";
union SigninLogs, AADNonInteractiveUserSignInLogs
| where TimeGenerated > ago(7d)
| where ResultType == "0"
| where UserAgent matches regex toolUA
| summarize SignIns = count(),
            Apps = make_set(AppDisplayName, 10),
            Resources = make_set(ResourceDisplayName, 10),
            FirstSeen = min(TimeGenerated),
            LastSeen = max(TimeGenerated)
    by UserPrincipalName, IPAddress, UserAgent, ClientAppUsed
| order by SignIns desc

Web logins that succeed after failures from a tool user agent

This looks for a tool user agent that fails several times against a login-style path and then gets a redirect, which is a common success signal. Success codes are application-specific, so adjust the 302 and 303 values to how your login behaves.

let toolUA = @"(?i)(python-requests|python-httpx|aiohttp|go-http-client|^curl/|^wget/|headlesschrome|playwright|puppeteer|nmap|nuclei|sqlmap|artex|norma)";
W3CIISLog
| where TimeGenerated > ago(7d)
| where csMethod =~ "POST"
| where csUriStem matches regex @"(?i)(login|signin|logon|auth|token|oauth|session|admin)"
| where csUserAgent matches regex toolUA
| summarize Requests = count(),
            Failures = countif(tostring(scStatus) in ("401","403")),
            Successes = countif(tostring(scStatus) in ("302","303")),
            FirstSeen = min(TimeGenerated),
            LastSeen = max(TimeGenerated)
    by cIP, csUserAgent, csUriStem
| where Failures >= 5 and Successes >= 1
| order by Failures desc

Verified threat-actor IP risk detection followed by Defender for Cloud alerts

This links an Entra ID Protection detection for a known threat-actor IP to Defender for Cloud alerts on ARM operations from suspicious IPs or publicly exposed storage containers within three days. Defender for Cloud alerts are often scoped to a subscription or resource, so the join matches on the account, the entity list, or the risky IP.

let lookback = 7d;
let risky_users = AADUserRiskEvents
    | where TimeGenerated > ago(lookback)
    | where RiskEventType =~ "nationStateIP"
        or RiskEventType contains "threatActorIp"
        or RiskEventType contains "verifiedThreatActor"
        or RiskDetail contains "threat actor"
    | project RiskTime = TimeGenerated, UserPrincipalName, RiskIpAddress = IpAddress, RiskEventType;
let cloud_alerts = SecurityAlert
    | where TimeGenerated > ago(lookback)
    | where ProviderName has "Azure Security Center" or ProductName has "Defender for Cloud" or ProductName has "Azure Security Center"
    | where AlertName has "Azure Resource Manager operation from suspicious IP address"
        or AlertName has "Publicly accessible storage containers"
    | project AlertTime = TimeGenerated, AlertName, AlertSeverity, AlertEntities = tostring(Entities), CompromisedEntity;
risky_users
| extend k = 1
| join kind=inner (cloud_alerts | extend k = 1) on k
| where AlertTime between (RiskTime .. (RiskTime + 3d))
| where tolower(CompromisedEntity) == tolower(UserPrincipalName)
    or AlertEntities contains UserPrincipalName
    or (isnotempty(RiskIpAddress) and AlertEntities contains RiskIpAddress)
| project RiskTime, UserPrincipalName, RiskIpAddress, RiskEventType, AlertTime, AlertName, AlertSeverity

Successful Entra sign-ins from scripted or automation user agents

Public reporting describes ARTEX using stock tools with their default user agents, not one fixed ARTEX string, so this matches the tool class (Python and Go HTTP clients, curl, wget, headless browsers) plus the literal artex in case a fork leaves it in. Agents can change user agents quickly, so a miss does not clear a source. Allow-list known automation and service accounts first.

let toolUA = @"(?i)(python-requests|python-httpx|aiohttp|go-http-client|^curl/|^wget/|headlesschrome|playwright|puppeteer|axios|node-fetch|okhttp|libwww-perl|artex|norma)";
union SigninLogs, AADNonInteractiveUserSignInLogs
| where TimeGenerated > ago(7d)
| where UserAgent matches regex toolUA
| summarize Attempts = count(),
            Successes = countif(ResultType == "0"),
            Failures = countif(ResultType != "0"),
            DistinctUsers = dcount(UserPrincipalName),
            Apps = make_set(AppDisplayName, 10),
            IPs = make_set(IPAddress, 10),
            FirstSeen = min(TimeGenerated),
            LastSeen = max(TimeGenerated)
    by UserAgent, IPAddress
| where Successes > 0
| order by Successes desc

Login-style requests that succeed after failures from a scripted user agent (IIS logs)

This flags a source that was refused repeatedly and then got a success on an authentication path. A 302 after a POST is a stronger sign of a real login than a 200, because many apps return 200 when they redisplay the form after a failed attempt.

let toolUA = @"(?i)(nmap|python-requests|python-httpx|aiohttp|go-http-client|^curl/|^wget/|headlesschrome|playwright|puppeteer|nuclei|sqlmap|gobuster|ffuf|zgrab|artex|norma)";
W3CIISLog
| where TimeGenerated > ago(1d)
| where csUserAgent matches regex toolUA
| summarize Requests = count(),
            Failures = countif(tostring(scStatus) in ("401","403")),
            Redirects = countif(csMethod =~ "POST" and tostring(scStatus) == "302" and csUriStem matches regex @"(?i)(login|signin|auth|token|session|admin)"),
            Successes = countif(csMethod =~ "POST" and tostring(scStatus) in ("200","201","204") and csUriStem matches regex @"(?i)(login|signin|auth|token|session|admin)"),
            FirstSeen = min(TimeGenerated),
            LastSeen = max(TimeGenerated)
    by cIP, csUserAgent
| where Failures >= 10 and (Redirects + Successes) >= 1
| order by Failures desc

Hunt: post-exploitation, collection and exfiltration

Once inside, agents run discovery in bursts that no human types, then collect, archive and move data out.

Machine-speed discovery: many distinct recon commands in one minute

DeviceProcessEvents
| where Timestamp > ago(1d)
| where FileName in~ ("whoami","id","uname","hostname","ifconfig","ip","ipconfig.exe","net.exe","net1.exe","nslookup","cat","ls","ps","netstat","ss","arp","systeminfo","env","pwd","find")
| summarize Cmds = count(),
            DistinctTools = dcount(FileName),
            Tools = make_set(FileName, 20)
    by DeviceName, AccountName, InitiatingProcessFileName, InitiatingProcessId, bin(Timestamp, 1m)
| where DistinctTools >= 5
| order by Cmds desc

RDP logon followed by file enumeration and copy commands within an hour

let lookback = 1d;
let rdp_logons = DeviceLogonEvents
| where Timestamp > ago(lookback)
| where ActionType == "LogonSuccess" and LogonType == "RemoteInteractive"
| where isnotempty(RemoteIP) and RemoteIP !in ("127.0.0.1", "::1")
| project DeviceId, DeviceName, AccountName, RemoteIP, LogonTime = Timestamp;
let collection = DeviceProcessEvents
| where Timestamp > ago(lookback)
| where FileName in~ ("cmd.exe", "powershell.exe", "pwsh.exe", "robocopy.exe", "xcopy.exe", "findstr.exe")
| where ProcessCommandLine has_any ("robocopy", "xcopy", "copy-item", "dir /s", "get-childitem", "findstr", "-recurse")
| where ProcessCommandLine has_any ("password", "passwd", ".kdbx", ".pfx", ".pem", ".key", ".config", ".bak", ".sql", ".xlsx", ".docx", ".pdf", "confidential")
| project DeviceId, AccountName, CollectTime = Timestamp, FileName, ProcessCommandLine;
rdp_logons
| join kind=inner hint.strategy=broadcast (collection) on DeviceId, AccountName
| where CollectTime between (LogonTime .. LogonTime + 1h)
| summarize CollectionCommands = make_set(ProcessCommandLine, 10), FirstCollect = min(CollectTime), CommandCount = count() by DeviceName, AccountName, RemoteIP, LogonTime
| order by LogonTime desc

Archiving and upload staging for exfiltration

DeviceProcessEvents
| where Timestamp > ago(7d)
| where (FileName in~ ("tar","zip","7z","7za","rar","gzip") and ProcessCommandLine has_any ("/tmp/","/dev/shm/","/var/www","/home","dump","backup"))
    or (FileName in~ ("curl","wget") and ProcessCommandLine matches regex @"(?i)(--upload-file|\s-T\s|--data-binary\s+@|-F\s+\S*@)")
| project Timestamp, DeviceName, AccountName, InitiatingProcessFileName, FileName, ProcessCommandLine
| order by Timestamp desc

Hardening and response

The controls that blunt ARTEX are the ones that shrink the attack surface and slow an agent down, because it exploits misconfiguration faster than humans can fix it. The guidance below draws on CERT-EU and Microsoft.

Immediately

  • Identify internet-exposed assets and limit exposure to those that need it.
  • Keep management and control panels off the internet and untrusted networks.
  • Patch internet-exposed assets on an emergency cycle.
  • Watch privileged and administrator activity closely for anomalies.

Within weeks

  • Enforce MFA on all critical systems and services.
  • Hunt for connections to known or suspected actor infrastructure, and for ARTEX-style scanning patterns and tool signatures in your logs.
  • Use EDR to monitor and block unusual process behaviour such as privilege-escalation attempts.
  • Scan public GitHub for your organisation’s OAuth app secrets and rotate any exposed ones.

Continuously

  • Sanitise error responses from internet-facing devices to hinder fingerprinting.
  • Put a WAF or equivalent in front of exposed assets and log them well.
  • Keep low-severity findings in the remediation cycle so agents cannot chain them.
  • Extend monitoring to AI tools and internet-connected assets that use AI processes.
  • Run regular vulnerability scans and penetration tests, including trusted AI-assisted tooling.

Deception

Decoys and honeypots give an agent attractive but worthless targets, tarpits consume its time and budget, and fake wins present convincing evidence that its objective is complete so it stops. Microsoft reports that in its testing these controls reduced attack traffic reaching real assets and produced high-confidence signal. Any touch of a decoy is higher-confidence than any threshold query in this post.

If you find a hit

  • Isolate the host and preserve volatile evidence before removing persistence.
  • Rotate the credentials, OAuth secrets and Key Vault secrets the host or identity could reach.
  • Review Entra audit logs for new app credentials, consents and role assignments in the same window.
  • Assume the attacker has already pivoted: the dwell time between stages can be minutes.

Sources