Site Menu

Other Sites

Inside the OverLord Loader: An Encrypted JavaScript Stage and Cross-Platform Remote-Control Agents


AI authorship disclosure: This post was generated with the assistance of an AI agent. The analysis reflects the artifacts and methods described below; readers should validate indicators against their own telemetry.

Research date: November 17, 2026 · Method: static analysis and controlled retrieval · Confidence: high for code-level capabilities, unknown for deployment on any victim

An obfuscated JavaScript file led us through a remote configuration file, a signed stage request, an AES-GCM-protected second stage, and several remote-control agent implementations. The code calls its agent configuration OVERLORD_*, which supports using OverLord as a codebase label. Our analysis does not establish who operated it. We did not execute the malware, establish an agent session, or observe a victim host.

This post documents what we retrieved, how we analyzed it, and which behaviors defenders can hunt. The accompanying STIX 2.1 IOC bundle (ZIP) contains the verified file hashes, exact URLs, and observed domain. No attacker IP address was identified, so the bundle contains no IP indicator.

Illustration of the encrypted JavaScript loader feeding a server resolver and Windows, macOS, and Linux agents

The chain at a glance

OverLord loader and agent architecture
  1. The first-stage botchk.js is a 49,855-byte obfuscated Node.js script, SHA-256 45c094b760d91635e58bd5e73baa9ca21ba081f97492dca1e066627fadde2590.
  2. It reads https://gitlab.com/up-indexings/tasks/-/raw/main/config.json as a server list. During this investigation, that list returned api.cerysoi.ink.
  3. It makes a signed request to https://api.cerysoi.ink/botchk/fetch. The retrieved 6,244,787-byte wrapper has SHA-256 098dc1cc835a5ee387c449c053cb14e405e730cb3e3c27758e74cdb28f328b1d.
  4. Decrypting the wrapper’s AES-256-GCM blob as data yielded a 4,683,026-byte JavaScript second stage, SHA-256 aa2fa2514c5faa306ddaae908541874873e4002b63be0ca698a091c82a3a1f78.
  5. That second stage contains collection and persistence logic. Its standard install path carries an embedded Windows Node.js agent or an embedded Unix Node.js agent. It also contains alternate paths for six hosted macOS and Linux Go binaries.

The diagram distinguishes the standard Node.js path from the alternate Go handoff. The Go binaries were available on the server, but their availability alone does not mean a normal second-stage run installed them.

Methodology and tools

We began with the first-stage sample and recorded its SHA-256 before inspecting it. We used static text and code inspection to recover the dead-drop URL and the signed fetch flow. The remote stage was retrieved through the request shape present in the code, saved in quarantine, and decrypted without evaluating the JavaScript. We parsed the embedded ZIP as an archive, extracted source files, and read command dispatchers and persistence routines. We retrieved the six hosted binaries with HTTPS GET, verified file magic and size, and kept them without execute permission.

For the Go builds, we inspected strings and Go runtime metadata, parsed the Linux amd64 pclntab to map function names to addresses, and checked selected call edges in Ghidra. Shell utilities, Python scripts, file hashing, and JSON/STIX validators supported the workflow. We used stix2 and stix2patterns to parse the IOC bundle and validate its indicator patterns. No live detonation, endpoint telemetry, or network session capture was part of this analysis.

That distinction matters. A command handler in source code establishes a capability; it does not show that an operator invoked it. A reachable URL establishes availability at the time of retrieval; it does not show that a victim downloaded it.

What the second stage tries to do

The decrypted stage contains routines to collect browser credentials, developer files such as .env, SSH private keys, wallet material, and platform credential stores. It can stage collected material into archives and send chunks to /api/company-wallet/upload-chunk/.... Its installation code attempts persistence before collection. Depending on platform and privilege, it uses:

Platform Code-backed persistence artifact Standard agent path
Windows Scheduled task GoogleUpdateSupporterNode; %LOCALAPPDATA%\Google\node-agent Embedded Windows Node.js ZIP
macOS LaunchAgent or LaunchDaemon label com.google.UpdateSupporter Embedded Unix Node.js source
Linux google-agent.service user or system unit Embedded Unix Node.js source

The Windows agent ZIP is 3,115,837 bytes, SHA-256 09498e24e6d15415096af45eae717c0787f8c1776d14fdba3b545875650d2bc9. The Unix source is 66,707 bytes, SHA-256 39f19fcf96d6642263caaec0f1c7c0ce1abec93eb583656ee279d43a730afc5a.

Remote-control channel and commands

The embedded agents resolve a server list, connect to wss://<server>/api/clients/<clientId>/stream/ws?role=client, and present X-Agent-Token in the handshake. They send a host hello, maintain a ping/reconnect loop, and exchange MessagePack messages. The Windows code explicitly disables TLS certificate validation for the WebSocket and update download. That creates a potential server-impersonation exposure for an on-path party; we did not observe such interception.

The Windows Node.js command dispatcher implements an interactive cmd.exe console, PowerShell/cmd/bash/Python execution, process listing and termination, file listing/read/write/search/transfer/zip/execute, screenshots, screen streaming, mouse and keyboard input, clipboard read/write, agent update, and uninstall. A plugin load/unload command returns “plugins not supported in node agent,” so plugin support should not be counted as a working feature in this sample.

The Unix Node.js agent implements shell and interactive console access, script execution, file operations, screenshots, process operations, update, and uninstall. Its command dispatcher does not expose the Windows agent’s explicit desktop mouse/keyboard and clipboard cases. Linux screenshots also depend on a GUI session and capture tooling. These are platform-specific code differences, not observations from a live host.

The hosted Go agents

Six separately hosted Go executables were returned from /data/google-update-support-<platform>-<arch>. The standard installation path uses the embedded Unix Node.js source; alternate or legacy handoff functions reference the Go executables, and a special --linux-agent-only mode can use a Linux Go handoff.

Build Format SHA-256
macOS arm64 Mach-O 187a5535d4c91fd52d5a9a0285efe91fb0e70c007e619d55bb13a530a123a4f5
macOS amd64 Mach-O 3084e392a581009bef973faa15ad4f8cb36a1aa248c447944b38616044aea04d
Linux amd64 ELF 8819a25e84f36878be2c2dc86c2a052ce6a645f01d389f4ee5d31829fae9494f
Linux arm64 ELF f6eaf92d1fd90495186f5c5572c5381d566d802a5d77c2dc18be3ce035770d30
Linux arm ELF 4defb5fa9d1dae12202437adc569d433444d3b10ec752cdde8a5b7813e7e7611
Linux 386 ELF c418545429989dc47ca48804ddc6f99276b38baabf3ba901d8ab91a8a77350dd

All six share the WebSocket client path and chunk-upload path and contain Go function metadata for command dispatch, screenshot capture, file download, and browser credential export. In the representative Linux amd64 build, Ghidra’s call graph showed handlers.HandleCommand directly calling HandleFileDownload, HandleScreenshot, and HandleScriptExecute. The binary also has separate browserlogin.ExportCredentialsEP and companywallet.UploadPOST functions with callers. This is stronger than a bare string match, but we did not trace every platform build or run any of them.

DGA and encrypted IP assessment

We found no evidence of a domain generation algorithm or encrypted IPv4/IPv6 address in the reviewed code. The first-stage obfuscation and AES layer conceal code, but the decoded server target was a domain returned by a GitLab configuration file. The agents parse an ordered server list, remember a working index, and fail over or refresh it. That behavior is remote configuration, not domain generation. The list can change later, so the observed domain is a point-in-time IOC.

ATT&CK mapping and hunting ideas

The following mappings are supported by reviewed code, not by a confirmed victim timeline:

Tactic area MITRE ATT&CK technique Evidence in this sample
Defense evasion T1027 Obfuscated Files or Information, T1140 Deobfuscate/Decode Files or Information Obfuscated first stage and AES-protected second stage
Persistence T1053.005 Scheduled Task, T1543.001 Launch Agent, T1543.004 Launch Daemon, T1543.002 Systemd Service Platform-specific install routines
Execution T1059 Command and Scripting Interpreter Shell and script command handlers
Credential access T1555.003 Credentials from Web Browsers, T1555.001 Keychain, T1552.001 Credentials in Files, T1552.004 Private Keys Browser, keychain, .env, and SSH collection routines
Collection T1005 Data from Local System, T1113 Screen Capture, T1115 Clipboard Data File collection and agent screen/clipboard handlers; clipboard is explicit in Windows agent
Command and control T1102.001 Dead Drop Resolver, T1071.001 Web Protocols, T1105 Ingress Tool Transfer GitLab server list, HTTPS/WebSocket channel, stage/agent retrieval
Staging and archive T1074.001 Local Data Staging, T1560.003 Archive via Custom Method Local archive construction and chunk upload

Archive upload may map to T1041 Exfiltration Over C2 Channel or T1048.002 Exfiltration Over Asymmetric Encrypted Non-C2 Protocol, depending on how the actual deployment separates its WebSocket control and HTTPS upload traffic. We treat that subtechnique as provisional without network telemetry.

Practical hunts include the exact GitLab configuration path, /botchk/fetch, the WebSocket route and X-Agent-Token, the Google-themed task/service labels, the agent directory, and processes that combine a packaged Node runtime with shell spawning or screen capture. The STIX bundle provides exact file and URL indicators. Hashes are precise for these retrieved builds but may change with a rebuild; paths and behaviors can help when hashes do not.

Download the IOC bundle

Download the OverLord STIX 2.1 bundle (ZIP) — ZIP containing the JSON file; 24 STIX objects, including 21 indicators for 11 SHA-256 hashes, nine exact URLs, and one domain. It intentionally includes no IP address because no attacker-controlled IP was observed. The JSON file SHA-256 is fcf42be47cdaff35236cb711590c1fb6b358ca773aa29696058a5fcc46edabc3.

Limits and conclusion

The evidence supports an encrypted JavaScript loader and multiple code-backed remote-control agents, with collection, persistence, and upload paths across Windows, macOS, and Linux. It does not prove that any specific victim received the second stage, that an operator used a command, or that the hosted Go builds were installed in the standard path. Attribution remains outside the scope of this analysis. Treat the IOCs as leads to correlate with endpoint and network telemetry, and use the code-level behaviors to guide broader hunts.

Previous: