Skip to content
QUIC and Covert: Novel HTTP/3

QUIC and Covert: Novel HTTP/3

Unit42.Paloaltonetworks • November 16, 2026

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 URL Filtering , Advanced DNS Security and Advanced IP Defense

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, the Unit 42 Incident Response team .

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 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:

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.

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.

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.

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

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

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

List/kill/start processes

COM-based process creation: Alternative execution path via COM objects

Code injection using the classic VirtualAllocEx , WriteProcessMemory and CreateRemoteThread techniques

Window enumeration and manipulation

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.

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.

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.

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:

Username and integrity level

OS type and architecture

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

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:

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

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.

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.

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 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 . Figure 9 shows the AgentiX interface when finding processes that communicate with a malicious domain used by KUKURAT.

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)

Europe and Middle East: +31.20.299.3130

Japan: +81.50.1790.0200

Australia: +61.2.4062.7950

India: 000 800 050 45107

South Korea: +82.080.467.8774

Indicators of Compromise

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

0cbde9b7f59dafca80f214121a04eda7804b920da28ce1c06939a4783e6b097f

cdc9757294d3063eb10c9a37d1d945d31f6857c652b864803815406b02eeefbf

82a989c728db4e09a2b85a4a55f7663cefa62844632cb16dcda5ca70bf09a8a5

71d897427329ca14dd621e777046dc35f3d9dc870d3b13a56125125391a56afe

6781f84417d0056df95ed38b3e7a6b49312d30119470356f6923238d49de3490

dd02d28c48cf5cabd35a0b32e05e7c99ff0de35541201026ae36c59e54968c78

e59b08eb03ffa10ccf9103d171af757308e6d43519c4e904ef5e0929ef92d8fd

99f571c07170250a84f0ae9de4179044df91244855d9b39978729933ea3d438f

7ee22a7b028102bb22f0a41d41cd101d5956c1db0cfd157b22bf4128bd472a4f

571067cc8f4224a4b80113b52672c7ac87e25dcdb0282a36a29a1784a24efa27

8d8ccf24b785a33a9388043baecc4be247ad01182b87df3f8e425957ef73087c

0e01c44e5a0615098d8c583930dd88dbd0ce6fe54b365c9f04d8b315a93f540a

1dd423ff0106b15fd100dbc24c3ae9f9860a1fcdb6a871a1e27576f6681a0850

04be76217500275335e82eb4c2c1588478f7a171efd7a0d9bdc6bbe83e315589

3deb43cc864f2322d374541d99af79d87ad08abf81cd967862c554f1c0c5fdb6

224ed1d3f8d7247989f812cb0accc1d1804197916c47d9600e6c4e9bef46a723

9b16333820189e94b2368e87cba0a9642595d5be0f985a6351f1ad834f5cd11d

bdcd0eefc62721814d0bd557285490aa99a4eb0425bf5204e6be16ec7ce93823

3e56d049f23ed45a7034e5c74bad45cae11ce6d15189fa7bda6b8d120439c7cc

834491282da22555f53b769ef8ad91a958f860c583ee5cb67b3f161caf19f85 4

PerfectPioneer RAT C2 Domains

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.

Table 2 lists the implemented commands in the newhttp3 variant of PerfectPioneer RAT.

Table 2. List of available commands in PerfectPioneer RAT newhttp3 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.

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.

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.

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 .

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.

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

Extracted Entities

APT Groups (2)

Campaigns (1)

Domains (1)

Industries (1)

SHA256 Hashes (70)

04be76217500275335e82eb4c2c1588478f7a171efd7a0d9bdc6bbe83e3155890533365accbba405757de7eb486533c11c8e0510a28d414ee8c5e6b8a41ed97b0c49e1b98a236d3391740473101b66dd48c719fa4112dbef3816b56bce58e6e70cbde9b7f59dafca80f214121a04eda7804b920da28ce1c06939a4783e6b097f0e01c44e5a0615098d8c583930dd88dbd0ce6fe54b365c9f04d8b315a93f540a183abf82951c2052e9a1829c70c173c11756e8df0e86c8071c27df0988caeaa019bb3012d846f3672fb98dad0449ae5c267ab30150800b2f1559036564c7d0b81dd423ff0106b15fd100dbc24c3ae9f9860a1fcdb6a871a1e27576f6681a0850224ed1d3f8d7247989f812cb0accc1d1804197916c47d9600e6c4e9bef46a7232281e754f70e11298db1a0a7c1b527cf2b5eec2056d4c73a46ed572ab873dc6e24c46bc9269e1c1ee54004e01d5c7c54f759bc1b93a282d3561d2d27f678af862e52b2936e67872d1364d2d0d26a8733ed9582b38f6f0b3a877ffdd6e2c04aa434cc9bc4a533b91e7cdb30fecc57ba609dc890780fd13ecfbc253047b3b37b783cb5376a5e6c0fcbd6844ab76f3dc73a42da7ecee6ecaaef285d4abe33964fa13deb43cc864f2322d374541d99af79d87ad08abf81cd967862c554f1c0c5fdb63e56d049f23ed45a7034e5c74bad45cae11ce6d15189fa7bda6b8d120439c7cc52d3442fb26023ebc0bc76542b56be88d1c3327c8bcedf1dcb95f80511527f07571067cc8f4224a4b80113b52672c7ac87e25dcdb0282a36a29a1784a24efa275805cb5b0a6fb738ef7c1873b8e5de4281c36c7f440f28717fa9f441c5e0ef175b779b81a9bb25591ecac6bd74bb44a4a5b2b8f257093f9efd5910346ab8d7725b7effbf0465c05e8dc9a8fea69b000a78237735ea0b854e8d9baee5b7af83445f857ff78bfbef2a55a846fc93744e11e07a9b72ee3fc3bc345c32ce9615ddee600572a912650b258d56aedeef0ab712abbe35a38cdd23faa5a95dacfdc67b7f619b749e1c6634d38f15c51005a4237e9076aaaf36927b562a990e8bc34fdfcb61f7e2f4159c566578e88cb05cdf49e4378f45ebddbd332224e97c11df92212063eac14921f138fffe73db417c12afd16d64202ebbee7ad5f08068697d2942d0662dc73e11b60b2f12c94b6b68da45de7bffece4b1dcc75679ed020629d0705d6781f84417d0056df95ed38b3e7a6b49312d30119470356f6923238d49de349071d897427329ca14dd621e777046dc35f3d9dc870d3b13a56125125391a56afe7225ef57161cf0908560811be798d22e9354c071d576540a43aa7900784c06887541222a1316ec54bf9c8660b923e1d0490a925b2ee92060b1567be7cb1bde4b7745523939fc6b31b6a73d8ca1f363c62438b6eef56f6fe8c39e71fcd14b65f4790e6699704395a7fad633f4e502312bc43693a44a8e18d43239209eefbd7ff27ee22a7b028102bb22f0a41d41cd101d5956c1db0cfd157b22bf4128bd472a4f82a989c728db4e09a2b85a4a55f7663cefa62844632cb16dcda5ca70bf09a8a586194c3b3cc7a58e439621aff42e116ca94d40f3a6f539f20ce483f1cf5a71918bf9401990d3255d1022a25884b02ee75ef01bd1a729d29ff52de2e5f0d637a28cfe629fc08ae06c8ba106113ba30bb16fa2fbbf8bd3dd6831d16b031e0ebe708d8ccf24b785a33a9388043baecc4be247ad01182b87df3f8e425957ef73087c904409ce8846394e1fe9a5ce37f2265cbf6933611278ae57fdf5fa74759af2bb92fb9545ea49e2fb4635fce1859ff3f609738be75f85d146614243fc8bc80b679721d65ee7695db2b3dc3705f5d8e5efe3a478c3b6d1704d66daf77fe95aeb0d99f571c07170250a84f0ae9de4179044df91244855d9b39978729933ea3d438f9b16333820189e94b2368e87cba0a9642595d5be0f985a6351f1ad834f5cd11d9dfefc7118646535d1193e1b036dd0c93fa66cc585a60301fcdceb6f45903aad9fb0976fcd1f92c4711726a91cff8be9a39944efedc4caf2d80f935327f8f490a214d264c6bb0d2ba89986f73e196ea200307574745a245fc42c32fbef4cc140a6a9ccffadd00b0e75e913b0f851b1f834fd20588df8b89759d9ae49a48c8e10ab06f540ecdd1d45491aa71bfc04c80852371c8f5cd43b9a6ebb53f1e1b69588b062b4d8c19baf5c1568e28b3e0a5e2318e9501ea61ddfe804d9755c1bdbf887b5bea4d8b94fbb39ac992e8e763680af6f39d12d42e264b43431fb61cf7b9a88b8dca1c7e7a74ce82ab4e4cad9b718a458735d2c6c956e4cf3109aac59bfd0e4b975f5932c04b381f8fa58a3303194f1aff950d3c6cd12dcc1d323bb3393718bbdcd0eefc62721814d0bd557285490aa99a4eb0425bf5204e6be16ec7ce93823bf59f8d7ef79b09a72bbb9c05ca8746466d03226a3779cc1096ba067117ca008bf8afbd1c2074c7cd6ff8b86dbe67a57ca5594817e46b24e226b71c4edde7697c4b4647795567ab15528edd1ab1bf37fb50e21b442e59a653051061973e87c02cd8f43da32849584751eec884cf7e3208eb0a71108197a32e9bb248612e757d2cdc9757294d3063eb10c9a37d1d945d31f6857c652b864803815406b02eeefbfcffcd6f2589d3ab4f3693805d1752b7c328a00cc543dd02b129763e179c3f311d700b573ea8387efad633a70124b7a2a3aece844a267157b1cb55be7b62f3b67d725ad8b523c94f99fca9e72a650e835dca47b9ebe7610d6c4eb3525d410c365dd02d28c48cf5cabd35a0b32e05e7c99ff0de35541201026ae36c59e54968c78e5689e1bf916c2f7649e178008e790ea13eb844aefc14516c06b0da8296377a1e59b08eb03ffa10ccf9103d171af757308e6d43519c4e904ef5e0929ef92d8fde8cd6bbcf6073669a7415ce0c9009a0fbb5551bf5e17803be12ef295f0c99889f4c9d5d13c1a09533876a02f6fa04831efbf600b05cfb3ed765a0ebde82b0457f5ebe85418655d75d1a760543858846db1478a060875fd19ddaa5e2febc038d7f82c06184ab36e91d28f7802c739e637792c241a7ff2fba9ca24178f12423684fb5b0b1d083d6f6afa90948bd1fd1a498b51dd3f6dc7f90a02a2a17818756563