AntiFox AI Agents Automate AWS Credential Theft

Threat actors use AntiFox AI agents to automate AWS credential theft via Alibaba Cloud, bypassing traditional security defenses.

A security analyst sits in a dimly lit server room monitoring multiple screens displaying live network traffic logs

Intro

Attackers are quietly moving from manual scripting to autonomous, AI-driven intrusion chains, and the latest evidence points to a specific tool that makes this transition almost trivial. I have been running VPS instances for small clients for over seven years, and I remember the early days when a single compromised SSH key meant you could sit there for an hour, copy logs, and trace the path. Now, the pace has changed completely. According to recent reporting from BleepingComputer (opens in new tab), threat actors are hosting self-managed instances of AntiFox, an open-source agentic penetration testing platform, on Alibaba Cloud infrastructure. They are using it to target internet-facing web services and associated AWS environments with a level of automation that traditional security teams are not fully prepared for.

The shift here is not just about speed. It is about volume and the ability to fail without consequence. In the past, if a script hit a dead end, a human had to debug it. With agentic tools like AntiFox, the system can cycle through hundreds of identities and make rapid API requests, succeeding on just a small fraction of attempts while the rest get blocked. That small fraction is enough to harvest production secrets, deploy webshells, and move laterally into cloud accounts. I have had to clean up after similar “low success rate” attacks on my own hosting boxes, where the attacker just kept throwing requests until one configuration file was left in a world-readable directory. It felt messy and slow then. Now, the same tactic is being executed by AI agents that do not care about reputation or noise, as long as they find one valid credential.

This development follows closely on the heels of similar campaigns involving ARTEX, another agentic framework that was linked to state-sponsored espionage against South Korean financial institutions. The pattern is consistent: open-source tools with aggressive automation capabilities are being weaponized by actors who do not care about the original intent of the software. AntiFox, in its current version, lacks technical enforcement of its “no illegal activity” policy, which means anyone can download it, configure it, and point it at a target. For defenders, this means the line between a friendly penetration test and a malicious attack is blurring rapidly. We can no longer assume that high-volume API probing from unexpected IP addresses is just a noisy scanner. We have to assume it is an agent working toward a goal, and that goal is likely your credential store.

I am not trying to scare anyone, but the operational reality is that our current monitoring setups are often too static to catch these patterns. If your team is still relying on simple IP blocklists or rate limits that do not correlate IIS webshell activity with AWS API calls, you are looking at a blind spot. The attackers are using valid identities, which makes the traffic look legitimate to basic boundary checks. This is the new normal for cloud security, and it requires a different kind of defense than what we used in the era of perimeter-only thinking.

Background

To understand why this specific campaign is so troublesome, we need to look at what AntiFox actually is and how it fits into the broader ecosystem of agentic security tools. It is not a mysterious, bespoke malware strain written specifically for one target. It is a fork of ARTEX 0.1.1, a framework that originally emerged in the context of Chinese state-sponsored espionage. The developers of AntiFox created a Chinese-language interface and added automation for common penetration-testing tasks, such as mapping exposed services and probing endpoints for vulnerabilities. The tool is still available on GitHub, which is the critical operational detail here. It is open source, publicly accessible, and, as of version 2.0, features improved documentation and reporting capabilities.

The publishers of the software include a policy that prohibits using the tool against live systems or for destructive and illegal activity. However, they do not describe any technical controls that enforce these restrictions. This is a crucial distinction. There is no license key that checks the target IP address. There is no API call that validates the user’s intent before the agent begins scanning. It is just software. Anyone can download it, configure it, and point it at a target. For defenders, this makes the tool infinitely more difficult to track because it does not have a unique digital fingerprint in the same way a custom botnet might. You cannot block “AntiFox” at your firewall, because it is just a Python application running on a generic VPS, likely hosted on Alibaba Cloud in these recent incidents.

The shift to version 2.0 is also worth noting, not because it made the tool more powerful in a brute-force sense, but because it improved how the tool documents and reports findings. This inadvertently makes it more attractive for structured attack operations. A human attacker might miss a subtle misconfiguration because they are tired or distracted. An agent that systematically documents and reports findings is less likely to make that mistake. It turns a chaotic manual process into a structured one. We saw this same pattern with ARTEX, which went closed-source after it was linked to attacks on South Korean banks. The transition from open source to closed source in ARTEX’s case was likely a direct result of the tool being used in high-profile espionage campaigns. AntiFox has not gone down that path yet. It remains on GitHub, updated and maintained.

What this means in practice is that the barrier to entry for sophisticated cloud attacks has dropped to the level of a GitHub clone. You do not need to be a nation-state actor to deploy this. You need to be able to read the documentation and have a cloud account. The tool handles the heavy lifting of vulnerability exploitation, webshell deployment, and credential validation. The human operator just sets the target and watches the logs. This is a fundamental change in the threat model. We are no longer defending against scripts that do one thing badly. We are defending against agents that do many things well, and they do not stop when they hit a denial. They move to the next endpoint. They try the next credential. They keep going until they find one valid path into your environment. This is the context in which the recent Arctic Wolf findings make sense. It is not a new type of virus. It is a new type of workflow, and that workflow is now public.

What’s Happening Now

Arctic Wolf researchers observed malicious AntiFox-linked infrastructure hosted on Alibaba Cloud using valid AWS identities to make authenticated requests to Amazon Web Services APIs. The key detail here is not just that the traffic came from a foreign IP address, but that it carried legitimate credentials. These attackers used IAM users and, in some cases, assumed EC2 roles that were already valid within the target account. To a standard perimeter defense, this traffic looks almost indistinguishable from a normal user logging in from a new location, except for the volume and the source.

In one documented intrusion, the attackers deployed an ASPX webshell on an internet-exposed IIS server. From there, they executed OS commands and accessed application settings. They specifically targeted database connection strings and copied configuration and log files to a web-accessible directory. This is a classic move: make the data easy to grab from the outside without needing persistent shell access. Once the files were in a public-facing folder, harvesting them was trivial. The agent then used those harvested credentials to probe AWS endpoints.

The scale of the automated probing was significant. In one specific instance, the attackers cycled through multiple identities and made hundreds of API requests in about thirty minutes. Most of these attempts were blocked by AWS policies, which is a good thing, but the attacker was successful in some cases and obtained production secrets. In a separate incident, they used a valid AWS identity to read, copy, and delete S3 objects. This isn’t just about stealing data anymore; it is about disrupting operations and potentially destroying evidence.

You can think of this like a burgler who doesn’t break the window. Instead, they pick a lock using a key they found in a house that the previous tenant failed to secure properly. They walk in, copy the keys to the safe, and then call in a team to go through the safe. The window is just the entry point; the real damage happens inside. If you are running IIS servers, check your c:\inetpub\wwwroot directory for unauthorized .aspx files that write to the filesystem. This is the primary delivery mechanism observed in these attacks. If you find one, it is not a static file. It is active malware waiting for a command. Rotate any credentials found in web-accessible directories immediately. Assume they have already been harvested by an automated agent that is still out there, testing what works. The primary source for these findings (opens in new tab) details the specific API calls made, which helps security teams correlate their own logs with this known pattern.

What It Means in Practice

Standard AWS monitoring tools often miss this because the traffic looks legitimate to basic boundary checks. The agents are not scanning from unlisted IP ranges or spoofing packets. They are using valid credentials stolen from compromised applications, such as IAM users or assumed EC2 roles. To a simple firewall rule, this is just another authenticated API request from a trusted identity. The danger lies in the correlation gap. Most teams treat IIS webshell activity and unusual AWS access patterns as separate incidents. One ticket goes to the web team, the other to the cloud security team. They rarely talk. In the AntiFox cases, Arctic Wolf researchers emphasized that defenders need to link these two data sources. If you see an ASPX file deployed on a server and then see a burst of AWS API calls from the same subnet or using the same instance profile within a short window, that is not a coincidence. That is an automated chain reaction.

Defenders also need to change how they review denial logs. It is tempting to ignore failures because the majority of probes get blocked. But in these attacks, the system successfully obtained production secrets despite a high failure rate on other endpoints. You have to look at the successful calls hiding inside bursts of denials. If an agent fails on 90% of probes but succeeds on the critical few that expose database connection strings, that success is the actual breach. The noise covers the signal.

Long-term access keys stored in application configurations remain the primary vector for initial access. This makes credential hygiene more pressing than perimeter defense. I have seen clients keep access keys in .env files that are checked into private Git repositories with overly broad permissions. Or worse, hardcoded in source code that sits on a web server’s filesystem. If that web server gets compromised via a SQL injection or a vulnerable plugin, the attacker does not need to hack AWS. They just read the file. Amazon’s recommendation to require IMDSv2 on EC2 instances helps mitigate the risk of metadata service attacks, but it does nothing for long-term keys stored in files. Keeping long-term access keys out of application configurations is the single most effective control here. It reduces the blast radius if one server is compromised.

I expect threat actors to expand the use of AntiFox beyond AWS to other cloud providers soon. The logic is simple: if you can steal an Azure Service Principal secret or a GCP Service Account key through a webshell, an AI agent can automate the validation and configuration discovery on those platforms just as easily. The line between “penetration testing” and “attack” continues to blur for these automated tools. Security teams should start treating high-volume API probing from unexpected internal IPs as malicious by default, even if the identity looks valid. A valid identity used from an unusual location or at an unusual time is a red flag that should trigger an immediate investigation, not just a log entry.

If you run a small hosting business, look at your own customer configurations. Are you storing keys in places that web applications can read? Are your IMDSv2 settings enforced? It takes ten minutes to check.

What to Expect Next

I have spent the last seven years watching security tooling evolve from simple scripts into autonomous frameworks, and this shift toward agentic penetration testing is accelerating. The immediate concern is not just that AntiFox is available on GitHub, but that its open-source nature means anyone, including state-sponsored groups and opportunistic script kiddies, can fork it, modify it, and strip away the ethical guardrails that currently exist only in the documentation. When ARTEX went closed-source after being linked to campaigns against South Korean financial institutions, the open community lost a shared reference point for how these agents behave. AntiFox version 2.0 improved its reporting and documentation, which sounds like a feature for legitimate testers, but it actually makes the tool more attractive to malicious actors who need structured data to feed into their next phase of exploitation.

We will likely see a surge in “low-and-slow” credential harvesting campaigns that bypass traditional perimeter defenses. The attackers are not breaking into AWS; they are walking in through the front door with keys they picked up from a compromised IIS server on port 80. This changes the detection game. We can no longer rely on anomaly detection based on IP geolocation or request volume alone, because the requests come from valid IAM identities. The next logical step for these threat actors is to pair AntiFox with other open-source reconnaissance tools to create a fully automated kill chain: map the external attack surface, identify exposed web servers, deploy a webshell, extract local credentials, and then pivot into the cloud environment using those stolen secrets.

I expect cloud providers to respond by tightening their default posture for new accounts, possibly moving toward zero-trust network access for all internal service communication by default. However, I do not know how this holds up at scale for smaller customers who rely on legacy integration patterns. For now, the burden remains on the administrator. If you are running a hosting business, assume that your customer-facing IIS servers are already compromised or will be soon. The risk is not that a new vulnerability will be discovered; the risk is that a generic vulnerability in a popular CMS plugin will be exploited by an automated agent that operates without fatigue.

The blurring of lines between authorized testing and unauthorized access is becoming a critical operational challenge. Security teams need to define their detection logic based on intent rather than just source. If an identity that has never accessed S3 suddenly starts listing buckets, that is an indicator of compromise, regardless of whether the identity was created by a legitimate admin. The days of assuming that “valid credentials mean good user” are ending. We have to treat every automated interaction with sensitive data as potentially malicious until proven otherwise. This mental shift is harder to implement than any technical control, but it is necessary.

For the next six months, I will be watching for specific indicators of AntiFox usage in my own monitoring dashboards. I expect to see patterns of failed API calls clustered around successful ones, as the agents probe for permissions they do not have. If you see a burst of AccessDenied errors followed by a single s3:GetObject success, investigate that specific object immediately. The attacker likely found the one secret that matters.

Audit Your Environment Today

The discussion shifts from theory to operation when you open your terminal and start checking for gaps that these automated agents exploit. The threat described in the BleepingComputer report (opens in new tab) is not hypothetical. It is a specific, technical failure chain that begins with long-term access keys stored in plain text within application directories. If you run IIS servers, your immediate task is to verify that the c:\inetpub\wwwroot directory does not contain unauthorized .aspx files that write to the filesystem. These are the primary delivery mechanisms observed in the AntiFox attacks. A webshell is not just a backdoor; it is a bridge that allows an attacker to execute OS commands and copy sensitive configuration files into a web-accessible location. Once those files are public, the attacker no longer needs to exploit a new vulnerability. They simply read the database connection strings and AWS credentials.

Start with the credentials. Search your code repositories and deployed application configurations for any static AWS access keys. These are the “long-term keys” that Amazon’s spokesperson specifically advised customers to remove. If you find them, rotate them immediately. Do not wait to confirm if they were used. Assume they were. An automated agent cycling through hundreds of API requests in thirty minutes will not leave a clear, logged trail of every successful probe. It will fail on ninety percent of its attempts, but that one success that exposes your production secrets is enough. You do not need to see the entire attack to know it happened. You just need to check the CloudTrail logs for s3:GetObject or ec2:DescribeInstances calls coming from IPs you do not recognize, specifically clustered around a burst of AccessDenied errors.

Next, enforce IMDSv2 on all EC2 instances. This is a simple configuration change that prevents many of the metadata service attacks that feed into these credential theft chains. If you are using instance profiles, you are safe from this vector. But if any part of your stack still relies on static keys in environment variables or config files, you are exposing a static target to a dynamic attacker. This is where the operational difference becomes clear. A human pentester might hesitate before exfiltrating a secret. An AI agent will not. It will process the file, encode the data, and exfiltrate it over a channel that looks like normal traffic.

Finally, check your IIS log directories. Look for recently created files that you did not deploy. If you find an .aspx file with a name like upload.aspx or log.php in your web root, delete it. Then, review the access logs to see who requested it. This is not a clean-up exercise. It is a containment procedure. The moment you identify the file, you must assume the attacker has already read the secrets stored in the same directory. Rotate those credentials, revoke the sessions, and monitor for further lateral movement. This is the only way to break the chain before the agent moves to the next target.