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:

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.

A flowchart in Cortex XDR depicting an attack on a compromised web server via a web shell, marked in red text. The flow includes multiple instances of "cmd.exe" executing commands and connecting a RAT. The chart shows a systematic execution path with labeled nodes.
Figure 1. Execution of the PerfectPioneer RAT from a web shell, as shown in Cortex XDR.

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.

Screenshot of a PDF document in Burmese, featuring a colorful logo with a hand symbol at the top. The document contains text beginning with "2025" in bold. The header text is highlighted in yellow.
Figure 2. A decoy PDF containing a notice regarding the 2025 Myanmar Prime Minister election.

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
  • 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.

Screenshot of a series of code snippets in a programming script. The code includes commands related to file operations and internet commands like "wget," "curl," and "powershell." Various numbers and symbols are used for reference and index numbers in brackets. Commands are primarily related to file deletion or downloading.
Figure 3. Code snippet from the PerfectPioneer RAT’s isDangerousCommand code.

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.

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.

Screenshot of a code snippet displaying a function related to loading and executing a screenshot module. Includes error messages like "Failed to load screenshot module" and "Failed to capture screenshot".
Figure 4. Code snippet of KUKURAT code that executes the screenshot module.

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.

A flowchart of a command execution process in Cortex XDR. Three main icons are shown, each labeled with "CGO." Lines connect these icons, indicating the sequence of commands leading to the execution of a file. There are red exclamation marks indicating alerts or risks, and the word "KUKURAT" is prominently displayed in red/ A command string at the bottom shows the execution pathway. Some text is redacted for privacy.

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).

Screenshot of Cortex XDR dashboard alert titled 'Execution of an uncommon process with a local/domain user SID at an early startup stage with suspicious characteristics.' The alert provides details about the execution of AdobePhoto.exe with potential persistence mechanisms. Status is shown as unassigned and severity as medium.
Figure 6. An alert raised for the log-on script persistence technique, as shown in Cortex XDR.

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.

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.

Screenshot of Cortex XDR dashboard showing execution alert. It includes a notification about an unusual process execution with a local/domain user SID at an early startup stage, flagged for suspicious characteristics. There are tabs labeled Overview, Resolution, Work Plan, and Analysis.
Figure 7. An alert for DCSync attack, as shown in Cortex XDR.

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.

  • 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.

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.

Screenshot of a diagram in Cortex XDR displaying a process tree for "powershell.exe". Three subprocesses branch from "powershell.exe," each executing distinct PowerShell commands and other mail and role assignments.
Figure 8. Execution of PowerShell commands targeting email infrastructure, as shown 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.

Screenshot of a screen from Cortex AgentiX related to an endpoint investigation. It details the process `Photo.exe` with frequent communication over multiple networks, indicating potential malicious behavior. The document mentions a specific path and file location, as well as technical insight into the process's activity and characteristics, highlighting it as suspicious.
Figure 9. Finding processes that communicated with www.investigationj6[.]com, using AgentiX.
Palo Alto Networks customers are better protected from the threats discussed above through the following products and services:

  • 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

IP Addresses

  • 27.254.164[.]212
  • 27.254.164[.]209

Additional Resources

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.

Screenshot of a table listing different project paths with columns for network protocol, persistence, keylogger, screenshot, SOCKS5 proxy, and unique features. Each row represents a project path. The network protocols are HTTP/3 and HTTP/2, some with fallback options. Persistence, keylogger, screenshot, and SOCKS5 proxy features are indicated with check marks or Xs. Unique features include process injection, masquerade as a PDF file, and local HTTP server, among others.
Figure 10. Structural matrix outlining the differences between the PerfectPioneer RAT variants.

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:

  1. / – API discovery: returns a list of all available endpoints
  2. /info – Agent metadata: returns agent name and variant
  3. /health – Liveness check: returns OK status with current timestamp
  4. /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:

  1. Registry Run key: Directly writes the executable's absolute path to HKCU\Software\Microsoft\Windows\CurrentVersion\Run
  2. 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.

Command Frame Architecture

When issuing commands to KUKURAT, the C2 server pushes the following structural convention.

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

Enlarged Image