What do hackers already know about your business? Get Your Free Report
Operation ArgonHunt: Open Directory Exposes a Crypto Exchange Breach and 44,000 Stolen AI API Keys
15 Mins Read
Summarize with:

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
1,600+
Exposed files
Roughly 700 MB of scripts, logs, credentials and stolen data
75+
Attack scripts
Drainers, brute forcers, SSRF and RCE tooling, scanners
200+
Forged withdrawal records
Logged across BTC, ETH and USDT drain runs
44,096
Stolen AI API keys
Across Gemini, OpenAI, OpenRouter, Anthropic and xAI
2,686
Keys confirmed working
HTTP 200 on the operator’s latest recheck
24.9M
Brute force pairs
Pre-built Base64 credential pairs for admin panels

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.

FunctionRepresentative filesWhat they hold
Fund drainingdrain.py, drain_eth.py, drain_usdt.py, sweep.pyBTC, ETH and USDT drainers and a multi-currency sweep
Execution logsdrain_ids.txt, usdt_ids.txt, sweep_ids.txt, hydra.out19 BTC, 15 USDT and 169 sweep entries; admin panel login hit on November 12
Access and pivotingrce1.py, ssrf.py, creds.py, tun.pyMySQL general log RCE, InfluxDB SSRF, MySQL credential spraying, proxy-tunneled MySQL
Brute force and crackingbrute.py, pairs_*.txt, adms.pot, conf.bakSMS OTP brute force, 24.9 million Base64 pairs, 17 cracked MD5 hashes, admin panel configuration
AI API keysall_gemini.txt, all_openai.txt, recheck-*.tsv, tcmod/main.go26,633 Gemini keys, 14,504 OpenAI keys, per-key recheck status, regex key scanner
Operator toolingcamofox-*.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.

Kill chain and timeline reconstructed from scripts, logs and output files.
Kill chain and timeline reconstructed from scripts, logs and output files.

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

~100
unsalted MD5 admin hashes obtained
17
cracked and stored in a potfile
~1 sec
for Hydra to find a valid admin login on November 12
24.9M
Base64 credential pairs staged for HTTP Basic brute force

What the 17 cracked passwords look like

Grouped by pattern
Name or word plus digits
9
Digits only
6
Generic pattern
2

One-time codes were attacked the same way

From brute.py and brute_otp.py
4
digit SMS code at loginAll 10,000 values tried across 12 parallel threads
6
digit code on password resetCycled through in order to set a new password
Customer accounts too: the operator specifically queried for accounts whose bcrypt hashes used a cost factor of 4 and that held high balances.

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 five-step drain pattern and a redacted excerpt from drain.py.
The five-step drain pattern and a redacted excerpt from drain.py.

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.

Forged withdrawal requests recorded in the operator's own drain logs.
Forged withdrawal requests recorded in the operator’s own drain logs.

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.

MySQL general log code execution and InfluxDB subscription SSRF, step by step.
MySQL general log code execution and InfluxDB subscription SSRF, step by step.

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.

Targeted companies by reported headquarters.
Targeted companies by reported headquarters.

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.

Harvested keys per provider and the share still working at the last recheck.
Harvested keys per provider and the share still working at the last recheck.

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.

The six-stage key pipeline and a redacted sample of its recheck output.
The six-stage key pipeline and a redacted sample of its recheck output.

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

IDTechniqueObserved in
T1595Active ScanningSubdomain brute force and port scans of victim ranges
T1190Exploit Public-Facing ApplicationInfluxDB subscription SSRF
T1078Valid AccountsDatabase and admin panel credentials
T1110.001Brute Force: Password GuessingHydra and ffuf against admin panels, OTP brute force
T1110.002Brute Force: Password CrackingMD5 and low-cost bcrypt hashes
T1110.003Brute Force: Password Spraying21 credential pairs across 13 MySQL hosts
T1552.001Unsecured Credentials: Credentials In FilesConfiguration backup with database credentials
T1213Data from Information RepositoriesStolen Git repository and admin panel source
T1505.003Server Software Component: Web ShellPHP written through the MySQL general log
T1090.002Proxy: External ProxyPublic CONNECT proxies used to reach MySQL
T1528Steal Application Access TokenAI API key harvesting and validation
T1565.001Data Manipulation: Stored Data ManipulationForged withdrawal and address records
T1657Financial TheftDrain and sweep scripts

Indicators of Compromise

Only attacker-controlled assets are listed. Victim-specific indicators have been shared through disclosure channels.

IndicatorTypeContext
176.65.148[.]2IPv4Staging server, open directory on port 8099
176.65.148[.]228IPv4Secondary host reached over SSH from the staging server
test[.]phoenixbot[.]lolDomainHostname associated with the operator’s infrastructure
bc1qfxdttzdqfzutaldppd0dy7gjn6w3xevskkmkmgBTC walletDrain destination
0xD2aFCE0c4cc6A115e8ef370d073A49f9e586349aETH walletDrain destination for ETH and USDT
/root/argon-hunt/File pathOperator toolkit directory
camofox-download-*.binFile patternAnti-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.

analysis passive credentials disclosure

Fatih Demir

Intelligence in your inbox every Thursday.

Join 30,000+ security professionals reading SOCRadar research.

Subscribe