VirLabs Blog
Reconstructing the toolset of a C77L affiliate
By Ivan Kwiatkowski ·
While hunting for potential ESXi malware samples, I came across a Rust executable called .vmtoolsd (SHA256 11d1aae0e834a6941fa9cbf20ee9b10599d1f3dceae7f608be377880241f11b5, VirLabs analysis). It has no malicious detections on VirusTotal at the time of writing this but contained enough ESXi-specific logic to warrant a closer look. Our analysis revealed it to be both a reverse-shell and a tunnelling tool. Pivoting from this file led to a victim report describing ESXi hosts affected by ransomware.
Further down the road, the discovery of small log files eventually led to two Windows executables sharing the same implementation, configuration and C2 server. I wasn't able to attribute this toolset to a specific group but I believe we have a reasonably solid picture of a cross-platform toolset, along with a few hypotheses to share with the broader community.
It's a double backdoor all the way across the sky!
The implant checks for VMware configuration files and the esxcli executable to select its installation routine. On ESXi, it copies itself to /etc/vmware/.vmtoolsd, modifies /etc/rc.local.d/local.sh, and adds a cron watchdog that checks whether it is still running every 15 minutes. If the process disappears, cron starts it again. It creates /etc/vmware/firewall/vmsvcesxics.xml, enables the corresponding ruleset, and allows outbound TCP connections to ports 8080 and 32921. Finally, it invokes /sbin/auto-backup.sh, evidently as a persistence mechanism.
There is a conventional Linux branch as well: if esxcli is not present, the executable becomes /usr/local/bin/systemd-update, with a service (helpfully) described as System Update Service. It adds systemd, cron and existing rc.local persistence depending on which of those mechanisms are available. The installation branches require root, but if permissions are unavailable the program simply moves on to its networking code.
The malware establishes two separate channels with its C2 server 66.23.235[.]118. Each serves a different purpose:
| Port | Purpose |
|---|---|
| 8080 | HTTP initialization followed by multiplexed TCP forwarding |
| 32921 | Independent reverse shell |
The implant's configuration is stored as 18 bytes XORed with 0xA7. Decoding it produces 66.23.235.118:8080. Nothing particularly exotic, although this small detail becomes important when hunting for relatives. The first packet looks like an ordinary HTTP request: the implant sends a JSON initialization body advertising version 2.1.0:
{
"sid":"0123456789abcdef0123456789abcdef",
"v":"2.1.0",
"init":true
}
Each initialization request carries two freshly generated random identifiers: a 32-character lowercase hexadecimal session ID in the JSON sid field, and a separate 16-character lowercase hexadecimal value in the HTTP X-Request-ID header. This request is sent to any one of the five following paths:
/api/v2/analytics/collect
/api/v1/telemetry/report
/cdn/assets/config.json
/api/v3/session/heartbeat
/api/v2/events/batch
The browser impersonation is somewhat optimistic: the hidden daemon on an ESXi server announces itself as Chrome, Firefox or Edge running on Windows (see exact user-agents used in the IOC section below). The implant reads the response headers and declared body, then searches the response for the substring 200 OK. After that, the connection stops being HTTP and switches to a custom binary protocol. Each message has a four-byte big-endian length followed by a one-byte type (see the next table), a four-byte big-endian channel ID, and a variable payload. (The length excludes its own four-byte field.)
| Type | Direction | Meaning |
|---|---|---|
| 1 | Controller to implant | Connect to the destination provided in the payload |
| 2 | Both | Forward data for an existing channel |
| 3 | Both | Close a channel or report its termination |
| 4 | Implant to controller | Destination connection succeeded |
| 5 | Implant to controller | Destination parsing or connection failed |
| 6 | Implant to controller | Keepalive |
Channel IDs let several destination connections share the same outbound session and establish tunnels. The controller asks the infected machine to open a connection, then exchanges bytes with the destination through the implant:
sequenceDiagram
participant C as Controller
participant I as Infected host
participant D as Internal service
I->>C: Outbound TCP and HTTP initialization
C-->>I: HTTP response containing 200 OK
C->>I: Type 1, channel ID, destination
I->>D: Open TCP connection
I-->>C: Type 4, connection succeeded
C->>I: Type 2, channel ID, request bytes
I->>D: Forward request
D-->>I: Response bytes
I-->>C: Type 2, channel ID, response bytes
I->>C: Periodic type 6 keepalive
A keepalive packet is sent every 20-25 seconds. Reconnection uses exponential backoff with jitter, with a base capped at five minutes. The second channel is straightforward: a separate process connects to port 32921, attaches the socket to standard input, output and error, and executes /bin/sh, with /bin/ash as a fallback.
A ransomware incident in the wild
A BleepingComputer help thread posted on September 26 mentions this exact malware sample. In it, the author describes a ransomware incident affecting ESXi 6.5 and 6.7 hosts, including a backup host and a vSAN cluster. Files were encrypted with the .aleks extension, and the ransom note was named aleksan_help.txt. The poster also reports a separate tool producing logs with the string esxi-enc build 20260924d-exec1-bg, and suspects initial access through reused root SSH credentials. The encryption payload remains missing, but it's not a stretch to imagine the attackers found a way in, used the tunneling tool to get their bearings inside the internal network and finally executed their ransomware plan.
The note supplies aleksandra@msg.ws and a Session identifier as contact means; I found no reuse of those exact contact details elsewhere, but the wording of the note resembles samples from the C77L family even retaining an instruction to use Tox after switching the contact method to Session. Templates travel, but I'd still tie the incident to C77L with moderate confidence -- and therefore the surrounding toolset to a C77L affiliate.
One C2, many implants
Expanding the search, I discovered three text files named svc.tmp submitted between April and August 2026. Each was 119 bytes long and contained text such as:
23:07:03 [INFO] connecting to 66.23.235.118:8080
23:07:03 [INFO] tcp connected
23:07:03 [INFO] handshake ok, streaming
This wording isn't present in the Rust binary in my possession, however those files traced back to two Windows executables (VirLabs analysis) written in Rust:
| Hash | Platform | Observed name |
|---|---|---|
3ca5c394111056c6c07622d463d94ae18dbc786d4b52a41a3fcd9f76a8f4931a | Windows x86 | srvsncs.exe |
47aa531e3963fddfb99f06da2a007bd3dbaf8f24d6928074048475d91099995d | Windows x64 | upconsec.exe |
Despite being compiled for different OSes, both executables contain the same tunneling features, C2 server and network protocol as the ESXi variant. Rust panic metadata also confirms the connection: all retain references to proto.rs, with aligned response-parser locations. All this to say, they are all descendants of the same codebase. The Windows x64 sample also appears in Digital Arts' August 31 malicious-email advisory, several weeks before the ESXi incident was reported. This indicates that email is likely one of the infection vectors.
This server also appears in a Windows backdoor written in Go (SHA256 40c687260322046108c2113d18a837652c9d3e383416942f16ce19c54c724a97, VirLabs analysis), configured to connect to port 61295. It is a straightforward reverse shell: after checking its environment, it starts a hidden command interpreter and relays commands and their output over a plaintext TCP connection. Like the Rust tunnel, it conceals its configuration using XOR 0xA7.
The infrastructure pivot produced one last result: an OTX/CAPE report identifies a QuasarRAT artifact configured for 66.23.235[.]118:3521. The report dates from September 7. Subsequent VT relationship checks identify this artifact as a dump and link it to an original executable first submitted on August 27. That original has the same endpoint and configuration strings in its existing behavior summary. The timing indicates that QuasarRAT was likely used by the same operators as the tunnelling implant described in this article: the Quasar executable was submitted two days before the Windows x64 tunnel client, and both precede the September ESXi report.
Conclusion
From an undetected ESXi backdoor, we could reconstruct the probable toolset of a C77L affiliate, including Windows clients, a Go reverse shell and QuasarRAT. The most revealing clues were a few tiny log files, likely collected during automated sandbox runs, which connected binaries whose shared endpoint was hidden from plaintext searches. The investigation did reveal an interesting detection gap: that even a known malware family on Windows can become essentially invisible when compiled to another OS.
Indicators of compromise
File hashes
11d1aae0e834a6941fa9cbf20ee9b10599d1f3dceae7f608be377880241f11b5 ESXi/Linux x64 Rust tunnel v2.1.0; .vmtoolsd
3ca5c394111056c6c07622d463d94ae18dbc786d4b52a41a3fcd9f76a8f4931a Windows x86 Rust tunnel v2.1.0; srvsncs.exe
47aa531e3963fddfb99f06da2a007bd3dbaf8f24d6928074048475d91099995d Windows x64 Rust tunnel; upconsec.exe
2faa786249553e701bbc3b2f7785f678fd20ae666076c2dd574fe35c76d452e0 RAR archive containing the Windows x86 Rust tunnel
7ea77a2a08a5ac8c1b29afb0a8da5cdf6fb3a0c41e793ad1da16e452bec4d37c svc.tmp log associated with Windows x64 execution
6405958f2e6bcd07b2b5097d2f2e6c1e8f34d6b2720fa7753e15889ffe8afc99 svc.tmp log related through the RAR archive
6b1214db600b9b585c19eef4c43cfd8070debf471123bb00ecb77807d828588e svc.tmp log associated with Windows x86 execution
12eb1e9ed90f13e6543ba7c1d28c4ec396c281f1b2bf24e2127125c57024d12f Quasar executable linked by shared infrastructure
e57b46ef3d1d9137b26e0734b75e9ef875f5492d893e3bc9d9008ceaf6d1a025 Related Quasar dump
efb81f8392405ba2d2356d769e63fda06ee65fff86aa6b8b9c5f79a4ada15934 Additional Quasar-related artifact; reviewed through metadata and behavior
40c687260322046108c2113d18a837652c9d3e383416942f16ce19c54c724a97 Go reverse shell
Network indicators
66.23.235[.]118:8080 Rust tunnel C2 endpoint
66.23.235[.]118:32921 ESXi/Linux ELF reverse-shell endpoint
66.23.235[.]118:3521 Quasar C2 endpoint
66.23.235[.]118:61295 Go reverse-shell C2 endpoint
User-Agents
Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/125.0.0.0 Safari/537.36 Rust tunnel HTTP user-agent impersonating Chrome 125
Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:126.0) Gecko/20100101 Firefox/126.0 Rust tunnel HTTP user-agent impersonating Firefox 126
Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/124.0.0.0 Safari/537.36 Edg/124.0.0.0 Rust tunnel HTTP user-agent impersonating Edge 124
File paths
/etc/vmware/.vmtoolsd ESXi Rust tunnel installation path
/etc/vmware/firewall/vmsvcesxics.xml ESXi firewall configuration
/usr/local/bin/systemd-update Linux Rust tunnel installation path
/etc/systemd/system/systemd-update.service Linux systemd persistence
/etc/cron.d/systemd-update Linux cron persistence
/tmp/.vmw-dsc-4f1e.lock ESXi/Linux ELF runtime marker
/tmp/.vmw-svc.log ELF log path
/var/log/.vmw-svc.log ELF log path
svchost_mtx_7F3A.tmp Windows file-lock marker created in a temporary directory
svc.tmp Windows log filename; requires correlation with other evidence
C:\Windows\SysWOW64\SubDir\svnhost.exe Observed Quasar execution path
