Operation ShadowCloud: Inside the GitDoor Backdoor
Securelist details Operation ShadowCloud, a modular intrusion campaign using MeshAgent, DLL sideloading, memory loaders, and GitHub-based command and control.
Operation ShadowCloud is a modular intrusion campaign that combines a legitimate remote-management utility, DLL sideloading, encrypted payloads, in-memory execution and cloud-hosted command and control. In its analysis, Securelist reports activity affecting government organizations in Asia and Africa, with identified activity in a Taiwanese organization. The campaign’s tooling is designed to make malicious traffic resemble ordinary use of services such as GitHub, Microsoft SharePoint and Ably.
The campaign is notable less for a single novel exploit than for how several familiar mechanisms are assembled into an adaptable delivery and control system. Securelist identified two backdoors, GraphDoor and GitDoor, along with multiple shellcode families and plug-ins. This article focuses on the initial infection evidence, the loader architecture and GitDoor’s GitHub-based communications, while separating directly observed behavior from details that remain unresolved.
What Securelist confirmed
Securelist says it identified two MeshCentral Agent instances running inside a Taiwanese organization. MeshCentral is a legitimate web-based administration tool that provides remote desktop, command-line and file-management functions. The exact means by which the attackers installed the agent was not established. However, the researchers found evidence consistent with reuse of an earlier compromise already present on the network.
The observed agent was configured to connect to 27[.]102[.]66[.]162 over a WebSocket path. After the session was established, the agent was used to place three components on the endpoint: a legitimate executable, a malicious DLL intended for sideloading, and an encrypted file containing a payload.
Securelist documented two deployment layouts. In one, a legitimate Sandboxie Start binary named start.exe loaded a malicious sbiedll.dll, with an encrypted payload stored in config.ini. In another, a legitimate Python application binary named dtsapo4service.exe loaded a malicious python39.dll, again alongside an encrypted configuration file. The researchers also observed other legitimate executables used with loader DLLs, including OpenJDK’s javaw.exe and the Sysinternals Screen Magnifier tool zoomit.exe. In the latter case, the attackers started the executable as a Windows service.
From trusted executable to memory-resident payload
The sideloading stage gives the operation a way to launch malicious code through applications that may appear familiar to administrators and security tools. Securelist identified loader names including jli.dll, SbieDll.dll, python39.dll, WINMM.dll and libcef.dll. The precise legitimate executable paired with each loader varied across samples.
The researchers analyzed two loader families. Type 1 uses a layered decoding process. Depending on the sample, the loader reads config.ini, applies a custom Base64 decoding routine, then decrypts the content with RC4 followed by XOR. It also transforms decoded bytes through Windows networking APIs that normally convert Ethernet addresses between text and binary representations. Securelist assessed this unusual data transformation as an evasion mechanism.
After decoding, the loader allocates memory, changes its protection to executable and transfers control to an embedded bootstrap routine. The bootstrap performs relocation and import resolution before invoking the payload. API names are concealed through hashing and encrypted strings. Other Type 1 samples use reflective loading and create a file-mapping object named in the form Local\sm%lu, where the process identifier is substituted at runtime.
Type 2 uses a simpler XOR-based payload decryption process. Before execution, the loader checks for specific byte patterns in Windows system libraries, installs a vectored exception handler under certain conditions, clears a hardware breakpoint register and verifies the process name. It then decrypts the payload, places it in memory and starts a new thread at the executable’s MZ header, which serves as a trampoline into bootstrap code. The loader selects native or conventional Windows memory and thread APIs according to the operating-system version.
These behaviors make conventional file-centric analysis less reliable. The payload is encrypted on disk, decoded during execution and copied into memory. Both GitDoor and GraphDoor also use control-flow flattening, layers of helper functions and indirect calls, all of which increase the effort required for static analysis. The source does not report a CVE associated with this activity.
GitDoor’s cloud-based control channel
GitDoor, identified by Securelist with MD5 552f0a9cc5fc3755721fa49be05e8035, uses GitHub repositories as a command-and-control system and also communicates with Ably. The analyzed sample used one repository to receive commands and plug-ins and another to store victim information and command output. The repositories cited by the researchers were github[.]com/LatonyCharnleyaW/Havo and github[.]com/LatonyCharnleyaW/Trix. Securelist reports that these repositories were later taken down.
At startup, GitDoor decrypts configuration values such as the repository locations, a GitHub personal access token, HTTP headers and a browser-like User-Agent string. It collects public and internal IP addresses, the Windows domain, username, hostname, working directory, process name and identifier, Windows version, CPU type and running-process information. The malware generates a host identifier and a session GUID, then creates a GitHub issue in the upload repository. The issue title and body contain the session and victim identifiers needed to associate subsequent files with the infected system.
Collected data is encrypted before transmission. Securelist describes AES-256-ECB encryption with a randomly generated key, followed by additional XOR processing, Base64 encoding and delivery through GitHub and Ably. The sample sends data to the Ably REST service at rest[.]ably[.]io and uses a channel name derived from the victim identifier. It also checks an Ably channel for status information and retries through another channel if a transfer fails.
On GitHub, the malware checks whether a victim-specific file exists and creates it when necessary. It then retrieves the contents of the command repository, searches filenames for the local victim code and downloads matching files. Securelist observed command and plug-in naming conventions that used filenames resembling main.<victim-code>.<random>.js, with extensions such as .kmap, .pmap, .apmap, .swp and .tmp.
The backdoor initially downloads plug-ins for screen capture and process enumeration. Those files undergo a two-stage decryption process and are loaded directly into memory. The wider command framework described by Securelist supports shellcode delivery, file operations, command execution, scheduled-task activity, registry operations, user and group enumeration, keylogging, screenshots, browser-cookie collection, credential-dumping tooling and proxy functions. These capabilities were reported in the analyzed toolset; their use in every identified intrusion was not established.
Detection implications
The most useful detection opportunity is the combination of behaviors rather than any one indicator. Security teams should review cases where a signed or familiar executable loads an unexpected DLL from the same directory, especially when the DLL name resembles a system or application library. Pay particular attention to service-created instances of tools that are not normally deployed as services.
Endpoint telemetry should also flag processes that read an adjacent encrypted configuration file, allocate executable memory, modify memory permissions to executable and writable, create a thread at an MZ header or perform reflective loading. API hashing, unusual memory mappings and execution from regions not backed by ordinary image files are additional useful hunting signals.
At the network layer, GitHub API activity from servers or administrative workstations should be reviewed in context. A process making repeated repository-content requests, creating or modifying issues, applying and removing labels, and accessing files with victim-specific names is unusual even when the destination is a legitimate service. The combination of GitHub API traffic and requests to rest[.]ably[.]io deserves investigation, particularly when the client process is a sideloaded binary or an unsigned DLL.
Teams should avoid treating GitHub or other cloud providers as inherently benign. Blocking those services outright may disrupt business operations, so a more practical approach is to apply identity-aware egress controls, monitor API use, restrict personal access tokens and alert on unusual repository access from endpoints that do not normally use developer services.
What organizations should do now
- Hunt for the supplied hashes: Search endpoint, EDR and malware repositories for the MeshAgent, loader, encrypted-payload, GitDoor and GraphDoor MD5 values listed below. Treat matches as leads requiring validation, not as proof that the complete campaign is present.
- Inspect DLL loading: Review module-load telemetry for
jli.dll,SbieDll.dll,python39.dll,WINMM.dllandlibcef.dllwhen they appear beside unexpected or uncommon legitimate executables. - Review remote administration tools: Confirm whether MeshCentral Agent deployments are authorized, identify their installation source and validate their configured destinations. Remove unapproved agents and investigate systems where the installation history is unclear.
- Monitor cloud-service behavior: Alert on unusual GitHub issue creation, repository-content polling, repeated label changes and uploads from production or government endpoints. Review Ably traffic and API-token use alongside endpoint process data.
- Protect credentials and tokens: Rotate exposed GitHub or cloud-service credentials, enforce least privilege and prevent personal access tokens from being embedded in unmanaged software or endpoint configuration.
- Investigate memory execution: Use EDR telemetry to identify executable private memory, reflective loading, suspicious thread creation and processes whose image and loaded modules do not match expected software inventories.
- Preserve evidence: If activity is suspected, collect volatile memory, process trees, service definitions, module-load events, DNS and proxy logs, GitHub API records and relevant files before removing the agent or payload.
What remains unknown
The initial entry point was not determined. Securelist’s evidence suggests reuse of an existing infection, but the research does not establish how that earlier compromise occurred. The report also documents technical clues that are examined further in a separate GraphDoor analysis; the supplied research does not establish a definitive threat-actor attribution for the activity covered here.
Conclusion
Operation ShadowCloud demonstrates how attackers can combine legitimate administration software with sideloaded loaders and cloud-hosted control channels. GitDoor’s use of GitHub issues, repository files and Ably allows command traffic and stolen data to blend with permitted web services, while encrypted payloads and in-memory execution reduce obvious disk artifacts. Defenders should therefore correlate module loading, memory behavior, service creation and cloud API activity instead of relying on domain blocking or file scanning alone.