ARTEX Deep Hunting: AI Agent Signals and KQL Detections – ThreatDefence
Skip to content
Security advisories/Open-source project
HighActive

ARTEX Deep Hunting: AI Agent Behavior That Is Hard to Hide

Anton Guzhevskiy
Anton Guzhevskiy · Principal Product Researcher
Published November 21, 2026

Most ARTEX intrusions seen so far ran the tool close to its defaults, but operators are already renaming it and changing user agents. Our team analyzed the ARTEX code and its behavior in a sandbox to find the AI agent traits that are hard to change.

TL;DR

Hunt for that behavior, not only for names and user agents.

At a glance
SeverityHigh
StatusActive
ExploitedYes. ARTEX has been used in real attacks since at least August 2026, by state-aligned and financially motivated groups. The FBI issued a FLASH on November 13, 2026
ProductARTEX autonomous penetration testing framework, open-source builds from July 26, 2026 onward
CVEsNone assigned
Fixed inARTEX is a tool, not a vulnerability, so there is no patch. Hunt for the agent behavior its code produces, which survives renamed builds and changed user agents

Threat actors hide what they can. When a tool gets a public name and a list of indicators, the people using it rename it, change its user agents and move its files. ARTEX is at the start of that curve. Most of the intrusions reported since August 2026 ran it close to how it was published, and they left strings that name the tool in sign-in logs, web logs and file systems. Some operators have already changed those strings, and the next ones will be more careful.

So our team analyzed the ARTEX source code and watched how it behaves in a sandbox, looking for the traits that come from how its AI agents work rather than from what they are called. We read the Go backend, the agent prompts, the skills that ship with it, the container build and the agent library it depends on, across the full history of the open-source code from the first release on July 26, 2026 to the public fork that continues it. Those traits are harder to change. The user agent the agents use to read web pages is hard-coded in a library, the TLS fingerprint stays the same under any user agent, the request rhythm is set by constants, and the host that runs ARTEX carries processes, ports and files that only it creates.

This article explains what an ARTEX operator can easily disguise, what they cannot, and how to hunt for the second kind. The example KQL hunts are also in our open-source repository, github.com/ThreatDefence/agentic-attack-detections, where they are numbered 23 to 30.

What intrusions show and what the code shows

The table compares what responders have reported from ARTEX intrusions with what the code itself does.

Reported about ARTEX What the code shows
Branded user agents such as artex-pentest/1.0, artex-readonly/1.0 and ARTEX-worker/1.0 Observed in real intrusions, published by Datadog from the AWS cases it investigated. The agents chose them at run time, so they are not in the code or its history. ARTEX-worker/1.0 exists in the code only as sample data in the console’s demo screens
Working folder C:\ProgramData\artx5v\, files named artex-probe-, accounts named ArtexProbe Observed in real intrusions that CrowdStrike and Google investigated. The agents chose these names at run time, so they are not in the code. ARTEX keeps its own working files in a task folder on its own host
An artex-enrich/1.0 enrichment user agent Not in the public code. ExtraHop saw it from a renamed build in its lab. The public enrichment probe sends Go’s default Go-http-client/1.1
norma/0.4 as a user agent seen in ARTEX activity Confirmed. It is hard-coded in the library ARTEX uses to read web pages, so every unmodified build sends it
Mozilla/5.0 (spa-api-recon) and Mozilla/5.0 (spa-api-recon spider) Confirmed. Both come from the API reconnaissance skill that ships with ARTEX
Tool names list_findings, record_fact and shell_send in model requests Confirmed, along with many more
Console on port 8787 Confirmed, with an unauthenticated recording proxy on 8788 next to it
Password spraying and OAuth application abuse No module for either. The code has no Entra ID, Microsoft Graph, Okta or Azure tooling, no Kerberos or lateral movement module and no persistence step. Those attacks are the operator’s choices, carried out with the tools in the image

None of this makes those indicators wrong. They were all observed in real intrusions, and they remain worth hunting. The reports explain why the code lacks them: Wiz saw a new user agent for every password spray burst, and Eye Security found the agents labeling their own web shells and test data with markers such as X-ARTX-KEY and ARTEX_WRITE_PROBE. The model writes its own requests and files and often names them after the tool, so the names describe particular runs and will not carry over to the next one. The signals below come from the code and from how the agents behave.

How ARTEX behaves on the network

ARTEX has no implant and no beacon. A planner agent decides what to try, and a pool of worker agents, three by default, run the tools from the ARTEX host. Idle workers poll the local database, busy workers renew their claim on a task every 15 seconds, and the console pings the operator’s browser every 20 seconds. None of that reaches a target. If you are looking for a regular callback, there isn’t one.

What a target sees is the work itself. Inside one worker, tool calls run one at a time, so the traffic arrives as up to three interleaved streams from one address, each a command, a pause while the model thinks, then the next command. Each task step runs for up to 20 minutes, and when the budget or deadline runs out the shell tool is taken away and every stream stops at once. A technique is usually tried about three times before the planner is told to move to a different surface. That rhythm of short bursts, long gaps, a few retries and a sudden stop fits what responders described inside networks, and it comes straight from constants in the code.

When the agents meet a captcha, an email code or an MFA prompt, they hand it to a person through a dedicated tool and wait. In sign-in logs that reads as a challenge, a silence of a few minutes, then a success from the same address. Approval gates add pauses of up to five minutes when the operator has turned them on.

Signals your web servers and identity logs can see

These reach the target, so they show in web server, WAF, proxy and sign-in logs. “Hard to remove” means the operator would have to change the code and rebuild.

Signal What it looks like How hard to remove
Page reads by the WebFetch tool GET only, user agent norma/0.4, a 30 second timeout, and never a request for .js, .css, images or fonts, because the tool refuses them. A source that reads pages but never loads their assets Hard. The ARTEX setting for a custom target user agent does not replace it
A direct retry After a proxy error, WebFetch requests the same URL once more without the proxy Hard
The enrichment probe One GET to each site the agents record, with Go-http-client/1.1, Connection: close, redirects not followed and certificate checks off, at most once every 5 minutes per site Easy under a noise profile, which can set a user agent on it
API reconnaissance scripts Mozilla/5.0 (spa-api-recon) reading JavaScript bundles and route lists, Mozilla/5.0 (spa-api-recon spider) crawling pages and forms Moderate. The skill files can be edited on disk
A Go TLS fingerprint under every user agent With traffic recording on, every tool’s connection goes through the ARTEX recording proxy, which opens a new TLS connection to the target from Go. curl, sqlmap, nuclei and headless Chromium all present Go’s JA3 and JA4 fingerprint, with no GREASE and no session resumption, whatever their user agent says Hard. Only turning recording off removes it, and if interception fails for a host, the tool’s own fingerprint leaks for a minute, so one source shows mixed fingerprints
Rewritten HTTP/1.1 headers Header names are canonicalized and sent as Host, User-Agent, Content-Length, then the rest in alphabetical order Hard
The pinned toolchain sqlmap 1.9.9, ffuf 2.3.0, nuclei 3.11.1, httpx 1.12.0, katana 1.8.0, dalfox 3.2.4, bbot 3.0.2, nmap, Playwright 1.64.1 with headless Chromium, and Debian bookworm’s curl/7.88.1 and Wget/1.21.3 Easy per tool, but the set from one address stays recognizable
Fixed pacing With a noise profile on, requests to each host are spaced at 500 to 750 ms (quiet, 2 a second), 200 to 240 ms (balanced, 5 a second) or 50 to 55 ms (aggressive, 20 a second). The agents also get matching flags, such as nmap -T2 --max-rate 2 --max-retries 2 and sqlmap --delay=0.5 --threads=1 Moderate. The profile is off by default, and the rates are code constants
Back-off on 429 and 503 The whole host is paused for the time in Retry-After. Only GET, HEAD and OPTIONS without a body are retried Moderate
No deletes Built-in safety rules block HTTP DELETE and paths such as /delete, /remove, /purge and /reset-all, so an ARTEX source creates accounts and objects but rarely removes them Easy. The rules can be deleted in the console
Self-registered accounts Workers test on accounts they create themselves first, with strong unique passwords, and pass the credentials to the next worker Moderate. This lives in the prompts
Headless browser sign-ins Logins to web applications and identity providers go through the bundled Playwright browser, whose user agent says HeadlessChrome unless the operator overrides it Easy
Bracketed paste in raw shells Multi-line input sent to an interactive shell is wrapped in the terminal codes ESC[200~ and ESC[201~. A raw reverse shell receives them as text and prints errors for both Hard

ARTEX also refuses some targets by default: .gov, .gov.cn, .edu and .edu.cn names are on a seeded blocklist that the operator can remove.

Signals when ARTEX runs on one of your hosts

If ARTEX runs inside your network, whether by an authorized tester you did not know about, an insider or an intruder who staged it there, the host gives it away clearly.

Signal What it looks like
Agent shells The agents’ bash is a symbolic link to the artex binary in a temporary folder named artex-exec-, running as user and group ID 10001, with ARTEX_EXEC_BASH, ARTEX_EXEC_UID, ARTEX_EXEC_GID and ARTEX_EXEC_HOME in its environment
Tool servers Helper servers start as artex __artex-exec-drop <uid> <gid> -- <command>
Proxy credential Every agent shell carries HTTP_PROXY=http://artex-pace:artex-pace@127.0.0.1:8788
Listening ports The console on 8787 and an unauthenticated recording proxy on 8788. Both bind to loopback by default and to every interface in the Docker image. A direct request to the proxy returns 400 with a Chinese-language error saying it is a proxy server
Direct DNS Every new domain the agents record is resolved by sending UDP port 53 straight to 1.1.1.1, 1.0.0.1, 8.8.8.8, 8.8.4.4, 9.9.9.9, 149.112.112.112, 208.67.222.222 and 208.67.220.220, bypassing your own resolvers
Recording CA A certificate authority named CN=mitmproxy, O=mitmproxy under the data folder, and every certificate it issues reuses the CA’s own public key
Skill scripts harvest_static.py, spider_mpa.py, runtime_harvest.js, and bbot runs with -o bbot-output
Update check When turned on, a daily GET https://api.github.com/repos/BaaRai/ARTEX/releases/latest with the user agent artex-update-check
Alerts to chat Finding alerts go straight to DingTalk, Feishu, WeCom, Telegram, a webhook or email, never through the proxy, so they show the host’s real address
Archives Task archives can be uploaded to S3 under artex/tasks/task-
Browser extension Testers capture authenticated sessions with an extension named ARTEX Traffic Capture, which posts to /api/traffic/ingest on the console

An exposed console is easy to recognize from a scan. Its page title is ARTEX followed by an em dash and Autonomous Penetration Testing Console, /api/health answers {"ok":true} without a token, the sign-in username is always ARTEX, API responses allow any origin and carry no Server header, and every unknown path returns the application page with a 200 status. The favicon hash is -576220750, and /icon.png hashes to -1898746557.

Signals in AI model traffic

ARTEX calls whichever model provider the operator chooses. Where outbound model traffic is inspected, through an AI gateway, a TLS-inspecting proxy or a data loss prevention tool, its requests carry fixed strings the console cannot edit away:

  • Tool function names such as record_fact, insert_assets, save_task_credential, search_all_worker_traces, graph_overview, add_intent, prove_goal and steer_work, next to the shell_open and shell_send interactive shell tools.
  • A data envelope written as [[ARTEX_DATA nonce= followed by 32 hex characters, and the replacement string artex-data-marker-removed.
  • Tool output framed as <<<UNTRUSTED_OUTPUT with a nonce, and system prompt headings such as Untrusted data rule (code-owned):.
  • Target account passwords in clear text in the first message to each worker.

The model calls themselves use Go’s default user agent unless the operator sets one, and carry no SDK headers.

Free SOC trial

Want this watched across your environment without building the hunts yourself? Our 24x7 SOC monitors your endpoints, servers and cloud during a free trial.

Start a free trial

How to hunt with the source code signals

The KQL below is example code for Microsoft Sentinel and Defender XDR advanced hunting. Adapt table and field names to your environment and test each query before relying on it. The web hunts read CommonSecurityLog and W3CIISLog. If your WAF, proxy or web server logs land in another table, swap it in with its source address, host, method, URL and user agent columns.

Run the hunts that need only web and sign-in logs first: hunts 1, 2 and 4 apply to any internet-facing application, and hunt 3 finds operators who turned on a noise profile to stay quiet. Hunts 6 and 7 look inside your own network. Hunt 8 is a weak signal on its own and works best as context for a host you already suspect.

Hunt 1: norma page reads and the enrichment probe that follows

A source that reads pages as norma/0.4 and never loads a static asset is behaving like the ARTEX page reader. A single Go GET to the same host from the same address within half an hour is the enrichment probe, and the two together are the strongest web signal on this page.

// Example: norma page reads with no static assets, and a Go probe from the same address
let Window = 14d;
let StaticExt = dynamic([".js", ".mjs", ".css", ".map", ".png", ".jpg", ".jpeg", ".gif", ".svg", ".webp", ".ico",
    ".woff", ".woff2", ".ttf", ".otf", ".eot", ".wasm", ".mp4", ".webm", ".mp3"]);
let Web = union isfuzzy=true
    (CommonSecurityLog
        | where TimeGenerated > ago(Window) and isnotempty(RequestClientApplication)
        | project TimeGenerated, Src=SourceIP, Host=DestinationHostName, Method=RequestMethod,
            Url=RequestURL, UA=RequestClientApplication),
    (W3CIISLog
        | where TimeGenerated > ago(Window)
        | project TimeGenerated, Src=cIP, Host=csHost, Method=csMethod, Url=csUriStem, UA=csUserAgent)
    | extend UA = replace_string(UA, "+", " ")
    | extend Path = tolower(tostring(split(Url, "?")[0]));
let Norma = Web
    | where UA == "norma/0.4"
    | summarize NormaRequests=count(), NormaPaths=dcount(Path), Methods=make_set(Method, 5),
        StaticHits=countif(Path has_any (StaticExt)), SamplePaths=make_set(Path, 15),
        NormaFirst=min(TimeGenerated), NormaLast=max(TimeGenerated) by Src, Host;
let Enrich = Web
    | where UA == "Go-http-client/1.1" and Method == "GET"
    | summarize EnrichProbes=count(), EnrichPaths=make_set(Path, 5), EnrichFirst=min(TimeGenerated) by Src, Host;
Norma
| join kind=leftouter Enrich on Src, Host
| extend EnrichNearNorma = isnotempty(EnrichFirst) and abs(datetime_diff('minute', EnrichFirst, NormaFirst)) <= 30
| where StaticHits == 0 and Methods has "GET" and array_length(Methods) == 1
| extend Strength = iff(EnrichNearNorma, "norma page reads plus a Go enrichment probe", "norma page reads only")
| project Src, Host, Strength, EnrichNearNorma, NormaRequests, NormaPaths, SamplePaths, NormaFirst, NormaLast, EnrichProbes, EnrichPaths, EnrichFirst
| order by EnrichNearNorma desc, NormaRequests desc

Hunt 2: the ARTEX container toolchain from one source

Many attack tools from one address in a minute is a known sign of agent frameworks. This hunt narrows it to the specific clients and versions in the ARTEX image. Three or more of them from one address in an hour is a strong lead, and the ARTEX-specific clients rank first.

// Example: three or more ARTEX image clients from one public address in an hour
let Window = 14d;
let Clients = (ua:string) { case(
    ua == "norma/0.4", "norma WebFetch",
    ua == "Go-http-client/1.1", "Go enrichment probe",
    ua has "spa-api-recon", "api-recon skill",
    ua startswith "sqlmap/1.9", "sqlmap 1.9",
    ua has "Fuzz Faster U Fool", "ffuf",
    ua has "Nmap Scripting Engine", "nmap NSE",
    ua has "HeadlessChrome", "headless Chromium",
    ua == "curl/7.88.1", "bookworm curl",
    ua == "Wget/1.21.3", "bookworm wget",
    ua startswith "python-requests/" or ua startswith "Python-urllib/3.12", "Python 3.12 clients",
    "") };
union isfuzzy=true
    (CommonSecurityLog | where TimeGenerated > ago(Window) and isnotempty(RequestClientApplication)
        | project TimeGenerated, Src=SourceIP, Host=DestinationHostName, UA=RequestClientApplication),
    (W3CIISLog | where TimeGenerated > ago(Window)
        | project TimeGenerated, Src=cIP, Host=csHost, UA=replace_string(csUserAgent, "+", " "))
| where not(ipv4_is_private(Src)) and Src != "127.0.0.1"
| extend Client = Clients(UA)
| where isnotempty(Client)
| summarize Requests=count(), Clients=dcount(Client), ClientList=make_set(Client), Hosts=make_set(Host, 10),
    SampleUAs=make_set(UA, 10) by Src, bin(TimeGenerated, 1h)
| where Clients >= 3
| extend Specific = set_intersect(ClientList, dynamic(["norma WebFetch", "api-recon skill", "Go enrichment probe"]))
| summarize Hours=count(), TotalRequests=sum(Requests), MaxClients=max(Clients), ClientList=make_set(ClientList),
    Specific=make_set(Specific), Hosts=make_set(Hosts, 20), SampleUAs=make_set(SampleUAs, 20),
    FirstSeen=min(TimeGenerated), LastSeen=max(TimeGenerated) by Src
| order by array_length(Specific) desc, MaxClients desc, TotalRequests desc

Hunt 3: request rates that match the ARTEX noise profiles

Web logs usually keep whole seconds, so this counts requests per second. A source busy in at least 80% of a ten-minute window at an almost fixed 2, 5 or 20 requests a second is pacing itself the way the noise profiles do. Exclude your own monitoring and uptime checks.

// Example: one source and host at a fixed 2, 5 or 20 requests a second for ten minutes or more
let Window = 7d;
let Web = union isfuzzy=true
    (CommonSecurityLog | where TimeGenerated > ago(Window) and isnotempty(RequestURL)
        | project TimeGenerated, Src=SourceIP, Host=DestinationHostName, UA=RequestClientApplication),
    (W3CIISLog | where TimeGenerated > ago(Window)
        | project TimeGenerated, Src=cIP, Host=csHost, UA=csUserAgent);
Web
| summarize PerSecond=count(), UAs=make_set(UA, 5) by Src, Host, Second=bin(TimeGenerated, 1s)
| summarize ActiveSeconds=count(), Requests=sum(PerSecond), MeanRps=avg(PerSecond), StdevRps=stdev(PerSecond),
    MaxRps=max(PerSecond), UAs=make_set(UAs, 10) by Src, Host, Window10m=bin(Second, 10m)
| where ActiveSeconds >= 480 and StdevRps <= 0.8
| extend Profile = case(
    MeanRps between (1.2 .. 2.1) and MaxRps <= 4, "quiet (2/s)",
    MeanRps between (4.0 .. 5.2) and MaxRps <= 10, "balanced (5/s)",
    MeanRps between (17.0 .. 20.5) and MaxRps <= 40, "aggressive (20/s)",
    "")
| where isnotempty(Profile)
| summarize Windows=count(), Requests=sum(Requests), Profiles=make_set(Profile), UAs=make_set(UAs, 10),
    FirstSeen=min(Window10m), LastSeen=max(Window10m) by Src, Host
| where Windows >= 2
| order by Windows desc

Hunt 4: headless browsers and scripted clients signing in, and the MFA relay pause

The first part lists sign-in attempts from headless and scripted clients. The second finds an MFA interrupt from such a client followed by a success from the same user and address one to fifteen minutes later, the pause while a person types the code for the agent.

// Example: headless or scripted sign-ins, and MFA completed after a pause
let Window = 14d;
let AgentClient = (ua:string) { ua has "HeadlessChrome" or ua == "norma/0.4" or ua has "spa-api-recon"
    or ua startswith "Go-http-client/" or ua startswith "python-requests/" or ua startswith "curl/" };
let SignIns = union isfuzzy=true SigninLogs, AADNonInteractiveUserSignInLogs
    | where TimeGenerated > ago(Window)
    | project TimeGenerated, UserPrincipalName, IPAddress, UserAgent, ResultType=tostring(ResultType), AppDisplayName;
let Clients = SignIns
    | where AgentClient(UserAgent)
    | summarize Attempts=count(), Successes=countif(ResultType == "0"), Results=make_set(ResultType, 10),
        Apps=make_set(AppDisplayName, 10), FirstSeen=min(TimeGenerated), LastSeen=max(TimeGenerated)
        by UserPrincipalName, IPAddress, UserAgent
    | extend Signal = "headless or scripted client";
let Interrupts = SignIns
    | where ResultType in ("50074", "50076", "50079", "500121") and AgentClient(UserAgent)
    | project InterruptTime=TimeGenerated, UserPrincipalName, IPAddress, InterruptUA=UserAgent;
let Relay = Interrupts
    | join kind=inner (SignIns | where ResultType == "0" | project SuccessTime=TimeGenerated, UserPrincipalName, IPAddress,
        SuccessApp=AppDisplayName) on UserPrincipalName, IPAddress
    | extend PauseMin = datetime_diff('minute', SuccessTime, InterruptTime)
    | where PauseMin between (1 .. 15)
    | summarize Attempts=count(), Successes=dcount(SuccessTime), Results=make_set(strcat("pause ", PauseMin, " min"), 10),
        Apps=make_set(SuccessApp, 10), FirstSeen=min(InterruptTime), LastSeen=max(SuccessTime)
        by UserPrincipalName, IPAddress, UserAgent=InterruptUA
    | extend Signal = "MFA relayed after a pause";
union Clients, Relay
| summarize Signals=make_set(Signal), Attempts=sum(Attempts), Successes=sum(Successes), Results=make_set(Results, 20),
    Apps=make_set(Apps, 20), FirstSeen=min(FirstSeen), LastSeen=max(LastSeen) by UserPrincipalName, IPAddress, UserAgent
| order by array_length(Signals) desc, Successes desc

Hunt 5: accounts registered by a source that is also probing the application

Adjust the registration paths to your applications. The count of DELETE requests is shown as a hint: an ARTEX source with its default safety rules rarely deletes anything.

// Example: several sign-ups in a day from an address reading many paths
let Window = 14d;
let RegisterPath = @"(?i)/(register|registration|signup|sign-up|sign_up|join|users/new|account/create|auth/register|api/users)(?:[/?]|$)";
let Web = union isfuzzy=true
    (CommonSecurityLog | where TimeGenerated > ago(Window) and isnotempty(RequestURL)
        | project TimeGenerated, Src=SourceIP, Host=DestinationHostName, Method=RequestMethod, Url=RequestURL,
            UA=RequestClientApplication),
    (W3CIISLog | where TimeGenerated > ago(Window)
        | project TimeGenerated, Src=cIP, Host=csHost, Method=csMethod, Url=csUriStem, UA=replace_string(csUserAgent, "+", " "));
Web
| summarize Requests=count(), Paths=dcount(tostring(split(Url, "?")[0])),
    Registrations=countif(Method == "POST" and Url matches regex RegisterPath),
    Deletes=countif(Method == "DELETE"),
    AgentUA=countif(UA == "norma/0.4" or UA has "spa-api-recon" or UA has "HeadlessChrome" or UA == "Go-http-client/1.1"),
    UAs=make_set(UA, 10), FirstSeen=min(TimeGenerated), LastSeen=max(TimeGenerated)
    by Src, Host, Day=bin(TimeGenerated, 1d)
| where Registrations >= 2 and Paths >= 50
| extend Strength = iff(AgentUA > 0, "sign-ups plus ARTEX client user agents", "sign-ups during probing")
| project Day, Src, Host, Strength, Registrations, Paths, Requests, Deletes, AgentUA, UAs, FirstSeen, LastSeen
| order by AgentUA desc, Registrations desc

Hunt 6: ARTEX running on a host you monitor

The query combines endpoint process and network events, the browser extension inventory and CloudTrail. Defender XDR and Sentinel tables are mixed, and isfuzzy skips the ones you do not have.

// Example: ARTEX shell shims, ports, resolver fan-out, extension and S3 archives
let Window = 30d;
let PublicResolvers = dynamic(["1.1.1.1", "1.0.0.1", "8.8.8.8", "8.8.4.4", "9.9.9.9", "149.112.112.112",
    "208.67.222.222", "208.67.220.220"]);
let NoiseFlags = @"--max-rate 2 --max-retries 2|-rate-limit 2 -c 1|-rl 2 -[tc] 1|-rate 2 -t 1|--rate-limit 2 --workers 1|--delay=0\.(5|2|05)\b";
union isfuzzy=true
    (DeviceProcessEvents
        | where Timestamp > ago(Window)
        | where FolderPath contains "/artex-exec-" or InitiatingProcessFolderPath contains "/artex-exec-"
            or ProcessCommandLine matches regex @"__artex-exec-drop|artex-pace:artex-pace|harvest_static\.py|spider_mpa\.py|runtime_harvest\.js|-o bbot-output"
            or (ProcessCommandLine matches regex NoiseFlags and FileName in~ ("nmap", "nuclei", "httpx", "katana", "ffuf", "dalfox", "python3", "sqlmap"))
            or (InitiatingProcessFileName =~ "artex" and FileName in~ ("bash", "sh", "nuclei", "httpx", "katana", "ffuf", "nmap", "node"))
        | project Timestamp, DeviceName, Signal="process", Process=FileName, Path=FolderPath, Account=AccountName,
            CommandLine=ProcessCommandLine, Detail=InitiatingProcessCommandLine),
    (DeviceNetworkEvents
        | where Timestamp > ago(Window)
        | where ActionType == "ListeningConnectionCreated" and LocalPort in (8787, 8788)
            and (InitiatingProcessFileName =~ "artex" or InitiatingProcessFolderPath endswith "/artex")
        | project Timestamp, DeviceName, Signal="console or recording proxy listening", Process=InitiatingProcessFileName,
            Path=InitiatingProcessFolderPath, Account=InitiatingProcessAccountName, CommandLine=InitiatingProcessCommandLine,
            Detail=strcat("port ", LocalPort)),
    (DeviceNetworkEvents
        | where Timestamp > ago(Window)
        | where RemotePort == 53 and RemoteIP in (PublicResolvers)
        | summarize Resolvers=dcount(RemoteIP), Queries=count(), FirstQuery=min(Timestamp),
            Process=take_any(InitiatingProcessFileName), Path=take_any(InitiatingProcessFolderPath)
            by DeviceName, Hour=bin(Timestamp, 1h)
        // dnsx spreads queries across the whole list; a normal forwarder uses one or two
        | where Resolvers >= 5
        | project Timestamp=FirstQuery, DeviceName, Signal="direct DNS to the dnsx resolver list", Process, Path, Account="",
            CommandLine="", Detail=strcat(Resolvers, " resolvers, ", Queries, " queries")),
    (DeviceTvmBrowserExtensions
        | where ExtensionName =~ "ARTEX Traffic Capture"
        | project Timestamp=now(), DeviceName=DeviceId, Signal="ARTEX capture extension installed", Process=BrowserName,
            Path=ExtensionId, Account="", CommandLine="", Detail=tostring(ExtensionRisk)),
    (AWSCloudTrail
        | where TimeGenerated > ago(Window)
        | where EventName in ("PutObject", "CreateMultipartUpload", "CompleteMultipartUpload")
        | where tostring(parse_json(RequestParameters).key) startswith "artex/tasks/task-"
        | project Timestamp=TimeGenerated, DeviceName=SourceIpAddress, Signal="ARTEX task archive written to S3",
            Process=UserAgent, Path=tostring(parse_json(RequestParameters).bucketName), Account=UserIdentityArn,
            CommandLine="", Detail=tostring(parse_json(RequestParameters).key))
| order by Timestamp desc

Hunt 7: ARTEX console and side traffic in outbound proxy logs

This needs a TLS-inspecting proxy that records full URLs. It finds people on your network driving a remote ARTEX console, the browser extension posting captured traffic, the update check and the Keenable search backend, and brings in chat alert traffic from the same source as context.

// Example: console sign-ins, capture uploads and the update check in proxy logs
let Window = 30d;
let NotifyHosts = dynamic(["oapi.dingtalk.com", "open.feishu.cn", "open.larksuite.com", "qyapi.weixin.qq.com", "api.telegram.org"]);
CommonSecurityLog
| where TimeGenerated > ago(Window) and isnotempty(RequestURL)
| extend Signal = case(
    RequestClientApplication == "artex-update-check" or RequestURL has "/repos/BaaRai/ARTEX/releases", "ARTEX update check",
    RequestURL has "/api/traffic/ingest", "capture extension posting to a console",
    RequestURL has_any ("/api/auth/status", "/api/auth/login", "/api/ready") and (DestinationPort == 8787 or RequestURL contains ":8787/"),
        "console sign-in on port 8787",
    (DestinationPort == 8787 or RequestURL contains ":8787/") and RequestURL contains "token=ey", "console session token in a URL",
    RequestURL has "api.keenable.ai", "Keenable search backend",
    "")
| where isnotempty(Signal)
| summarize Requests=count(), Signals=make_set(Signal), Destinations=make_set(DestinationHostName, 10),
    SampleURLs=make_set(RequestURL, 10), UAs=make_set(RequestClientApplication, 5),
    FirstSeen=min(TimeGenerated), LastSeen=max(TimeGenerated) by SourceIP, SourceUserName
| join kind=leftouter (CommonSecurityLog
    | where TimeGenerated > ago(Window) and DestinationHostName in (NotifyHosts)
    | summarize NotifyRequests=count(), NotifyDestinations=make_set(DestinationHostName) by SourceIP) on SourceIP
| project-away SourceIP1
| order by array_length(Signals) desc, Requests desc

Hunt 8: bracketed-paste bytes in shell input

Where shell input, TTY audit records or command errors reach your logs, look for the terminal paste codes. The 1b5b3230307e value is how auditd writes the same bytes in hex.

// Example: terminal paste codes in Syslog and endpoint events
let Window = 30d;
union isfuzzy=true
    (Syslog
        | where TimeGenerated > ago(Window)
        | where SyslogMessage contains "[200~" or SyslogMessage contains "[201~" or SyslogMessage contains "1b5b3230307e"
        | project TimeGenerated, Computer, Source="Syslog", Process=ProcessName, Detail=SyslogMessage),
    (DeviceProcessEvents
        | where Timestamp > ago(Window)
        | where ProcessCommandLine contains "[200~" or ProcessCommandLine contains "[201~"
        | project TimeGenerated=Timestamp, Computer=DeviceName, Source="DeviceProcessEvents", Process=FileName,
            Detail=strcat(InitiatingProcessFileName, " > ", ProcessCommandLine)),
    (DeviceEvents
        | where Timestamp > ago(Window)
        | where tostring(AdditionalFields) contains "[200~" or ProcessCommandLine contains "[200~"
        | project TimeGenerated=Timestamp, Computer=DeviceName, Source="DeviceEvents", Process=FileName,
            Detail=strcat(ActionType, " ", ProcessCommandLine))
| order by TimeGenerated desc

Which signals survive a modified build

Every signal on this page can be removed by someone willing to change the code, but the effort differs a lot. A user agent in a scanner flag or a prompt changes in seconds, and the campaign indicators show that operators do change them. The norma/0.4 page reads, the Go TLS fingerprint, the agent shell shim, the proxy credential and the resolver list each need a code change and a rebuild, and most operators run what they downloaded. The renamed builds in circulation kept the same platform underneath, so expect the code-level signals to carry over to them even when the names change.

The strongest combinations put signals of different kinds together. A source that reads pages as norma/0.4, sends a Go probe minutes later and presents a Go TLS fingerprint under a curl user agent is very hard to explain as anything other than an agent framework. A host with a bash process inside an artex-exec- folder needs no second signal at all.

Detection rules to keep

  • Web requests with the user agent norma/0.4 that never fetch a static asset.
  • A Go client sending a single GET with Connection: close to a site minutes after another client from the same address read it.
  • Three or more of the ARTEX image’s tools seen from one address in an hour.
  • One address hitting one host every second for ten minutes at 2, 5 or 20 requests a second.
  • An MFA challenge from a headless or scripted client followed by a success from the same address a few minutes later.
  • Several new accounts registered in a day by an address that is also reading dozens of paths.
  • Any process inside an artex-exec- folder, any command line containing __artex-exec-drop or artex-pace:artex-pace, and anything listening on 8788 that belongs to an artex binary.
  • A host sending DNS queries to five or more public resolvers in an hour.
  • A TLS client fingerprint that does not match the user agent, where your sensors record JA3 or JA4.

Frequently Asked Questions

Does an unmodified ARTEX send the artex-pentest user agent?

No. The open-source code never sends artex-pentest/1.0 or any of the other branded user agents. Its page reader sends norma/0.4, its enrichment probe and model calls send Go’s default, and its scanners send their own defaults. The branded strings were observed in real intrusions, chosen at run time by the agents in those cases, and they are the first thing a careful operator changes.

Is norma/0.4 enough to call something ARTEX?

No. norma is an agent library that other tools also use, so norma/0.4 alone is a lead. Combined with no static asset requests, a Go enrichment probe from the same address or a Go TLS fingerprint, it becomes a strong one.

Does ARTEX beacon to its targets?

No. Nothing in the code reaches a target on a timer. The regular traffic in ARTEX stays between its own components and the operator’s browser. On the target side, look for bursts of commands separated by the model’s thinking time, rather than for a fixed interval.

Can TLS fingerprinting detect ARTEX?

Yes, when traffic recording is on, which is how ARTEX captures the evidence for its findings. Its proxy opens every target connection from Go, so a request that claims to be curl, sqlmap or Chrome arrives with Go’s fingerprint. You need a sensor or load balancer that records JA3 or JA4 to see it.

Should we block ports 8787 and 8788?

Yes, at the perimeter, where nothing legitimate should need them. Blocking does not stop an operator who moves the console behind port 443, so also hunt for the processes and files ARTEX leaves on a host, which do not depend on the port.

Does the code include password spraying?

No. There is no spraying, brute force or OAuth abuse module, and the built-in safety judge only lists spraying as a technique an authorized test may use. Sprays seen in ARTEX campaigns were run by operators through the shell tools, so hunt for them by their timing, such as failed sign-ins for many users at a steady one-second rhythm, rather than for an ARTEX string.

How ThreatDefence is responding

We have added the source code signals on this page to the detection content we run for clients. Across all monitored environments, our SOC is:

  • looking for norma/0.4 page reads and the Go enrichment probe on internet-facing applications
  • checking sign-ins from headless browsers and scripted clients for the MFA relay pattern
  • watching endpoints for the ARTEX shell shim, the recording proxy credential and the direct resolver fan-out, in case ARTEX is run from inside a client network

If you would like help checking whether an ARTEX console has been run from your network, or whether your applications have been read by one, contact us. Read more about our threat hunting service and 24x7 SOC.

Need help checking your environment for this issue? Talk to the ThreatDefence SOC.Talk to Our SOC

Talk to Our SOC

Questions about this advisory or help checking your environment.

    I'm an MSP, MSSP, or reseller

    By submitting this form, you accept the terms in our privacy policy.