BOSSAI's AI agents raided Taipei emergency systems via open doors; here's how to check your clients' web apps for the same gaps.
One person steering a dozen AI agents pulled Taipei's 119 emergency-dispatch records, while a fire-department platform served ambulance patient data with no password at all. Acronis's Threat Research Unit reported on 4 November 2026 that the campaign, BOSSAI, confirmed access or data theft at about 10 targets. Check every client's public web apps for the same unlocked doors today.
BOSSAI is a campaign in which one operator ran a mesh of 12 AI agents, nine of them active, against organisations in 11 countries, per Acronis's report. Over the 12 days Acronis watched, about 10 targets in three countries had confirmed access or data theft, and about 15 more were attacked without a confirmed break-in.
The victims Acronis describes:
Run these on each client's web servers (as a normal user with sudo) and from a machine outside the client's network. Search from 25 July 2026, the earliest date in Acronis's report; if logs don't reach it, a clean result can't rule out earlier contact.
Preserve evidence. Copy the web logs and hash them before touching anything. Pass: the .sha256 file lists every copied log.
D=/root/ir-bossai-$(date +%F); sudo mkdir -p "$D"
# one of the two log folders may not exist; that error is expected
sudo cp -a /var/log/nginx /var/log/apache2 "$D"/
sudo find "$D" -type f -exec sha256sum {} + | sudo tee "$D.sha256"
Search for the indicators. These look for the nine IPs and nine domains Acronis published in web, firewall and DNS or proxy logs. Pass: both searches print nothing. Any hit is contact with known attacker infrastructure: treat it as a likely compromise and escalate.
IPS='\b(112\.121\.185\.218|156\.240\.109\.26|49\.158\.237\.136|202\.160\.76\.(15[3-7]|174))\b'
sudo find "$D" <exported-firewall-log> -type f -exec zgrep -HE "$IPS" {} +
DOM='(vps|xss|c)\.xs1\.ccwu\.cc|attacker-collector\.com|boss\.jytian\.cc\.cd'
DOM="$DOM|gd[ps]\.gasjy\.kdns\.fr|888\.bossjy\.kdns\.fr|ssh\.gputw\.ai"
zgrep -HiE "$DOM" <exported-dns-or-proxy-log>
Call each API without a login. List the client's API routes from its docs or asset inventory in api-urls.txt; this requests each with no token. Pass: every route not meant to be public returns 401 or 403.
while read -r U; do
printf '%s %s\n' "$(curl -sk -o /dev/null -w '%{http_code}' "$U")" "$U"
done < api-urls.txt
Check database ports and admin panels from outside. nmap, a port scanner, tests four database ports; the phpMyAdmin path is our guess, since Acronis doesn't name the admin product. Pass: all four ports show filtered or closed, and curl prints 404 or 000.
nmap -Pn -p 1433,1521,3306,5432 <client-public-ip>
curl -sk -o /dev/null -w '%{http_code}\n' https://<client-host>/phpmyadmin/
Find database accounts with no password. On each MySQL or MariaDB server, this lists accounts whose stored credential (authentication_string, per MySQL) is empty. Pass: no rows except auth_socket or unix_socket accounts.
# a known factory password won't show here; fix step 5 rotates root anyway
sudo mysql -e "SELECT user,host,plugin FROM mysql.user WHERE authentication_string=''"
Look for keys in browser code. The first command lists the app's JavaScript files; the second searches one for key-like strings. Pass: no line shows a literal key value.
curl -sk https://<client-app>/ | grep -oE 'src="[^"]+\.js"'
curl -sk https://<client-app>/<bundle>.js | grep -oiE '(aes|secret|api_?key|private_?key)[^,;]{0,40}'
Look for sqlmap in the logs. Acronis saw the agents use sqlmap, whose default user agent is sqlmap/1.x.x.x#dev (https://sqlmap.org) per its wiki. Pass: no output.
# attackers can change the user agent, so no output doesn't clear the app
sudo find "$D" -type f -exec zgrep -Hi 'sqlmap' {} +
Preserve evidence before changing anything. This confirms the copies from check 1 are intact. Pass: no output.
sudo sha256sum -c "$D.sha256" | grep -v ': OK$'
Lock admin panels and open API routes. Put each path flagged in checks 3 and 4 behind an allowlist with nginx's allow and deny rules, a stopgap until developers add a login. Pass: rerun checks 3 and 4; the blocked paths return 403.
location ^~ /phpmyadmin/ {
allow 203.0.113.0/24; # replace with the client's admin range
deny all;
}
# then run: sudo nginx -t && sudo systemctl reload nginx
Close database ports. Block inbound 1433, 1521, 3306 and 5432 at the client's edge firewall. Pass: check 4's nmap shows all four filtered.
Remove footholds. List the database accounts and drop any the client doesn't recognise with MySQL's DROP USER. Pass: the list shows only expected names.
sudo mysql -e "SELECT user,host FROM mysql.user"
sudo mysql -e "DROP USER '<unknown>'@'<host>'"
Rotate passwords and keys. Set new passwords for root and every account check 5 flagged with ALTER USER; move any key from check 6 server-side and issue a new one. Pass: the old root password is refused.
# skip accounts whose plugin is auth_socket or unix_socket
sudo mysql -e "ALTER USER 'root'@'localhost' IDENTIFIED BY '<new long password>'"
mysql -u root -p # enter the OLD password; it must be refused
Rerun checks 2 to 7. Pass: each meets its own Pass line.
BOSSAI matters because one operator reached organisations in 11 countries and listed 489 potential targets in Thailand alone, yet the confirmed break-ins came through ordinary gaps: open APIs, SQL injection, hard-coded keys and default credentials. Acronis put it plainly: "when a system is properly configured, there was substantially less that the agents could do."
What BOSSAI ran was an intrusion, not a pentest: a pentest is authorised, scoped and reported to the system's owner. Commercial models Grok and MiniMax refused the offensive requests (Acronis notes that "giving commands" does not equal "authorization"), so the operator turned to locally run models with their safety training stripped out.
The agents were also sloppy. More than half of one tool's high and critical findings were false positives, and one "critical" Apache flaw it reported didn't exist, per Acronis. Verify every finding before acting on it, including the ones in reports you hand clients.
For earlier cases, see how one attacker let AI agents do the breaking in and AI agents working a hit list of 200 organisations.
KinoSec's autonomous web app pentest checks whether each client's public web apps and APIs give up data or access to someone outside with no login, the kind of open door Acronis found at Taipei's fire department, and backs each finding with a working exploit. It is the same reconnaissance BOSSAI ran, done with your client's permission, scope limits and a report they can act on. For an MSP, the value is coverage: run it across your client portfolio continuously instead of once a year, then use the report to drive the fixes listed here. It doesn't read client firewall or DNS logs; checks 2 and 7 still do that. Start with autonomous web app and API pentesting for your clients.
eSecurity Planet reported that CyberStrikeAI used 44 AI agents against organisations in Japan, but listed it as related activity not confirmed as connected to BOSSAI. Acronis's BOSSAI report describes one operator and 12 agents. Treat them as separate campaigns that lean on the same kind of weak spots.
Search web and firewall logs for the nine IPs Acronis published, starting with zgrep -HE '202\.160\.76\.' /var/log/nginx/access.log*. Scan each client's public IP from outside with nmap -Pn -p 1433,1521,3306,5432 <client-ip>. Search web logs for sqlmap with zgrep -Hi sqlmap /var/log/nginx/access.log*. Any indicator hit is contact with known attacker infrastructure: treat it as a likely compromise and escalate.
Keep it off the open internet with an nginx allowlist that admits only the client's admin range and denies everyone else, as shown in nginx's access module docs. Have staff reach it over the client's VPN rather than a public address. Replace any factory login with a long, unique password, then confirm that a curl from outside gets a 403.
Yes. Acronis says the BOSSAI activity reached organisations in 11 countries, with confirmed access or data theft at about 10 targets in three countries. The gaps it relied on, open APIs, SQL injection, hard-coded keys and default credentials, are not tied to any country, so any client with a public web app warrants the same checks.