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.

The chain at a glance

- The first-stage
botchk.jsis a 49,855-byte obfuscated Node.js script, SHA-25645c094b760d91635e58bd5e73baa9ca21ba081f97492dca1e066627fadde2590. - It reads
https://gitlab.com/up-indexings/tasks/-/raw/main/config.jsonas a server list. During this investigation, that list returnedapi.cerysoi.ink. - It makes a signed request to
https://api.cerysoi.ink/botchk/fetch. The retrieved 6,244,787-byte wrapper has SHA-256098dc1cc835a5ee387c449c053cb14e405e730cb3e3c27758e74cdb28f328b1d. - Decrypting the wrapper’s AES-256-GCM blob as data yielded a 4,683,026-byte JavaScript second stage, SHA-256
aa2fa2514c5faa306ddaae908541874873e4002b63be0ca698a091c82a3a1f78. - 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.
