Skip to the stories
AI & ML

PerfectPioneer and KUKURAT Show How HTTP/3 Is Entering Espionage Malware

  • Tom Fakterman
  • 417 reads

A campaign targeting Southeast Asian organizations pairs HTTP/3 command traffic with two evolving RATs, modular payloads and layered stealth tactics.

PerfectPioneer and KUKURAT Show How HTTP/3 Is Entering Espionage Malware

Two custom remote access Trojans show how a persistent espionage operation is adapting its tooling. PerfectPioneer, a Go-based implant first observed in July 2025, uses HTTP/3 for command traffic and falls back to HTTP/2. Its successor, KUKURAT, appeared in March 2026 with a modular design that retrieves capabilities from command infrastructure as needed. Both are linked to TGR-STA-0049, a group active since at least March 2023 and known by other tracking names, including REF7707, Earth Alux and Ink Dragon.

The activity targets high-value organizations, particularly government entities in Southeast Asia, with earlier targeting also reported in South America and Europe. Its combination of server exploitation, phishing, domain-level spread and extensive data collection points to a long-running intelligence-gathering operation. The shift from PerfectPioneer to KUKURAT matters because it changes how defenders may need to inspect and investigate the malware: KUKURAT keeps much of its post-compromise functionality outside its core executable, loading modules dynamically from its command server.

From server access to endpoint control

Compromised servers are the primary entry point described in the investigation. Attackers exploited vulnerable, unpatched Microsoft Exchange and web servers, then installed web shells to run commands and deploy malware. The observed shells included custom tools and public or previously reported variants such as ASPXSpy, Godzilla, Bysunue.aspx and Suo5. A web shell gives an operator a way to issue commands through an exposed server, making it useful both for initial reconnaissance and for staging additional payloads.

Phishing served as a secondary route. The attackers used decoy PDFs, lookalike domains and tailored documents intended to match their targets. PerfectPioneer also appeared in decoy installer packages and through DLL side-loading, where a malicious library is loaded by a legitimate application. This mix lets operators adjust delivery to the systems and users they can reach.

One decoy impersonated a 2025 document from Myanmar’s Union Election Commission. That detail illustrates how the operators tailored lures to their intended audience; it does not establish that every infection followed the same delivery path. Across the observed activity, the tools and decoys suggest a campaign designed to gain access in more than one way and then maintain it.

PerfectPioneer’s evolving toolkit

Researchers recovered six PerfectPioneer variants, with development visible from at least July 2025. Their core code is similar, but features and network protocols vary. Some builds are relatively lean, while others include credential collection, process manipulation, proxying or remote desktop functions. The compilation timestamps were altered or absent, so the samples do not support a reliable, precise development chronology.

The most feature-complete sample, called newhttp3 in a recovered project path, provides a view into the implant’s capabilities. Its functions are compiled into a Go binary rather than fetched as independent modules. The available command set covers data collection, host control and resource management, giving the remote operator broad access to an infected system. That bundled design can make a single implant capable, but it also means the code for those functions is present in the executable for analysis.

PerfectPioneer uses HTTP/3 as its main command channel and switches to HTTP/2 if the first connection fails. HTTP/3 runs over QUIC, which carries web traffic over UDP rather than TCP. For operators, this offers a different network path from the TCP traffic many monitoring setups have traditionally emphasized. The implant’s fallback also gives it another way to communicate when HTTP/3 connectivity is unavailable.

The malware contacts its command infrastructure through four principal URL endpoints. Some overlap with endpoints later used by KUKURAT, an artifact that supports a shared development lineage. The implant also automates routines intended to keep communication stable and limit resource use. Together, fallback transport and background maintenance are designed to keep the agent available while reducing conspicuous host activity.

Two PerfectPioneer variants, named Pioneer and rat_http3_cc, contain a function called isDangerousCommand. Before running a received instruction, the malware checks it against a built-in blocklist and refuses certain commands. The blocked items include administrative and destructive operations likely to draw attention or disrupt the infected machine. This guardrail appears intended to prevent operators from issuing commands that could expose the intrusion or break their access.

The blocklist includes Windows and Linux command syntax. Since Go can be compiled for both operating systems from shared source code, that mix suggests the developers were considering a Linux build. The mechanism is also revealing in another way: the operators anticipated that their own activity could create a detection signal, and built restrictions into the implant to reduce that risk.

The variants show different operational roles. An early sample called RatAAkk-tt uses HTTP/2 and lacks persistence, process injection, resource monitoring and self-update features, but includes an interactive shell manager. Another HTTP/2 build disguised as a PDF adds token impersonation, encryption and interactive desktop control, while omitting several other capabilities. HTTP/3-only builds named rat_http3_ls and Pioneer are lighter, without features such as keylogging, screenshots, proxying, process injection or persistence. A later Pioneer branch adds functions while retaining its basic design.

These differences suggest the family was not simply being expanded in a straight line. Some samples appear suited to initial access and basic reconnaissance, while others carry more tools for sustained operation. The recovered evidence does not establish exactly how the group selected a variant for each target, but the range gives operators room to trade capability against footprint.

KUKURAT moves capabilities out of the core binary

KUKURAT marks a more substantial architectural shift. Written in C++, it has been observed in two variants: one communicating over HTTP/2 and one over HTTP/3. Their structure is largely alike, with network transport as the clearest difference. Unlike PerfectPioneer, KUKURAT is modular: most post-compromise functions are separate DLLs that the agent loads dynamically from its command server.

The core supports at least 12 named modules. The analyzed logic and strings point to functionality for reconnaissance, command execution, data collection and exfiltration, and movement through a compromised network. Because modules can be loaded even when they do not match a pre-existing handler in the core, operators can add capabilities without replacing the entire implant.

That design changes what a static inspection of the main executable can reveal. If the binary contains little of the advanced functionality, a scan of the file alone may miss what the agent can do after it contacts its server. Loading modules into memory only when needed also limits the material available for later forensic recovery from the host. It gives operators flexibility, while making network activity and runtime behavior more important evidence sources.

At startup, KUKURAT contacts a /register endpoint and sends system details. The server replies with runtime settings, including a session identifier and operation timeouts. The agent then periodically calls a /heartbeat endpoint. Those messages tell the server that the implant is active and allow it to retrieve queued instructions.

Some endpoint paths are represented in the code by hashed counterparts. For example, the heartbeat route can be sent as /c8a4e192. Other paths in the malware may correspond to functions implemented in its modules rather than the core. The endpoint structure therefore offers clues about capabilities that may not be visible in the main executable.

The malware checks whether a requested module is loaded before running it. In one screenshot example, the operator’s command invokes a module using the parameter capture. If loading or execution fails, KUKURAT reports an error. This arrangement separates the command interface from the implementation of each capability, so operators can select a function and supply parameters at runtime.

Camouflage and persistence on infected hosts

KUKURAT includes a heuristic camouflage engine that can generate dummy, legitimate-looking activity across network traffic, registry operations and files. Operators can enable or disable each area through a set_obfuscation command. The approach aims to make the malware’s actions resemble ordinary system activity and complicate automated analysis. Its distinguishing feature is the coordination of several camouflage methods, controlled at runtime.

In multiple incidents, KUKURAT also ran alongside a watchdog program. The implant writes its active file path to a local named pipe called WINDOW_SEC_WATCHDOG every three seconds. The companion process checks for a heartbeat every second and relaunches KUKURAT if 15 seconds pass without one. This is a straightforward recovery loop: if the primary process stops, the watchdog uses the cached path to bring it back.

In one case, the watchdog was placed under C:\ProgramData\Cyvera\Ransomware\, a directory structure historically associated with Cortex XDR. Using a path that resembles a security product’s folder can make a file less conspicuous during casual inspection, though the path alone is not evidence that the security product caused or enabled the activity.

Researchers also recovered PsExecService.exe, deployed through KUKURAT alongside another executable, SecurityGuard.exe, which they could not retrieve. A compiled program database string identified PsExecService as part of a KUKURAT modules project, even though it runs as a standalone executable rather than a DLL. Its code appears to draw in part on the public MyPsExec project.

When run, PsExecService registers as a local Windows service named PsExec and creates a named pipe, \\.\pipe\PSEXEC. It supports four commands, though the available description does not enumerate them. The service also has a self-removal timer: after five minutes without activity, it uninstalls itself and removes its artifacts. That short cleanup window can reduce the evidence left by this component when it is no longer in use.

Propagation, credential access and collection

Once inside an organization, the attackers used domain log-on scripts to spread KUKURAT to users’ endpoints. After gaining control of a domain controller, they installed malicious scripts that ran when users authenticated. The scripts then downloaded and executed the implant. This technique turns ordinary domain log-on activity into a distribution mechanism and can reach many machines without requiring a separate user action for each endpoint.

The group also used familiar remote administration methods, including PsExec, Windows Management Instrumentation and Windows Remote Management. These tools and protocols can support legitimate system administration, so their presence alone does not establish malicious activity. In context, their use alongside altered log-on scripts and custom implants helped the attackers move through compromised networks.

Credential collection included dumping memory from the Local Security Authority Subsystem Service, or LSASS, and using DCSync to obtain password hashes from a domain controller. In one observed technique, attackers misused the Windows utility comsvcs.dll to dump LSASS memory, invoking the MiniDump function by its ordinal number rather than its name. That choice can evade detections that look for the literal string MiniDump.

DCSync mimics directory replication to request credential data from a domain controller. Combined with high-privilege credentials gathered elsewhere in the network, it can give an operator a route to broader access. The investigation also found use of credential-dumping utilities, administrative tools and registry manipulation, although the available account does not name every tool involved.

After establishing access and collecting credentials, the operators sought documents for exfiltration. Targeted files included PDFs, Word documents, spreadsheets and images. Filenames suggested material related to international relations and internal political matters, but filenames alone cannot confirm the contents of documents that were taken.

Email systems were another target. From compromised Exchange servers, the attackers used PowerShell to check whether accounts they controlled had administrative rights and to inspect impersonation permissions. They then granted a compromised account read and write access across mailboxes. That access could expose messages at scale, extending collection beyond files stored on individual endpoints.

What defenders should take from the campaign

The sequence from exploited server to domain-level spread and mailbox access shows why endpoint malware detection is only one part of the problem. The implants are designed to survive, change their behavior and conceal activity; the operators also use existing administrative mechanisms to move and collect data. A single alert on an executable may miss the broader chain.

HTTP/3 and QUIC add a network visibility challenge. Organizations that focus inspection on TCP traffic may have less context for UDP-based web communications. Monitoring should account for unexpected HTTP/3 connections, especially when they originate from servers or endpoints that have no clear need for them. Correlating those flows with process behavior and destination patterns can help distinguish an implant’s traffic from routine use.

Host and identity telemetry also matter. Unusual log-on script changes, unexpected services and named pipes, LSASS access, directory replication requests, and broad mailbox permission changes each provide signals. Any one can have legitimate explanations, so defenders should look for combinations and timing that connect these behaviors to an initial server compromise or an unfamiliar process.

The campaign’s progression from a feature-rich Go implant to a modular C++ framework points to continued adaptation. KUKURAT’s runtime-loaded modules make its capability set harder to infer from the core file, while its two transport variants preserve options for command traffic. For defenders, the practical priority is to retain enough network, identity and endpoint history to reconstruct what happened after initial access—and to investigate unusual UDP web traffic alongside the more familiar signs of credential theft and lateral movement.

Source: Tom Fakterman · unit42.paloaltonetworks.com

From the same set