Operation ArgonHunt: Open Directory Exposes a Crypto Exchange Breach and 44,000 Stolen AI API Keys
Threat actors rarely hand over their working notes. This one did. During routine threat hunting, SOCRadar found a staging server that was serving its entire /tmp directory to the internet over port 8099. Inside were more than 1,600 files and roughly 700 MB of attack scripts, logs, stolen credentials and output data.
The directory documents two operations run by the same operator from the same server. The first is a deep compromise of a Türkiye-based cryptocurrency exchange, complete with scripts that forge customer withdrawals directly in the production database. The second is an automated pipeline that harvests, validates and stockpiles API keys for the major AI providers. We track the activity as Operation ArgonHunt. The name comes from the operator’s own toolkit directory, argon-hunt.
Key Takeaways
- A misconfigured file server exposed the full toolkit and working data of an active, financially motivated operator
- The operator holds read and write access to an exchange’s production database and has run scripts that swap withdrawal addresses and forge withdrawal records for BTC, ETH and USDT. The logs record more than 200 forged entries, the largest for 76,000 USDT
- The same server holds 44,096 unique AI API keys across Gemini, OpenAI, OpenRouter, Anthropic and xAI. The operator’s own rechecks mark 2,686 of them as working
- A reconnaissance list of 281 exchange domains and a short list of 16 key targets show that the exchange breach was not meant to be a one-off
- The tradecraft is uneven. MySQL log abuse for code execution and InfluxDB subscription SSRF sit next to hardcoded passwords and an open directory
How the Operation Surfaced
The server at 176.65.148[.]2 ran a plain HTTP file listing on port 8099. Service directories created by systemd, X11 sockets, dozens of temporary Chromium profiles and a tmux session directory show that this was the live temporary filesystem of a working Linux host, and not a staged collection.
Our analysis was passive. We cataloged the listing, retrieved scripts, configurations and logs, reviewed the code statically and correlated infrastructure and techniques across files. We did not use any credential found in the directory and did not touch victim systems. The affected exchange is not named in this post, and victim-side indicators are withheld.
Representative files from the exposed directory, grouped by function. Victim identifiers and credentials are withheld.
| Function | Representative files | What they hold |
|---|---|---|
| Fund draining | drain.py, drain_eth.py, drain_usdt.py, sweep.py | BTC, ETH and USDT drainers and a multi-currency sweep |
| Execution logs | drain_ids.txt, usdt_ids.txt, sweep_ids.txt, hydra.out | 19 BTC, 15 USDT and 169 sweep entries; admin panel login hit on November 12 |
| Access and pivoting | rce1.py, ssrf.py, creds.py, tun.py | MySQL general log RCE, InfluxDB SSRF, MySQL credential spraying, proxy-tunneled MySQL |
| Brute force and cracking | brute.py, pairs_*.txt, adms.pot, conf.bak | SMS OTP brute force, 24.9 million Base64 pairs, 17 cracked MD5 hashes, admin panel configuration |
| AI API keys | all_gemini.txt, all_openai.txt, recheck-*.tsv, tcmod/main.go | 26,633 Gemini keys, 14,504 OpenAI keys, per-key recheck status, regex key scanner |
| Operator tooling | camofox-*.bin, playwright-*/, massdns/, tmux-0/ | Anti-detect browser, browser automation, DNS brute force, live operator session |
Campaign I: Inside a Crypto Exchange Breach
The evidence points to compromise at every layer that matters for an exchange. The scripts carry credentials for more than a dozen MySQL accounts on the victim’s hosting ranges, including one account with read and write access to the production database.
A stolen copy of the admin panel and CRM source code sits beside the exchange’s Git history. Output from fuzzing tools, which probe an application for hidden paths, maps internal API routes for user listing, deposits, SMS and withdrawals. A log from Hydra, a common password-guessing tool, shows a successful login to the admin panel on November 12, 2026, four days before our analysis. Pieced together from the operator’s own files, the intrusion runs in nine stages, from reconnaissance to fund theft.

Weak Credentials at the Front Door
The admin panel stored staff passwords as unsalted MD5 hashes, an outdated format that is fast to crack. Of roughly 100 hashes the operator obtained, 17 were cracked, and nine of those were a name or a common word followed by digits. A Hydra run then found a valid admin login in about one second.
One-time codes were attacked the same way. One script cycles through all 10,000 four-digit SMS codes on 12 parallel threads, and a variant targets the six-digit code in the password reset flow. The operator also queried the database for high-balance customer accounts whose bcrypt hashes used a cost factor of 4, the lowest setting bcrypt allows and the fastest to crack.
How the Admin Panel Fell
What the 17 cracked passwords look like
One-time codes were attacked the same way
Draining at the Database Layer
The most serious finding is a family of four Python scripts: drain.py, drain_eth.py, drain_usdt.py and the combined sweep.py. None of them touches the exchange’s application. Each connects straight to the database, selects accounts above a balance threshold, replaces the customer’s saved withdrawal address with the operator’s wallet, and inserts a withdrawal request for 95 percent of the balance together with its matching withdrawal record. The origin address on the forged request is set to 127.0.0.1, so it appears to come from the server itself.
Because the records are written beneath the application, the checks that run when a customer submits a withdrawal never happen. The forged requests are created in a pending state and flagged for approval, which explains much of the remaining toolkit: the admin panel credentials, the server-side request forgery (SSRF) route to internal panels and a JavaScript payload that calls the withdrawal verification endpoint for specific accounts all serve to push those requests through. One script goes a step further and adds 2.5 BTC to a single account before draining it, which suggests the operator was also testing balance forgery.

The scripts wrote their results to /tmp, and those output files were in the open directory. They list 15 USDT entries worth about 253,000 USDT, 19 BTC entries worth about 4.7 BTC, and a later sweep with 169 entries for about 55,600 USDT, 15.87 ETH and 0.134 BTC. These files confirm that the scripts ran against production data and show what was requested. We did not verify on-chain settlement of the individual requests, so the figures should be read as attempted theft and not as confirmed losses.

Two Less Common Pivots
Code execution through the MySQL general log. rce1.py uses a database account with sufficient privilege to point the general query log at a file inside the web root, runs a SELECT statement that contains PHP, and then requests the file over HTTPS to confirm execution. It walks through 12 candidate document roots until one answers. In effect, the database writes a web shell for the operator.
SSRF through InfluxDB subscriptions. ssrf.py creates an InfluxDB subscription whose destination is an internal URL, then writes a data point so the database itself makes the HTTP request. The operator used this to send login and transaction check requests to admin panels that were not reachable from outside. A captured callback on the staging server confirms that the technique worked. In effect, the victim’s own database becomes a proxy into its internal network.

Around these sit the supporting tools: SMS one-time code brute forcers for four- and six-digit codes, 24.9 million pre-built Base64 credential pairs for HTTP Basic authentication, Playwright scripts that capture session headers during login, public proxy hunting to reach IP-restricted database ports, and watcher scripts that retry withdrawal verification whenever a victim service comes back online.
One Victim Today, a Long List for Tomorrow
The exchange with confirmed exploitation is the first entry on a short list of 16 key targets that also includes several large international exchanges. A wider list holds 281 exchange domains, and the target and key target lists hold 56 entries, a mix of crypto exchanges, banks and payment providers.
By reported headquarters, the United Arab Emirates leads with five companies, followed by Singapore with four, Türkiye with three, and Brazil and the United States with two each, with one company each in Armenia, Austria, Canada, the Cayman Islands, Kyrgyzstan, Lithuania, Russia, Seychelles and Uzbekistan.
The evidence shows targets at different stages: certificate transparency monitoring for four more Turkish exchanges, domain reconnaissance on five further Turkish platforms, and full subdomain enumeration for a Brazilian exchange. We saw no evidence of compromise beyond the primary victim.

Campaign II: An Assembly Line for Stolen AI Keys
The second campaign is unrelated to the exchange breach and runs at a much larger scale. A small Go program built on a high-throughput regular expression library scans text for the key formats of OpenAI, Google and Cohere, along with generic JWT tokens. What it finds flows into a set of per-provider files that hold 44,096 unique keys. Gemini accounts for 26,633 of them and OpenAI for 14,504, followed by OpenRouter with 1,873, Anthropic with 983 and xAI with 107. The stockpile includes administrative and service account keys, and 519 Google Cloud tokens with broader scope than a simple API key.

Raw volume overstates the value. Only 6.1 percent of the keys answered with HTTP 200 on the operator’s most recent recheck. The survival rate differs sharply by provider: about 41 percent of OpenRouter keys were still alive, against roughly 6 percent for Gemini and under 2 percent for OpenAI.
The file names describe the workflow. Raw collections become validated sets, validated sets are tested again in numbered rounds, and recheck files record the HTTP status, rate limits, usage and free-tier flag for each key, which separates paid keys from free ones. That level of bookkeeping is what a seller or a proxy service operator needs, although the directory does not show where the keys go next. A separate log of intercepted API traffic containing a live service account token shows that scanning is not the only collection method.

For the key owner the consequences are concrete: compute billed to their account, exposure of any data reachable through the key, and abuse that traces back to them and not to the attacker.
Who Is Behind It?
Several traits point to a single operator or a very small team: one coding style across more than 75 scripts, chaotic personal file naming with many numbered retries, a job queue configured for one worker, and a single toolkit directory referenced as /root/argon-hunt.
Turkish-language artifacts are everywhere in the data, but most of them come from the victim’s own environment, such as staff names in cracked credentials and branch names in the stolen repository. The browser automation scripts set a Turkish locale and the Europe/Istanbul time zone, which would also be the natural choice for anyone imitating the victim’s customers.
The same directory holds an unrelated bilingual Persian and English project. On this evidence the operator’s deep familiarity with the target is clear and the operator’s origin is not.
The staging server had been up since July 2026. The stolen repository history covers July and August 2023, which dates the code and not necessarily the intrusion.
MITRE ATT&CK Mapping
| ID | Technique | Observed in |
|---|---|---|
| T1595 | Active Scanning | Subdomain brute force and port scans of victim ranges |
| T1190 | Exploit Public-Facing Application | InfluxDB subscription SSRF |
| T1078 | Valid Accounts | Database and admin panel credentials |
| T1110.001 | Brute Force: Password Guessing | Hydra and ffuf against admin panels, OTP brute force |
| T1110.002 | Brute Force: Password Cracking | MD5 and low-cost bcrypt hashes |
| T1110.003 | Brute Force: Password Spraying | 21 credential pairs across 13 MySQL hosts |
| T1552.001 | Unsecured Credentials: Credentials In Files | Configuration backup with database credentials |
| T1213 | Data from Information Repositories | Stolen Git repository and admin panel source |
| T1505.003 | Server Software Component: Web Shell | PHP written through the MySQL general log |
| T1090.002 | Proxy: External Proxy | Public CONNECT proxies used to reach MySQL |
| T1528 | Steal Application Access Token | AI API key harvesting and validation |
| T1565.001 | Data Manipulation: Stored Data Manipulation | Forged withdrawal and address records |
| T1657 | Financial Theft | Drain and sweep scripts |
Indicators of Compromise
Only attacker-controlled assets are listed. Victim-specific indicators have been shared through disclosure channels.
| Indicator | Type | Context |
|---|---|---|
| 176.65.148[.]2 | IPv4 | Staging server, open directory on port 8099 |
| 176.65.148[.]228 | IPv4 | Secondary host reached over SSH from the staging server |
| test[.]phoenixbot[.]lol | Domain | Hostname associated with the operator’s infrastructure |
| bc1qfxdttzdqfzutaldppd0dy7gjn6w3xevskkmkmg | BTC wallet | Drain destination |
| 0xD2aFCE0c4cc6A115e8ef370d073A49f9e586349a | ETH wallet | Drain destination for ETH and USDT |
| /root/argon-hunt/ | File path | Operator toolkit directory |
| camofox-download-*.bin | File pattern | Anti-detect browser artifacts |
Recommendations
For Cryptocurrency Exchanges
- Monitor the database, not only the application: Alert on writes to withdrawal request, withdrawal and saved address tables that do not originate from the application’s own service accounts and hosts
- Reconcile before release: Require that every withdrawal released to the hot wallet has a matching application-layer event, and hold any that do not
- Restrict database privileges: Remove SUPER and FILE from application accounts, block runtime changes to the general log path, and do not reuse one password across service accounts
- Close the quiet doors: Keep .git directories and configuration backups out of the web root, limit database and InfluxDB ports to known sources, and disable InfluxDB subscriptions where they are not needed
- Harden the admin panel: Enforce multi-factor authentication and IP allowlisting, replace MD5 and low-cost bcrypt password storage, and rate limit one-time code verification per account
For Teams That Use AI APIs
- Scan for secrets before they ship: Use pre-commit hooks and pipeline checks so keys never reach repositories, logs or client-side code
- Scope and rotate: Prefer project-scoped keys with spend limits over administrative keys, and rotate on a schedule
- Watch usage: Unexpected models, regions or volume on a key are often the first sign that it sits in someone’s stockpile
Frequently Asked Questions
What Is Operation ArgonHunt?
Operation ArgonHunt is SOCRadar’s name for two financially motivated operations run by the same operator from one staging server: a compromise of a Türkiye-based cryptocurrency exchange and an automated pipeline that harvests and validates AI API keys. Both came to light through an exposed open directory.
How Did SOCRadar Discover Operation ArgonHunt?
During routine threat hunting, SOCRadar found a staging server that was serving its entire /tmp directory over port 8099. It held more than 1,600 files and roughly 700 MB of attack scripts, logs, stolen credentials and output data. The analysis was passive, and no credential found in the directory was used.
How Did the Operator Steal Funds From the Exchange?
Four Python scripts connect straight to the exchange’s production database, replace customers’ saved withdrawal addresses with the operator’s wallet and insert withdrawal requests for 95 percent of each balance. Because the records are written beneath the application, the checks that run when a customer submits a withdrawal never happen.
Were the Funds Actually Stolen?
The operator’s output files record more than 200 forged withdrawal entries, including about 253,000 USDT and 4.7 BTC in the main drain runs. SOCRadar did not verify on-chain settlement of the individual requests, so the figures should be read as attempted theft and not as confirmed losses.
Which AI API Keys Were Stolen?
The server held 44,096 unique keys across Gemini, OpenAI, OpenRouter, Anthropic and xAI, including administrative and service account keys. The operator’s most recent recheck marked 2,686 of them, 6.1 percent, as working, with OpenRouter keys surviving at the highest rate.
Who Is Behind Operation ArgonHunt?
The evidence points to a single operator or a very small team with deep familiarity with the target, while the operator’s origin remains unclear.
How Can Cryptocurrency Exchanges Defend Against This Type of Attack?
Exchanges should alert on database writes to withdrawal and saved address tables that do not come from the application’s own service accounts, require a matching application-layer event before any withdrawal is released, remove SUPER and FILE privileges from application accounts, and keep .git directories and configuration backups out of the web root.
Conclusion
Two lessons stand out. For exchanges, an attacker who can write to the database does not need to defeat the application, so integrity controls have to exist below it. For everyone building on AI services, API keys are now collected, tested and inventoried at industrial scale, and should be treated with the same care as any other production credential. SOCRadar continues to monitor the infrastructure described here.
Analysis was passive. SOCRadar did not use any credentials found in the directory and did not touch victim systems. Victim-specific indicators were shared through disclosure channels.

