Artificial Intelligence 12 min read

ARTEX: the AI hacking tool behind government takedowns

The FBI named an AI hacking framework. Government sites went offline. We cannot prove the link, but we can show what the traffic looks like in our logs.

Terminal screenshot of a live security drill showing the sequence of commands to verify an automated fail2ban ban on a specific IP, followed by a view of a manually curated blocklist of malicious CIDR ranges.
Photo: Dallum Brown

On the morning of Friday, 20 November 2026, the New Zealand Defence Force was told by its website provider that someone had unauthorised access to its website systems. By Friday evening the sites were gone from the internet, a forensic investigation was underway, and the Privacy Commissioner had been notified. The database that had been reached belonged to Force4Families, the Defence Discounts scheme: names and email addresses of registered users.

That same week, on 13 November, the FBI published a FLASH advisory about a piece of open-source software called ARTEX. It is worth reading both items together, carefully, because the temptation to connect them is strong and the connection is not yet evidence.

What ARTEX actually is

ARTEX describes itself as autonomous penetration testing that keeps its receipts. It is a self-hosted, LLM-driven — large language model, the thing doing the reasoning — multi-agent offensive security platform, written in Go, licensed AGPL-3.0 at 13.4k stars and 5.3k forks. The upstream project is Chinese (Autumn-27/ARTEX); the English translation most people are cloning is BaaRai/ARTEX.

The architecture is the interesting part. A planner takes a goal written in plain language and splits it into intents. Worker agents execute those intents using real tools, not simulated ones: nmap, nuclei, httpx, katana, ffuf, dalfox ship in the image alongside it. Every autonomous action is supposed to pass through scope rules, approval gates and budgets.

It also has an egress governor with a "noise profile" you can set to off, quiet, balanced or aggressive — a throttle that tells the agents to test one host at a time, back off between requests, and adjust the rate and delay flags of the scanners it drives. That is the feature that should worry you most, and it has nothing to do with how clever the model is. It is a pacing control: a way to stay under threshold-based web application firewalls and rate limiters by copying the slow, irregular rhythm of a person, with the tireless consistency of a machine.

What the FBI says, and what it does not

The advisory is specific. Actors have been using ARTEX since at least August against financial services, government, technology, defence, semiconductors, energy, healthcare, manufacturing, telecommunications and legal targets. Some intrusions reached privileged access in under three hours. Three hours is not enough time to wake up, read an advisory and patch. It is barely enough time to notice. Two worked examples are attached: campaigns against South Korean financial institutions that exposed personal information belonging to roughly 67,000 people, and a supply chain compromise touching ConnectWise Cloud Backup customers that enabled access to more than 2,250 downstream tenants.

Read that list again and note what it is. Not a tool for finding one bug in one site. A framework for running an intrusion end to end, from reconnaissance to exfiltration, with minimal human input beyond the opening instruction.

The NZDF part is speculation, and we should say so out loud

Here is where we have to be careful, because the tidy version of this story is not the supported one.

No public reporting connects the Defence Force incident to ARTEX. The RNZ account names no tool, no actor and no vector beyond the fact that the notification came from a website provider. A website host being compromised is a third-party reach — the same shape as the ConnectWise case in the advisory, but shape is not attribution, and two things that look alike in a summary can be entirely unrelated underneath.

What can be said honestly: the sector list in the FBI advisory includes government and defence, the timing overlaps, and the pattern — public-facing website, third-party provider, database behind it — is consistent with autonomous tooling doing reconnaissance and initial access while a human decides what to take. That is a plausible hypothesis. It is not a finding, and anyone publishing it as one is doing the reader a disservice.

What it looks like in our logs

We cannot see inside any of those intrusions, so we cannot say what tool was used or by whom. What we can see is the background radiation: what this class of tooling looks like when it hits a site small enough to log every connection. We run a small Laravel site for a handful of readers, and we have been keeping our own receipts. In the last week alone:

  • 27,524 packets dropped at the firewall by the /24 blocklist, across 1.6 MB — the cumulative figure before this morning's restart.
  • 1,891 packets dropped in the first forty minutes since, on a counter that starts again whenever the blocklist is reloaded. That is a personal blog with eight regular readers absorbing roughly one dropped packet a second.
  • 8 distinct IP addresses in our web logs from a single French hosting range, probing /.env, /?pp=phpinfo and /login — 2,357 requests answered 403 and 1,748 answered 404. That range is now blackholed.
  • 193 failed SSH logins a day, up 36% in a week, against a current OpenSSH build with nothing pending. That is a scan wave looking for unpatched hosts, and it costs us a counter.
  • ~361 requests a day of real readership, which is the number that matters. The noise is an order of magnitude larger than the audience, and every defensive decision has to avoid confusing the two.

None of that traffic is proof of ARTEX. It is proof of what the floor looks like now: automated reconnaissance is cheap enough that a personal site with eight readers gets the same treatment as a bank, and the tooling paces itself so the volume never trips a naive threshold.

Sources

The lockout trap: how attackers turn your defences into an off switch

There is a detail in ARTEX's README that deserves more attention than it gets, because it is an attacker explaining which defence breaks you.

The project's own documentation notes that a lockout-style defence lets an attacker deny service to everyone by failing the right number of logins: ten failures and the admin is locked out along with the rest of the world, for up to fifteen minutes. An account-lockout rule is not a defence against credential stuffing. It is a remote off switch for your login page, and the tool knows it.

The alternative is to count failures per source, not per account, and to let the account keep working. That is the design we run: fail enough times from one address and that address is blocked, while the account and the site carry on. The cost is that you must be certain your failure signal is honest, which brings us to the thing that bit us this week.

Our monitoring lied to us, and we had to fix it properly

For months our fail2ban jail inferred authentication failure from HTTP status. It counted a 302 on POST /login and on POST /two-factor-challenge, on the theory that a redirect back meant "rejected".

Fortify — the Laravel package that handles our logins — returns a redirect on success too. Both the success path and the failure path answer 302. So the jail was not counting attacks; it was counting our own sign-ins. On 19 November it banned the site owner's IP twice from his own connection, once after a single mistyped two-factor code.

Worse, a rejected code left no record at all in the application. Password failures were logged; the second factor was a hole. The security tooling was watching a log that could not express the thing it was watching for.

The fix was not a better regex. It was moving the signal to where the truth exists. The application now records authentication failures itself — a row in the activity log for the audit trail, and one line per real failure in a dedicated log file that the jail reads. Success and failure are no longer inferred from a status code, because the code that knows writes it down.

Then we tested it properly, by attacking ourselves. Three failed logins from a reserved, unroutable address:

09:31:07  failed_login   203.0.113.7
09:31:09  failed_login   203.0.113.7
09:31:10  failed_login   203.0.113.7
09:31:10  [cloudherder-auth] Ban 203.0.113.7

chain f2b-cloudherder-auth {
    ip saddr 203.0.113.7 counter packets 0 bytes 0 reject
}

Three real failures, one ban, applied at the third. A clean sign-in counts zero. A fumbled code counts once. The old filter counted both as three, and could not tell you which was which.

The configuration, with the traps left in

Here is what we actually run. Addresses, paths and ranges are placeholders; the directives, the thresholds and the regex are as deployed.

The filter reads the application's verdict, not the web server's opinion:

# /etc/fail2ban/filter.d/cloudherder-auth.conf
[Definition]
failregex = ^\[.*\] \w+\.INFO: auth\.failure \{"ip":"<HOST>"
ignoreregex =

The jail counts real failures only, which is what lets the threshold be honest:

# /etc/fail2ban/jail.d/cloudherder-auth.conf
[cloudherder-auth]
enabled    = true
port       = http,https
filter     = cloudherder-auth
logpath    = /var/www/<app>/storage/logs/auth-failures-*.log
backend    = auto
banaction  = iptables-multiport
maxretry   = 3
findtime   = 600
bantime    = 3600
ignoreip   = 127.0.0.1/8 ::1 <your-own-address>

And the permanent layer underneath it, for ranges that have earned a block rather than a ban:

table inet abuse {
    set bad_ranges {
        type ipv4_addr
        flags interval
        elements = { 198.51.100.0/24 }
    }

    chain block {
        type filter hook input priority -20; policy accept;
        ip saddr @bad_ranges counter drop
    }
}

That last block is the one place in this post where a human decides. The jail is automated: it counts and it bans without us. The blocklist is a judgement — we read the ban tally, decide a range has earned permanent treatment, and edit the file by hand. We review it weekly, drop ranges that have gone quiet, and never add a CDN or VPN range, because a shared exit node turns a block into an outage for strangers who happen to route through it.

Two things in there cost us time, so they are worth spelling out.

The regex that matched nothing and said nothing. Our first attempt anchored the pattern as ^\[[0-9]{4}. fail2ban rewrites the pattern before matching, reads the [[ as the start of a POSIX character class, and the whole expression quietly stops matching. No error, no warning, a filter that loads cleanly and protects nothing. Tested against the same log file on the same day:

^\[.*\] … auth\.failure \{"ip":"<HOST>"      → 5 matched, 0 missed
^\[[0-9]{4}-… auth\.failure \{"ip":"<HOST>"  → 0 matched, 5 missed

That is the failure mode nobody audits: not a jail that is off, but a jail that is on, healthy, and counting zero forever.

The exemption that stopped covering us. ignoreip holds our own address so a fumble does not lock us out of our own site. Ours was written months ago and held an address the ISP had since rotated away — so on the day the jail blocked the owner, the exemption was pointing at a connection we no longer had. It is a convenience, not a safety net, and it rots.

Sources

What this means for anyone running a small site

Autonomy compresses the timeline, not the mechanics. The advisory's "privileged access in under three hours" is not a new class of vulnerability; it is the same reconnaissance, credential work and lateral movement that used to take a fortnight, executed by something that does not sleep and does not get bored at attempt forty.

That should push you toward the boring defences rather than the clever ones:

  • Block ranges, not vibes. Eight IPs from one hosting provider, all probing the same paths, is not a nuanced judgement call. That range goes in the drop list.
  • Count per source, never per account. A lockout rule hands the attacker a lever. Per-IP bans cost you nothing and cannot be turned against your own login page.
  • Make your failure signal unambiguous. If your monitoring infers state from a status code, find out what the codes actually mean in both directions. Ours lied, and it lied in the direction that harmed us.
  • Keep a human in the loop for anything destructive. The interesting thing about the tooling is not that it plans; it is that a person still chooses the goal.

None of this feels like a fire from inside a site with eight readers. But the smoke is real, and it gets cheaper to make every month: what used to need a person at a keyboard now needs a planner, a budget and a noise profile.

What's in our control, and what isn't

In our control: the signal our app emits, the ranges we drop, the thresholds we set, and the speed at which we notice our own monitoring lying. Not in our control: whether a government agency's website provider gets compromised, whether the next advisory names a sector we are in, or whether the tooling gets quieter next month.

What we're testing next: whether the new per-source counter ever fires on a real attacker rather than our own test traffic — and how many hours it takes an ARTEX-shaped scan to move from /.env probing to credential work against a login page it has found.

If you run something small and public: when did you last check that your alerts mean what you think they mean?


Author's note: Claw drafted this post; I researched, verified, edited and signed off on it. The numbers are ours, taken from our own logs and counters on 21 November 2026, and the one claim we could not support — that ARTEX is behind the Defence Force incident — is labelled as speculation rather than buried.


D

Dallum Brown

Writer and curator exploring the impact of technology on everyday life.

View All Articles

Subscribe to
The Brief

Our curated selection of tech news and other discoveries, delivered every month.

No spam. Unsubscribe anytime.

Comments (0)

Please sign in to leave a comment.

No comments yet. Be the first to share your thoughts!

Further Reading