Skip to content
NewCybercrime Report 2026 · Eight Chapters · A Post Is Not An Incident → Explore The ChaptersCybercrime Report 2026 → Explore
All full reports
Full reportDeveloper toolingMonograph 09 / 1921 min read

Electron IDE Secret Theft and Single-Host Exploit Workbenches

How attackers mine desktop AI tools for OAuth secrets, and why most "shared C2 hubs" are look-alikes

By
Odin by Brandefense
Published
19 November 2026
Reading time
21 min read
Edition
Version 1.1 · TLP:CLEAR
Scope
Prepared November 2026

1. Executive Summary

In short

In data with an evidence cutoff of 15 November 2026, Odin by Brandefense found a 24-script workbench built to pull OAuth secrets out of a commercial Electron AI IDE. We also found three single-host Java and JWKS exploit kits. Across 2,019 values shared between 140 exposed servers, all 52 apparent multi-server hubs were open-source fixtures or public constants. Replace static desktop OAuth secrets with PKCE, pin JWKS origins, and check multi-host matches before blocking them.

Desktop AI coding assistants and local agent gateways keep powerful credentials on developer machines. These include OAuth client secrets, model API keys and cloud session tokens. This report looks at three things: staged tooling that targets those secrets, three compact exploit workbenches, and a common analysis trap that makes unrelated servers look like one C2 network.

1

A 24-script workbench targets OAuth secrets inside an Electron AI IDE.

Host W (US, address withheld; 1,228 files) holds 24 Node.js scripts written to search a 249 MB Electron archive and a 12.5 MB CLI bundle. No recovered IDE secret was found. Separately, two exposed developer gateways serve .env files and upstream code that can fall back to CLI or Keychain tokens.

2

Three single-host workbenches stage Java deserialization, API recon and rogue JWKS kits.

Host 202.162.109[.]5 stages rogue LDAP and MySQL servers, an H2 database payload and a reverse shell to 143.92.57[.]247. Host 129.226.71[.]134 holds 15 custom Python recon tools. Host 38.246.253[.]11 stages a rogue RS256 JWKS keyset and cloud metadata redirectors.

3

All 52 apparent shared C2 hubs were fixtures or public constants.

Of 2,019 values, 52 appeared on three or more servers, up to 71. Forty were bundled open-source fixtures and 12 were public constants such as cloud metadata URLs. No real value appeared on more than 2 servers.

Three Decisions for Leaders

  1. Remove static OAuth secrets from desktop apps. Replace embedded client secrets in Electron archives and companion CLI bundles with PKCE (RFC 8252). Turn on Electron ASAR integrity checks.
  2. Pin JWKS origins and harden cloud metadata. Accept token-signing keys only from allowlisted origins. Re-check private and link-local addresses on every HTTP redirect hop, and turn on each cloud provider's metadata protections.
  3. Check multi-host matches before you block. Bundled wordlists, documentation URLs and cloud metadata addresses appear on many servers. Filter them out of threat feeds so they never look like a shared C2 network.

The Study in Numbers

NumberWhat it is
2,019Unique C2, callback and credential values found across 140 exposed servers (7,146 file hits)
52Values that looked like shared hubs on 3 or more servers: 40 open-source fixtures and 12 public constants
1,544Values that remain real findings (76.5%) once fixtures and constants are set aside
126Real values seen on exactly 2 servers, the widest real overlap; 8 sit on adversary hosts
24Node.js scripts written to slice a 249 MB Electron IDE archive on Host W
192 of 200AI provider API keys that are real exposures rather than test fixtures
27Published indicators: 12 IPv4 hosts and 15 SHA-256 file hashes

How to use this report.

Security leaders can read Chapters 1, 7 and 10. Detection engineers and SOC analysts should start with Chapters 7 to 9. CTI analysts will find the workbench detail in Chapters 3 to 6 and the hub analysis in Chapter 2.

2. Look-Alike Hubs: What 2,019 Shared Values Really Were

In short

Values that appear on dozens of servers look like shared attacker infrastructure. In this data set, every one of them turned out to be a bundled fixture or a public constant.

The trap

A common way to find shared attacker infrastructure is to match the same URL, key or callback across many exposed servers. Taken at face value, our data looked alarming. Of 2,019 unique values, 210 appeared on two or more servers. Fifty-two appeared on 3 to 71 servers each.

Raw counts also suggested wide secret exposure: 66 Google API keys, 42 private keys and 30 AWS access keys. Most of these were not what they seemed.

Figure 1: What 2,019 cross-server C2, callback and credential values turned out to be
Figure 1: What 2,019 cross-server C2, callback and credential values turned out to be

In Figure 1, the top bar adds the one bare reverse-shell prefix to the 1,334 C2 URLs, so it shows 1,335.

What the values turned out to be

OutcomeValuesShareWhat it covers
Real findings1,54476.5%Includes staged C2 URLs (1,091), AI provider keys (192), private keys and signed JWTs (40), and per-session OAST and Telegram tokens
Open-source fixtures24512.1%Documentation and unit-test examples, security wordlists, cloned Nuclei templates
Public constants23011.4%Loopback and RFC1918 URLs (200), public cloud metadata URLs (9), root OAST nameservers and code-syntax matches (20), one bare shell prefix
Total2,019100%

The two largest look-alike clusters were a Jupyter live-kernel documentation URL on 71 servers and a cli-config.yaml.example endpoint on 67 servers. Both ship inside open-source packages.

Where the fake secrets came from

A single Metasploit wordlist, flask_secret_keys.txt, explains most of the alarming secret counts.

Secret typeFoundRealMain source of the rest
C2 URLs1,3341,091200 loopback or RFC1918 URLs and 9 public cloud metadata URLs
Out-of-band callbacks14087Nuclei CVE templates (37) and root OAST domains (16)
OpenAI API keys126126None; 113 sit in one mirrored plaintext key list
Google API keys66363 in Metasploit flask_secret_keys.txt
Telegram bot tokens45441 open-source documentation example
Private keys421520 in the Metasploit wordlist, 7 open-source test keys
Generic passwords3625aiohttp and yarl tests, plus fallback_getpass on 7 servers
AWS access keys30228 in the Metasploit wordlist
Slack tokens13112 in MobSF signature rules and open-source tests

Other real AI keys include 22 DeepSeek, 17 Stability, 13 Anthropic, 7 OpenRouter and 3 Groq keys. We did not test whether any key still works.

The 12 public constants behind the biggest "hubs"

Twelve of the 52 wide clusters were not open-source files at all. Each is a public value that many unrelated servers contain.

ServersValueExample host and file
42bash -i >& /dev/tcp/ (bare shell prefix, no target)202.162.109[.]5, /hr.sh
42http://169.254.169.254/latest/meta-data/ (AWS metadata)129.226.71[.]134, /vt2.py
23http://169.254.169.254/metadata/instance (Azure metadata)Developer host, withheld
21http://169.254.169.254/latest/meta-data/instance-idDeveloper host, withheld
19http://100.100.100.200/latest/meta-data/ (Alibaba Cloud metadata)38.246.253[.]11, /redir.log
15http://169.254.169.254/metadata/v1/id (DigitalOcean metadata)Developer host, withheld
7fallback_getpass (code identifier)Developer gateway, withheld
5http://127.0.0.1:18789/__openclaw__/canvas/ (loopback)Developer gateway, withheld
5http://169.254.169.254/latest/user-data/8.137.114[.]242, generate_rules.py
4keyboardshortcuts (code identifier)Unrelated host, withheld
3http://100.100.100.200/latest/meta-data/ram/security-credentials/38.246.253[.]11, /redir.log
3e.oauth.grantType?n (minified code fragment)8.138.12[.]59, /k4_app.js

The top two rows matter most. Each made a single-host workbench look like part of a 42-server network. Chapter 4 shows what those hosts really are.

The real overlap is small

Among real findings, no value appears on more than 2 servers. There are 126 such two-server values, anchored to 6 servers.

Anchor hostPortValues shared with one other serverContext
Exposure host, withheld8000113Plaintext list of OpenAI project keys; owner unknown
43.230.171[.]15080807/apply_AC2.json, /D_job.sql, /AD_svc.sql and a settings file; adversary host
Developer host, withheld40003Agent session logs with 1 OpenAI, 1 Anthropic and 1 Telegram token
129.226.71[.]13488991Google API key in a staged web template; adversary host
Developer host, withheld88991DeepSeek key in an agent .env file
Developer host, withheld88881OpenRouter key in an agent profile .env file

Only 8 of the 126 values sit on the 2 adversary hosts. The other 118 sit on 4 hosts that look like exposed developer or unattributed machines. Those 4 hosts are not on any block list in this report.

3. Electron IDE Secret Extraction and CLI Token Fallback

In short

One exposed server holds 24 scripts written to dig OAuth secrets out of a commercial Electron AI IDE. Separately, exposed agent gateways ship code that can borrow a developer's CLI login.

Why Electron apps leak secrets

Electron packs an app's source into an app.asar file. That file is not encrypted. Any Node.js script can read it with ordinary file calls. RFC 8252 (OAuth 2.0 for Native Apps) states that a desktop binary cannot keep a static client secret confidential.

So if an app embeds OAUTH_APP_SECRET or appSecret inside app.asar, a local script can recover it. The holder of that secret can then act as the app in the OAuth authorization_code exchange.

The 24-script workbench on Host W

Host W (US, address withheld) exposes 1,228 files totalling 3,066,253 bytes. They show someone reverse-engineering a commercial Electron AI IDE, whose name we withhold.

Instead of unpacking the archive with the standard @electron/asar tool, the operator wrote 24 numbered scripts. They run from find_secret.js through find_secret24.js, each between 303 and 1,148 bytes. The scripts load the IDE's resources/app.asar (about 249 MB) and a companion CLI .cjs bundle (about 12.5 MB) as text.

Figure 2: Iterative ASAR secret extraction on Host W and CLI token fallback in a developer gateway
Figure 2: Iterative ASAR secret extraction on Host W and CLI token fallback in a developer gateway

The scripts move through three phases, from simple string search to slicing the bundled code.

PhaseCountWhat the scripts look for
1. String and login search9OAUTH_APP_SECRET, OAUTH_CLIENT_SECRET, appSecret and tokenByAuthCode, then walk back to the enclosing function to map the login call chain
2. Child-process environment8The process spawner (spawnHostProcess) and its environment object (hostProcessLocalEnv), to find .env loaders and injected secrets
3. Bundle slicing7Sub-megabyte windows of app.asar around hostProcessLocalEnv, measuring distance between webpack chunks to isolate the function that returns the secret

The target archive and any extracted secret were not on the server. The scripts show intent and method, not a recovered secret or a breach of the IDE vendor.

What else sits on the same server

ToolFilesPurpose
Panel automationagent_panel.js, agent_v3.js, agent_v4.jsPlaywright scripts that drive a web panel
Browser capturecdp_screenshot.jsChrome DevTools Protocol screenshot utility
Account registrationexploit_register.py, exploit_semi.py, exploit_v2.py to exploit_v15.py (11 scripts)Iterative scripts that register accounts
Wallet keystoreOne file, 2,038 bytes (path withheld)Exposed cryptocurrency wallet keystore

A dual-use caveat. The registration scripts create accounts with names that suggest a penetration test. This server may belong to a red team that left its test box exposed, or to a hostile operator. We cannot tell which, and authorization is unknown.

Agent gateways that can borrow CLI logins

Two exposed gateways run the open-source NousResearch hermes-agent on port 8080. Their owners appear to be developers, not attackers, so both hosts stay anonymous.

The larger gateway serves 523 files over plain HTTP. They include its live /.hermes/.env (26,669 bytes, 542 lines) and gateway.log (17,889 bytes). They also include the upstream module anthropic_credentials.py (41,534 bytes, 816 lines).

That module's resolve_anthropic_token() function tries four sources in order.

StepSourceWhat it reads
1Environment tokenANTHROPIC_TOKEN or CLAUDE_CODE_OAUTH_TOKEN
2Static API keyANTHROPIC_API_KEY (sk-ant-api* keys, sent as x-api-key)
3Hermes OAuth file~/.hermes/.anthropic_oauth.json (sk-ant-oat* tokens, sent as a Bearer token)
4Borrowed CLI login~/.claude/.credentials.json or the macOS Keychain entry for Claude Code, copied into the Hermes credential pool (auth.json)

Step 4 is an upstream feature, not malware. The risk comes from serving ~/.hermes/ over HTTP. If a borrowed token or a session history database is stored there, anyone can read it.

We found no auth.json, no CLI or Keychain token, no SQLite history and no log showing step 4 ran. Across all servers in the study, .env files expose 22 DeepSeek and 13 Anthropic keys.

4. Java Deserialization and Recon Workbenches

In short

Two hosts looked like members of a 42-server network only because each contains a common public string. Each is in fact a self-contained, single-host workbench.

Hosts 202.162.109[.]5 and 129.226.71[.]134 each appeared in a 42-server cluster. For the first, the shared value was the bare shell prefix bash -i >& /dev/tcp/. For the second, it was the AWS metadata URL. Both strings appear on many unrelated servers, so neither cluster is evidence of shared infrastructure.

Figure 3: Single-host Java JNDI/JDBC and recon workbenches behind two 42-server look-alike matches
Figure 3: Single-host Java JNDI/JDBC and recon workbenches behind two 42-server look-alike matches

202.162.109[.]5: a Java deserialization kit

This host (Singapore) exposes 23 directory entries across ports 8081 and 8080. We retrieved 15 files. The operator did not use public frameworks such as ysoserial or rogue_mysql_server. Instead, they wrote small Python emulators for each protocol.

FileSizeListens onWhat it does
/evil-ldap.py3,698 B, 103 linesTCP 1389Rogue JNDI LDAP server. Answers a search request with javaClassName: Exploit and a javaSerializedData payload, which sidesteps the trustURLCodebase limit in JDK 8u191 and later
/evil-mysql-blob.py3,326 B, 105 linesTCP 3312Rogue MySQL server with banner 5.7.36-evilblob. Returns a serialized object as a BLOB column to any MySQL Connector/J client using autoDeserialize=true
/S.py3,630 B, 103 linesTCP 3314Configurable rogue MySQL server with banner 5.7.36-debug. Lets the operator set column type and other fields, and injects a payload into SELECT results
/evil1.sql505 B, 2 linesServed over HTTPH2 database script that defines CREATE ALIAS HR_X to call Runtime.getRuntime().exec, and sends id, hostname and a web-root listing to 143.92.57[.]247:8081
/hr.sh56 BServed over HTTPBash reverse shell to 143.92.57[.]247:4444
/x.js172 BServed over HTTPScript that calls back to 143.92.57[.]247:8080
/start-blob.sh, /start-s.sh236 B, 179 BLaunchers for the two MySQL servers

The server's own logs add context. /ldap.log (40,432 bytes, 1,472 lines) records evil-ldap on :1389 payload=1323B and repeated inbound LDAP connections. /blob3312.log (177 bytes) records two outside JDBC clients receiving 1,298-byte BLOB payloads.

/httpd.log (262,144 bytes, 3,287 lines) carries entries dated 25 October 2026. These show GET /evil1.sql requests from 127.0.0.1, which are the operator's own self-tests. Internet scanner probes such as GET /api/mcp also appear. This date is a timestamp in the attacker's log file, not part of our observation period.

The operator's infrastructure spans 2 hosts: 202.162.109[.]5 and the callback host 143.92.57[.]247.

129.226.71[.]134: an API and cloud recon workbench

This host (Hong Kong, port 8899) exposes 390 directory entries in 106 subfolders, totalling 4,416,662 bytes. We retrieved 15 custom Python tools, plus 1 vendored setup.py from the open-source SendSafely client library. A staged RSA private key also sits on the server (path withheld).

ScriptSizeWhat it is written to do
/vt2.py1,444 B, 28 linesSend 7 injection tests to /security/v1/verify: NoSQL injection, SQL injection, template injection ({{7*7}}), path traversal and an AWS metadata URL
/apienum.py1,925 B, 27 linesProbe 35 REST routes such as /api_gateway/v1/users, /wallets, /kyc and /auth/v1/token with 4 threads. Companions: /enum2.py, /enum3.py
/actenum.py1,087 B, 14 linesEnumerate 26 activity, admin, internal and debug endpoints with an Android Pixel 8 user agent
/byp.py1,571 B, 23 linesProbe 45 gateway routes with custom X-platform headers to find WAF bypass responses. Companions: /probe.py, /leads.py
/cffi.py1,024 B, 20 linesTest TLS-fingerprint bypass with curl_cffi impersonating Chrome 131 through 24 SOCKS5 proxies. Companions: /geo.py, /mob.py, /mob2.py, /proxycheck.py, /pw2.py
/dnsbrute.py1,234 B, 31 linesBrute-force subdomains with dnspython across 60 threads against 8.8.8[.]8 and 1.1.1[.]1

The routes in these scripts (wallets, KYC, auth tokens) suggest interest in financial or crypto platforms. We found no execution log on this host, so we cannot say whether any target was probed.

5. Rogue JWKS Keys and Cloud Metadata Redirectors

In short

Host 38.246.253[.]11 stages everything needed to test forged-token acceptance through the JWT jku header. It also runs redirectors aimed at Alibaba Cloud's metadata service.

Host 38.246.253[.]11 (Hong Kong) exposes 32 directory entries across ports 8082 and 8085. We retrieved 9 files. Together they cover two attack paths.

Figure 4: Single-host workbench 38.246.253[.]11 pairs RS256 JWKS staging with cloud metadata redirectors
Figure 4: Single-host workbench 38.246.253[.]11 pairs RS256 JWKS staging with cloud metadata redirectors

Path 1: a rogue JWKS keyset

A signed JWT can carry a jku header (RFC 7515). It points to a URL that serves the public keys (a JWKS, RFC 7517) used to check the signature. If a server trusts any jku origin, an attacker can sign a token with their own key and point jku at their own keyset.

The host stages all three parts of this attack.

PartFileSizePort
Attacker RSA private keyName withheld1,704 B8082
Matching public key/jwt_pub.pem451 B (2048-bit RSA)8085
Served keyset/jwks.json438 B, "kid": "hktest1", "alg": "RS256"8085

The access log (/access.log, 262,144 bytes, 1,183 lines) mostly records internet scanners and directory browsing. We therefore do not claim that any service accepted a forged token. The key ID hktest1 is the most useful hunting value.

Path 2: redirectors that reach cloud metadata

Many web apps and AI agent sandboxes block requests to 169.254.169.254 or 100.100.100.200. Many do not re-check the address after following an HTTP redirect. The host stages two small Python servers built on BaseHTTPRequestHandler to exploit that gap.

/redir_server.py (897 bytes, 23 lines) listens on TCP 8083 and answers six short paths with 302 Found.

PathRedirects to
/r-metahttp://100.100.100.200/latest/meta-data/ (Alibaba Cloud ECS metadata root)
/r-ramhttp://100.100.100.200/latest/meta-data/ram/security-credentials/ (RAM role temporary credentials)
/r-imghttp://38.246.253[.]11:8082/test.png (harmless test image)
/r-local80, /r-local8080http://127.0.0.1/ and http://127.0.0.1:8080/
/r-selfThe host's own address (withheld)

/redir2.py (826 bytes, 21 lines) listens on TCP 8084. It maps /r301, /r302, /r307 and /r308 to redirects of the same status code. This tests which codes a client follows. Codes 307 and 308 also keep the POST method and body.

Two logs show the redirectors in use. /redir.log (112,905 bytes, 2,211 lines) and /redir2.log (14,456 bytes, 295 lines) record repeated 302 answers for /r-ram and /r-meta. The logs do not show which clients made the requests or what they received.

The metadata URLs inside /redir.log also produced two look-alike clusters, on 19 and 3 servers. Both are public constants (see Chapter 2).

6. Other Adversary Staging Hosts

In short

Eight more hosts stage droppers, phishing kits, callback harvesters and exploit tooling. They complete the published list of 12 adversary IPv4 hosts.

HostPortWhat it stages
43.230.171[.]1508080/AD_svc.sql, /D_job.sql, /apply_AC2.json and a settings file; 7 of its values also appear on one other server (16 values in total)
38.207.179[.]1798088/cmds.txt and token files yielding 716 real C2 URL and token values
51.194.215[.]358080/b/*.sh dropper scripts that fetch from http://51.194.215[.]35:8080/h/* (236 real values)
8.137.114[.]2428080GoPhish and recon tooling: /gophish/gophish.log, /gophish/nohup.out, /ApolloFish/nohup.out and key and config files (60 real values)
144.172.99[.]1998080/assemble_dnslog.py and /dbg18.log with 43 unique per-session OAST and DNSLog callbacks
8.138.12[.]599999Fastjson tooling: /fastjson_probe.py, /ssrf_nacos.sh, /ssrf_probe2.sh and token-capture files (13 real values of 18)
38.60.227[.]2108082/deploy_ghc2.sh (a GitHub-based C2 agent), /actor.ps1 and /miner/install_user.sh (8 real C2 URLs)
47.109.23[.]778888/jndi.log recording exploit.class and downstream botnet payload URLs (8 real values)

Apart from the 7 values that 43.230.171[.]150 shares, nothing in this data links these hosts to each other or to the three workbenches. Treat them as separate operations.

7. What Defenders Should Do

Figure 5: Five-stage defense pipeline for desktop OAuth secrets, Java and JWKS kits, and look-alike hubs
Figure 5: Five-stage defense pipeline for desktop OAuth secrets, Java and JWKS kits, and look-alike hubs

Within 24 hours

  • Block the adversary IPv4 hosts in the Indicators tab, and alert on any internal host that contacts them.
  • Hunt for the 15 file hashes, the script names find_secret*.js, evil-ldap.py, evil-mysql-blob.py, redir_server.py and redir2.py, and the JWKS key ID hktest1.
  • Rotate any API key that ever sat in an exposed .env file, agent profile or session log.

Within 72 hours (application and platform teams)

  • Desktop apps. Treat Electron .asar bundles and bundled .cjs CLI scripts as readable source. Replace static OAUTH_APP_SECRET values with Authorization Code plus PKCE (S256). Enable the @electron/fuses setting EnableEmbeddedAsarIntegrityValidation.
  • JWT verification. Pin trusted JWKS origins. Reject unpinned jku headers and unknown kid values such as hktest1.
  • Redirects. Re-check 169.254.0.0/16, 100.100.100.200/32 and 127.0.0.0/8 on every 301, 302, 303, 307 and 308 hop.

Within 7 to 30 days

  • Cloud metadata. On AWS, require IMDSv2 (HttpTokens=required). On Alibaba Cloud ECS, use hardened mode (HttpTokens=required, HttpEndpoint=enabled). On Azure, enforce the Metadata: true header and host firewall rules. On DigitalOcean Droplets, block non-root egress to 169.254.169.254.
  • Java tiers. Block outbound traffic from application servers to untrusted LDAP (1389, 389) and MySQL (3306, 3312, 3314) ports. Remove autoDeserialize and queryInterceptors from Connector/J connection strings, or upgrade to Connector/J 8.2.0 or later, where autoDeserialize is removed.
  • H2. Disable H2 web consoles for remote users and forbid INIT=RUNSCRIPT in JDBC URLs.
  • Agent dotfiles. Require an explicit opt-in before an agent framework reads ~/.claude/.credentials.json or the Keychain. Look for ad-hoc HTTP servers (python3 -m http.server) inside ~/.hermes, ~/.claude and ~/.codex, and set those files to mode 0600.
  • Threat feeds. Before a multi-host match goes on a block list, check what it is. Wordlist entries, documentation URLs, cloud metadata addresses, loopback URLs and bare shell prefixes are not shared infrastructure. Keep a full reverse shell with a routable IP and port as a real finding.

8. Detection Rules

The full rules are in the Detection rules tab. Each file targets one stage of the activity in this report.

Rule fileWhat it catches
suricata_ide_secrets_jndi_and_jwks_ssrf.rulesSuricata 7: seven signatures for the rogue JWKS response, metadata redirects, the H2 payload, Hermes path probes, raw-IP JWKS fetches, the reverse-shell script and rogue LDAP responses
sentinel_electron_asar_and_imds_jwks_hunt.kqlMicrosoft Sentinel and Defender XDR: ASAR scraping commands, extractor or credential file writes, and contact with staging hosts or rogue Java ports
sigma_electron_asar_unpack_and_cli_cred_theft.ymlSigma (3 rules): ASAR secret scraping, non-official access to agent credential stores, and JVM reverse shells
yara_electron_asar_jndi_blob_and_jwks_toolkits.yarYARA (4 rules): the find_secret extractors, the LDAP and MySQL servers, the H2 payload, and the JWKS and redirector kit

How the Suricata signatures work

Signatures 9902601 to 9902606 read HTTP buffers. They need cleartext HTTP (ports 8080 to 8085 in this data) or TLS-inspected proxy or egress traffic. Signature 9902607 reads raw TCP on port 1389.

SIDLooks forWhy
9902601Inbound HTTP 200 response whose body holds "keys" and "hktest1"Catches the rogue JWKS keyset used for jku abuse (RFC 7515)
9902602HTTP 301, 302, 303, 307 or 308 whose Location points to an AWS, Alibaba, Azure, DigitalOcean or GCP metadata path, including encoded forms of 169.254.169.254Catches redirect-based SSRF into cloud metadata
9902603Inbound HTTP 200 body with CREATE ALIAS and Runtime.getRuntime().execCatches the H2 RCE script in transit (T1190)
9902604HTTP request for /.hermes/.env, a profile .env, .anthropic_oauth.json or sessions/Catches probes for exposed agent credential stores
9902605Outbound request for /jwks.json to a raw IPv4 hostCatches a verifier fetching keys from an unpinned, IP-only origin
9902606Outbound request for /hr.shCatches a fetch of the staged reverse-shell script (T1059.004)
9902607javaSerializedData in traffic from external TCP port 1389Catches a rogue JNDI LDAP answer reaching an internal Java host

How the other rules work

The KQL hunt has a 14-day lookback and three branches. The first reads process events. It flags asar extract, find_secret, or commands that touch app.asar or cli-bundle.cjs together with OAUTH, SECRET, readFileSync or hostProcessLocalEnv. It also flags non-official processes that reference agent credential files.

The second branch reads file events. It flags new find_secret files and writes to .credentials.json, .anthropic_oauth.json or .env inside .claude or .hermes by processes other than the official CLI. This matters because Defender file events record writes, not plain reads.

The third branch reads network events. It flags contact with the 12 staging hosts and Java processes connecting to public ports 1389, 3312, 3314 or 4444. It also flags plain-HTTP JWKS fetches from raw IP addresses.

The three Sigma rules cover Linux, macOS and Windows process creation:

Sigma ruleFires whenMain false positive
ASAR secret scrapingasar extract, or a command touching app.asar or cli-bundle.cjs with OAUTH, APP_SECRET, readFileSync or hostProcessLocalEnv, or node running find_secretAuthorized app security audits and packaging pipelines
Agent credential store accessA non-official process references ~/.claude/.credentials.json or ~/.hermes/ tokens, queries the Keychain for Claude entries, or runs python -m http.server inside .hermes, .claude or .codexDeveloper debugging
JVM reverse shellA Java process spawns sh, bash, cmd.exe or PowerShell with /dev/tcp/, nc -e, ncat, /hr.sh, /evil1.sql or :8081/r?d= in the command lineSecurity test harnesses; gradle, maven, jenkins, surefire and bazel builds are excluded

Each YARA rule needs two or more independent strings and a small file size:

YARA ruleFires on
ODIN_Electron_IDE_ASAR_Secret_ExtractorFiles under 50 KB that combine readFileSync, an app.asar path and a secret or closure name such as OAUTH_APP_SECRET or hostProcessLocalEnv
ODIN_Rogue_JNDI_LDAP_and_MySQL_JDBC_Blob_KitjavaSerializedData with the BER encoder, or the MySQL packet helper with autoDeserialize or the 5.7.36-evilblob / 5.7.36-debug banners
ODIN_H2_Database_Create_Alias_Java_RCEScripts with CREATE ALIAS IF NOT EXISTS, Runtime.getRuntime().exec and java[.]net.URLEncoder.encode together
ODIN_Rogue_JWKS_and_Cloud_IMDS_SSRF_RedirectorA keyset with "keys", "hktest1" and "RS256", or a BaseHTTPRequestHandler script that sets Location to a metadata address or a redirect path such as /r-ram

9. Indicators

The full list is in the Indicators tab. The published set has 27 indicators; the dual-use Host W address is withheld.

TypeCount
Adversary IPv4 hosts12
SHA-256 file hashes of staged tools15
Exposed developer gateways or unattributed exposure hosts0 published

Adversary hosts

HostPortRole
202.162.109[.]58081Java JNDI LDAP, MySQL BLOB and H2 exploit workbench
143.92.57[.]2474444Reverse-shell, H2 callback and script callback listener
129.226.71[.]1348899Cloud, API and DNS recon workbench
38.246.253[.]118085Rogue RS256 JWKS and metadata redirector host
43.230.171[.]1508080AD and SQL dropper and credential staging host
38.207.179[.]1798088C2 payload and command staging server
51.194.215[.]358080Shell-dropper staging host
8.137.114[.]2428080GoPhish and recon tooling workbench
144.172.99[.]1998080OAST and DNSLog callback harvest host
8.138.12[.]599999Fastjson exploitation and token harvest workbench
38.60.227[.]2108082GitHub-based C2 agent and cryptominer dropper host
47.109.23[.]778888JNDI class-loader and botnet staging host

File hashes

FileSizeHostSHA-256
/find_secret.js957 BHost W58d60d46032f0773450f3423c590e33def5c8d82d99ea7d3eeb030e48bcf75da
/find_secret10.js1,015 BHost Wfa4c8b7e32a988708b8be3f242f8da7b4950317e744d25dc29562f2d7668b89b
/find_secret15.js936 BHost Wae94f76f756ba03d649fd1cfd5d5e4499964d35d240004ae1201f2d69a6ff561
/find_secret19.js706 BHost W82bf3e60b1a88f3aec71340135071c7ef274bbc79d0af957feda96ef03ecd722
/find_secret21.js1,148 BHost W67e0a6cd4f9d33100b5586db7fc520a9c3bdf552efba25eaa26193a271cacb96
/evil-ldap.py3,698 B202.162.109[.]5f168a63ff299f329042018ac619a5798ff7f32db84e00d695486dbdb52e230d5
/evil-mysql-blob.py3,326 B202.162.109[.]5fd02682812241e87923e1dd84c143172311e2fd2ccd96e24102902712d94c3bf
/S.py3,630 B202.162.109[.]52905df5e743e78e506301a5eb5db64d5ee2693ac1b2db4f471e3752f27814240
/evil1.sql505 B202.162.109[.]51c17f27b9f5dac7c800e1e8525d51eaa776de908f55f17acd2acc8d9f465fd0f
/hr.sh56 B202.162.109[.]56d52a91e2c376bb58f95d67b34bbdf6c79215d80074d77f19f21c551c56cf8fb
/redir_server.py897 B38.246.253[.]11a6d229a047b79585c56440d4cf51bffda83431f4917d592abc15ca50bff5093a
/redir2.py826 B38.246.253[.]11ecd9a613e61a457652b9a587e2c698687056ae961d743cfeb0d80235d69af23b
/jwks.json438 B38.246.253[.]11ddf4f0ffd2f5a3d1f1e68801975a1788de48079f4746ff7f41eb6c14218796b7
/apienum.py1,925 B129.226.71[.]1348215966f15ad99df70d12359b5357322fb2e4d6a9b47b0e97f47cbc25b823b68
/dnsbrute.py1,234 B129.226.71[.]1345ef1c728993da674a1ce87e7dcce45fb377ef905338a6e0c553cb11b6df7ea59

Supporting hunting values: JWKS key ID hktest1, MySQL banners 5.7.36-evilblob and 5.7.36-debug, the log line evil-ldap on :1389, and H2 alias HR_X.

Withheld: the two developer gateways, the four developer or unattributed exposure hosts, and the IDE vendor and install paths. Also withheld are the staged private keys, the wallet keystore, the redirector's self-probe address, and all exposed API keys and tokens.

MITRE ATT&CK mapping

TacticTechniqueWhere it appearsDetection
Credential AccessT1552.001 Credentials In Filesfind_secret*.js scraping app.asar; exposed .env filesSigma rule 1; YARA extractor rule; KQL branches 1 and 2
Credential AccessT1528 Steal Application Access TokenRecovering an embedded OAuth client secret; borrowing CLI OAuth tokensSigma rules 1 and 2; SID 9902604
Credential AccessT1555.001 KeychainHermes fallback code that queries the macOS KeychainSigma rule 2
Initial AccessT1190 Exploit Public-Facing ApplicationRogue JNDI LDAP, MySQL BLOB and H2 servers on 202.162.109[.]5SID 9902603, 9902607; YARA JNDI and H2 rules
Credential AccessT1552.005 Cloud Instance Metadata APIRedirectors to 100.100.100.200 RAM credentialsSID 9902602; YARA JWKS and redirector rule
ExecutionT1059.004 Unix Shell/hr.sh reverse shell to 143.92.57[.]247:4444SID 9902606; Sigma rule 3

10. Scope and Limits

  • Time frame. Findings use an evidence cutoff of 15 November 2026. The 25 October 2026 date in Chapter 4 is a timestamp inside the attacker's own log, not a start date for our observation.
  • Staged does not mean used. The scripts, kits and keys show intent and capability. We did not see any of them succeed against a victim. No IDE secret, borrowed CLI token or accepted forged JWT was found.
  • Presence is not validity. A key or C2 URL found on a server may be expired or fake. We did not test any key.
  • Dual use. Account names on Host W leave open that it is an exposed red-team server. Authorization is unknown, so its address is withheld; its script hashes stay published as tool indicators.
  • Developer hosts are not attackers. The Hermes gateways and other exposure hosts look like misconfigured developer machines. They are withheld and not on any block list.
  • No hidden network. Apart from 7 values shared by 43.230.171[.]150, nothing in this data links the adversary hosts to each other.
  • Rule testing. Every published rule file loads without errors in its engine (Suricata 7.0.12, YARA-X, pySigma and Microsoft's Kusto.Language analyzer, checked on 20 November 2026). The rules were not replayed against live traffic, so test and tune them in your own environment before production use.

11. Sources

  1. Electron. ASAR Archives. https://www.electronjs.org/docs/latest/tutorial/asar-archives (verified 15 November 2026)
  2. IETF. RFC 8252, OAuth 2.0 for Native Apps (BCP 212). https://datatracker.ietf.org/doc/html/rfc8252 (verified 15 November 2026)
  3. MITRE ATT&CK. T1190 Exploit Public-Facing Application. https://attack.mitre.org/techniques/T1190/ (verified 15 November 2026)
  4. IETF. RFC 7515, JSON Web Signature, Section 4.1.2 (jku), and RFC 7517, JSON Web Key. https://datatracker.ietf.org/doc/html/rfc7515 (verified 15 November 2026)
  5. MITRE ATT&CK. T1552.005 Cloud Instance Metadata API. https://attack.mitre.org/techniques/T1552/005/ (verified 15 November 2026)
  6. MITRE ATT&CK. T1552.001 Credentials In Files. https://attack.mitre.org/techniques/T1552/001/ (verified 15 November 2026)
  7. Alibaba Cloud. ECS: Access instance metadata using hardened-only mode. https://help.aliyun.com/en/ecs/user-guide/access-instance-metadata-using-hardened-only-mode (verified 15 November 2026)
  8. Oracle. MySQL Connector/J 8.2.0 release notes. https://dev.mysql.com/doc/relnotes/connector-j/en/news-8-2-0.html (verified 15 November 2026)

What is…?

Short explanations of the tools and families named in this study.

All explanations

Frequently asked questions

How do attackers get secrets out of a desktop AI app?

Many desktop apps are built with Electron. Electron packs the app's code into a file called app.asar, which is not encrypted. Any script can read it. The OAuth standard for native apps (RFC 8252) says plainly that a desktop app cannot keep a built-in client secret private.

Why are developer agent gateways a risk?

Two exposed servers run an open-source agent gateway called hermes-agent. Their owners look like developers, not attackers, so we keep them anonymous. One serves 523 files over plain HTTP, including its live .env file and logs.

What do the three exploit workbenches contain?

Each workbench is a small, self-contained kit on a single server. The Java kit targets old Java and MySQL driver settings that turn data into running code. The JWKS kit targets services that accept a token's signing key from any URL. The redirectors target apps that block cloud metadata addresses at first but follow redirects without checking again.

Why did so many servers look connected?

Matching the same value across many servers is a common way to find shared attacker infrastructure. In our data, 52 values appeared on three or more servers, up to 71. That looked like a large C2 network.

Defender kit

Indicators of compromise

Verified adversary infrastructure and tool hashes from this study. Every value below is also discussed in the report.

IDTypeIndicatorPortContextAction
R09-IOC-01 IPv4 202.162.109[.]5 8081 Java JNDI LDAP, MySQL JDBC BLOB & H2 RCE Exploit Workbench Block
R09-IOC-02 IPv4 143.92.57[.]247 4444 Downstream Reverse-Shell, H2 Exfiltration & XSS Listener Block
R09-IOC-03 IPv4 129.226.71[.]134 8899 Cloud/API/DNS Reconnaissance & Injection Validation Workbench Block
R09-IOC-04 IPv4 38.246.253[.]11 8085 Rogue RS256 JWKS (RFC 7515 jku) & HTTP 301/302/307/308 Redirector Block
R09-IOC-05 SHA-256 67e0a6cd4f9d33100b5586db7fc520a9c3bdf552efba25eaa26193a271cacb96 8000 Electron AI IDE ASAR Nearest-Neighbor Closure Locator #21 SHA-256 Hunt
R09-IOC-06 SHA-256 58d60d46032f0773450f3423c590e33def5c8d82d99ea7d3eeb030e48bcf75da 8000 Electron AI IDE app.asar & CLI Bundle OAuth Secret Scanner #1 SHA-256 Hunt
R09-IOC-07 SHA-256 fa4c8b7e32a988708b8be3f242f8da7b4950317e744d25dc29562f2d7668b89b 8000 Electron AI IDE hostProcessLocalEnv Spawn-Host Inspector #10 SHA-256 Hunt
R09-IOC-08 SHA-256 ae94f76f756ba03d649fd1cfd5d5e4499964d35d240004ae1201f2d69a6ff561 8000 Electron AI IDE ASAR Module Scope Parser #15 SHA-256 Hunt
R09-IOC-09 SHA-256 82bf3e60b1a88f3aec71340135071c7ef274bbc79d0af957feda96ef03ecd722 8000 Electron AI IDE ASAR Minified Closure Locator #19 SHA-256 Hunt
R09-IOC-10 SHA-256 2905df5e743e78e506301a5eb5db64d5ee2693ac1b2db4f471e3752f27814240 3314 Configurable Rogue MySQL Protocol BLOB Server (TCP 3314) SHA-256 Hunt
R09-IOC-11 SHA-256 f168a63ff299f329042018ac619a5798ff7f32db84e00d695486dbdb52e230d5 1389 Rogue Log4Shell javaSerializedData LDAP Server (TCP 1389) SHA-256 Hunt
R09-IOC-12 SHA-256 fd02682812241e87923e1dd84c143172311e2fd2ccd96e24102902712d94c3bf 3312 Rogue MySQL JDBC autoDeserialize BLOB Server (TCP 3312) SHA-256 Hunt
R09-IOC-13 SHA-256 1c17f27b9f5dac7c800e1e8525d51eaa776de908f55f17acd2acc8d9f465fd0f 8081 H2 Database CREATE ALIAS Java Runtime RCE Payload SHA-256 Hunt
R09-IOC-14 SHA-256 6d52a91e2c376bb58f95d67b34bbdf6c79215d80074d77f19f21c551c56cf8fb 8081 Bash /dev/tcp/143.92.57[.]247/4444 Reverse Shell Script SHA-256 Hunt
R09-IOC-15 SHA-256 a6d229a047b79585c56440d4cf51bffda83431f4917d592abc15ca50bff5093a 8085 HTTP 302 IMDS (100.100.100.200 RAM) SSRF Redirector SHA-256 Hunt
R09-IOC-16 SHA-256 ecd9a613e61a457652b9a587e2c698687056ae961d743cfeb0d80235d69af23b 8085 Multi-Code (301/302/307/308) HTTP Redirect Bypass Server SHA-256 Hunt
R09-IOC-17 SHA-256 ddf4f0ffd2f5a3d1f1e68801975a1788de48079f4746ff7f41eb6c14218796b7 8085 Rogue RS256 JWKS Public Key Set (kid=hktest1) SHA-256 Hunt
R09-IOC-18 SHA-256 8215966f15ad99df70d12359b5357322fb2e4d6a9b47b0e97f47cbc25b823b68 8899 Recon Workbench API Endpoint Enumerator SHA-256 Hunt
R09-IOC-19 SHA-256 5ef1c728993da674a1ce87e7dcce45fb377ef905338a6e0c553cb11b6df7ea59 8899 Recon Workbench Subdomain Brute-Forcer SHA-256 Hunt
R09-IOC-20 IPv4 43.230.171[.]150 8080 Multi-Host AD/SQL Dropper & Credential Staging Host Block
R09-IOC-21 IPv4 38.207.179[.]179 8088 High-Density C2 Payload & Command Staging Server Block
R09-IOC-22 IPv4 51.194.215[.]35 8080 Automated Shell-Dropper Staging Infrastructure Block
R09-IOC-23 IPv4 8.137.114[.]242 8080 Exposed Gophish & Reconnaissance Tooling Workbench Block
R09-IOC-24 IPv4 144.172.99[.]199 8080 OAST & DNSLog Out-of-Band Callback Harvest Host Block
R09-IOC-25 IPv4 8.138.12[.]59 9999 Fastjson Exploitation & Session Token Harvest Workbench Block
R09-IOC-26 IPv4 38.60.227[.]210 8082 GitHub-C2 Agent & Cryptominer Dropper Staging Host Block
R09-IOC-27 IPv4 47.109.23[.]77 8888 JNDI Exploit Class-Loader & Botnet Staging Host Block

1 records from this study are not published in this table: candidate, suspected and dual-use hosts, victim-related values, and hashes of exposed secrets or files.

Defender kit

Detection rules

The rule files exactly as printed in the report. Test them in your own engine before deployment.

Sentinel KQL sentinel_electron_asar_and_imds_jwks_hunt.kql 34 lines
Download
Sigma sigma_electron_asar_unpack_and_cli_cred_theft.yml 137 lines
Download
Suricata suricata_ide_secrets_jndi_and_jwks_ssrf.rules 18 lines
Download
YARA yara_electron_asar_jndi_blob_and_jwks_toolkits.yar 82 lines
Download