Executive Summary
Unit 42 has uncovered a multi-stage cyberespionage campaign that has been targeting Southeast Asian government entities since at least July 2025. We track this activity as TGR-STA-0049 (also tracked as REF7707, Earth Alux, Ink Dragon). The defining signature of the threat actor behind the activity is the targeting of government entities, combined with the use of advanced custom payloads that are designed for high-stealth intelligence collection operations, with an emphasis on evading security detection tools.
The campaign we investigated demonstrates high operational stealth and novel tool sets.
Activity associated with this group previously included deploying Squidoor (AKA FINALDRAFT) – an advanced backdoor used against high-value global targets since 2023.
Recently, activity associated with this group has included expanded tradecraft. Associated activity that we observed included deploying two previously undocumented custom remote access Trojans (RATs): PerfectPioneer RAT (spotted in July 2025) and its modular successor, KUKURAT (deployed in March 2026).
Over a nine-month period, we observed the attackers behind the activity consistently refining their capabilities to meet evolving operational needs. This campaign’s tradecraft features three particularly advanced capabilities:
- Covert HTTP/3 (QUIC) C2 communications: An early adoption of HTTP/3 over UDP, providing a highly efficient command and control channel that may bypass traditional TCP-optimized deep packet inspection.
- An operational safety switch: PerfectPioneer RAT features a built-in validation engine that actively blocks remote operators from executing noisy or destructive commands that could trigger environment security alerts.
- Multi-vector heuristic camouflage: KUKURAT employs a custom spoofing engine that generates synthetic, benign-looking network, registry and file activity. By manipulating the behavioral baseline of the endpoint, it can successfully obscure indicators of compromise within a vast volume of artificial noise.
We provide a comprehensive technical breakdown of these unique malware families, the group’s evolving techniques, tactics and procedures (TTPs) and the highly targeted data exfiltration observed in this campaign.
Cortex AgentiX Agentic Assistant streamlined our investigation.
Palo Alto Networks customers are better protected from the threats described in this article through the following products and services:
- Advanced WildFire
- Advanced URL Filtering, Advanced DNS Security and Advanced IP Defense
- Cortex XDR and XSIAM
- Idira Endpoint Privilege Manager (EPM)
- Idira Privileged Access Management (PAM)
- Idira Secure Infrastructure Access (SIA)
Organizations can access tailored adversary intelligence, direct analyst consultations, and specialized exposure tracking through Unit 42 Threat Intel Services and its Deep and Dark Web Service.
If you think you might have been compromised or have an urgent matter, contact the Unit 42 Incident Response team.
| Related Unit 42 Topics | Remote Access Trojan (RAT), Cyberespionage, Command and Control (C2) |
Background on TGR-STA-0049
TGR-STA-0049 has been active since at least March 2023. It primarily targets high-value sectors, including government organizations across Southeast Asia, South America and Europe. The targeting of strategic entities for data collection and exfiltration, combined with advanced stealth practices and long-term persistence, are characteristic of cyberespionage operations.
In previous campaigns, this group deployed Squidoor, a backdoor targeting Windows and Linux systems. As the group expanded its operations, it continued to integrate new tools and malware variants into its tool set. In their most recent campaign, dating back to mid-2025, the attackers introduced two previously undocumented, advanced malware families designed for stealth, data collection and exfiltration: PerfectPioneer RAT and KUKURAT. As this campaign progressed into early 2026, the threat actor began transitioning their infrastructure from PerfectPioneer to the new KUKURAT, which has been observed in the wild since March 2026.
We uncovered six distinct variants of PerfectPioneer RAT that the group tracks as:
- newhttp3
- PerfectRat
- Pioneer
- RatAAkk-tt
- rat_http3_ls
- rat_http3_cc
All six variants have evolved iteratively since at least July 2025, exhibiting rapid, adaptive development cycles. Our analysis focuses on newhttp3 as a representative example.
Operational Overview and Infrastructure
We examine the TTPs observed in this recent TGR-STA-0049 campaign, and map the full operational lifecycle, including:
- Initial infection vectors
- Adopting HTTP/3 as a communication protocol
- Credential harvesting and data exfiltration methodologies
We also provide a deep dive into the underlying architecture and specialized capabilities of the PerfectPioneer RAT and KUKURAT malware families, focusing on:
- A structural comparison of different PerfectPioneer RAT variants across the development lifecycle.
- PerfectPioneer RAT’s unique isDangerousCommand fool-proofing mechanism that prevents the malware operator from executing forensics-heavy or destructive commands.
- KUKURAT's extensive modular framework.
- KUKURAT’s integration of automated heuristic camouflage engines.
Infection Vectors
The attackers behind this activity leverage a dual-track infection strategy to establish and maintain a foothold inside targeted organizations through a combination of server exploitation and phishing.
Server exploitation is the primary infection vector observed in this campaign — such as the exploitation of vulnerable, unpatched Microsoft Exchange servers and web servers to deploy web shells. We observed a mix of custom and publicly available web shells, including variations of ASPXSpy, Godzilla, Bysunue.aspx and Suo5. This tooling is consistent with the actor's past campaigns.
Figure 1 shows the execution of the PerfectPioneer RAT from a web shell, and how attackers use it to execute initial reconnaissance commands on the infected server.

Our investigation revealed that the threat actor employed phishing tactics as a secondary infection vector, leveraging decoy PDFs and lookalike domains to manipulate users into compromising their hosts. The use of tailored infrastructure and industry-specific decoys demonstrates a highly targeted strategy designed to maximize deception within high-priority sectors.
HTTP/3 Adoption
Both PerfectPioneer RAT and KUKURAT use HTTP/3 as the primary method for communicating with C2 infrastructure. While the adoption of HTTP/3 is rare across the broader malware landscape, its deployment in this campaign reflects an emerging trend among advanced threat actors. The deployment of HTTP/3 provides:
- A secure and fast communication channel: HTTP/3 uses the QUIC transport protocol running over UDP.
- An effective defense evasion mechanism: Because HTTP/3 uses UDP, enterprise network defenses cannot perform passive TLS interception without breaking the underlying connection. Some corporate firewalls and traditional IDS/IPS engines are not updated to inspect UDP traffic with the same level of scrutiny as standard TCP traffic. When legacy security policies are not optimized exclusively for TCP-based web channels, outbound UDP port 443 communications frequently bypass deep packet inspection entirely – potentially allowing malicious QUIC traffic to flow unhindered.
PerfectPioneer RAT: Deep Dive
Since at least July 2025, the group associated with this activity has deployed PerfectPioneer RAT, a custom Go-based malware family. We examine the RAT's execution methods on infected hosts and explore the architecture and behavior of a representative variant. Our structural comparison of six distinct iterations illustrates the adversary's active development pipeline.
Loaders and Execution
In addition to being dropped to disk as an executable, we observed the execution of PerfectPioneer RAT via three methods across compromised networks: DLL side-loading, decoy installers and phishing. This tactical versatility underscores the threat actor’s operational agility, optimizing target deception and defense evasion across varied environments.
- DLL side-loading: The attackers dropped a legitimate, benign executable that they had structurally modified to contain XOR-encrypted shellcode embedded with the PerfectPioneer RAT payload. A malicious loader DLL accompanies this altered binary. Upon execution, the modified legitimate application loads the side-loaded DLL, which reads, decrypts and executes the shellcode from the tampered host executable. The shellcode then deploys the payload in memory.
- Decoy installers: The actor used decoy software installers to drop to disk and execute the PerfectPioneer RAT background agent, while running a seemingly normal application setup wizard. In one case, we found that a decoy software installer wrote to disk and executed a GlobalProtect installer. This legitimate Palo Alto Networks secure remote access product was used as a cover, while an executable of PerfectPioneer RAT was written to disk and executed in the background.
- Phishing: Unsuspecting targets downloaded several malware samples from domains masquerading as official government websites. To evade detection and deceive victims, these executable files are disguised as PDF files, displaying a PDF icon. When the victim attempts to open the PDF file, they actually click on the malware which launches a decoy PDF document to maintain the illusion of legitimacy while the malware runs in the background.
Figure 2 shows one of the decoy PDF documents used by the threat actor, impersonating a 2025 official document from the Union Election Commission of the Republic of the Union of Myanmar.

The newhttp3 Variant
Our deep dive focuses primarily on a variant that the author labeled newhttp3, as revealed in one of the recovered project paths: D:/proj/http3/newhttp3/agent/. We selected this sample for deeper technical evaluation because it represents the most feature-complete variant.
Commands and Capabilities
The newhttp3 variant contains an expansive array of commands that potentially grant the remote operator total control over the compromised endpoint. These capabilities are natively compiled into the Go binary, unlike the dynamic modules architecture later introduced in KUKURAT.
newhttp3 includes a diverse suite of capabilities for comprehensive data harvesting, host control and resource management, which can be structurally grouped into the following functional categories:
- File operations
- List, upload, download, delete: Full file system access
- Chunked transfers: Large files are transferred in chunks with progress tracking
- Temporary files management: Open file handles are tracked and periodically cleaned up
- Shell execution
- Command execution capabilities
- Process management
- List/kill/start processes
- COM-based process creation: Alternative execution path via COM objects
- Code injection using the classic VirtualAllocEx, WriteProcessMemory and CreateRemoteThread techniques
- Keylogging
- SOCKS5 proxy
- Screenshot capture
- Window enumeration and manipulation
- Resource monitoring
We provide the full list of commands in Appendix A: Analysis of Additional PerfectPioneer RAT Features.
Architecture and Communication
The newhttp3 variant’s communication framework appears to be designed with a focus on both network evasion and operational stability. Rather than relying on a single communication channel, the malware blends stealthy network protocols with automated routines aimed at maintaining steady connectivity and managing host resource overhead.
PerfectPioneer RAT relies on HTTP/3 as its primary C2 communication mechanism, automatically falling back to HTTP/2 in the event of connection failure.
The agent interacts with the C2 infrastructure via four principal endpoints, as detailed in Table 1. The URL endpoints used by PerfectPioneer RAT overlap with those used later by KUKURAT, representing another key artifact connecting the two families to a common development pipeline.
| URL Endpoint | Usage |
| /agent/register | Register a new agent |
| /agent/heartbeat | Send heartbeat to C2 |
| /agent/tasks | Get tasks from C2 |
| /agent/result | Send task execution result |
Table 1. URL endpoints used by PerfectPioneer RAT newhttp3 variant.
Self-Healing Connection Architecture
PerfectPioneer RAT implements three highly specific automated routines. These are designed to maintain stable connections and manage system overhead, to minimize its forensic footprint and maintain a low profile.
- Reconnection routine: This routine ensures the connection to the C2 remains active by tracking an internal variable named connected. If the connected variable is toggled to false by either the heartbeat or command polling routines due to a network disruption, the reconnection routine immediately steps in. It cancels the active heartbeat and command polling loops, then forces a clean re-registration workflow with the C2 server in an attempt to forcefully reset the connection state.
- Cleanup routine: Designed to limit the malware's forensic footprint on disk and prevent excessive consumption of host memory, this routine achieves its goals via two automated methods:
- Cleanup temporary files: Continuously tracks and deletes all temporary files created during operation. This minimizes the creation of persistent artifacts on disk and shortens the window of opportunity for endpoint detection tools or forensic analysts to recover cached operational data from the file system.
- Cleanup memory usage: Monitors the active memory footprint of the RAT. If memory usage exceeds 100 MB, it explicitly forces Go’s runtime garbage collection cycle to aggressively purge unallocated memory. Keeping the process memory footprint low reduces the likelihood of triggering suspicion due to high CPU usage.
- Resource monitoring routine: This routine tracks client-side CPU and memory utilization on behalf of the operator. It captures a performance snapshot every 30 seconds, which the remote operator can later retrieve via a specific command to monitor host machine overhead.
Comparison of PerfectPioneer RAT Variants
We identified six distinct variants of PerfectPioneer RAT. Comparing these provides a unique window into the group’s active development cycle and illustrates how they adapt their code to meet specific operational constraints.
While the underlying codebase is very similar across variants, we observed differences in communication protocols and functional features. The compilation timestamps across all analyzed samples were either systematically modified or completely omitted, which prevents the reconstruction of a definitive chronological development timeline.
The specific feature combinations vary across the variants. Certain iterations maintain a lightweight footprint and are feature-sparse, whereas other variants have a broader suite of credential harvesting, process manipulation and network tunneling utilities.
The six variants that we recovered are distinguished by their compiled project paths:
- D:/proj/RatAAkk-tt/agent/
- D:/proj/PerfectRat/agent/
- D:/proj/http3/newhttp3/agent/
- D:/proj/http3/rat_http3_ls/agent/
- D:/proj/http3/Pioneer/
- D:/proj/http3/rat_http3_cc/
A detailed feature comparison of each variant is provided in Appendix A: PerfectPioneer RAT Variants Comparison.
The isDangerousCommand Foolproof Mechanism
isDangerousCommand is one of the most notable and unprecedented features uncovered during our analysis. It is implemented in two specific variants that the author named Pioneer and rat_http3_cc.
Before executing any incoming command from the C2, the isDangerousCommand routine cross-references the instruction against a list of hard-coded commands. If it finds a match, the command is blocked entirely. The blocklist includes administrative commands that would be highly destructive or forensics-heavy (noisy) if executed and which security tools could potentially monitor. The inclusion of this operational “safety switch” prevents the operators from making mistakes that could result in the activity being detected.
Our analysis revealed that the hard-coded blocklist includes a mix of both Windows and Linux environment syntax, as Figure 3 shows.

Because Go code can be cross-compiled for Windows and Linux from the same source code, the inclusion of Linux syntax strongly suggests that the threat actor was developing a parallel Linux variant. The full list of blocked commands can be found in Appendix A: Foolproof Mechanism Blocked Commands.
KUKURAT: A Deep Dive into the Latest Modular Backdoor
In March 2026, the threat actor introduced a new custom payload explicitly named KUKURAT into multiple networks that had already been compromised by PerfectPioneer RAT.
Written in C++, we identified two variants of KUKURAT in the wild. While their core functionality is similar, the variants use different underlying network protocols to communicate with the C2: one variant leverages HTTP/2, the other uses HTTP/3.
Unlike PerfectPioneer RAT, KUKURAT is a completely modular malware framework. Almost every post-exploitation capability is implemented as a separate DLL module loaded dynamically at runtime directly from the C2 server. KUKURAT’s code supports at least 12 distinct named modules.
By pulling capabilities directly into memory only when needed, KUKURAT achieves a high level of evasiveness and adaptability. Because the static core binary contains no advanced feature code, it successfully evades standard binary scans, simplifies feature updates and prevents forensic analysts from recovering the underlying payloads.
Registration and Heartbeat
On startup, KUKURAT registers with its C2 infrastructure by connecting to a /register node and posting the following system information from the infected endpoint:
- Hostname
- Username and integrity level
- OS type and architecture
- Host IP address
- Agent instance ID (randomly generated at runtime)
The C2 responds with initial runtime configuration for the agent.
The JSON values below represent KUKURAT's default hard-coded configuration, featuring a session ID, various operation timeouts and the heuristic camouflage engine status.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 |
{ "session_id": "<session_id>", "obfuscation": { // Heuristic Camouflage ON/OFF "network": 0, "registry": 0, "file": 0 }, "runtime_config": { "heartbeat_timeout_ms": 300000, // Maximum wait time for heartbeat response "command_result_timeout_ms": 300000, // Maximum wait time for command result "file_transfer_chunk_timeout_ms": 300000, // Timeout per file transfer chunk "file_transfer_max_retries": 5, // Max retries for file transfers "file_transfer_retry_delay_ms": 300, // Delay between file transfer retries "heartbeat_retry_before_rereg": 1, // Failed heartbeats before full re-registration "command_worker_threads": 5, // Number of concurrent command execution threads "module_exec_timeout_ms": 600000 // Timeout for module execution calls } } |
Periodically, the KUKURAT agent uses a /heartbeat node to communicate with the C2. This heartbeat lets the backend know the agent is alive and pulls any queued commands waiting for execution. The complete heartbeat JSON is available in Appendix B: KUKURAT Heartbeat JSON Structure.
Capabilities and Supported Commands
Due to its highly modular architecture, KUKURAT’s main binary lacks the embedded code required to perform post-exploitation activities. Instead, according to our analysis of the malware's underlying logic and compiled strings, the modules enable features related to data collection and exfiltration, command execution, reconnaissance and lateral movement.
The modules provide the following capabilities:
- Screenshots and keylogging
- Host and port scanning
- Process management – listing processes, killing processes and process injection
- File management – uploading, downloading, listing, deleting and executing files
- Execution of native shell commands via cmd.exe and PowerShell
- Lateral movement via PsExec
- Server Message Block (SMB) credential brute-forcing
- SOCKS tunneling
- Local privilege elevation
- Execution of Beacon Object Files (BOF)
- Silent mode configuration
KUKURAT’s modular framework facilitates the loading and execution of any arbitrary external module, even if it does not match a pre-existing command handler in the base code. This allows the threat actor to dynamically introduce new capabilities and adapt to shifting operational needs in real time.
See Appendix B: KUKURAT Command Frame Architecture for the full list of KUKURAT commands.
Figure 4 shows a snippet of the KUKURAT code that executes the screenshot module. KUKURAT verifies whether the module is loaded before executing it using the hard-coded parameter capture that is passed to the loaded module. If the loading of the module or the screenshot capture fails, an error message is sent back to the operator.

Deployment of Separate KUKURAT Modules
During our investigation, we observed the attackers using KUKURAT to deploy two additional executables named PsExecService.exe and SecurityGuard.exe. While we could not retrieve SecurityGuard.exe, we successfully recovered PsExecService.exe for analysis.
According to the file's compiled program database (PDB) string, the attackers explicitly classify this binary as an external module of KUKURAT, despite it being compiled as a standalone executable rather than a DLL:
d:\proj\KUKURAT\modules\MyPsExec-master\PsExecService\
This tool is a custom remote execution service that appears may be partially based on the open-source MyPsExec GitHub project. Upon execution, PsExecService.exe registers itself as a local Windows service named PsExec and creates a named pipe called \\.\pipe\PSEXEC. The service natively supports four commands:
- Shell execution
- File uploading
- File downloading
- Directory listing
To limit its forensic footprint, the service employs an internal self-destruct timer that automatically uninstalls the service and cleans up its artifacts after five minutes of inactivity.
Spoofing Endpoint Activity: Heuristic Camouflage Engine
KUKURAT introduces a unique heuristic camouflage engine capable of operating across three system axes: network, registry and files. The purpose of this engine is to generate dummy, legitimate-looking activity on the endpoint to camouflage the malware's actual operations. By mimicking normal operational behavior, the threat actor establishes a false baseline, which may significantly affect automated detection and other forensic efforts. The threat actor can toggle each method on or off via the C2 command set_obfuscation:
- Network noise generation: KUKURAT generates 10 decoy HTTP requests per operational cycle to randomly selected domains, pulled from a hard-coded list of 15 popular websites using randomly generated URL paths. This camouflages traffic, blending C2 communications into normal web noise.
- Registry manipulation mimicking browser activity: KUKURAT mimics legitimate Google Chrome browser behavior by writing random data to the registry path HKCU\Software\Google\Chrome\BrowserCrashRecovery, reading the data back, and then deleting the key. It then opens and enumerates the HKCU\Software\Google\Update\ClientState registry key. The purpose of this sequence is to make the agent's registry operation appear like Chrome crash recovery.
- File noise generation: The malware continuously creates temporary files with random names and randomized content inside the system %temp% directory, only to immediately delete them. This technique generates file system noise, masking the agent's file modifications.
While certain elements of this evasion technique have been previously documented across various malware families, KUKURAT distinguishes itself through a highly unique design choice. It can coordinate heuristic camouflage across three separate vectors, while dynamically enabling or disabling each feature at runtime.
The Watchdog Component
In multiple incidents, attackers deployed KUKURAT alongside a separate watchdog executable that ensures the malware remains active.
When KUKURAT’s main binary executes, it creates a dedicated thread to communicate with the companion watchdog component. KUKURAT writes its own active file path to a local named pipe called WINDOW_SEC_WATCHDOG, every three seconds. The companion watchdog process reads this path and pulls a heartbeat message every second. If 15 seconds pass without receiving a heartbeat, the watchdog assumes that KUKURAT has been terminated and automatically relaunches it using the cached file path.
On one occasion, we observed the threat actor deploying this watchdog component into the C:\ProgramData\Cyvera\Ransomware\ directory path. This folder structure was historically associated with Cortex XDR, demonstrating the threat actor’s attempt to lower suspicion by hiding within security-product directory structures.
Comparison of Variants
The investigation identified two distinct variants of KUKURAT, leveraging HTTP/2 and HTTP/3 respectively for C2 communications. Aside from the difference in network transport protocols, the two variants are structurally almost identical except for a few noteworthy code developments that affect the malware's development adaptability and operational survivability:
- Command-handling architecture: In the HTTP/2 variant, the threat actor implemented a large, nested If-Else conditional chain inside a single command-handling function. All execution and module-loading logic is embedded directly within those conditions. The HTTP/3 variant demonstrates the transition to an array of function pointers that map to individual commands, creating a standalone function for each execution routine. This design shift enables the malware developers to add or remove capabilities on the fly more efficiently.
- Built-in exec bypass command: While KUKURAT is engineered to function as a completely modular malware framework that loads code dynamically, the HTTP/3 variant introduces an explicit, natively coded command called exec. This command enables the attacker to spawn a subprocess directly on the host endpoint via CreateProcessA and pipe the resulting terminal output back to the C2 backend. Because this command does not exist in the HTTP/2 variant, its inclusion suggests that the author sought to provide a built-in survival option: allowing operators to run system commands natively without needing to fetch an external module DLL from the staging server.
Post-Exploitation and Network Propagation
The following section details TTPs used throughout this campaign to move laterally across compromised enterprise networks, gather credentials, transition from Active Directory control to endpoint infection and exfiltrate sensitive data.
Lateral Movement via Domain Log-on Scripts
The threat actor’s most notable method for network propagation involves the manipulation of domain log-on scripts, a stealthy persistence mechanism used to execute code across the environment. In addition, they use well-known tools and remote management protocols such as PsExec, Windows Management Instrumentation (WMI) and Windows Remote Management (WinRM).
After successfully compromising a Domain Controller, the attackers installed malicious log-on scripts. Consequently, whenever a legitimate user authenticated to the domain, the malicious script automatically executed on their local endpoint, triggering the download and execution of the KUKURAT malware.
Figure 5 illustrates the execution of a malicious log-on script that downloads and executes the KUKURAT malware to the infected host, as shown in Cortex XDR.

Figure 5. KUKURAT deployed via a malicious log-on script, as shown in Cortex XDR .
Figure 6 shows that the log-on script persistence technique triggered an alert, due to an uncommon startup process executing with a local or domain user Security Identifier (SID).

Credential Stealing Techniques
Upon gaining initial access, the threat actor employs multiple techniques to harvest credentials including Local Security Authority Subsystem Service (LSASS) memory dumping and Directory Service Replication (DCSync).
The threat actor also actively used a robust suite of credential-dumping tools, dual-use administrative tools and registry manipulation techniques, including:
- Mimikatz and ProcDump
- SharpDPAPI, to decrypt DPAPI credentials and secrets
- Manually dumping the SAM and SYSTEM registry hives to extract local account hashes
LSASS Memory Dumping
The attackers leveraged a living off the land technique to dump the memory of the lsass.exe process. They misused the native comsvcs.dll Windows utility using the following command.
|
1 |
CmD.exe /Q /c for /f "tokens=1,2 delims= " %A in ('"tasklist /fi "Imagename eq lsass.exe" | find "lsass""') do rundll32.exe C:\windows\System32\comsvcs.dll, #+000024 %B \Windows\Temp\MxA.tar full |
Instead of calling the MiniDump function by name, the attackers invoked it via its ordinal hidden index number, #+000024. This evasion tactic is designed to bypass security detection mechanisms that look for the explicit MiniDump string.
Directory Service Replication
To further compromise the identity infrastructure, the attackers executed DCSync attacks to extract password hashes directly from the Domain Controller. This allowed them to simulate the behavior of a Domain Controller replicating user credentials, as Figure 7 shows.

Data Exfiltration
After systematically moving through the network and harvesting high-privilege credentials, the threat actor initiated their primary objective: cyberespionage. Leveraging the PerfectPioneer RAT and KUKURAT malware families, the threat actor attempted to exfiltrate vast quantities of documents back to their C2 infrastructure. The targeted data predominantly consists of .pdf, .docx, .xlsx and .png files with filenames that suggest potential sensitive information in their content,with a pronounced focus on international relations and internal political affairs.
Beyond document exfiltration, the attackers also targeted email infrastructure. From their initial foothold on a compromised Exchange server, they executed various PowerShell commands to identify and misuse administrative privileges.
- Reconnaissance for impersonation rights: The attackers first checked for accounts assigned the ApplicationImpersonation role. In Microsoft Exchange, this role allows a single account to impersonate any user (or a specific subset of users) in the organization. By leveraging this privilege, an account can access other mailboxes directly without needing to know or supply the explicit passwords of those individual users.
The threat actor executed the following commands to identify whether an account they already controlled possessed these rights.
|
1 |
"C:\Windows\System32\WindowsPowerShell\v1.0\powershell.exe" -NoExit -Command "& { . 'C:\Program Files\Microsoft\Exchange Server\V15\bin\exshell.psc1'; Get-ManagementRoleAssignment -Role:ApplicationImpersonation }" |
|
1 |
C:\Windows\System32\WindowsPowerShell\v1.0\powershell.exe -NoLogo -NoProfile -Command "Add-PSSnapin Microsoft.Exchange.Management.PowerShell.SnapIn; Get-ManagementRoleAssignment -Role:ApplicationImpersonation" |
- Broad mailbox access acquisition: If the initial reconnaissance reveals that the threat actor does not have access to an account with existing impersonation rights, the threat actor switches to a more direct backup plan.
Using administrative rights, we observed the threat actor executing a command to loop through every single mailbox in the environment and explicitly grant a compromised user account unrestricted read/write privileges.
|
1 |
C:\Windows\System32\WindowsPowerShell\v1.0\powershell.exe -WindowStyle Hidden -NoLogo -NoProfile -Command "Get-Mailbox -ResultSize Unlimited | ForEach-Object { Add-MailboxPermission -Identity $_.PrimarySmtpAddress -User 'REDACTED' -AccessRights FullAccess -AutoMapping:$False -Confirm:$False }" |
After using a web shell to conduct reconnaissance for impersonation rights, the attackers executed a command to grant themselves access to every single mailbox in the environment. Figure 8 shows the execution of the PowerShell commands targeting email infrastructure in Cortex XDR.

Conclusion
The operations of TGR-STA-0049 reveal a highly adaptive threat actor targeting government infrastructure across Southeast Asia. Through the deployment of KUKURAT and the PerfectPioneer RAT, the attackers behind this activity are actively evolving to stay ahead of traditional network defenses by implementing protocol-level evasion via HTTP/3 and QUIC over UDP.
What makes this group particularly evasive is the extensive effort invested in maintaining operational security and remaining hidden on compromised endpoints. From the implementation of PerfectPioneer RAT’s automated self-healing connection architectures to KUKURAT's highly sophisticated heuristic camouflage engine, the group demonstrates a mature understanding of modern defensive ecosystems. They have even gone so far as to embed hard-coded administrative safety switches within their binaries to prevent their own operators from running loud or destructive commands that might trigger security alerts.
Ultimately, the group’s stealthy tradecraft serves a broader objective: ensuring the success of a highly targeted data exfiltration campaign. This was characterized by the actor’s widespread attempts to steal what appears to be sensitive intelligence, based on filenames, and to exploit mailbox impersonation rights across compromised Exchange environments.
To counter this advanced generation of espionage, defenders must look past legacy, TCP-centric visibility. Protecting high value networks requires a comprehensive shift toward capturing unauthorized UDP-based web traffic, strictly auditing Active Directory validation mechanisms and monitoring for host-level behavioral anomalies that these stealth focused campaigns leave behind.
Palo Alto Networks Protection and Mitigation
To better protect against the TTPs used by TGR-STA-0049, organizations should consider implementing the following network-level and host-level behavioral controls:
- Monitor or restrict QUIC and force protocol fallback: Network administrators should configure edge firewalls to either log and inspect QUIC traffic or block outbound UDP port 443 altogether. Blocking forces HTTP/3 and QUIC communications to gracefully fall back to TCP-based HTTP/2 or TLS channels, ensuring standard deep-packet inspection and decryption engines can monitor the traffic natively.
- Audit active directory log-on scripts: Secure and continuously audit the sysvol share and Group Policy Objects for unauthorized modifications. Configure EDR platforms to alert on suspicious processes executing with domain user SIDs during user authentication.
- Monitor blind LSASS dumping methods: Create behavioral detection rules tracking rundll32.exe interacting with comsvcs.dll to capture ordinal-based invocation methods (such as #+000024) that bypass standard string-based text filtering.
- Audit exchange impersonation and access permissions: Regularly execute validation scripts to review accounts assigned the ApplicationImpersonation role. Monitor Exchange logs for the execution of Add-MailboxPermission commands, specifically flagging automated loops that grant an account FullAccess privileges across the organization.
Cortex AgentiX Agentic Assistant streamlined our investigation by enabling the team to query the data using natural language, providing deeper context and insights, and suggesting clear recommendations on what we should do next. Figure 9 shows the AgentiX interface when finding processes that communicate with a malicious domain used by KUKURAT.

- The Advanced WildFire machine-learning models and analysis techniques have been reviewed and updated in light of the indicators shared in this research.
- Advanced URL Filtering, Advanced DNS Security and Advanced IP Defense identify known domains and URLs associated with this activity as malicious.
- Cortex XDR and XSIAM are designed to prevent the execution of known malicious malware and prevent the execution of unknown malware using Behavioral Threat Protection and machine learning based on the Local Analysis module.
- Idira Endpoint Privilege Manager (EPM) can help enable enterprises to reduce risk, satisfy compliance and streamline operations. It helps implement least privilege via policy-driven elevation and removal of standing admin rights, and blocks risky actions such as executing unvetted applications and access to memory of other processes, while providing audit-ready evidence and unified identity governance.
- Idira Privileged Access Management (PAM) can help unify privileged access across human, machine and agentic identities to secure cloud access across multi-cloud environments. Building on proven PAM, it delivers centralized secrets management alongside modern controls like just-in-time access and zero standing privileges.
- Idira Secure Infrastructure Access (SIA) can help enforce zero standing privileges (ZSP) through just-in-time (JIT) provisioning, which grants temporary, tightly scoped access only as needed. Backed by continuous session recording and real-time command monitoring, SIA can detect high-risk actions before an attacker compromises critical systems.
Organizations can access tailored adversary intelligence, direct analyst consultations, and specialized exposure tracking through Unit 42 Threat Intel Services and its Deep and Dark Web Service.
If you think you may have been compromised or have an urgent matter, get in touch with the Unit 42 Incident Response team or call:
- North America: Toll Free: +1 (866) 486-4842 (866.4.UNIT42)
- UK: +44.20.3743.3660
- Europe and Middle East: +31.20.299.3130
- Asia: +65.6983.8730
- Japan: +81.50.1790.0200
- Australia: +61.2.4062.7950
- India: 000 800 050 45107
- South Korea: +82.080.467.8774
Palo Alto Networks has shared these findings with our fellow Cyber Threat Alliance (CTA) members. CTA members use this intelligence to rapidly deploy protections to their customers and to systematically disrupt malicious cyber actors. Learn more about the Cyber Threat Alliance.
Indicators of Compromise
SHA256 Hashes
PerfectPioneer RAT – RatAAkk-tt
- 2281e754f70e11298db1a0a7c1b527cf2b5eec2056d4c73a46ed572ab873dc6e
- 9721d65ee7695db2b3dc3705f5d8e5efe3a478c3b6d1704d66daf77fe95aeb0d
- d725ad8b523c94f99fca9e72a650e835dca47b9ebe7610d6c4eb3525d410c365
PerfectPioneer RAT – PerfectRAT
- f4c9d5d13c1a09533876a02f6fa04831efbf600b05cfb3ed765a0ebde82b0457
- 19bb3012d846f3672fb98dad0449ae5c267ab30150800b2f1559036564c7d0b8
PerfectPioneer RAT – rat_http3_ls
- 92fb9545ea49e2fb4635fce1859ff3f609738be75f85d146614243fc8bc80b67
PerfectPioneer RAT – Pioneer decoy installer package
- ab06f540ecdd1d45491aa71bfc04c80852371c8f5cd43b9a6ebb53f1e1b69588
PerfectPioneer RAT – Pioneer core agents
- bf59f8d7ef79b09a72bbb9c05ca8746466d03226a3779cc1096ba067117ca008
- 8bf9401990d3255d1022a25884b02ee75ef01bd1a729d29ff52de2e5f0d637a2
PerfectPioneer RAT – newhttp3 modified host binary
- 5f857ff78bfbef2a55a846fc93744e11e07a9b72ee3fc3bc345c32ce9615ddee
PerfectPioneer RAT – newhttp3 loader DLL
- 61f7e2f4159c566578e88cb05cdf49e4378f45ebddbd332224e97c11df922120
PerfectPioneer RAT – newhttp3 core agents
- 5b7effbf0465c05e8dc9a8fea69b000a78237735ea0b854e8d9baee5b7af8344
- cd8f43da32849584751eec884cf7e3208eb0a71108197a32e9bb248612e757d2
- 7541222a1316ec54bf9c8660b923e1d0490a925b2ee92060b1567be7cb1bde4b
- cffcd6f2589d3ab4f3693805d1752b7c328a00cc543dd02b129763e179c3f311
- 5805cb5b0a6fb738ef7c1873b8e5de4281c36c7f440f28717fa9f441c5e0ef17
- a6a9ccffadd00b0e75e913b0f851b1f834fd20588df8b89759d9ae49a48c8e10
PerfectPioneer RAT – rat_http3_cc modified host binary
- b975f5932c04b381f8fa58a3303194f1aff950d3c6cd12dcc1d323bb3393718b
- 904409ce8846394e1fe9a5ce37f2265cbf6933611278ae57fdf5fa74759af2bb
- d700b573ea8387efad633a70124b7a2a3aece844a267157b1cb55be7b62f3b67
- 52d3442fb26023ebc0bc76542b56be88d1c3327c8bcedf1dcb95f80511527f07
PerfectPioneer RAT – rat_http3_cc loader DLL
- 8cfe629fc08ae06c8ba106113ba30bb16fa2fbbf8bd3dd6831d16b031e0ebe70
PerfectPioneer RAT – rat_http3_cc core agents
- 619b749e1c6634d38f15c51005a4237e9076aaaf36927b562a990e8bc34fdfcb
- fb5b0b1d083d6f6afa90948bd1fd1a498b51dd3f6dc7f90a02a2a17818756563
- 183abf82951c2052e9a1829c70c173c11756e8df0e86c8071c27df0988caeaa0
PerfectPioneer RAT unknown variant
- 0533365accbba405757de7eb486533c11c8e0510a28d414ee8c5e6b8a41ed97b
- 3cb5376a5e6c0fcbd6844ab76f3dc73a42da7ecee6ecaaef285d4abe33964fa1
- f5ebe85418655d75d1a760543858846db1478a060875fd19ddaa5e2febc038d7
PerfectPioneer RAT unknown variant – modified host binary
- b5bea4d8b94fbb39ac992e8e763680af6f39d12d42e264b43431fb61cf7b9a88
- 7745523939fc6b31b6a73d8ca1f363c62438b6eef56f6fe8c39e71fcd14b65f4
PerfectPioneer RAT – loader DLL components
- 0c49e1b98a236d3391740473101b66dd48c719fa4112dbef3816b56bce58e6e7
- 24c46bc9269e1c1ee54004e01d5c7c54f759bc1b93a282d3561d2d27f678af86
- e5689e1bf916c2f7649e178008e790ea13eb844aefc14516c06b0da8296377a1
- 63eac14921f138fffe73db417c12afd16d64202ebbee7ad5f08068697d2942d0
- 790e6699704395a7fad633f4e502312bc43693a44a8e18d43239209eefbd7ff2
- f82c06184ab36e91d28f7802c739e637792c241a7ff2fba9ca24178f12423684
- 2e52b2936e67872d1364d2d0d26a8733ed9582b38f6f0b3a877ffdd6e2c04aa4
- 9dfefc7118646535d1193e1b036dd0c93fa66cc585a60301fcdceb6f45903aad
- 600572a912650b258d56aedeef0ab712abbe35a38cdd23faa5a95dacfdc67b7f
- 86194c3b3cc7a58e439621aff42e116ca94d40f3a6f539f20ce483f1cf5a7191
- e8cd6bbcf6073669a7415ce0c9009a0fbb5551bf5e17803be12ef295f0c99889
- 5b779b81a9bb25591ecac6bd74bb44a4a5b2b8f257093f9efd5910346ab8d772
PerfectPioneer RAT – additional variants
- c4b4647795567ab15528edd1ab1bf37fb50e21b442e59a653051061973e87c02
- bf8afbd1c2074c7cd6ff8b86dbe67a57ca5594817e46b24e226b71c4edde7697
KUKURAT – HTTP/3 variant
- b8dca1c7e7a74ce82ab4e4cad9b718a458735d2c6c956e4cf3109aac59bfd0e4
- 9fb0976fcd1f92c4711726a91cff8be9a39944efedc4caf2d80f935327f8f490
KUKURAT – HTTP/2 variant
- 7225ef57161cf0908560811be798d22e9354c071d576540a43aa7900784c0688
- a214d264c6bb0d2ba89986f73e196ea200307574745a245fc42c32fbef4cc140
- 662dc73e11b60b2f12c94b6b68da45de7bffece4b1dcc75679ed020629d0705d
KUKURAT companion watchdog process
- b062b4d8c19baf5c1568e28b3e0a5e2318e9501ea61ddfe804d9755c1bdbf887
KUKURAT PsExecService.exe Module
- 34cc9bc4a533b91e7cdb30fecc57ba609dc890780fd13ecfbc253047b3b37b78
SharpDPAPI
- 0cbde9b7f59dafca80f214121a04eda7804b920da28ce1c06939a4783e6b097f
- cdc9757294d3063eb10c9a37d1d945d31f6857c652b864803815406b02eeefbf
Unmapped files
- 82a989c728db4e09a2b85a4a55f7663cefa62844632cb16dcda5ca70bf09a8a5
- 71d897427329ca14dd621e777046dc35f3d9dc870d3b13a56125125391a56afe
- 6781f84417d0056df95ed38b3e7a6b49312d30119470356f6923238d49de3490
- dd02d28c48cf5cabd35a0b32e05e7c99ff0de35541201026ae36c59e54968c78
- e59b08eb03ffa10ccf9103d171af757308e6d43519c4e904ef5e0929ef92d8fd
Web shells
- 99f571c07170250a84f0ae9de4179044df91244855d9b39978729933ea3d438f
- 7ee22a7b028102bb22f0a41d41cd101d5956c1db0cfd157b22bf4128bd472a4f
- 571067cc8f4224a4b80113b52672c7ac87e25dcdb0282a36a29a1784a24efa27
- 8d8ccf24b785a33a9388043baecc4be247ad01182b87df3f8e425957ef73087c
- 0e01c44e5a0615098d8c583930dd88dbd0ce6fe54b365c9f04d8b315a93f540a
- 1dd423ff0106b15fd100dbc24c3ae9f9860a1fcdb6a871a1e27576f6681a0850
- 04be76217500275335e82eb4c2c1588478f7a171efd7a0d9bdc6bbe83e315589
- 3deb43cc864f2322d374541d99af79d87ad08abf81cd967862c554f1c0c5fdb6
- 224ed1d3f8d7247989f812cb0accc1d1804197916c47d9600e6c4e9bef46a723
- 9b16333820189e94b2368e87cba0a9642595d5be0f985a6351f1ad834f5cd11d
- bdcd0eefc62721814d0bd557285490aa99a4eb0425bf5204e6be16ec7ce93823
- 3e56d049f23ed45a7034e5c74bad45cae11ce6d15189fa7bda6b8d120439c7cc
- 834491282da22555f53b769ef8ad91a958f860c583ee5cb67b3f161caf19f854
PerfectPioneer RAT C2 Domains
- www.maui-cocktailbar[.]com
- ads-edge[.]com
- www.wkuyda[.]com
- www.thailisting[.]net
- www.yangon.it[.]com
KUKURAT C2 Domains
- www.cloudflacecdn[.]com
- www.police.gr[.]com
- www.investigationj6[.]com
Domains
- www.sacofficegov[.]com
- 27.254.164[.]212
- 27.254.164[.]209
Additional Resources
- Inside Ink Dragon – Checkpoint
- What is QUIC? Understand The Protocol – Checkpoint
- A Guide to the Go Garbage Collector – go.dev
- HTTP/3 — Challenges to security and possible response – Medium
Appendix A: Analysis of Additional PerfectPioneer RAT Features
Comparison of Variants
This section details the primary architectural evolutions and functional modifications observed across the different recovered variants of PerfectPioneer RAT. Figure 10 provides a comprehensive structural matrix outlining which post-exploitation capabilities and communication protocols have been added or omitted throughout the malware family's active development lifecycle.

newhttp3 Variant
Table 2 lists the implemented commands in the newhttp3 variant of PerfectPioneer RAT.
| Command | Description |
| file_info | Get file metadata |
| file_list | List directory contents |
| file_delete | Delete files |
| file_upload | Upload file to victim |
| file_download | Download file from victim |
| file_download_chunk | Chunked file download |
| file_upload_status | Check upload progress |
| shell_execute | Execute shell commands |
| process_info | Get process details |
| process_list | List running processes |
| process_kill | Kill process by PID |
| process_kill_by_name | Kill process by name |
| process_start | Start new process |
| process_create_com | Create process via COM |
| process_inject_shellcode | Inject shellcode into process |
| window_list | List open windows |
| window_close | Close a window |
| window_minimize | Minimize a window |
| keylogger_start | Start keylogger |
| keylogger_stop | Stop keylogger |
| keylogger_status | Get keylogger status |
| keylogger_get_events | Retrieve captured keystrokes |
| keylogger_clear | Clear keystroke buffer |
| screenshot_capture | Capture screen |
| screenshot_cleanup | Clean up screenshot files |
| resource_stats | Get CPU/memory stats |
| resource_history | Get resource usage history |
| socks5_proxy | SOCKS5 proxy management |
| update_check | Check for agent updates |
| update_start | Start agent update |
| update_status | Check update progress |
| update_cancel | Cancel pending update |
Table 2. List of available commands in PerfectPioneer RAT newhttp3 variant.
RatAAkk-tt Variant
Project Path: D:/proj/RatAAkk-tt/agent/
The RatAAkk-tt variant appears to be one of the earliest iterations of the malware. This variant relies strictly on HTTP/2 for communication. Other major architectural differences include a lack of persistence mechanisms, no process injection capabilities, no built-in memory or resource monitoring routines, and no self-update engine. However, it features a specialized component named TerminalManagerV2, which functions as an interactive persistent shell session manager.
PerfectRat Variant
Project Path: D:/proj/PerfectRat/agent/
This variant of the malware was specifically built to masquerade as a PDF file and was likely delivered via phishing campaigns. Like the RatAAkk-tt variant, it relies solely on HTTP/2. Key additions include token impersonation capabilities used for local privilege escalation, encryption modules, and direct desktop control features. It lacks persistence, process injection engine modules, and SOCKS5 proxy capabilities.
The desktop control feature in this variant implements a complete interactive remote desktop where the operator can see the screen and control the mouse/keyboard remotely.
rat_http3_ls Variant
Project Path: D:/proj/http3/rat_http3_ls/agent/
This variant is also built to masquerade as a PDF file and was likely delivered via phishing campaigns. This variant shifts to using HTTP/3 communication exclusively. It lacks the majority of secondary post-exploitation features seen in other variants, such as a keylogger, screenshot capturing, a SOCKS5 proxy, process injection and persistence. The absence of these modules suggest that it functions as a streamlined, lightweight footprint variant designed solely for initial access.
Pioneer Variant
Project Path: D:/proj/http3/Pioneer/
This variant also communicates via HTTP/3 only. Like the rat_http3_ls variant, it lacks a keylogger, screenshot capabilities, a SOCKS5 proxy, process injection and persistence. This keeps the Pioneer variant lightweight, making it suitable for initial infection and basic reconnaissance.
This variant introduces the isDangerousCommand.
rat_http3_cc Variant
Project Path: D:/proj/http3/rat_http3_cc/
This variant appears to be a direct continuation of the Pioneer development branch. It retains all the base capabilities of the Pioneer variant but introduces two key additions:
- Active local persistence mechanisms
- An embedded local HTTP server
The local HTTP server is used solely for local monitoring. It listens on port 56793 and has four endpoints:
- / – API discovery: returns a list of all available endpoints
- /info – Agent metadata: returns agent name and variant
- /health – Liveness check: returns OK status with current timestamp
- /status – C2 connection status: returns dynamic JSON with an isConnected boolean indicating whether the agent is currently connected to the remote C2 server
Commands Blocked by isDangerousCommand
The isDangerousCommand foolproof mechanism uses a three-layered protection model to block categories and commands:
Layer 1: Hard-Coded Keyword Filters
This layer blocks a total of 41 explicit destructive, system modification and administrative commands attempted by the operator:
- Disk destruction:
Blocks commands that format, wipe or overwrite raw storage.
Keywords: format, fdisk, mkfs, dd if=, diskpart, cipher /w:, sdelete, wipe, shred
- Recursive deletion:
Prevents aggressive, unconstrained file deletion commands.
Keywords: rm -rf /, del /f /s /q c:
- System power actions:
Intercepts commands that would shut down or restart the host, killing the agent's active session.
Keywords: shutdown, reboot, halt, poweroff, init 0, init 6
- Denial of service (fork bomb):
Blocks the classic Linux shell resource exhaustion string.
Keywords: :(){ :|:& };:
- Permissions and ownership tampering:
Blocks broad access modifications targeting root structures.
Keywords: chmod 777 /, chown root /
- User and group management:
Prevents the rogue manipulation, addition, or removal of system accounts.
Keywords: passwd, su -, sudo su, userdel, useradd, usermod, groupdel, groupadd
- Service disruption and process killing:
Filters commands designed to terminate background tasks or wipe automated execution schedules.
Keywords: crontab -r, systemctl stop, systemctl disable, service stop, killall, pkill -9, kill -9 1
- Firewall disruption:
Blocks commands that attempt to flush or reset host-based firewall configurations.
Keywords: iptables -F, ufw --force reset, netsh firewall
- Registry and boot configuration manipulation:
Intercepts Windows-specific administrative tweaks that alter system states or delete sensitive hives.
Keywords: reg delete, regedit, bcdedit
Layer 2: Malicious Execution Pattern Filters
This layer acts as a heuristic filter, blocking 16 common payload delivery shortcuts, obfuscation attempts and command chaining:
- Chained deletions:
Detects attempts to append file removal commands onto logical execution operators.
Patterns: && rm, | rm, ; rm, && del, | del, ; del - Direct device writes:
Blocks direct outputs to raw Linux terminal paths or data redirection loops designed to suppress error messages.
Patterns: > /dev/, 2>/dev/null - Download-and-execute pipelines:
Intercepts classic script-staging methods that download and immediately pipe online payloads into a local shell.
Patterns: curl | sh, wget | sh, curl | bash, wget | bash - Encoded PowerShell execution:
Blocks attempts to run heavily obfuscated, Base64-encoded PowerShell payloads natively.
Patterns: powershell -enc, powershell -e - Silent string echoing:
Prevents script manipulation shortcuts or automated interactive prompting bypasses.
Patterns: cmd /c echo, echo y |
Layer 3: Core Directory Staging Protections
The final layer serves as a localized guardrail. It explicitly drops any file removal commands (rm, del, rmdir, rd) if they are directed at one of 12 critical operating system paths required to keep the endpoint stable and online:
- Linux protected directories:
/etc/, /bin/, /sbin/, /usr/bin/, /usr/sbin/, /boot/, /sys/, /proc/ - Windows protected directories:
c:\windows, c:\program files, c:\program files (x86), c:\system volume information
PerfectPioneer RAT Persistence
PerfectPioneer RAT establishes long-term persistence on infected hosts via two concurrent methods:
- Registry Run key: Directly writes the executable's absolute path to HKCU\Software\Microsoft\Windows\CurrentVersion\Run
- Startup folder shortcut: Creates a .lnk shortcut file inside the logged-in user's Startup folder.
Appendix B: Analysis of Additional KUKURAT Features
Heartbeat JSON Structure
The KUKURAT agent communicates with its C2 server via a designated /heartbeat node. This mechanism verifies agent liveness and retrieves queued operator tasks. The structural JSON payload transmitted by the agent is shown in the following code.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 |
{ "session_id": "<session_id>", "heartbeat_interval_min": <int>, // Minimum heartbeat interval "heartbeat_interval_max": <int>, // Maximum heartbeat interval "silent_mode_enabled": <0|1>, // Silent mode ON/OFF "silent_remaining_seconds": <int>, // Remaining time for silent mode "runtime_config": { "heartbeat_timeout_ms": <int>, // Maximum wait time for heartbeat response "command_result_timeout_ms": <int>, // Maximum wait time for command result "file_transfer_chunk_timeout_ms": <int>, // Timeout per file transfer chunk "file_transfer_max_retries": <int>, // Max retries for file transfers "file_transfer_retry_delay_ms": <int>, // Delay between file transfer retries "heartbeat_retry_before_rereg": <int>, // Failed heartbeats before full re-registration "command_worker_threads": <int>, // Number of concurrent command execution threads "module_exec_timeout_ms": <int> // Timeout for module execution calls }, "loaded_modules": ["module1", "module2", ...], // Loaded modules list "module_states": [ { "name": "module1", // Module identifier "alive": <0|1>, // Whether the module is active "active_calls": <int>, // Number of currently executing calls "unloading": <0|1>, // Whether the module is being unloaded "last_error": <int>, // Last error code from module execution "last_action_tick_ms": <int> // Timestamp of last module action } ] } |
Command Frame Architecture
When issuing commands to KUKURAT, the C2 server pushes the following structural convention.
|
1 2 3 4 5 6 |
"commands": [ { "id": "<command_id>", // Never parsed by the agent "type": "<command_type>", // Command type "params": "<params_string>" // Parameters to be passed to the modules } |
Some of the commands in KUKURAT’s code are executed through modules, and others are used to modify KUKURAT’s configuration. Each module that is loaded and executed can receive additional parameters from the C2.
Table 3 lists the command types of KUKURAT, in the order that they appear in the code.
| Command Type | Description |
| screenshot | Loads and uses the screenshot module, using a hardcoded capture parameter that is passed to the module. |
| portscan | Loads and uses the portscan module. Async port scan in separate thread with progress reporting. |
| hostscan | Loads and uses the hostscan module. Runs an async host scan in a separate thread. |
| processlist | Loads and uses the processmanager module. Used to perform process-related operations such as listing, killing and process injection. |
| keylogger | Loads and uses the keylogger module. |
| filemanager | Loads and uses the filemanager module. Used to perform file-related activities. |
| file_download | Downloads file from the infected host using the filemanager module. |
| file_upload | Uploads file to the infected host using the filemanager module. |
| shell | Loads and uses the shell module. Used to execute shell commands. |
| execute_module | Downloads and executes a BOF via a module named BofLoader.dll. Downloads and executes any module named by the attacker. |
| load_module | Loads a module DLL into the agent. |
| my_psexec | Loads and uses a module named MyPsExec.dll. |
| smb_brute | Loads and uses a module named SmbBrute.dll. |
| socks | Loads and uses a module named yuze_dll.dll. |
| set_heartbeat | Adjusts heartbeat interval. |
| set_runtime_config | Updates runtime configuration. |
| set_silent | Enables silent mode for N hours. Silent mode suppresses all command execution except set_silent itself. |
| set_obfuscation | Enables or disables network, registry, or file heuristic camouflage. |
| com_exec | Loads and uses a module named ComExec.dll. |
| unload_module | Unloads a specific module by name. |
| unload_all_modules | Unloads all loaded modules. |
| exec | Enables the attacker to execute a process via CreateProcessA. No module is necessary. Appears only in HTTP/3 variant. |
Table 3. KUKURAT command types.
Obfuscating Commands as Hashes
When KUKURAT communicates with the C2 it uses specific endpoint URLs. These endpoint URLs have a hardcoded hashed counterpart in the code which is used for C2 communication. For example, when KUKURAT sends a heartbeat to the C2, it uses the hashed counterpart of the /heartbeat endpoint URL (/c8a4e192), and sends the heartbeat to [C2-domain]/c8a4e192.
KUKURAT uses these hashed endpoint URLs to send the result of different operations for the C2. The malware code contains endpoint URLs which are not referenced in the base code of KUKURAT, but are likely referenced in some of the available modules. The endpoint URLs provide an indication of KUKURAT’s additional capabilities:
| bypass_uac
register heartbeat get_sysinfo port_scan screenshot |
proxy_start
proxy_stop load_module unload_module download_module execute_command |
file_list
file_download file_upload file_delete file_execute shell_execute |
process_list
process_kill process_inject keylogger_start keylogger_stop powershell_execute elevate_privilege |