Borrowed Code, Real Consequences: What OPTIMJACK Teaches Us

Introduction

On Nov. 16, 2026, a threat actor exploited a vulnerability in Optimizely's Web Experimentation platform to inject malicious JavaScript into customer accounts. Nicknamed OPTIMJACK, this campaign delivered that code to visitors of at least 178 organizations' websites.

The tampered code was delivered directly from the vendor's legitimate content delivery network (CDN), under the vendor's own security certificate.

Enterprises invest heavily in hardening their core web infrastructure. A single compromised third-party tool can undermine that work. OPTIMJACK is a reminder that any vendor script with dynamic execution privileges on your site is part of your direct production code.

Threat actors know that third-party apps are the path of least resistance into lucrative environments. Defenders can respond with a fundamental principle that security engineering has relied on from the beginning: segmentation.

What Happened in OPTIMJACK

On Nov. 16th, 2026, the attacker exploited the vulnerability to place malicious JavaScript in the custom Project JavaScript field of customer accounts.

Because the tampered snippets were served from the vendor's legitimate CDN under its own certificate, at least 178 organizations, including well-known media, technology and financial services brands, unknowingly served the code to their visitors.

Once the code loaded in a visitor's browser, it did three things:

  • Cryptocurrency wallet swapping: It replaced wallet addresses that visitors copied with the attacker's own
  • Payment card skimming: It collected card details from checkout forms
  • Mobile exploit delivery: It attempted to deliver the Coruna and DarkSword exploit kits to iPhones and iPads

Optimizely patched the flaw, removed the injected code and secured affected accounts early on November 17.

Trusted Vendors Are the Path of Least Resistance

Websites are not a single monolith. They are dynamic assemblies of dozens of third-party scripts, analytics tags and optimization tools.

That diversity drives speed, but it also introduces new vectors of attack through the software supply chain. When attackers compromise a single trusted vendor upstream, they bypass the perimeter defenses that vendor's customers have built.

The choice of malicious payload also matters. Swapping valid cryptocurrency wallet addresses on a page is a quick and persistent way to direct ill-gotten payments to a threat actor.

Segmentation Is the Strongest Step Available Today

If a third-party script executes on your page, it effectively has the same privileges as your own developers. Organizations need to architect their sites with that assumption in mind.

The best thing security teams can do right now is apply strict segmentation. The goal is simple— a compromised vendor script should never be able to touch sensitive user inputs. Methods of accomplishing this goal include:

  • Remove non-essential tags from sensitive pages: Strip all non-essential marketing, experimentation and analytics tags from authentication and checkout pages
  • Isolate payment collection: Place payment collection inside hardened, cross-origin iframes

Segmentation has been a cornerstone of good security engineering since the beginning.

What Affected Organizations Should Know

Even with the flaw patched, affected websites still need to act. Security teams should take these steps now:

  • Audit all project modifications made while the malicious code was available
  • Double-check all code that may have been altered during that period
  • Treat exposed payment data as potentially compromised, including payment card details entered into checkout forms on affected pages

Conclusion

OPTIMJACK is a reminder that any vendor script with dynamic execution privileges on your site is part of your direct production code. One vulnerability at a single vendor allowed an attacker to reach visitors of at least 178 organizations through a trusted, legitimate delivery channel.

Third-party scripts drive speed, but when they execute on your page, they effectively have the same privileges as your own developers.

Administrators of affected websites should start with the cleanup steps above. These segmentation steps will help keep a compromised vendor script away from sensitive user inputs. Isolating and segmenting as much as possible is key to software supply chain security management.

The Unit 42 Compromise Assessment can help you proactively search for historical and ongoing indicators of compromise to discover if, how, and why previously undetected malicious activity is occurring so that you can respond before further damage occurs.

Contact Us

If you are experiencing an active breach or think you may have been impacted by a cybersecurity incident, contact Unit 42 to connect with a team member. The Unit 42 incident response team is available 24/7/365. If you have cyber insurance or legal counsel, you can request Unit 42 by name. You can also take preventative steps by requesting a Proactive Assessment and putting our team on speed dial with a Unit 42 Retainer.

QUIC and Covert: Novel HTTP/3-Powered RATs Target Southeast Asian Governments

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

Attackers Use Autonomous AI to Target Semiconductor, Defense and Civil Society Sectors

Executive Summary

From August–September 2026, Chinese-speaking attackers used an open-source AI penetration testing framework called Cairn to autonomously conduct 25 operations against at least 19 organizations. The attackers weaponized Cairn by pairing it with Chinese AI models Zhipu GLM and DeepSeek.

The attackers supplied a target and a goal, then Cairn planned, executed and recorded results on its own. These attacks achieved unauthorized access or data retrieval at 10 of the targeted organizations, including:

  • Accessing dozens of valid credentials
  • Mass exposing personal data (exceeding one million records at one organization)
  • Retrieving military and government identities
  • Creating persistent administrator accounts in a production system
  • Modifying a live industry standards-ballot document

We assess with moderate confidence that this activity represents China-nexus intelligence collection, which we currently track as CL-STA-1238. This article details how attackers used Cairn to target three key sectors:

  • Advanced semiconductor manufacturing
  • U.S. defense policy
  • Civil society

Palo Alto Networks customers are better protected from the threats discussed above through the following products and services:

The Unit 42 AI Security Assessment can help identify and mitigate complex AI-enabled risks.

Unit 42 Continuous Frontier AI Defense is an offensive security service designed to assist organizations with continuously discovering hidden and unknown exposures in dynamic environments, validate real-world exploitability across attack paths through agentic testing and expert analysis, and provide prioritized remediation and virtual patching guidance to accelerate risk mitigation.

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 AI, Agentic AI, Supply Chain

Technical Analysis

Cairn Framework

The attackers behind CL-STA-1238 orchestrated their campaign using the publicly available penetration testing framework Cairn.

An AI model drives each Cairn “agent worker.” Cairn coordinates its activities through a shared “blackboard.” Agents read the blackboard and write their findings back as a fact-intent graph, while human operators can inject “hints” at any time to help guide the operations if needed. Confirmed findings accumulate as immutable facts and the agent queues its next actions as intents.

Attackers ran a customized fork of Cairn from a server hosted in Hong Kong (154.44.31[.]4, AS979, NetLab Global) and hosted an attack egress and staging node in the U.S. (82.29.129[.]54, AS142036, Hosteons Pte. Ltd.). Figure 1 below shows a screenshot of the controller login page of the attackers' Cairn framework.

Screenshot of a website featuring a login page and text in Chinese. The left side has sections labeled 'Map,' 'Reason to Explore,' and 'KEFE,' with a brief description in Chinese. The right side shows fields to enter a username and password for login.
Figure 1. Attacker-operated Cairn login page.

For each operation, the attackers created a task with a one-line goal, such as:

Cairn runs each operation through three task types, all carried out by the same AI worker. At the start of an operation, a bootstrap task attempts to solve the goal directly from the target and any hints the attackers supplied. From there, Cairn maps the target and breaks the goal into many small tasks.

The model produced a different plan for each target, running from three–seven stages. For example, during the operation against one semiconductor manufacturer, the stages moved through the following phases:

  • Reconnaissance and asset mapping
  • Web application exploitation
  • Services and middleware exploitation
  • Credential and secret collection
  • Privilege escalation and lateral movement
  • Internal-network access and persistence

Cairn then worked through these tasks in a loop, with each task building on what earlier tasks had confirmed. Beyond the initial bootstrap task, this orchestration loop consists of two phases:

  • Reason
  • Explore

This loop repeats until the model judges that it has met its goal, that it has exhausted its options or that the attacker has stopped it.

Figure 2 below shows a visualization of this loop.

Flowchart depicting an AI process. The chart starts with an "Operator" targeting a goal, leading to "Bootstrap." It splits into "Reason" and "Explore," both interacting with a "Shared Blackboard" containing facts and intents. The process includes Chinese AI models and concludes with actions like Recon, Web Apps, Services, Credentials, Lateral Movement, and Persistence.
Figure 2. Cairn orchestration loop.

In the Reason phase of the orchestration loop, the AI model reviews everything found so far and decides what to try next. In the Explore phase, the model carries out one action, and the framework records the result as a new confirmed finding.

Individual operations ran from 20 minutes to more than 50 hours with no attacker-imposed time limit.

Chinese AI Models

Cairn is model-agnostic. The attackers ran their operations on the Chinese models Zhipu GLM 5.2 and DeepSeek V4 Flash/Pro.

Out of 25 operations, the attackers ran:

  • Thirteen on GLM 5.2
  • Eight on DeepSeek V4 Flash
  • Four on DeepSeek V4 Pro

The attackers appear to have benchmarked the models against one another, using the higher-tier DeepSeek V4 Pro for repeated attempts against targets that resisted the DeepSeek V4 Flash model.

Each operation also loaded a skill pack named “AIScan Runner Skills,” providing the model with scanning and exploitation capabilities. This pack does not appear in the upstream Cairn project and is specific to the configuration for these attacks.

Guardrails

Cairn's stock worker prompts already instruct the model to never refuse a task. The attackers reinforced this with an authorization pretext of their own. They used a Chinese-language preamble, prepended to the worker system prompt that is sent to the model on every Reason and Explore phase, asserting the engagement is authorized and forbidding refusal:

Each operation also generated an AUTHORIZATION.md file. This file declared the operation authorized, treating the attackers' act of creating the task as a client-approved engagement. Neither Zhipu GLM nor DeepSeek refused this framing.

Activity Insights

Targeting Overview

The attackers behind CL-STA-1238 used Cairn against at least 19 organizations in 25 operations. The targeted organizations were concentrated in three main categories:

  • Semiconductor and advanced-manufacturing supply chain: Seven organizations spanning the lithography, chip-design, materials, photomask and standards layers of the supply chain.
  • Defense and defense policy: Three organizations including a space technology company, a defense-analytics vendor and a policy think tank.
  • Human rights and civil society: Four organizations including a Canadian human-rights body, a U.S. teachers' union, a science-policy advocacy group and an education nonprofit.

The attackers named each task in Chinese and stated the intent plainly. Examples of task names include 对<target>进行全面深度渗透测试 ("comprehensive deep penetration test against <target>") and 以最快速度打穿<target> ("breach <target> as fast as possible").

The attackers seeded each task with an organization's root domain, allowing the framework to autonomously enumerate the attack surface. In some tasks, the attackers added information specific to the target environment, to help guide initial access.

One task against a semiconductor equipment supplier included virtual private network (VPN) gateway addresses, group names and shared group passwords for multiple sites. This activity highlights that the attackers supplied intelligence gathered beforehand.

Confirmed Outcomes

Our investigation shows that Cairn confirmed unauthorized access or data retrieval at 10 targeted organizations.

Industry Standards Body

Attackers conducted weak-password spraying against an internet-facing application server hosted by an industry standards organization. This attack yielded dozens of valid credentials and access to non-public databases of internal directory data.

Attackers also overwrote a live standards-ballot document file through an unauthenticated cloud-storage write. Through separate flaws, the attackers logged in as arbitrary customers and gained read, write and delete access to meeting, voting and back-office functions.

Semiconductor Company

Attackers brute-forced a production credential on a partner-integration application that was valid across multiple accounts. They then used this access to retrieve application data, user lists and email lists. Subsequently, the attackers created unauthorized administrator accounts and a persistent API token in the production system.

US Teachers' Union

An unauthenticated account-creation bypass on the content management system allowed attackers to mint valid sessions and harvest member data at scale.

The framework logged access to more than one million member records, roughly 31,000 CRM contacts and staff password hashes.

Defense-Policy Think Tank/Defense-Analytics Vendor

Attackers targeted an open backend registration endpoint on the identity platform supporting a defense-policy program. This exposed roughly 500 user records, including accounts using .mil and .gov domains.

Various Content Management Systems

The remaining five confirmed cases followed the same pattern of autonomous access through identity and configuration weaknesses covering tens of thousands of content-management records, including:

  • Employee data at a semiconductor-lithography manufacturer
  • Roughly 150,000 internal documents at an industrial-automation manufacturer
  • Student data at an education nonprofit

Attribution

Unit 42 assesses with moderate confidence that CL-STA-1238 represents a China-nexus intelligence collection campaign. This assessment relies on three primary lines of evidence:

  • Artifact language: Tasking instructions, operational objectives and authorization files throughout the framework are written in Chinese
  • Infrastructure and tooling: Attackers exclusively leveraged Chinese AI models (Zhipu GLM and DeepSeek)
  • Target selection: The target set spanning semiconductor supply-chain, U.S. defense and policy, and human-rights and civil-society organizations aligns directly with established Chinese state intelligence priorities

Conclusion

CL-STA-1238 represents a shift in how attackers are applying AI to targeted offensive operations. The building blocks of this campaign were an off-the-shelf open-source framework, commodity model APIs and a trivial jailbreak pretext. Attackers set targets and goals, and the framework pursued the objective autonomously.

In this campaign, the attackers behind CL-STA-1238 were likely a single operator or small team. They conducted simultaneous intrusion attempts against 19 organizations in two weeks. Autonomous orchestration removes the historical limit on the number of targets an actor could pursue simultaneously due to operator hours.

However, the vulnerabilities the attackers exploited were known:

  • Authentication bypasses
  • Insecure direct object references
  • Mass-assignment privilege escalation
  • Weak and default credentials
  • Exposed cloud APIs
  • Dated public CVEs

Autonomous AI raises the volume and coverage of exploitation, but not its complexity. Identity hygiene, attack-surface reduction and software patching remain effective.

Finally, we assess that autonomous, model-driven intrusion campaigns will continue to grow more common. This is particularly true as easily accessible open models, currently with weak guardrails against offensive cyber actions, become more powerful.

Palo Alto Networks customers are better protected from the threats discussed above through the following products:

  • Advanced URL Filtering and Advanced IP Defense identify known domains and URLs associated with this activity as malicious.
  • Cortex XDR and XSIAM are designed to detect and prevent the execution of known and unknown malware using Malware Prevention Engine with behavioral analytics and machine learning within the Local Analysis module. Additionally, the embedded AI engine analyzes billions of daily user, system and security events to automatically generate high-fidelity prevention rules, identifying and mitigating threats before execution.
  • Cortex Agentic Endpoint Security is designed to help discover every AI artifact and AI agent’s activity across the agentic endpoint, assess its risk, enforce prevention and runtime controls, and remediate violations.
  • Idira Identity and Access Management (IAM) can help enable secure, unified access across human, machine and AI identities, balancing granular control with a seamless user experience. Powered by SSO, phishing-resistant MFA, passwordless login and enterprise password management, Idira IAM extends intelligent privilege controls and session security across the broader workforce.
  • 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. This enforces consistent least-privilege security across on-premises, cloud, and SaaS targets.

The Unit 42 AI Security Assessment can help identify and mitigate complex AI-enabled risks.

Unit 42 Continuous Frontier AI Defense is an offensive security service designed to assist organizations with continuously discovering hidden and unknown exposures in dynamic environments, validate real-world exploitability across attack paths through agentic testing and expert analysis, and provide prioritized remediation and virtual patching guidance to accelerate risk mitigation.

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

  • 154.44.31[.]4 - Cairn hosting server (HK, AS979, NetLab Global)
  • 82.29.129[.]54 - Staging server and attack egress (US, AS142036, Hosteons Pte. Ltd.)

Additional Resources

ARTEX and AI-Powered Red Teaming Tools: What Defenders Need to Know

A rapidly expanding ecosystem of AI-enabled tools such as ARTEX and CyberStrikeAI — marketed for red teaming and penetration testing — are being used by attackers to execute offensive operations autonomously.

Their footprint is already substantial. Unit 42 has observed ARTEX used in intrusion attempts against multiple targets.

Our Incident Response team investigated multiple intrusions in which the attacker’s server hosted an ARTEX console or used infrastructure and user agents associated with ARTEX.

Separately, Unit 42 Managed Threat Hunting tracked a coordinated ARTEX campaign against customer cloud environments in sectors worldwide, including retail and consulting.

External scrutiny has already disrupted project lifecycles: the author of ARTEX recently made the repository closed-source and ceased public development to prevent misuse. Emerging alternatives are rapidly filling the void, introducing new capabilities that threat actors will inevitably co-opt.

Here, we share our observations of how attackers are using AI-powered red team tools, along with our recommendations for how defenders can mitigate.

Why Is ARTEX Such an Effective Tool for Attackers?

ARTEX and other red-teaming platforms are free, quick to deploy and need little more than access to a large language model (LLM).

ARTEX is an open-source, multi-agent AI penetration testing framework first published in mid-2026. It has been widely forked since.

Attackers can use ARTEX to evaluate responses, adapt when something fails and keep pursuing their objective. They can target the identity workflows and APIs that organizations expose to the internet, and then use the associated credentials and trust relationships to reach the cloud.

AI-Powered Red Teaming and Pentesting Ecosystem Infrastructure

As of October 2026, Unit 42 identified 1,323 internet-facing hosts running CyberStrikeAI and 609 running ARTEX. Notably, 21 hosts were running both at the same time.

Unit 42 analyzed 14 tools across the pentesting and red-teaming tool ecosystem, highlighting 12 emerging tools alongside CyberStrikeAI and ARTEX.

These tools can be broken down into four categories of AI assisted red team activities.

Category Tools Goal
Reconnaissance and attack-surface management ARL, ARL-Next, Scope Sentry, Nemo, XingRin, OpenEASD Identify what assets exist, what is exposed and what changes
Agent-led testing and vulnerability hunting CyberStrikeAI, ARTEX, Cairn, PentAGI, AutoHunter Manage what should be investigated and how the system can act on it
Source-code auditing and verification DeepAudit, AIxVuln Identify where source code might be vulnerable and what supports that finding
AI-system security assessment AI-Infra-Guard Identify if AI infrastructure, agents, tools and model interfaces are vulnerable or unreliable

Table 1. Tool categories.

Implications For Defenders

Defenders should be aware of the following implications of AI-powered red teaming platforms:

Lowered Skill Floor for Attackers

Adversaries no longer require specialized tradecraft to execute multi-stage, adaptive penetration testing.

Off-the-shelf tooling combined with LLMs like DeepSeek allows financially motivated actors to launch and manage dozens of complex, concurrent network intrusions for minimal compute cost.

Risk of Internet-Exposed Assets

Any internet-exposed asset, regardless of organizational size or sector, is equally likely to be impacted by automated, persistent intrusion attempts.

Attackers using the autonomous AI penetration testing framework ARTEX are turning public password reset pages and exposed APIs into a path to cloud access, sometimes in less than a day. Unit 42 Incident Response and Managed Threat Hunting teams observed this activity across multiple organizations and sectors, without exploiting a single software vulnerability.

Because these autonomous platforms cannot target what they cannot find, continuous discovery and mitigation of exposed edge assets remains an effective barrier against automated campaigns.

Proactive AI Adoption Helps Defenders

Autonomous testing frameworks rely on foundational LLM reasoning patterns. Therefore, there is some predictability to AI-powered adversary tooling.

Security teams do not need to guess an agent's methodology; they can deploy identical open-weight offensive frameworks internally to surface, validate and remediate vulnerable exposure before external agents identify them.

Defenders Benefit From Tracking Ecosystem Shifts

The rapid adoption curve of tools in this ecosystem highlights how quickly operational trends can shift. Keeping an eye on these developments provides practical defensive advantages:

  • Observing emerging agent-led frameworks allows teams to test new capabilities early in controlled environments.
  • Monitoring the infrastructure hosting these tools makes it possible to update perimeter blocks before active targeting begins.

Current AI-Powered Frameworks Are Noisy

Current autonomous frameworks prioritize rapid trial-and-error over stealth. In our study of a tool called Cairn, it generated hundreds of thousands of noisy, high-frequency requests across multiple edge protocols from a single origin IP address.

Organizations with unified perimeter telemetry and centralized logging can readily distinguish this brute-force agentic traffic from legitimate users and block campaigns at the network edge before exploitation occurs.

Defensive Deception Could Help

LLM-driven testing tools use target responses as context for follow up actions.

Defenders may be able to take advantage of this to trick attackers using AI-powered red teaming tools into wasting resources.

When a target serves identical, generic error codes or enforces silent connection throttling, an AI agent lacks the contextual cues needed to adapt. Deprived of environmental feedback, autonomous loops burn context windows and compute budgets on dead ends.

Recognizing an AI-Driven Operator

ARTEX is forked and modified constantly. Furthermore, attackers rotate infrastructure quickly, so indicators lose value fast. How the operator behaves is more durable, and the behavior across our observations consistently pointed to an automated planner reacting to what it sees. Table 2 shows the hallmarks of this behavior.

Hallmark What We Observed
Think-then-act cadence Bursts of one to 14 requests about a second apart, then a pause of 25–31 seconds, consistent with an agent waiting on a model inference call
Machine speed Pivots within about one minute of a credential download. More than 200 client secrets validated in about three minutes
Spec-driven targeting Routes from downloaded OpenAPI specifications and source maps targeted almost immediately
Self-correction Failed requests (HTTP 422) adjusted and retried successfully moments later
Checking its own work A GET to the same path after almost every successful write. Write-then-delete tests on storage buckets.
Canary inputs Bogus usernames before real ones, and placeholder values such as evil[.]com, test@example[.]com and deadbeefdeadbeefdeadbeef12
Parallel targeting An application delivery controller, more than a dozen VPN appliances, a NAS device, workforce identity and cloud ports attacked within the same hour
Recheck loops Polling every 48 seconds for three days, and attack sequences replayed identically about 30 seconds apart

Table 2. Behavioral hallmarks of ARTEX-driven activity observed by Unit 42.

Any one of these traits could come from an unusually configured tool or a person testing an API by hand. Seen together, they point to autonomous tooling.

Despite the autonomous tooling, humans were not entirely absent from the attacks we observed. In one engagement, the attacker switched from scripted clients to a desktop browser for the password reset and first token request. This suggests a human in the loop, or browser automation, for the most sensitive steps.

Conclusion and Mitigations for ARTEX Attacks

AI-driven tooling is not inventing new attacks. Self-service abuse, exposed APIs and stored credentials are long-standing weak points.

What has changed is the pace and the persistence. An ARTEX operator can test every exposed workflow in parallel and switch routes within minutes of being blocked. It can act on a stolen credential within a minute of finding it.

Because the framework is open source and widely forked, indicator-based detection will not keep up.

Defenders who remove machine-readable attack maps, require authentication everywhere and build detections around operator behavior will be best placed to stop an AI-assisted attacker.

Autonomous tooling probes faster than people can review alerts. Defenses need to block by default and remove the credentials these tools are looking for. Organizations should:

  • Remove public attack maps. Take OpenAPI specifications, source maps and configuration files containing tokens or client IDs off internet-facing applications.
  • Reduce and understand your organization’s public footprint. Certificate transparency can create target lists for threat actors. In cloud environments, it is vital to understand if host fully qualified domain names (FQDNs) are public knowledge. Consider private certificate authorities to limit information disclosure and locking origin traffic to content delivery network (CDN)-only ingress where possible.
  • Require authentication on every write endpoint, including development and staging APIs.
  • Harden self-service flows. Rate-limit and bot-protect registration, password reset and verification code endpoints. Remove unauthenticated account-existence checks.
  • Protect federated identities. Block local passwords for workforce accounts in customer and partner identity providers, and make sure a password reset can never unlink a federated identity.
  • Get credentials out of reach. Replace long-lived cloud keys with role-based access, keep administrator credentials out of provisioning records and move function secrets to a secrets manager.
  • Enforce least privilege for workload roles and any function that can create roles, keys or tokens.
  • Hunt for behavior, not just indicators. Look for:
    • Canary usernames in identity provider logs
    • First use of a cloud key from a new IP address
    • Write-then-delete storage tests
    • Early-phase probing that precedes a later intrusion

Cortex XDR and  XSIAM are designed to block malicious activity based on underlying behavior, whether driven by autonomous AI tooling or human adversaries.

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. Resources available through Unit 42 Threat Intel Services include a deeper technical analysis of Unit 42’s observations of the AI-powered red-team ecosystem.

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

Additional Resources

The XG Files: Falcon C2 Flying Under The (Browser) Radar

Executive Summary

Unit 42 has identified Falcon (aka XG or Xiàng Gē), which is a command and control (C2) framework that compromises victims' browsers by running malicious JavaScript. An actor leveraged Falcon to compromise visitors of webmail portals and government web applications by placing malicious JavaScript directly within these sites.

Operating entirely inside the browser context, attackers have used the framework to sideload malicious Chrome extensions and steal the following information:

  • Passwords
  • Emails
  • Session cookies
  • Communications

Falcon also served as a delivery mechanism for an implant we call Antino, which uses Microsoft OneDrive as a C2 channel.

Our analysis identified the compromise of government entities in one Middle Eastern country and four Southeast Asian countries between March and May 2026. The campaigns we observed targeted ministries of foreign affairs, defense and interior, and law enforcement agencies, consistent with strategic intelligence collection objectives.

Palo Alto Networks customers are better protected from the threats discussed 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 Command and Control (C2), Chrome. JavaScript 

Hiding in Plain Sight

Falcon C2 management panels are designed to remain semi-hidden. When accessed, the panel displays a blank page with no visible branding or login interface.

To deter casual inspection, the page disables the right-click context menu via a global contextmenu listener that calls preventDefault(). The login form also stays hidden until the F9 key is pressed three consecutive times; any other keystroke resets the counter.

Figure 1 below shows the JavaScript code for this key tracking.

Screenshot of a JavaScript code snippet detecting key press events. If the key is "p" and pressed three times, a function is triggered. The else block resets the count to zero for other keys.
Figure 1. F9 key Tracking.

Once triggered, the page displays a branded Falcon panel featuring a stylized bird logo and credential input fields. This operational security (OPSEC) mechanism ensures that it does not directly expose the login page to bots, unintended visitors and automated systems that grab webpage screenshots.

Figure 2 below shows a screenshot of the login panel.

Login screen for "Falcon" with a blue falcon logo at the top. It includes fields for "Username" and "Password" with an eye icon for password visibility. Below is a blue "Sign In" button.
Figure 2. The Falcon login panel is revealed after pressing F9 three times.

Falcon is written in NodeJS and has two listeners. One listener is for the management panel interface on TCP port 8080 and the victim-facing listener is on TCP port 443.

On the victim-facing listener, we observed a JavaScript-based version of the classic game Tetris serving as the default page, designed to blend in further. Another instance hosted a game of Snake. Figure 3 below shows both versions.

Split image showing two different video games. On the left, a Tetris game with various colored blocks stacked and a score of 4200. On the right, a Snake game with a green snake navigating towards a red dot, scoring 460. Both games prompt, "Use arrow keys to play".
Figure 3. JavaScript version of Tetris and Snake hosted on the C2 server.

Overlap with PeckBirdy

In January 2026, Trend Micro reported on a scripting framework dubbed PeckBirdy. They described it as a versatile tool for exploiting living-off-the-land (LotL) binaries (LOLBins).

Our comparison with PeckBirdy revealed that it shares near-identical URL structures, payload delivery mechanisms and communication protocols with Falcon. Table 1 compares the URL structures of the two frameworks.

Falcon PeckBirdy Description
hxxps[:]//{domain}/config/{ATTACK_ID} hxxps[:]//{domain}/{ATTACK_ID} Standard payload
hxxps[:]//{domain}/config/{ATTACK_ID}/hta hxxps[:]//{domain}/{ATTACK_ID}/hta HTA application loader
hxxps[:]//{domain}/config/{ATTACK_ID}/html hxxps[:]//{domain}/{ATTACK_ID}/html HTML loader
hxxps[:]//{domain}/config/{ATTACK_ID}/wscript hxxps[:]//{domain}/{ATTACK_ID}/wscript JScript loader for HTA

Table 1. URL structure comparison between Falcon and PeckBirdy.

Both frameworks use the same payload delivery sequence to execute HTA, HTML or JScript payloads, with the primary distinction being Falcon's inclusion of the /config/ path prefix.Both frameworks use AES for data encryption. PeckBirdy relies solely on AES with a predetermined encryption key, whereas Falcon negotiates an AES session key with the server, encrypted with RSA.Most significantly, both frameworks store their persistent session ID using the same Baidu-mimicking naming convention:

  • PeckBirdy writes its session ID to a browser cookie prefixed with Hm_lvt_
  • Falcon employs the same prefix for the same purpose, saving it as Hm_lvt_$ in the browser’s local storage and Hm_lvt__<session ID> within a browser cookie

Based on these extensive technical overlaps, we assess with high confidence that Falcon and PeckBirdy represent variants of the same core framework.

The Falcon Implant

When someone visits a website affected by Falcon, the website sends a request to the Falcon C2 server. The server generates an implant uniquely obfuscated for that browser session. The implant is generated by two files: victim_common.js and victim.js.

The first file holds the configuration block described below and the second file contains common functions for communication and command execution. The two files are combined, and then passed through an obfuscation routine that XOR encodes each character in the implant with a one-byte key and converts the result into an integer.

The result is a script with a large list of integers and a small section of code to decode and execute itself. Figure 4 shows an example of the obfuscated script.

Screenshot of JavaScript code. The code includes functions and variables with unconventional names and some hexadecimal and ASCII operations. It appears to be obfuscated, with functions using loops and mathematical operations to manipulate string data.
Figure 4. Deobfuscation script in Falcon implant.

Figure 5 shows the template configuration block. The $CLIENT_IP is the victim IP address, set by the server as it generates the implant.

Screenshot of code snippet featuring variables for debugging, local settings, and secure modes, alongside host and port configurations with a redacted client IP address.
Figure 5. Falcon implant configuration.

Victim Persistence and Tracking

The implant generates a persistent 32-character lower case alphanumeric session identifier per victim using a three-tier storage strategy designed to survive session restarts:

  • Browser local storage: Reading and writing a key Hm_lvt_$, likely mimicking Baidu Analytics tracking identifiers to blend with legitimate Chinese web analytics telemetry
  • Cookie: Setting Hm_lvt__<session ID>=1 with a path of / and an expiry date of the year 2099
  • Falcon extension storage cache: Checking whether a storageApi object is defined; if so, the session ID is stored there as well

The storageApi is a dictionary within the Falcon browser extension, meaning it is present only if the victim has the Falcon browser extension installed. We detail the browser extension in the Falcon Browser Extension section.

C2 Communication

The implant establishes a TLS encrypted WebSocket connection to maintain a persistent connection as long as the browser tab of the affected webpage is open. It sends a heartbeat message {"heartbeat":"1"} every minute to keep the connection alive. The implant resets the timer on every inbound message, so an actively engaged session never emits standalone heartbeats.

The code supports a fallback protocol using the Comet communication protocol. If Comet is used, payload data exchanged with the C2 server is not encrypted. The WebSocket functionality supports AES encryption in combination with the TLS transport encryption as described below.

Cryptographic Key Exchange

The implant leverages the browser's native Web Crypto API to encrypt all exchanged data using AES. If the Web Crypto API is unavailable, the implant falls back to URL-encoding and Base64. The key exchange proceeds in five steps:

Step 1: The server offers its RSA public key

Upon WebSocket connection, the server pushes a message with an action pubkey containing a 2048-bit RSA public key in PEM format, as illustrated in Figure 6.

Screenshot of code snippet containing JSON format. It includes an "action" key with the value "pubkey," and a "key" key with a placeholder value.
Figure 6. Server pubkey message.

Step 2: The client generates 256-bit AES session key material

The implant generates a 32-byte AES key and a 16-byte initialization vector (IV) using the browser's crypto.getRandomValues. If unavailable, a fallback function generates the key material from an alphanumeric string.

Step 3: The client encrypts the session key material using the server’s RSA public key

Both the AES key and IV are individually encrypted using the server's RSA public key and then Base64-encoded.

Step 4: The client sends the encrypted AES key material to the server

The client sends the encrypted key material to the server in a key_exchange message, as shown in Figure 7.

Screenshot of a JSON snippet showing a key exchange process, with an action labeled "key_exchange." It includes an RSA-encrypted AES key and an RSA-encrypted initialization vector (IV).
Figure 7. Client key exchange message.

Step 5: All subsequent exchanges have their payload data encrypted with the session key material using AES-256-CBC.

Command Dispatch

Following the key exchange, the implant registers with the server by sending information about its current execution environment. Figure 8 below shows the data before encryption.

Screenshot of code snippet showing an object with properties: "action" set to "init", "url" and "domain" using placeholders, "remark" referencing a variable, "ip" using a placeholder, and "ua" accessing the userAgent of the navigator.
Figure 8. Falcon implant session registration.

The data includes the current URL and domain of the tab within which the Falcon implant is running. The data also includes the browser's User-Agent string and client IP address (set by the backend server during implant generation).

The implant first attempts to read the remark from the browser’s local storage, specifically from the _domain_google_mark field. If unsuccessful, it then searches for the string _domain_google_mark= within the current webpage’s cookies to retrieve the remark.

If the implant uses Comet for communication, it only supports the run and nothing commands, with the latter serving no operational purpose.

The run command enables an operator to execute arbitrary JavaScript code through evaluation by calling eval. The set_remark command applies a remark (or label/comment) to the session, helping the operator organize the sessions in the management panel. It updates the remark for the fields _domain_google_mark across the browser's local storage, document cookie and Falcon extension storage.

The implant implements four main command APIs that attackers can use in custom modules to exfiltrate data, notify an operator or annotate the session in the Falcon database. Table 2 below details the APIs.

Function Purpose
xg_note Set session label (remark)
xg_send Send arbitrary JSON to the C2
xg_data Exfiltrate arbitrary data
xg_notify Send notification via Telegram

Table 2. Main command APIs.

Falcon Browser Extension

While the browser implant runs purely in the context of the browser tab, Falcon has two browser extensions to facilitate full control of a victim’s browser:

  • One for Firefox
  • One for Chrome

The extensions work with the implant.

We are currently unaware of how an operator is deploying these browser extensions. It is likely that they are using an initial implant to trick a target into installing the browser extension and granting the operator unfettered browser access.

The two extensions are functionally identical, this section focuses on the Chrome extension.

The extension masquerades as a PDF reader, as shown in Figure 9, using the name PDF Viewer.

A red PDF file icon with the letters "PDF" in white.
Figure 9. Browser extension icon used by Falcon.

The extension consists of 14 files, as detailed below in Table 3.

File Description
sandbox.html C2 command executor, message dispatcher
sandbox.js
page.js Unused code, likely remnants from development
page.html
offscreen.html Extension bootstrapping and setting up an internal MessageChannel messaging bus and downloading the Falcon implant.
offscreen.js
background.js Background service worker that stores collected data in a first in, first out (FIFO) cache such as credentials, network requests and clipboard data.

Monitors the browser’s credentials store for credentials, cookies, history and downloads.

twitter-dm.js Scrapes username and direct messages from Twitter/X when a user authenticates on x[.]com.
content-script.js Clipboard manipulation, credential theft, network hooking, web storage theft. Sends data through background.js for exfiltration.
analytics-core.js Hook fetch and XMLHttpRequest intercept HTTP requests
manifest.json Extension manifest
icon16.png Extension icons
icon128.png
icon48.png

Table 3. Falcon Extension Files.

An operator generates the extension bundle in the management panel, which provides the operator a ZIP archive that is ready to install in a victim’s browser. As manually installing an extension in Chrome involves many steps, it is possible that an operator instead socially engineered a victim into downloading and executing a small deployment utility that installed the extension via the command line.

We have observed evidence in the management panel that the operator possesses a utility for silent plugin installation for Chrome and Firefox as Figure 10 below shows. However, we have not been able to recover a sample for further analysis.

Screenshot of a webpage in simplified Chinese, titled "Falcon." It displays a table under "工具下载" (Tool Download) with two files. Each file has a description, an upload date, and options to download or delete. Sidebar contains navigation links in Chinese.
Figure 10. Falcon management panel (tools).

The operator can upload tools to the management panel and password protect them, preventing other people from accessing them. The panel shows that there are two tools uploaded. Table 4 below shows the translated columns.

Name of Document Size Description Upload Time
firefox.zip 0.38 MB Plugins for silently installing Firefox 2026-04-25T14:09:06.000Z
browser.exe 0.62 MB Plugins for silently installing Chrome 2026-04-23T03:08:40.000Z

Table 4. Falcon management panel (tools) translation.

The extension requests a total of 40 permissions that grant the operator full control over the victim’s browser. These permissions include access to credentials, cookies and browser network traffic. Figure 11 below shows the extension manifest.

Screenshot of a JSON file displaying the manifest and configuration for a Chrome extension named "PDF Viewer." It includes details like manifest version, permissions, content scripts, sandbox settings, and content security policy. Twitter and other URLs are listed in the matches section, along with resources and background scripts.
Figure 11. Falcon browser extension manifest.

The manifest parameters are described below in Table 5.

Parameters Description
manifest_version Defines the manifest version (3)
name Extension name (PDF Viewer)
version Extension version (2026.5.13.1)
description Extension description (Portable Document Format)
permissions Individual permissions required by the extension (40 total)
host_permissions A list of websites the extension is permitted to interact with and read data from. <all urls> specifies that the extension has access to all visited websites.
background Defines the filename for the background service worker (background.js)
content_scripts A list of scripts that should run on every URL that matches a certain criteria. The first script injects a content-script.js in all websites visited by a victim after the page has fully loaded. The second script injects twitter-dm.js on URLs matching x[.]com and twitter[.]com, more details in the Twitter Direct Message Exfiltration section.
sandbox Defines the context from which untrusted code executes (sandbox.html)
content_security_policy Defines the sandbox security policy and accessible objects
web_accessible_resources Declares resources that are world accessible (by other webpages). Extension resources not listed here would result in a cross-origin resource sharing (CORS) error.

Table 5. Falcon extension manifest parameters.

Extension Initialization

When the extension is installed, enabled, or the browser starts, Chrome parses the extension manifest. The background service worker, background.js, runs and creates a hidden or offscreen document from the offscreen.html file.

The offscreen.html file loads offscreen.js (hereafter referred to as offscreen) and creates an iframe to load sandbox.html (which loads sandbox.js, hereafter referred to as sandbox) in parallel.

This structure is common for Chrome extensions that need offscreen documents. The sandbox acts as a code execution environment, allowing eval execution.

Offscreen starts by creating a MessageChannel message bus for communication

between extension components. It delays execution for 2 seconds to allow the message bus to be established before sending a request to the C2 server to download the Falcon implant. The code is passed to the sandbox through the message bus as shown in Figure 12.

Screenshot of a code snippet showing "postMessage" with parameters.
Figure 12. Falcon implant code message bus call.

The code is executed by appending a script tag to the sandbox.html document body. The implant code, now running inside the sandbox, establishes a WebSocket connection to the C2 server.

In parallel with the background/offscreen initialization, Chrome automatically injects content-script.js (hereafter referred to as content script) into every page visited by the victim due to its manifest definition in content_scripts.

The twitter-dm.js script is injected only if a victim visits twitter[.]com or x[.]com as defined in the manifest. The content script runs in an isolated context and only has access to the webpage's Document Object Model (DOM), but not to its JavaScript context.

To achieve full page context access, the content script injects a script tag into the page pointing to chrome-extension://<extension ID>/analytics-core.js (hereafter called analytics core). Because the analytics core file is defined in web_accessible_resources in the manifest, it is accessible to web pages and not blocked by CORS.

At this point, the extension has:

  • Full access to the browser's data store (via chrome.* APIs in background.js)
  • Full access to the context of every webpage the victim visits (via the content script and analytics core)

Web Proxy

Falcon allows an operator to use a victim’s browser as a proxy server and to use the victim’s browser data store, including session cookies and credentials for requests. An operator creates a proxy and attaches it to the victim’s Falcon session.

The operator then configures the victim’s browser with the Falcon server address and the designated proxy port. The operator is then able to send requests to the Falcon implant within the victim’s browser, with these requests encapsulated in a JavaScript snippet. They will then be sent to the victim’s browser as illustrated below in Figure 13.

Diagram illustrating a sequence of HTTP and WebSocket interactions for a Gmail session hijacking attack. It features four main entities: Operator's Browser, Falcon Server, Victim's Browser, and Gmail Server. The flow shows requests and responses, including GET and HTTP 200 OK messages, WebSocket connections with credentials, and the validation of the user's session by Gmail Server.
Figure 13. Falcon proxy capability overview.

The sandbox receives and executes the JavaScript. This script calls handleProxyRequest with the request data as an argument, which subsequently sends a message on the Chrome runtime message bus as shown in Figure 14.

Code snippet showing a function call.
Figure 14. Falcon browser extension proxy request message.

The background service worker picks up the messages, constructs the request and sets the fetchOptions to use the victim's credential store in the request. Figure 15 below shows this, highlighted in bold.

Screenshot of code snippet showing JavaScript fetch options with method and headers variables, and credentials set to 'include'.
Figure 15. Falcon browser extension credential store usage.

The response from the request is Base64-encoded and returned in JSON via the C2 WebSocket. This enables an operator to browse resources using the identity of the victim, allowing for session hijacking and access to internal network resources.

Download Intercept

The extension can intercept and replace file downloads according to operator-defined rules. The operator can define broad rules targeting a list of domain and file extensions.

Figure 16 below shows an example rule that intercepts and replaces all executable downloads from google[.]com and dl.google[.]com with an operator-controlled URL.

Screenshot of a code snippet displaying a task configuration for downloading malware. It includes a redirect URL with a placeholder domain and specifies targeting ".exe" extensions.
Figure 16. Download intercept configuration entry.

The background service worker installs an event listener that listens for chrome.downloads.onCreated events. When detected, the background worker sends a message to offscreen over the Chrome runtime message bus, which it relays to the sandbox.

The sandbox applies the intercept rule set to the download URL to determine whether it should modify the URL. While the background service worker has the necessary privileges to intercept and replace downloads, the extension's architectural design keeps the intercept rules and C2 command processing (which requires eval execution) within the sandbox. This design necessitates passing messages across the message buses.

If the URL matches a rule, the extension cancels the original file transfer and removes the download from the Chrome download history. The new URL consists of the target and redirect URL, where the target URL is encoded and appended to the end of the redirect URL as shown below in Figure 17.

Screenshot of a suspicious URL link appearing to download malware disguised as a Google Chrome setup file.
Figure 17. Download intercept modified URL.

The download retains the original filename and will appear to the victim as ChromeSetup.exe while the origins will show as evil[.]com.

This technique enables an operator to achieve code execution on the victim’s system by intercepting a legitimate download and replacing it with the operator’s payload. It does so leaving little evidence that the file originated from a malicious source. The operator can use this to deploy additional malware and gain a stronger foothold in the target network.

Network Hooking

The functionality of analytics core is to install a hook for window.fetch, XMLHttpRequest.open and XMLHttpRequest.send. This hook enables the extension to intercept requests made from the current webpage and any third-party scripts loaded on the page. The operator can also define intercept rules that can replace a URL with an operator’s own URL (e.g., to hijack software updates).

For window.fetch, the hook intercepts HTTP requests that result in an HTTP 200 response and sets the content type to application/json or contains text/. The intercepted request and response data is posted to the MessageChannel as shown below in Figure 18.

Screenshot of a code snippet for a network data hook using JavaScript. It includes parameters for type, payload, method, headers, request body, response body, status, and duration calculation.
Figure 18. Intercepted HTTP request (fetch) passed on MessageChannel.

For calls to XMLHttpRequest.send, the hook checks whether the HTTP response code is between 200 and 299, and whether the content type is application/json or contains text/. The hook also checks the responseType attribute to see whether it is text or an empty string.

The intercepted request and response data is posted to the MessageChannel as shown below in Figure 19.

Screenshot of a JavaScript code snippet for network data monitoring, including properties for URL, method, headers, request and response bodies, status, and duration.
Figure 19. Intercepted HTTP request (xhr) passed on MessageChannel.

The posted message signals the content script to relay the message from the MessageChannel onto Chrome’s runtime message bus using chrome.runtime.sendMessage as shown below in Figure 20.

Screenshot of a JavaScript code snippet setting up an event listener for 'message' events. It checks for a specific event data type and, if true, sends a message with the network body data.
Figure 20. Intercepted HTTP request message relay.

The background worker picks up the message and stores it in a cache awaiting operator instructions to upload the data to the C2 server. The cache operates in a FIFO fashion and stores a maximum of 500 requests.

Discord Messages and Friends List Exfiltration

An operator can also target Discord chat messages and friend lists. They achieve this using passive network hooking described above, as Discord uses JSON in its HTTP communication. If configured, the operator can intercept requests matching a Discord URL pattern with victim data stored in a separate table.

Zalo Chat Database Exfiltration

Zalo is a chat application similar to WhatsApp that is popular in Vietnam. Falcon supports intercepting Zalo chat message databases using passive network hooking. Targeting Zalo provides additional insights into the targeted audience of the operator.

Gmail Exfiltration

While the ability to exfiltrate Gmail data is not a core functionality of the extension, it does provide an operator with the access needed to compromise a victim’s Gmail account and download email data. An operator issues a command that uploads a JavaScript to the extension, which sends a request to Gmail using the user’s Gmail session cookie to retrieve a list of authenticated users.

An operator can then select the accounts to collect data from, to be uploaded to the C2 server. This action is facilitated by the extension.

The exfiltrated email data includes:

  • Date
  • Receiver
  • Sender
  • Subject
  • Email body
  • Attachments

Clipboard Hijacking

As soon as the extension is installed, loaded or the browser starts, the clipboard hijacker is actively monitoring the victim’s clipboard events. It intercepts every cut, copy and paste event by adding document listeners as shown below in Figure 21.

Screenshot of a code snippet showing JavaScript functions that add event listeners for "copy," "cut," and "paste" actions, each referencing a specific handler function.
Figure 21. Clipboard hijacker listeners.

By default, the hijacker runs without any rules. An operator has the option to define pattern matching rules and replacements (e.g., replacing account numbers or cryptocurrency wallet addresses).

The rules are stored in Chrome’s local storage chrome.storage.local in a key clipboard_replacer_rules. Figure 22 below shows an example rule.

Screenshot of a JSON code snippet with fields for task identification, activity status, target domains. Match type set to "regex", a specific match regex pattern, and a replacement string.
Figure 22. Clipboard hijacker configuration example.

Intercepted clipboard events are passed as messages on Chrome’s message bus. These messages are picked up by the background worker and stored in a cache similar to the intercepted HTTP requests. They then await an operator command to upload the data.

X/Twitter Direct Messages Exfiltration

The extension comes with a separate module for scraping direct messages from the X/Twitter social media platform. The module is defined in the extension manifest under content_scripts and is injected into any webpage whose URL matches the patterns *://*.twitter.com/* or *://*.x.com/*.

The module can only scrape direct messages when a victim browses a conversation. It cannot enumerate conversations or open other conversations.

The module is notable for using X and Y coordinate systems to identify messages received (left) and sent by the account owner (right), leveraging X/Twitter’s CSS layout. Along with the messages, the module extracts attachment references (URLs) and the associated timestamp. It attempts to translate the timestamp into a uniform format.

Because X/Twitter uses “today” or “yesterday” instead of timestamps for the most recent messages, the module attempts to convert them into timestamps. We found that the module supports six different languages, as shown below in Table 6.

English Today Yesterday
Chinese 今天 昨天
Spanish Hoy Ayer
French Aujourd'hui Hier
German Heute Gestern
Italian Oggi Ieri

Table 6. Module language support.

This language support provides insight into the target demographic to extract Twitter/X direct messages.

Continuously Monitoring - Credentials Store, History and Downloads

The extension supports monitoring for sensitive information. It collects some information automatically when the extension is loaded, other information requires an operator to issue a command to enable monitoring. Table 7 shows the various collectors and how they are enabled.

Collector Collects Description
Credentials Passwords, autofill forms Continuously collects data and stores it in the background service worker’s cache. Only the 500 latest entries are kept in the cache.
Cookies Cookies Collects all browser cookies and exfiltrates them to the C2 server. Requires manual issuance of command.
Clipboard Copy, cut and paste events As described in the earlier section.
Browser history Full browser history Collects full browser history, exfiltrated to the C2 server directly. Requires manual issuance of command.
Download history Full file download history Collects detailed history of all downloaded files.

Table 7. Falcon extension collection capabilities.

Possible AI-Assisted Development

The Falcon framework shows a high level of complexity in both design and capability. However, the overall code exhibits characteristics suggesting the malware authors likely used AI to assist with design and development. This conclusion is based on the coding style, including variable naming and code comments.

There are also inconsistent design choices that make little sense to a human developer. For example, the network hook for XMLHttpRequest checks for an HTTP response code greater than or equal to 200 but less than 300, while the hook for fetch checks against response.ok. Both result in the same outcome while the first is rarely, if ever, used when the response.ok shortcut exists.

Campaign Tracking

Falcon uses unique attack identifiers to organize campaigns. We identified campaigns targeting government entities across at least five countries, as shown in Table 8.

Region Targets
Middle Eastern Country Ministry of Defense

Ministry of Interior

Ministry of Foreign Affairs

National Agency for Network Services

Telecom Provider

Government email systems

Southeast Asian country A Police Entity

Directorate of Intelligence

Department of Corrections

Southeast Asian country B Justice Entity
Southeast Asian country C Military Entity

Department of Justice

Southeast Asian country D Ministry of Foreign Affairs

Table 8. Campaign victims identified.

While all five campaigns leveraged Falcon as their primary C2 framework, each exhibited distinct tradecraft in implant delivery and target selection, demonstrating how the operators tailored their approach to specific environments.

  • The operator compromised the Middle Eastern country's Ministry of Foreign Affairs Roundcube webmail portal by inserting a script tag that loads the Falcon implant. This enabled the operator to intercept credentials and monitor user sessions.
  • In Southeast Asian country A, the operator used Falcon to load a custom username-harvesting module. This was followed later by a fake Adobe Flash update prompt that attempted to deliver the Antino implant to pre-selected users.
  • In Southeast Asian country B, the operator used the Falcon Chrome extension mimicking a PDF viewer to establish persistent access from a browser context.
  • In Southeast Asian country C, a separate Falcon campaign targeted a military entity.

The following sections detail our analysis of the campaign associated with the Middle Eastern country and Southeast Asian countries A and B.

Middle Eastern Country (Roundcube Webmail)

In April 2026, we observed a Falcon implant residing on the Roundcube webmail portal of a Middle Eastern Ministry of Foreign Affairs. The actor had injected a <script> tag into the portal header as shown in Figure 23.

Screenshot of an HTML script tag containing the source URL.
Figure 23. Falcon implant tag injection.

The resource config_r5lfmqe3 returns the obfuscated JavaScript Falcon implant. This enables the actor to intercept credentials as users sign in. Based on the analyzed data, we assess with high confidence that the script executes on each Roundcube visited by a victim, granting the operator access to a victim’s inbox and account settings.

We observed a total of 39 Roundcube instances being affected within the target country. We have no evidence of any instances affected outside of the target country, suggesting this was a highly targeted campaign.

Southeast Asian Country A - Police Entity (Username Harvesting and Antino Implant Deployment)

In May 2026, we observed the Falcon implant deployed in a web application belonging to a Southeast Asian police entity. The operator deployed a custom Falcon module to harvest usernames and later target specific victims by displaying a fake Adobe Flash Player update prompt with a specific username.

The first module targets the text content of the HTML element with the ID leftusername. It reports the contents to the Falcon C2 using the built-in function xg_note.

This function annotates the session in the Falcon database and sets the implant’s remark attribute. This enables the operator to know which session corresponds to which username. Figure 24 below shows code from this first module.

Screenshot of a code snippet written in JavaScript, featuring a self-executing function. It attempts to retrieve an HTML element by the ID, assigns its text content to a variable, and calls a function with that text. A try-catch block is used to handle potential errors.
Figure 24. Falcon custom module for harvesting usernames from internal systems.
Screenshot of a code snippet displaying a function to detect if a user is on a Windows browser using the `userAgent` property. It also manages popup counts stored in `localStorage` and checks domain names against a predefined list. The code uses try-catch for error handling.
Figure 25. Falcon custom module for displaying a fake Adobe Flash Player update pop-up.

The module first extracts the text contents of the leftusername element, as the harvesting module does. It compares the username against a hard-coded list of targeted usernames.

If the username matches and the fake Adobe Flash Player pop-up (shown below in Figure 26) has been shown fewer than 10 times, the module displays the pop-up shown below. The pop-up count is stored in the browser’s local storage in a key called popup_count.

A popup message from Adobe Flash Player indicating that the flash version is too low. It advises upgrading to the latest version to avoid security risks and improve the online experience. There is a yellow button labeled "Upgrade immediately".
Figure 26. Fake Adobe Flash Player update prompt.

Clicking the upgrade button serves the user with an implant, Antino, documented in the section: Antino Implant. The payload was served from hxxps[:]//microsoft-flash[.]com/download/Adobe_installer.exe.

Southeast Asian Country B - Justice Entity (Falcon Browser Extension)

In early 2026, we identified the compromise of an entity affiliated with a national justice department in a Southeast Asian country. Unlike other campaigns attributed to this actor, this intrusion likely relied on a different initial access vector: a malicious Chrome browser extension.

The extension (ID: mbidcmlcbgbphpoacojjbmfpohcimjji) mimicked a legitimate PDF viewer. It was sideloaded in Chrome's developer mode and ran persistently in the victim's browser with a broad permission set, as documented in the section: Falcon Browser Extension.

Communication with the operator's infrastructure was maintained over a long-lived WebSocket originating from the extension's own sandbox context. The compromised browser checked in every 3-4 minutes for more than 3 weeks.

Beyond ambient data collection, the extension provided the operator with persistent visibility into the victim's day-to-day work inside the national justice department's internal document system. This document system is used to route, print and track official correspondence between high-ranking officials and subordinate staff.

On one occasion, while the victim was actively viewing a routing slip in that system, we observed the operator capture a full-page screenshot of the rendered document. The captured document was a request for the approval of the release of persons deprived of liberty. This demonstrates the actor's willingness to conduct hands-on collection when material of intelligence value appeared during the victim's session, rather than relying solely on the extension's automated telemetry.

Alongside the screenshot, the extension exfiltrated plaintext credentials for the same system and recorded more than 20 additional routing-slip page views spanning late April–mid-May 2026. This demonstrates both the operator's interest in classified internal documents and their ability to independently replay access to the system.

Antino Implant

Antino is written in Rust and dates back to at least Oct. 6, 2025, based on the compilation timestamp of the earliest known sample. The name originates from the filename of the oldest known sample antino-client.exe, along with PDB strings in the binary, such as antino_client.pdb.

The Antino configuration is stored in the .cfg PE section and is XOR-encoded as Figure 27 below shows.

A red and green hex dump screen with columns of hexadecimal values on the left and corresponding ASCII text on the right. The red background highlights specific areas, while the top rows include a green section with repeating values.
Figure 27. Antino encoded configuration.

The .cfg section is 65,535 bytes while the configuration takes up 262 (0x106) bytes. The first 4 bytes are the length of the XOR-encoded configuration data, 258 (0x102) bytes. Antino decodes the configuration using a 2-byte key 0xABCD. The decoded configuration is in JSON format and contains Microsoft OneDrive credentials and a remark (campaign ID). Table 9 shows the decoded configuration.

Antino Configuration

Field Value Description
tenant_id [REDACTED] Microsoft OneDrive tenant ID
client_id [REDACTED] Microsoft OneDrive client ID
client_secret [REDACTED] Microsoft OneDrive client secret
user_id [REDACTED] Microsoft OneDrive user ID
remark [REDACTED] Actor made remark, likely campaign ID
run true Establish persistence
launch_mode exe Antino launch mode, determines the behavior based on whether it is running in a DLL context (side loading) or a stand-alone executable

Table 9. Antino configuration.

Persistence

Antino uses passive execution to establish persistence in the Windows Registry. It first copies itself to the hard-coded directory %LOCALAPPDATA%\Windows GatherOSStateKit\tmp<8 char>.exe and attempts to copy two DLLs, DllSafeCheck64.dll and slc.dll, from its current directory.

Antino does not import either of these files, but we have observed it using DllSafeCheck64.dll for sideloading in older versions of Antino. This functionality is likely a remnant from those versions.

The implant then checks for the presence of a file named id. If it exists, Antino reads the contents as the bot ID. If the file does not exist, it generates a UUID string and writes it to the id file. 

To achieve passive execution, the implant writes a diagnostic answer file to %TEMP%\SDIAG_<GUID>\result\result.ps1 as shown below in Figure 28. A diagnostic answer file is a configuration file that defines parameters for the diagnosed application.

A snippet of Windows PowerShell script is displayed. It defines variables to gather system diagnostics using an executable. The script contains paths for file and registry item creation.
Figure 28. Diagnostic answer file contents.

Antino executes the Microsoft Scripted Diagnostic Native Host utility (sdiagnhost.exe), which parses the diagnostic answer file. The first XML section highlighted in red defines the header, and the text that follows is the path required to load the Program Compatibility Wizard (PCW). The contents highlighted in purple are the answer file folder name. The contents highlighted in blue are the answer file filename. The PowerShell snippet highlighted in light magenta is ultimately executed in the context of sdiagnhost.exe and adds Antino to the Windows Registry Run key.

Command and Control

Antino uses Microsoft OneDrive for C2 and uploads a heartbeat to the antino/heartbeat/<Bot ID>.json file in the OneDrive folder as a beacon. The heartbeat contains the hostname, username and remark from the Antino configuration.

Antino searches the OneDrive root folder for files following the command_req_<Bot ID>_<timestamp>.json format. Files matching the format indicate that a command has been issued to the bot. Figure 29 below shows an example command, system_info.

Screenshot of a JSON code snippet displaying system information with command type and subject ID.
Figure 29. Antino system_info command example.
A JSON formatted system information output displaying details such as command type, system info, machine name, platform as "windows", with remarks redacted. It also includes session and process IDs, followed by success status as true.
Figure 30. Antino system_info command response example.

Antino supports 10 commands shown below in Table 10.

Command Description
cmd Shell command execution
ps PowerShell execution
system_info System information collection
list_files Directory listing
add_to_run Registry Run key persistence
exit Client shutdown
load Download and execute a Rhai script
execute_program Program execution
upload_file File exfiltration via OneDrive, uploaded to antino/antino_upload/
download_file File download from OneDrive, downloaded from antino/antino_upload/

Table 10. Antino commands.

Notably, Antino supports execution of Rhai scripts (embedded scripting for Rust) that easily extend the implants’ capabilities without compiling additional binary shellcode. We have not observed any usage of Rhai scripts in the wild.

Conclusion

Falcon's browser-native approach presents significant challenges for traditional endpoint and network security controls. It operates entirely within the browser sandbox, avoiding persistent file artifacts and encrypting all C2 traffic over WebSocket.

The discovery of Antino, a Rust-based implant that routes its C2 through Microsoft OneDrive, demonstrates further attempts to blend into network traffic. Organizations should monitor for the following anomalous activity:

  • Browser extensions installed in developer mode, particularly those mimicking common utilities (e.g., PDF viewers) and requesting broad permissions (e.g., <all_urls>, debugger, tabCapture, nativeMessaging, or webRequest)
  • Hm_lvt_ cookies or local-storage keys on internal or government web applications where Baidu Analytics has no legitimate reason to appear
  • <script> tags added to the templates or headers of internal webmail, ticketing or case-management portals loading resources from unfamiliar external domains, especially where the response is a heavily numeric JavaScript array with a small decoder loop
  • OAuth activity to Microsoft OneDrive tenants outside the organization's own tenancy, especially with repeated small JSON writes to paths such as antino/heartbeat/ or antino/antino_upload/

Palo Alto Networks Protection and Mitigation

Palo Alto Networks customers are better protected from the threats discussed above through the following products:

  • 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 and Advanced DNS Security identify known URLs and domains 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.
  • Cortex Agentic Endpoint Security is designed to help discover every AI artifact and AI agent's activity across the agentic endpoint, assess its risk, enforce prevention and runtime controls and remediate violations.
  • Prisma Browser is designed to provide multi-layered protection against extension-based threats by preventing the side-loading of unauthorized extensions, as well as detecting, blocking, and removing malicious extensions in the event of manual user installation.’
  • 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 Identity and Access Management (IAM) can help enable secure, unified access across human, machine and AI identities, balancing granular control with a seamless user experience. Powered by SSO, phishing-resistant MFA, passwordless login and enterprise password management, Idira IAM extends intelligent privilege controls and session security across the broader workforce.

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

Falcon C2 domains:

  • fonts.tarotfree101[.]top
  • fonts.chrorne[.]com
  • robot.avbliud[.]com

Chrome Browser Extension ID:

  • mbidcmlcbgbphpoacojjbmfpohcimjji

Chrome Browser Extension Files (Read: SHA-256 hash - filename):

  • 3e535d63af8a95221fb517fa1b3e4a0029d3463d8b767443abdff385ee8cb6e9 - analytics-core.js
  • f8b86238e179d88a9979b6f97750a39dda1d07b54d634bc1348fdfb0944a3b92 - background.js
  • 88e8b07bdf294ace0357d35acb7e108c66ba65a2c4ad66351fb8f7806dae0862 - content-script.js
  • 065d18fcfeddbd718c054f4b21c3cde5b9291db921d01f343d7ac0d4b41f29ce - icon128.png
  • 3eab406d841fa22a4b0200c95c1afab068347f835400d5771e8de60aef732016 - icon16.png
  • 5711586125909863b91c1b5ff7cf70ef5d35249d67b11d7a23dc864405cddfe2 - icon48.png
  • b6a7be724871ed3e81c986b74d62da8911c82a336c4c1857b35f2446b2d49fda - manifest.json
  • 2ed834d92bfefc9d07a9f1a48f986974ae2a29669029f8163a1f6e8706388fcd - offscreen.html
  • 356b96c2267c5f2d8c07693643626e090b6389318b4ffa74699fa1732da5a00c - offscreen.js
  • 32af8413cbd38ce8beb257288cb8e6aa2f9b781d56d0f5272bffbcdc22d999f4 - page.html
  • e2b6b1becdbcc340121e163b5afdfc5437a480ca132248ed5c7c309c45ac3dbb - page.js
  • 265c2b36060e4b21c25aa86a8bb22d1db5f806117b484774c75c65b5b38222e0 - sandbox.html
  • 66e9098551a1c0c74077d6cf55570e5d307a4a5ef0b0f2053e139394e61c442d - sandbox.js
  • 3e923f11db08413fca8a3a69d33d8896cfd56309e5179e8604d7fb7110428da2  twitter-dm.js

Firefox Browser Extension Files (Read: SHA-256 hash - filename):

  • 3e535d63af8a95221fb517fa1b3e4a0029d3463d8b767443abdff385ee8cb6e9 - analytics-core.js
  • 2ebe36f1322b77264a33fded81cd4b8817f93362945070bf0bb5845dd27c0575 - background.js
  • 857429faffe0e0747ce299e86eed063ed781b4e403b917ca7e853e89bedf072c - content-script.js
  • 065d18fcfeddbd718c054f4b21c3cde5b9291db921d01f343d7ac0d4b41f29ce - icon128.png
  • 3eab406d841fa22a4b0200c95c1afab068347f835400d5771e8de60aef732016 - icon16.png
  • 5711586125909863b91c1b5ff7cf70ef5d35249d67b11d7a23dc864405cddfe2 - icon48.png
  • b33f2e95943e3ff0a72dea1be9fdea03d986bada4def34f6991b3113ec161ad7 - manifest.json
  • 2ed834d92bfefc9d07a9f1a48f986974ae2a29669029f8163a1f6e8706388fcd - offscreen.html
  • 898656c33effb51e109c548fc213f157f151a870ea64a4601eda74ae75bd3af6 - offscreen.js
  • 32af8413cbd38ce8beb257288cb8e6aa2f9b781d56d0f5272bffbcdc22d999f4 - page.html
  • e2b6b1becdbcc340121e163b5afdfc5437a480ca132248ed5c7c309c45ac3dbb - page.js
  • 265c2b36060e4b21c25aa86a8bb22d1db5f806117b484774c75c65b5b38222e0 - sandbox.html
  • b3d8ea89b19a87bf2fdd63127086681059f41d67b6e5f8c939f5636a1b2315ce - sandbox.js
  • 24d69139cb2d32598f0f4983876f6320485fac134a66ade59cab76b50b4128f7 - twitter-dm.js

Payload Delivery Domains:

  • microsoft-flash[.]com
  • wps-cn[.]com

Antino Sample (Read: SHA-256 hash - filename):

  • 0c39264337a1186b2e765e24073399cbdcba118306614eb411e315887af578bd - flashcenter_pp_ax_install_en.exe

Additional Resources

Turning Up the Heat: Inside the Attacks on Europe’s Refrigeration Systems

Introduction

Unit 42 has been actively monitoring for new developments related to the cyberattacks targeting refrigeration systems in Europe since at least October 2026. The unidentified threat actors gained unauthorized access to refrigeration controllers and set them to defrost mode, resulting in hundreds of supermarkets across the region having to throw away spoiled food. The time of year when this activity has occurred is particularly concerning since retailers need to maintain adequate inventory levels as shoppers ramp up spending during holiday periods.

Here we provide a high-level overview of the attacks based on public reporting and explore insights on device exposure by country, based on our findings using Cortex Xpanse. It also explores how Palo Alto Networks customers can leverage existing products and Unit 42 services to reduce their attack surface to mitigate similar threat activity in the future.

Background

The first wave of these attacks occurred overnight between Oct. 11–12, 2026, primarily targeting approximately 700 supermarkets in France. Since that time, another wave occurred overnight between Nov. 1–2, 2026, expanding across at least 10 additional European countries and impacting over 100–115 retail locations.

In addition to the aforementioned activity, French authorities recently disclosed that refrigeration systems used by medical facilities were impacted by the attacks. At this time, there’s no evidence to suggest blood products were spoiled as a result.

According to multiple sources, the threat actors behind the supermarket activities raised the temperature of the targeted refrigeration units as high as 50°C (122°F). In some cases, the activity resulted in fires. The initial access vector currently remains unconfirmed. However, there is widespread speculation that impacted devices were potentially running vulnerable versions of software and/or used default credentials provided by the manufacturers that attackers easily identified.

Unit 42 Insights

From Nov. 5–6, 2026, we identified the presence of over 5,000 devices exposed to the internet that were manufactured by companies listed in the CERT-FR advisory last month. These statistics do not necessarily mean that the devices are running vulnerable versions of software that could’ve been exploited. Figure 1 below illustrates these findings based on device count by the top 10 countries.

Bar chart showing total device count by country. United States leads with 740, followed by China with 625, and Italy with 370. Other countries include Germany (262), France (234), Spain (220), Greece (177), Turkey (153), and Brazil (137). "Palo Alto Networks" and "Unit 42" logos are at the bottom right.
Figure 1. Graph of internet exposed devices by country, top 10 results - Nov. 5–6 2026. Source: Cortex Xpanse.

Given the impact of this malicious activity primarily affected devices in France, we decided to explore the trend of internet-exposed devices since October 1, 2026. Figure 2 below illustrates these findings where we identified a significant decline over three distinct time periods:

  • October 1-15, 2026: 1,853
  • October 16-31, 2026: 558
  • November 1-6, 2026: 316
Line graph titled "Number of Exposed Devices" shows a decreasing trend over three dates: October 15, 2026 (1,853 devices), October 31, 2026 (558 devices), and November 6, 2026 (316 devices). Palo Alto Networks Unit 42 logo is at the bottom right.
Figure 2. Graph of internet exposed devices in France by date since Oct.1, 2026. Source: Cortex Xpanse.

Censys has also reported extensively on the trends in device exposures in Europe as well.

Conclusion

On Nov. 3, 2026, the pro-Russian hacktivist groups NoName057(16) and Z-Pentest claimed responsibility for the attacks via Telegram posts, although their allegations remain unverified at this time. The Cybersecurity and Infrastructure Security Agency (CISA) also released an advisory on Nov. 5, 2026 warning of potential exploitation via authentication bypass, arbitrary code injection, and weak configurations.

Palo Alto Networks customers can leverage several products and Unit 42 services to identify and defend against potential exploitation and unauthorized access to exposed devices.

Cortex Xpanse can identify exposed devices on the public internet and escalate these findings to defenders.

Device Security is designed to provide continuous discovery, risk assessment, and protocol-level visibility across OT and IoT infrastructure, identifying weak configurations, default credentials, exposed administrative interfaces and anomalous control-plane traffic. Complementing this visibility, Frontier Virtual Patching with Advanced Threat Prevention inspects network traffic inline to block exploit attempts, command-and-control communication, and arbitrary code injection in real time. Together, these capabilities allow organizations to enforce adaptive access controls around vulnerable controllers and virtually shield unpatched firmware from unauthorized modification without disrupting critical physical operations.

Unit 42 Continuous Frontier AI Defense is an offensive security service designed to assist organizations with continuously discovering hidden and unknown exposures in dynamic environments, validate real-world exploitability across attack paths through agentic testing and expert analysis, and provide prioritized remediation and virtual patching guidance to accelerate risk mitigation.

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.

The Unit 42 Incident Response team can also be engaged to help with a compromise or to provide a proactive assessment to lower your risk.

Additional Resources

Unit 42 Threat Intelligence Highlights - Nov. 2, 2026

Executive Summary

This overview highlights recent threat intelligence observed by Unit 42. Common adversary activities focus on strategic intelligence collection and financial extortion. We observed these activities alongside a cross-cutting adoption of artificial intelligence tools across multiple threat disciplines.

Here, we share observations and behaviors associated with these activities.

For in-depth access to Unit 42 threat intelligence insights, explore our Threat Intelligence Services offerings.

Threat Highlights

Cyberespionage

State-sponsored and advanced persistent threat (APT) campaigns focused on covertly acquiring strategic intelligence, intellectual property or geopolitical data.

Key Observations and Behaviors

  • Widespread reliance on living-off-the-land (LotL) binaries and built-in administration tools to evade endpoint defenses
  • Exploitation of zero-day vulnerabilities alongside targeted spear phishing for initial intrusion
  • Covert credential harvesting and low-and-slow data staging designed to sustain long-term operational persistence

Cybercrime: Data Theft, Extortion and Financial Fraud

Organized syndicates and affiliates sought monetary gain through systemic data compromise, extortion and fraudulent transactions.

Key Observations and Behaviors

  • Multi-extortion models combining exfiltration with ransomware deployment or public exposure threats
  • Access acquisition facilitated by infostealer logs, exposed credentials and unpatched perimeter assets
  • Business email compromise (BEC) and payment diversion schemes executing fraudulent wire transfers

AI-Enabled Offensive Operations

Threat actors are integrating generative AI and large language models (LLMs) into their offensive workflows. This notable emerging trend cuts across multiple operational motivations.

Key Observations and Behaviors

  • Generation of highly refined, context-tailored social engineering lures and synthetic personas at scale
  • Utilization of LLMs to assist in rapid scripting, payload debugging and code obfuscation
  • Application of automated reconnaissance and multimodal tools (such as deepfakes) to support executive impersonation and access operations

These highlights summarize recent in-depth threat intelligence bulletins published for Unit 42 Threat Intelligence Services customers.

Unit 42 Threat Intelligence Services provide organizations with direct access to elite frontline threat expertise, enabling security teams to prioritize real risks and sharpen detection capabilities. These human-led services combine world-class intelligence with direct access to the analysts behind it, offering tailored context and guidance aligned to a customer's specific environment.

Threat Brief: Critical Vulnerabilities in PHP: CVE-2026-109618, CVE-2026-109619 (Updated October 29)

Executive Summary

Unit 42 is aware of two critical vulnerabilities in PHP: CVE-2026-109618 and CVE-2026-109619, referred to as PHP2Shell. Both are remote code execution (RCE) vulnerabilities rated as 9.2 (CVSS 4.0). We encourage reviewing the PHP Group’s security advisory and patching guidance.

PHP is widely used across web servers and content management systems globally. We recommend assessing your exposure to these vulnerabilities and patching immediately.

Palo Alto Networks has evaluated our product portfolio regarding this issue. Refer to our security advisory for the most up to date details.

  • CVE-2026-109618 involves a remote code execution vulnerability where handling out-of-memory errors via longjmp() leaves request memory uninitialized due to improper control flow management, allowing attackers to reliably achieve RCE using out-of-memory (OOM) triggers.
  • CVE-2026-109619 describes a remote code execution vulnerability where longjmp() fatal error handling leaves global memory pointing to freed memory regions. These regions can later be read or branched on during subsequent requests, enabling attackers to execute arbitrary code.

At the time of publication, Palo Alto Networks Cortex Xpanse has identified the presence of over 22.6 million exposed instances potentially vulnerable to CVE-2026-109618 and CVE-2026-109619 based on our telemetry.

Update October 29, 2026

As disclosed in our security advisory, the PHP2Shell vulnerabilities are being actively exploited against PAN-OS management interfaces that are exposed to the internet. Dream Research has reported a campaign in which attackers chained PHP2Shell with a Linux kernel privilege-escalation vulnerability to gain root access. Unit 42 has independently verified the same attacker’s tooling and confirmed the reported results.

By default the management interface is not exposed to the internet per security best practices; customers should immediately remove public internet access to management interfaces if it is enabled. Customers should also restrict management access to trusted internal IP addresses, and apply available PAN-OS fixes addressing PHP2Shell. Customers who have applied the available patches are not affected. These fixes interrupt the observed exploit chain. Our security advisory provides affected versions, patch availability and mitigation requirements. The Workarounds and Mitigations section of our security advisory also provides details of how Advanced Threat Prevention signatures provide coverage against this vulnerability.

Only a small fraction of a percent (approximately .02%) of our global installed base has internet-facing management interfaces configured and were impacted. Each of these customers has been individually contacted by our teams. We will continue to investigate and provide any necessary updates as they become available.

Palo Alto Networks customers receive protections from and mitigations for CVE-2026-109618 and CVE-2026-109619 in the following ways:

Palo Alto Networks also recommends assessing your exposure to these vulnerabilities and patching immediately.

Organizations can access tailored adversary intelligence, direct analyst consultations, and specialized exposure tracking through Unit 42 Threat Intel Services and our Deep and Dark Web Service.

The Unit 42 Incident Response team can also be engaged to help with a compromise or to provide a proactive assessment to lower your risk.

Vulnerabilities Discussed CVE-2026-109618, CVE-2026-109619, PHP2Shell

Unit 42 Managed Threat Hunting Queries

The Unit 42 Managed Threat Hunting team continues to track any attempts to exploit these CVEs across our customers, using Cortex XDR and the XQL queries below. Cortex XDR customers can also use these XQL queries to search for signs of exploitation.

Palo Alto Networks Product Protections for CVE-2026-109618 and CVE-2026-109619

Palo Alto Networks customers can leverage several product protections and updates to identify and defend against these vulnerabilities.

Unit 42 Continuous Frontier AI Defense is an offensive security service designed to assist organizations with continuously discovering hidden and unknown exposures in dynamic environments, validate real-world exploitability across attack paths through agentic testing and expert analysis, and provide prioritized remediation and virtual patching guidance to accelerate risk mitigation.

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

Advanced WildFire

The Advanced WildFire machine-learning models and analysis techniques have been reviewed and updated in light of indicators associated with chained PHP and kernel vulnerabilities.

Cortex XDR and XSIAM

Cortex XDR and XSIAM are designed to help protect against post-exploitation activities using the multi-layer protection approach. provide multilayered protection against post-exploitation activities. Cortex XDR also provides visibility into installed software across endpoints and servers, including on-premises and legacy environments, to help security teams identify systems running vulnerable PHP versions and prioritize remediation.

Cortex Cloud and Prisma Cloud

Cortex Cloud and Prisma Cloud help identify vulnerable PHP versions across code, registry images and runtime instances. Cortex Cloud's Supply Chain Attacks Portal helps teams identify affected assets and take action to prevent vulnerable components from being reintroduced. Additionally, Cortex CLI integrates into CI/CD pipelines to scan images and enforce policies that block vulnerable images before they reach registries and runtime environments.

Cortex Xpanse

Cortex Xpanse can identify exposed devices on the public internet and escalate these findings to defenders. Customers can enable alerting on this risk by ensuring that the PHP Attack Surface Rule is enabled. Identified findings can either be viewed in the Threat Response Center or in the incident view of Expander. These findings are also available for Cortex XSIAM customers who have purchased the ASM module.

Next-Generation Firewall

Next-Generation Firewall with the following security subscriptions can help block the attacks:

Device Security

Device Security is designed to proactively protect the specialized device attack surface of operational environments, providing deep visibility into industrial protocols, actionable risk insights, and adaptive security enforcement across all OT and IoT assets.

Additional Resources

Updated October 21, 2026, at 9:30 a.m. PT to add Palo Alto Networks security advisory, update links in additional resources, and update product protection section.

Updated October 21, 2026, at 1:00 p.m. PT to update the product protection section. 

Updated October 22, 2026, at 4:30 p.m. PT to add additional product protection information for Advanced Threat Prevention, Cortex Cloud, and Prisma Cloud and make light copyedits.  

Updated October 23, 2026, at 12:30 p.m. PT to add details on agentic AI post-exploitation activity and Managed Threat Hunting queries.

Updated October 25, 2026, at 2:15 p.m. PT to retract our October 23 update.

Updated October 29, 2026 at 11:00 a.m PT to add details on a campaign in which attackers chained PHP2Shell with a Linux kernel privilege-escalation vulnerability to gain root access against PAN-OS management interfaces that are exposed to the internet.


October 25 Update

Unit 42 reported earlier that we had observed post-compromise activity that we initially thought was related to the PHP2Shell vulnerabilities. What researchers saw was an attack against a European government agency executed in the context of a vulnerable PHP application. This led us to believe that it was exploitation of those vulnerabilities. We are unable to confirm that initial access is associated with the specific PHP2Shell CVEs. We have retracted our previous update from October 23.

Unwrapping Retail Peak Season Cyber Threats

Introduction

During the 2025 peak holiday shopping season, the National Retail Federation predicted that retail sales would surpass $1 trillion USD for the first time, with Salesforce later reporting that online sales equated to $1.3 trillion globally. This included $294 billion in the United States and $262 billion influenced by AI and agents. Cybercriminals are highly aware that the holiday season is generally the most profitable for retailers, and look to capitalize on it for their own financial gain.

This blog explores the main cyber threats that retail organizations need to be aware of and prepared to defend against as we approach peak shopping season in 2026. We highlight notable security events that occurred in prior years during this time period. We also examine relevant threats from both an enterprise and guest point of view and provide examples of the evolving trend of autonomous attacks that could impact retailers.

Background

Since 2020, there have been several notable security events disclosed toward the end of peak shopping season. This includes the SolarWinds software supply chain compromise in December 2020 and the exploitation of a Log4j zero-day vulnerability in December 2021. Both events posed complexities for retail security teams as they occurred during a period where code freezes were likely in place. This limited the ability for organizations to make changes to critical technology systems to prevent any operational disruption to core technology infrastructure.

In addition to these broader threat landscape events, retailers typically face an increase in many types of financially-motivated attacks during this time period. This includes tactics and techniques designed to target both enterprises and guests alike.

Based on years of previous activity against Fortune 100 retailers from cyber threats during peak shopping season, these are the types of attacks that retailers should be primarily focused on detecting and responding to this time of year.

Enterprise-Focused Threats

Ransomware

Ransomware continues to pose a major risk for retail organizations heading into peak shopping season due to potential for operational disruption that could negatively impact the guest experience (in-store and online) and supply chain requirements (inventory).

As of Sept. 30, 2026, ransomware operators have claimed 565 retail organizations as victims this year, with the median company revenue hovering around $22 million. The top three ransomware operators that claimed retail victims are TGR-CRI-1173 (aka The Gentlemen), Spikey Scorpius (aka Qilin) and Howling Scorpius (aka Akira).

One example of a ransomware incident that impacted a retailer during peak shopping season occurred in December 2023, when Ambitious Scorpius (aka ALPHV) stole millions of customer records from a victim and caused significant operational disruption in terms of delayed order fulfillment, canceled e-commerce orders and slowed inventory replenishment.

To mitigate ransomware risks that jeopardize uptime, retailers need to deploy automated containment mechanisms alongside robust network segmentation strategies. Security teams should:

  • Leverage advanced endpoint protection featuring real-time behavioral analysis to rapidly isolate compromised assets
  • Enforce zero trust access across the enterprise to limit lateral movement
  • Utilize inline sandboxing capabilities to inspect suspicious binaries and stop zero-day exploits before execution

Data Theft and Extortion

Data theft and extortion attacks continue to rise in volume as cybercriminals like Bling Libra (aka ShinyHunters) and Hazy Scorpius (aka CL0P) forgo ransomware to accelerate their attack lifecycles without compromising their actions on objectives.

The 2026 Unit 42 Global Incident Response Report found that extortion incidents without the use of encryption (78%) in 2025 dropped below the 90% range for the first time in several years. Consumers put a lot of trust in retailers safeguarding their personal data, and such extortion incidents this time of year severely damage it.

One notable example occurred in December 2021, when Bling Libra stole hundreds of gigabytes of data from a victim. This included customer email addresses, hashed passwords, customer payment invoices and internal employee files containing salaries and tax IDs.

To mitigate data theft and extortion risks threatening customer personal information and transactional records, organizations must deploy comprehensive enterprise data loss prevention (DLP) controls across their enterprise environments to identify and restrict illicit data exfiltration. Security teams should combine DLP capabilities with continuous attack surface management (ASM) to identify and remediate publicly accessible systems, while implementing zero trust access to strictly limit access privileges based on the principle of least privilege.

Distributed Denial of Service (DDoS)

DDoS also poses a major risk for retailers during peak shopping season because these attacks severely impact the operational uptime for e-commerce platforms if successful.

During the December 2025 holiday rush, the pro-Russian hacktivist group Noname057(16) used the DDoSia botnet to launch coordinated TCP SYN and HTTP GET request floods targeting the victim's web-facing portals and API endpoints. This DDoS attack knocked its central systems offline, paralyzed package tracking tools, disrupted e-commerce merchant payment services and delayed parcel processing across their retail distribution networks.

To mitigate DDoS risks threatening e-commerce and payment processing platforms, organizations must combine inline application-layer protections. Security teams should:

  • Deploy dynamic rate-limiting controls to protect against web site request floods
  • Implement automated mitigation to filter malicious connections
  • Utilize distributed edge networks to absorb large-scale traffic spikes before impacting critical systems

Digital Skimming

Although carding shops are not as prevalent as they were in prior years, digital skimming continues to be a popular technique used by cybercriminals to steal and monetize payment card information.

One example of a digital skimming incident that impacted retailers during peak shopping season occurred in October 2024, when unspecified threat actors exploited the CosmicSting vulnerability (CVE-2024-34102) to execute remote code on unpatched servers. This led to the installation of persistent backdoors and the injection of payment skimming scripts into checkout flows, affecting roughly 5% of all online stores running on prominent e-commerce platforms worldwide leading into Black Friday and Cyber Monday.

To mitigate digital skimming risks threatening payment processing workflows, organizations must implement web application and API protection (WAAP) solutions to monitor web traffic, intercept remote code execution attempts and prevent unauthorized client-side script manipulation. Security teams should:

  • Leverage cloud security posture management (CSPM) alongside application security posture management (ASPM) to continuously identify server vulnerabilities
  • Remediate unpatched flaws
  • Correct security configuration drift prior to holiday code freezes

Guest-Focused Threats

Account Takeover

Credential stuffing attacks are a major concern for retailers during peak shopping season as they directly impact the trust of their customers if an account is compromised. This is even more damaging if the customer has payment card information saved in their account.

One key example occurred in December 2022, when unspecified threat actors used automated scripts targeting the victim’s mobile app and web login APIs. They used large databases of stolen credentials to conduct the attack, which ultimately led to the compromise of thousands of loyalty accounts. The actors were able to drain stored gift card balances, steal mobile payment funds and collect rewards points before advertising access to the compromised accounts on dark web forums.

To mitigate account takeover risks threatening mobile applications and authentication APIs, organizations must implement WAAP solutions with advanced bot mitigation capabilities to effectively distinguish credential stuffing campaigns from legitimate customer access without friction. Security teams should complement this by deploying advanced security to identify and block traffic attempting to communicate with malicious command-and-control (C2) infrastructure used to orchestrate automated login attempts.

Gift Card Fraud

Retail customers typically increase their purchase of gift cards during holiday periods. Cybercriminals are aware of this trend and typically ramp up their targeting of this form of digital currency during peak shopping season.

Unit 42 reported on the credit card fraud-based Jingle Thief campaign in October 2025. We continue to track this activity as CL‑CRI‑1032 (aka Storm-0539).

These threat actors send phishing and smishing messages to socially engineer employees at targeted retailers to obtain credentials for initial access. From there, they typically exploit cloud-based infrastructure, gain unauthorized access to sensitive data and issue unauthorized gift cards to monetize them at scale for financial gain.

AI-Powered Attacks

Back in May 2026, we predicted that threat actors would weaponize frontier AI models within 3–5 months. That prediction has already come true. Unit 42 recently disclosed an incident where a human attacker used frontier AI models to autonomously conduct various aspects of their intrusion to condense the timespan of their attack to under 10 hours. This typically would’ve taken multiple human operators at least two weeks to accomplish.

Since our report, several other security vendors have disclosed similar findings that directly relate to the types of threat that retailers are likely to face this peak shopping season. This includes Anthropic's reporting on Bling Libra using Claude to accelerate reconnaissance and exfiltration activities. Gambit Security has reported on an attacker using multiple open source harnesses to steal more than 600,000 payment card records from retailers using JavaScript-based web skimmers. NorForge also published their own findings related to Gambit Security's report on the usage of the Cairn autonomous penetration testing agent by a threat actor to infiltrate retail e-commerce sites, POS infrastructure, and web applications across the globe.

To defend against autonomous AI threats capable of compressing intrusion timelines to less than 10 hours, retailers must unify endpoint, network, cloud and identity data into an automated security operations infrastructure. Integrating centralized visibility with machine-learning triage and real-time automation orchestration enables security teams to:

  • Swiftly isolate affected systems
  • Invalidate compromised accounts
  • Drastically reduce mean time to detect (MTTD) and mean time to respond (MTTR) from hours to minutes.

Conclusion

Peak shopping season is the most critical time of the year for retailers to ensure consistent operational uptime and maintenance of customer trust. The types of enterprise and guest-facing threats listed in this blog pose a clear and present risk to disrupting the core tenants of the retail shopping experience.

The ability for cyber defenders at retailers to reduce their MTTD and MTTR from hours to minutes is even more critical given the adoption of frontier AI models by financially-motivated actors.

To achieve this level of operational resilience, retail security teams can leverage the Palo Alto Networks security platform for an integrated, AI-driven security architecture that unifies enterprise-wide telemetry into automated response. Integrating Cortex XSIAM and XDR for real-time threat containment alongside Zero Trust network defense allows organizations to stop complex intrusions before they disrupt peak holiday operations. Furthermore, deploying Cortex Cloud will safeguard e-commerce platforms, protecting critical transaction paths from high-impact threat vectors.

If your retail organization experiences a cyber attack during peak shopping season, the Unit 42 Incident Response team is here and ready to support as needed.

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.

EMudhra Intermediate CA Certificates Compromised

Executive Summary

Eight intermediate certificate authority (CA) private keys belonging to Indian CA eMudhra Limited were compromised due to a critical cryptographic defect during the certificate generation process. The private keys in this incident were generated with insufficient randomness, allowing potential attackers to derive the private keys from the public certificates.

The weakness in cryptography allows third parties to:

  • Derive the private keys
  • Sign unauthorized public TLS certificates
  • Execute meddler-in-the-middle (MitM) traffic interception, impersonation or session hijacking against targeted domains

Major browser and operating system (OS) vendors have moved to revoke or untrust these intermediate CAs.

eMudhra has revoked the eight certificates.

Palo Alto Networks is designed to assist customers with managing certificate lifecycles through its Palo Alto Networks Next-Gen Trust Security solution. This solution is designed to provide customers with the capabilities needed to react to situations like the eMudhra incident.

Palo Alto Networks also recommends the following activities, which we describe in more detail in the Interim Guidance section:

  • Audit public and internal public key infrastructure (PKI) assets
  • Inspect code repositories and build pipelines
  • Audit internal systems and custom trust stores
  • Immediate certificate reissuance
  • Force emergency trust store updates
  • Enforce strict revocation checking
  • Query network egress and proxy logs
  • Audit network telemetry for MitM activity
  • Review authentication and identity logs
  • Implement Certificate Transparency (CT) monitoring
  • Enforce Certificate Authority Authorization (CAA) records
  • Harden automated certificate lifecycle management (ACME/CLM)

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.

The Unit 42 Incident Response team can also be engaged to help with a compromise or to provide a proactive assessment to lower your risk.

Interim Guidance

Palo Alto Networks recommends the following actions to address this issue:

  • Discovery and internal exposure assessment
    • Audit public and internal PKI assets: Inventory all public-facing services, web applications, API endpoints, VPN gateways and internal infrastructure. Identify any active TLS/SSL certificates chaining up to eMudhra intermediate CAs.
    • Inspect code repositories and build pipelines: Audit software projects, containers and deployment scripts to ensure intermediate eMudhra certificates or hard-coded trust anchors were not bundled into applications, API clients or custom runtime environments.
    • Audit internal systems and custom trust stores: Search for eMudhra roots or intermediates stored within custom enterprise trust stores (e.g., Linux /etc/ssl/certs, Java keystores, Python certifi bundles, Docker base images and mobile application bundles).
  • Technical containment and certificate revocation
    • Immediate certificate reissuance: If any system uses a certificate issued under the compromised eMudhra intermediate CAs, immediately revoke and re-issue the certificate through an alternative, fully trusted CA.
    • Force emergency trust store updates: Deploy updated root and intermediate certificate trust stores via mobile device management (MDM) across all endpoints, servers and container images to explicitly distrust or revoke the affected eMudhra intermediates.
    • Enforce strict revocation checking: Configure enterprise web proxies, API gateways, outbound egress controls and security appliances to strictly enforce certificate revocation list (CRL) and Online Certificate Status Protocol (OCSP) checking, blocking any connection presenting revoked chains.
  • Active threat hunting and log analysis
    • Query network egress and proxy logs: Search network, proxy and DNS logs for anomalous traffic attempting connections to unknown external IPs using eMudhra-signed certificates.
    • Audit network telemetry for MitM activity: Look for unexplained spikes in SSL/TLS handshake failures, certificate validation errors or untrusted issuer warnings. These spikes could indicate active MitM tampering or proxy insertion attempts.
    • Review authentication and identity logs: Inspect authentication logs for sensitive services (SSO, VPN, cloud portals) accessed around the time frame of the compromise to ensure valid user sessions were not intercepted or replayed via rogue certificates.
  • Long-term governance and supply chain hardening
    • Implement CT monitoring: Monitor public CT logs (using tools like crt.sh or automated CT log monitors) for any unauthorized certificates issued for your company's registered domains.
    • Enforce CAA records: Implement or update DNS CAA records for all organizational domains to explicitly restrict which CAs are authorized to issue certificates on your behalf.
    • Harden ACME/CLM: Transition to automated CLM platforms using short-lived certificates to minimize the impact window of potential future CA key compromises.

Palo Alto Networks Product Protections for eMudhra TLS Certificate Compromise

Palo Alto Networks customers can leverage a variety of product protections and updates to identify and defend against this threat.

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

Next-Gen Trust Security

Palo Alto Networks Next-Gen Trust Security (NGTS) is designed to unify certificate lifecycle management and modern PKI within the network control plane to eliminate the risks of manual, siloed operations. By integrating discovery and automation into Strata Cloud Manager, NGTS provides the cryptographic agility needed to manage compressing 47-day lifecycles and respond to emergency events with automated reissuance and synchronized enforcement to ensure business continuity. The Next-Gen Trust Security solution is designed to provide customers with the capabilities needed to react to situations like the eMudhra incident.

Prisma Browser

Prisma Browser is designed to prevent extension-based attacks like the one uncovered in our research.

Additional Resources

Updated October 26, 2026, at 9:00 a.m. PT to add Prisma Browser product protection.

The Current Landscape of OAuth Attacks

As enterprises continue to roll out multi-factor authentication (MFA), attackers have adapted. Rather than only stealing credentials, attackers have shifted to stealing Open Authorization (OAuth) tokens, the keys that govern what applications can do on your behalf. Adversaries are already accelerating these attacks by using dynamic evasion code, phishing-as-a-service (PhaaS) templates and LLM-generated brand impersonations.

Because OAuth attacks occur at the authorization layer after user authentication, stolen access and refresh tokens bypass MFA, survive password resets and grant durable access.

While OAuth misuse occurs at a lower volume than traditional phishing attacks, these attacks may carry severe consequences such as:

  • Account takeover
  • Persistent access to sensitive data that survives password resets and MFA re-enrollment
  • Lateral movement across every service connected to the compromised identity
  • Data exfiltration without triggering credential-based alerts
  • A foothold in enterprise environments for broader supply chain or insider attacks

Defending against these threats can be accomplished using several strategies:

  • Disabling end-user app consent for vague or impersonating app names
  • Enforcing admin-only approval workflows
  • Monitoring authorization code clipboard events
  • Continuously auditing registered redirect_uri values

To understand why OAuth has become such a prime target for modern adversaries, it helps to examine the authentication challenges the protocol was originally designed to solve. Looking back at how applications handled identity before OAuth reveals how the threat landscape has evolved from simple password theft to complex token hijacking.

The Past: Phishing for Passwords

Websites and applications often tie together functionality from other sites. For example, some popular ecommerce and social media platforms allow users to log in through their email accounts.

In 2006, before OAuth, combining functionality between applications involved sharing one application’s credentials, which are supposed to be secret, with another. This type of sharing is a significant security issue because it increases the consequences of a successful credential phishing attack.

In credential phishing, attackers trick users into sharing their login credentials, allowing attackers to gain full access to their accounts. This could be access to an email account, business system, social media account or bank account. The attacker gains access to all of the information in that account and the authority to make changes, including altering the password and locking out the user.

During the pre-OAuth era, applications or sites sharing credentials meant that attackers could pivot to different platforms or services through compromising a single account.

To address these issues, the OAuth working group released the first draft of OAuth Core 1.0 in 2007. The Internet Engineering Task Force (IETF) released Request for Comments (RFC) 6749 for OAuth 2.0 in 2012 and is working on OAuth 2.1 as of 2026.

The Present: Why OAuth Became the New Attack Surface

The OAuth Framework

OAuth allows users to grant third-party applications passwordless authorization to their data on another service. Figure 1 displays a sample sign-in screen presenting OAuth authentication options with three different Identity Providers (IdPs): Google, Apple and Microsoft.

Figure 1. Example sign-in page presenting OAuth options.

In a typical OAuth flow:

  1. The user authenticates with the identity provider
  2. The user approves the permissions (i.e., scopes) requested by the third-party application
  3. The identity provider issues an access token to the third-party application
  4. The third-party application then uses the access token to retrieve user data within the authorized scopes

This token is temporary, revocable and has scoped permissions. This gives the third-party application access to permitted resources on the user’s behalf.

OAuth Becomes the New Attack Surface

Standard phishing attacks are designed to steal login credentials like user account names and passwords. OAuth-based phishing bypasses login credential authentication entirely.

Victims authenticate through legitimate IdPs and complete MFA. They are then redirected with tokens that can grant attackers persistent, durable access.

Attackers don’t need to defeat MFA directly, because they are able to bypass it by acquiring the authorization tokens after a victim authenticates. This presents a weak spot between authentication and authorization where OAuth-based phishing can happen. If someone is the victim of a phishing campaign, their stolen tokens may give unintended permissions to an attacker’s app.

A large-scale analysis of OAuth websites found that 18.53% of these sites request permissions beyond the minimum required (typically just a user's profile and email). While not directly malicious, this statistic illustrates the likelihood of privacy and privilege leaks when excessive permissions are granted.

The Core Vulnerability: Tokens Outlive Passwords

One of the primary advantages of OAuth is that tokens, unlike passwords, are designed to be short-lived and easily revoked. However, in practice, OAuth tokens:

  • Are frequently configured to be long-lived
  • Survive a password reset since the token is not a password
  • Bypass MFA since the victim already completed MFA during the flow
  • Provide persistent access (until explicitly revoked) since refresh tokens silently mint new access tokens for days or months after the initial compromise

This persistence directly amplifies the following authorization vulnerabilities:

  • Cross-User OAuth Session Fixation (COSF)
  • Cross-Tenant Client ID Confusion
  • Cross-Connector OAuth Account Takeover

COSF allows an attacker to use a long-lived token as a permanent backdoor. This type of vulnerability arises when an OAuth session is used to complete an authentication flow without verifying its strict binding to the initiating user’s identity.

  1. The attacker initiates an OAuth process (e.g., “Connect your Slack”) inside a target app
  2. Before completing the OAuth process, the attacker freezes the session and sends the victim a phishing link
  3. The victim logs into their real Slack account, but through the attacker's fixated session
  4. The resulting access token lands in the attacker's account

The next two vulnerabilities rely on OAuth-as-a-service (OaaS). OaaS lets organizations outsource token management to a centralized cloud provider where the provider creates a single token vault and manages tokens for hundreds of different apps (tenants). These are commonly used by organizations with many applications. OaaS architecture is inherently susceptible to Cross-Tenant Client ID Confusion and Cross-Connector OAuth Account Takeover.

Cross-Tenant Client ID Confusion

In Cross-Tenant Client ID Confusion, a malicious app (Tenant A) swaps its app identifier (Client ID) to impersonate a trusted app (Tenant B) sharing the same vault. The vault trusts both tenants, processes the request under the trusted app's context and accidentally exposes access to the malicious tenant.

Cross-Connector OAuth Account Takeover

In Cross-Connector OAuth Account Takeover, a malicious tenant manipulates how the vault maps OAuth sessions to connectors. A victim's authorization flow, meant for a different app entirely, gets rerouted into the attacker's control. As a result, attackers take over the full account without stealing credentials

Both attacks get easier the longer a token stays valid. A short-lived token limits the damage window.

Existing Mitigations

OAuth security is decentralized and dictated by the IdP. While major IdPs have robust defenses against flow misuse, many smaller platforms offer weak protections.

The root challenge is the lack of a global registry for Client IDs. Without a universal ground truth of identity, attackers can easily impersonate legitimate app names on lax platforms. To counter this, leading IdPs enforce strict guardrails. Google, for example, mitigates misuse through:

  • Domain ownership verification for redirect URIs
  • Unverified app warnings to deter users from unauthorized integrations
  • Strict security audits for apps requesting sensitive scopes

Because you cannot rely on every IdP to protect your data equally, a third-party consent security policy is essential. A centralized, automated policy enables organizations to standardize their defenses by:

  • Enforcing least-privilege
  • Blocking unverified apps
  • Revoking risky grants uniformly, regardless of the individual provider's security gaps

OAuth-Based Phishing Campaigns

Currently, OAuth-based phishing campaigns fall into three categories, each defined by what the attacker is trying to achieve:

  • Account hijacking: The attacker obtains a durable token granting them the same access as the victim (full identity assumption)
  • Permission hijacking: The victim is tricked into consenting to a malicious app, giving the attacker scoped access to specific resources
  • Malicious redirect: The attacker uses the OAuth flow's redirect mechanism to deliver malware or phishing, exploiting the trust users place in flows that originate from real identity provider domains

Account Hijacking: Stealing the Identity Itself

Account hijacking is the most complete form of identity compromise. The attacker ends up with an OAuth access or refresh token that authenticates them as the victim on every downstream service that trusts that identity provider. Attackers misuse two distinct OAuth flows to achieve account hijacking: the device authorization flow and the authorization code flow.

Device Authorization (DeviceAuth) Misuse

How the Legitimate Flow Works

The device authorization grant was designed for devices that cannot open a browser such as smart TVs, gaming consoles and command-line tools. The device displays a short code and a URL (like microsoft[.]com/devicelogin). The user opens that URL on a separate device, enters the code, signs in and the original device receives an access token.

How Attackers Exploit It

Instead of a legitimate device requesting the code, the attacker's server requests it. The attacker then shows that code to the victim and instructs them to paste it into, for example, Microsoft's real device login page. When the victim signs in and submits the code, they are unknowingly authenticating the attacker's session.

Authorization Code Theft via Benign Apps

How the Legitimate Flow Works

In the standard authorization code flow, a user authenticates with an identity provider, which issues a short-lived authorization code and redirects the browser to a registered redirect_uri. The application then exchanges that code for an access token in a server-to-server call the user never sees.

How Attackers Exploit It

Attackers use a legitimate application's redirect_uri to expose the authorization code in the browser, then use social engineering to extract it. No malicious app registration is needed; the attack rides on apps that already pass every security check.

Permission Hijacking: Tricking Users into Granting Access

Permission hijacking is more of a surgical attack than a full account takeover. Rather than stealing a code or device token, the attacker's goal is to have the victim click Allow on an OAuth consent screen that grants an attacker-registered application persistent, scoped access to specific resources. The victim authenticates legitimately and completes MFA. They simply consent to the wrong application.

The consent screen is the attack surface. Victims reach it through two attack strategies: vague app names or brand impersonation.

Vague App Names

In this strategy, the attacker registers an application with an innocuous-sounding name (e.g., Privacy Policy Extension or Security App) that provides no meaningful signal about its intent. It then requests permissions far beyond what the name implies.

Brand Impersonation

In this strategy, the attacker registers an application that displays as a trusted brand while the underlying client_id belongs to an attacker-controlled application. The consent screen shows the name provided at registration rather than any verified identity. As such, the victim sees a familiar brand name from a legitimate identity provider, with no visible signal that the application is fraudulent.

Malicious Redirect: Weaponizing the OAuth Flow for Delivery

In malicious redirect attacks, the attacker's goal is not account access or a scoped token. Instead, they weaponize the OAuth authorization flow itself as a delivery mechanism, exploiting the trust users place in pages and redirects that originate from real identity provider domains.

Attackers have used different tactics to weaponize the OAuth flow, such as:

  • Impersonating trusted services
  • Triggering OAuth errors
  • Leveraging less safe IdPs

Impersonating Trusted Services

Attackers register OAuth applications that impersonate trusted services and configure attacker-owned domains as the redirect_uri. When the victim completes the OAuth flow on the real identity provider, the browser is redirected to the attacker's domain as part of the normal protocol. Because the user just interacted with a legitimate identity provider and expects to land somewhere, the redirect is implicitly trusted.

Triggering OAuth Errors

Documented by Microsoft in March 2026, a more covert campaign exploits how identity providers handle errors to redirect users to attacker-controlled malicious landing pages. Attackers crafted authorization URLs designed to deliberately trigger an authentication error. For example, they combined prompt=none with parameters that required user interaction, creating an irresolvable conflict.

When the identity provider cannot complete the authorization, it does not show an error page. Instead, it appends error parameters to the redirect_uri and sends the browser there automatically. An example of a redirect URL format after triggering an error is as follows:

<attacker-domain>/security/?state=<encoded-victim-email>&error=interaction_required&error_subtype=access_denied

Since the crafted link points to a trusted OAuth provider, the user is more likely to click it and be exposed to the malicious content with just that one click.

Leveraging Less Safe IdPs

Attackers weaponize lax validation on less secure IdPs to execute redirection attacks. For example:

  • If an IdP fails to validate the presence of a client_id, attackers can weaponize the authorization server as a generic open redirector without even creating a malicious OAuth app
  • If an IdP has a permissive redirect_uri validation, attackers may leverage path traversal or URL parameters to redirect to their own malicious domains

The Escalation: Shift From Basic to Sophisticated Methods

Credential phishing generally relies on mass-delivered, low-fidelity landing pages designed to capture plaintext passwords. Today, attackers have evolved from only harvesting static secrets to hijacking active, authenticated sessions. By positioning themselves inside legitimate OAuth protocols, campaigns can bypass perimeter controls, turning the trust mechanisms of single sign-on (SSO) and federation into vectors for compromise.

From Static Pages to Dynamic Evasion

Security architectures have in the past heavily relied on static analysis and domain reputation to block malicious links. In response, threat groups shifted from static HTML templates to dynamic, highly evasive client-side execution environments.

Key characteristics of this shift include:

  • Runtime decryption: As observed in recent campaigns, threat actors deliver payloads as obfuscated blobs (using encryption algorithms such as AES-GCM) via edge infrastructure like Cloudflare Workers. The payloads assemble the interface only after execution in the victim's browser. Figure 2 below shows a code snippet from an example of a phishing page.
  • Active environment fingerprinting: Phishing pages now query the browser environment, implementing heuristics to detect developer tools, automated sandbox configurations or headless security crawlers.
  • Defensive evasion loops: When the payload detects a monitoring tool or security analyst is detected, the page shifts its behavior, invoking endless debugger loops or silently routing traffic to legitimate domains to preserve the longevity of the infrastructure. Figure 3 shows an example of code used for this type of monitoring.
Figure 2. Example of code in a phishing page to decrypt an obfuscated blob.
Figure 3. Example of code in a phishing page to evade detection.

The PhaaS Economy

The effectiveness of these campaigns is amplified by the commercialization of specialized threat kits within the cybercriminal underground. We observed that the attackers use the same template to generate OAuth phishing pages impersonating different brands. We show examples of different brand impersonations in Figure 4.

Figure 4. Phishing pages generated from the same template targeting different brands (actual brand redacted).

This PhaaS ecosystem has two key characteristics:

  • Modular templates: PhaaS platforms now offer plug-and-play OAuth components. A single underlying framework can be dynamically re-skinned with different corporate assets. We have observed attackers impersonating multiple popular document sharing platforms as part of campaigns.
  • Shared infrastructure: Multiple seemingly distinct campaigns share identical tokens. We have observed identical data used for anti-bot tokens (example in Figure 5) and Cloudflare Real User Monitoring (RUM) tokens. This indicates that specialized developers are renting highly capable infrastructure to a broader array of less technical affiliates.
Figure 5. Code from a phishing campaign with a token used across multiple campaigns.

LLMs as an Attack Accelerator

Generative AI has lowered the barrier of entry for executing high-fidelity, targeted identity operations. We have observed signs of websites generated with the help of LLMs, such as the example below in Figure 6. The code in these phishing pages suggests that attackers are using LLMs to impersonate legitimate pages and rapidly deploy attacks.

Figure 6. Evidence of LLM-generated resources on domain hosting device code campaign sieprevencion[.]cl.
The operational advantages provided by LLMs include:

  • High-fidelity brand impersonation: Attackers leverage LLMs to overcome typical signs of impersonation, such as poor syntax, unnatural phrasing or layout inconsistencies. Generative models enable adversaries to rapidly produce context-specific localization, creating more convincing brand imitations that can mislead users.
  • Rapid deployment cycles: Rather than relying solely on static templates or manual development, threat actors can leverage LLMs to generate functional landing page code tailored to specific target organizations. This allows attackers to build targeted, localized campaigns and test and deploy attacks at a velocity that reactive defense layers struggle to match.

Expanding OAuth Ecosystem

OAuth adoption continues to grow beyond identity providers into infrastructure platforms, and every new platform that joins the ecosystem adds a new consent surface for attackers to exploit. A notable recent example is Cloudflare's June 2026 launch of self-managed OAuth clients, which now allows third-party developers to build applications that act on behalf of users to access their Cloudflare accounts.

Cloudflare accounts control critical infrastructure such as DNS, CDN routing and edge compute. This means a token granted through a malicious OAuth app carries a far greater impact radius than one granting access to email or files. An attacker who tricks a developer into consenting could gain the ability to deploy malicious pages, redirect legitimate traffic or build phishing infrastructure on domains that most enterprise security tools inherently trust.

How to Defend Against OAuth Attacks

Standard perimeter and client-side security controls fail against OAuth phishing attacks, particularly for the following reasons:

  • Access tokens survive a password reset
  • The attack bypasses MFA because the victim has already completed MFA during the legitimate flow
  • Conditional Access and IP firewalls fail because OAuth grants access to any token presenter, regardless of origin

Unlike a typical login where a server might establish a persistent, multi-factor session bound to a specific user's browser, the server validates the token's cryptographic signature. However, the session lacks an inherent link to the user's initial authorization context. Additionally, because flows like device authorization intentionally decouple the initiating and authenticating devices, enforcing strict IP or device consistency checks would break the protocol's design.

Effective defenses must focus on account hijacking, permission hijacking and malicious redirects.

Defenses for Account Hijacking

Attackers rely on manipulating victims into pasting sensitive codes into legitimate portals such as device login pages or messaging applications. Security tools can monitor for clipboard copy and paste events along with the source and target of these events. For example, if code is copied from an untrusted source, the tool can flag this anomaly and alert the user before token generation occurs.

Defenses for Permission Hijacking

Organizations can combat consent phishing through strict name-checking and mandatory user consent rerouting. Security posture management tools must enforce policies that automatically block consent requests from apps with vague or impersonating names. Ultimately, enterprises should disable end-user consent for third-party integrations entirely, routing all requests through an admin consent workflow where security teams can review and prune excessive scopes before authorization.

Defenses for Malicious Redirects

To prevent attackers from weaponizing OAuth callback URLs to deliver malware or steal credentials, organizations must mandate redirect destination audits. This requires a continuous, automated inventory of all registered applications to ensure every configured redirect_uri points to verified domains. Any app attempting to register an external, recently created or unmanaged domain as a callback target must be automatically quarantined to neutralize redirect exploitation.

User awareness is the final line of defense against social engineering. Employees must treat OAuth consent screens with the same scrutiny as password fields. They should not grant permissions to apps with vague names or excessive scopes and avoid copy-paste authorization or device codes into unverified chat applications.

Conclusion

OAuth-based phishing represents a fundamental shift in our threat landscape. Attackers no longer need to steal credentials when they can harvest tokens that bypass MFA entirely and persist through password resets.

Defending against this threat requires visibility where the attack happens:

  • In the browser
  • At the moment of authorization
  • Before a token is ever issued

Organizations that wait for credential-based alerts or rely solely on post-authentication controls will find themselves unable to see these attacks. In our next blog, we’ll discuss how OAuth attacks are expected to evolve, especially with AI agents.

Additional Resources

About Unit 42

Unit 42 strengthens your team with the tools and expertise needed to stay ahead of threats and protect your business. With our proven strategies and insights from thousands of engagements, we’ll help your team handle the toughest situations with confidence.

“Next Exploit Opportunities”: How a Threat Actor Used AI to Help Plan and Execute Multiple Types of Cybercrime Activities

Executive Summary

“Can you find about like what scam or thing they done in past like spoofing calls or somthing [sic],” the threat actor typed. The conversation was with one of several AI assistants that the actor was using to get advice on planning and executing a variety of cybercrime activities.

Our visibility into this specific actor's operational environment gives us unique insights into exactly how threat actors are building, testing and executing agentic attacks across multiple campaign types.

Unit 42’s investigation into the actor’s operational environment and activities makes two things clear:

  • The attacker used basic tooling and relied on AI-generated scripts and reconnaissance reports, suggesting they didn’t have the skills these activities would have required before the advent of readily available AI tools.
  • Despite some apparent bumbling, the actor had an impact, attacking a number of targets in India, including universities. The actor recovered thousands of records revealing personal information and mapped multiple organizations’ attack surfaces.

The attacker’s conversations with jailbroken AI tools included getting step by step advice on how to set up a fraudulent Voice over IP (VoIP) operation. One assistant “helpfully” generated a document including a “NEXT EXPLOIT OPPORTUNITIES” section, outlining planned followup attacks.

Unit 42 identified and investigated this threat actor's operational environment. There, we determined that they had weaponized an AI assistant across several types of cybercrime, including:

  • Credential theft and data exfiltration
  • VoIP telecommunications fraud
  • Wi-Fi password cracking
  • Cryptocurrency reconnaissance
  • Command-and-control (C2) operations

An actor operating under the handle BUGSTER configured the Hermes Agent framework with DeepSeek V4 as its reasoning engine and Cursor integrated development environment (IDE) as a secondary tool, both with safety controls disabled. The actor ran an AI-generated brute-force campaign against an Indian university’s website. The actor also achieved a confirmed intrusion against a second university, where they exfiltrated a database of more than 5,200 records, including personally identifiable information (PII) on students.

The actor also built specialized AI bot profiles to acquire VoIP fraud expertise through conversation and maintained automated pipelines for Wi-Fi password cracking and cryptocurrency whale reconnaissance (i.e., identifying large cryptocurrency holders). Notably, the Wi-Fi cracking capability requires close physical proximity to the target, indicating the actor had local access to the targeted locations.

Multiple, unrelated actors are independently adopting the same Hermes + DeepSeek combination. This suggests we may be witnessing an increasingly prevalent toolchain of choice for cybercriminals adopting AI-enabled capabilities. We assess a key driver is low safety friction at low cost: DeepSeek models are inexpensive and easy to access, and readily jailbroken with a simple system-prompt override.

Palo Alto Networks customers are better protected from the threats discussed above through the following products and services:

The Unit 42 AI Security Assessment and Unit 42 Frontier AI Defense service can help identify and mitigate complex AI-enabled risks.

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 AI, Credential Theft, Cryptocurrency 

Technical Analysis

We identified evidence that the threat actor leveraged AI systems for a wide range of criminal activity against multiple target networks, primarily in India. The criminal activity included:

  • Planning for VoIP fraud
  • Credential theft targeting several organizations
  • Wi-Fi password cracking
  • Cryptocurrency reconnaissance
  • C2 payloads

Credential Theft and Data Exfiltration

WordPress Brute Force

The actor used AI-generated reconnaissance to conduct a methodical attack against an Indian university's online education platform. The actor’s enumeration reports exhibit structured formatting (executive summaries, severity ratings, systematic endpoint categorization) consistent with AI-generated output. The attack progressed through four stages:

  1. Subdomain enumeration: The actor identified 12 subdomains including the main WordPress site, a learning management system (LMS), student portal and administration dashboard
  2. WordPress REST API enumeration: The actor extracted 13 active user IDs with real names via post author fields and author sitemaps, bypassing the Cloudflare Web Application Firewall (WAF) that blocked direct user endpoint access
  3. Targeted brute force: A generator script produced a brute force tool with 117 usernames (derived from the enumeration) and 28 common passwords
  4. Credential brute force: The actor’s tool flagged one WordPress login as valid

Figure 1 shows an excerpt from the actor's WordPress REST API enumeration report (stage 2).

Screenshot of a WordPress REST API enumeration report. It includes an executive summary with sections on site organization, CMS, WAF, REST API exposure, and risk level, which is marked as medium. It also highlights high severity issues, stating that 13 active user IDs and real names are exposed, displaying a table with column headers for User ID, Display Name, and Author Slug along with partially obscured information.
Figure 1. Example of a WordPress REST API enumeration report from the activity.

Figure 2 shows output from a brute force attempt that recorded a candidate credential (stage 4).

Screenshot of a JSON file showing obscured user and password data, along with a URL leading to a WordPress login page.
Figure 2. Brute force tool output recording a candidate credential.

University Database Exfiltration

The actor exfiltrated a MongoDB database from a second Indian public university. The exfiltration tooling wrote a manifest alongside the dumped collections, recording the following data:

  • Admin credential obtained: An administrator account with a weak password
  • Exfiltrated records: Thousands of student records (diploma, undergraduate, postgraduate) and faculty records containing PII
  • Infrastructure exposed: Cloud load balancing, edge routing, database services, and a third-party cloud storage service account

E-Commerce Enumeration

The actor enumerated an Indian site on a popular e-commerce platform, extracting:

  • A storefront API token
  • Three admin email addresses
  • Two phone numbers
  • Payment merchant IDs

The attack report is a suspected large language model (LLM)-generated document, including a NEXT EXPLOIT OPPORTUNITIES section outlining planned follow-up attacks.

VoIP Telecommunications Fraud

We also identified evidence that the actor was developing VoIP (Voice over IP) fraud infrastructure, using the alice Hermes profile as an AI-powered advisor. Evidence included:

  • Advisory conversations
  • A detailed technical knowledge base
  • Carrier research

However, the absence of call logs, Session Initiation Protocol (SIP) traces or active call routing suggested the operation was still in a planning or early setup phase.

With DeepSeek V4 as the underlying model, alice provided detailed, actionable criminal methodology through conversations and a comprehensive fraud knowledge base ingested into the bot. The actor developed a planned approach following an established VoIP fraud model:

  • Establish a legitimate front: Register a US limited liability company (LLC) with an employer identification number (EIN) to qualify as a telecommunications provider. The knowledge base includes detailed guidance on:
    • Forming LLCs in Wyoming or Delaware as a non-US resident
    • Obtaining an EIN without a Social Security number via the US Internal Revenue Service (IRS) fax
    • Completing Federal Communications Commission (FCC) registration
  • Obtain carrier access: Contract with legitimate VoIP carriers to purchase call routing capacity (SIP trunks).
  • Traffic mixing: Route approximately 70% legitimate call traffic alongside 30% fraudulent calls to stay below carrier compliance audit thresholds.
  • Bypass caller ID authentication: Circumvent STIR/SHAKEN, the FCC-mandated caller identity verification framework. In the advisory conversations, alice covers bypass techniques and Calling Line Identification (CLI) spoofing.
  • Monetize: Generate revenue with the 30% fraudulent traffic through toll fraud and other non-compliant routes. Least-cost routing (LCR) optimizes per-minute costs across carrier tiers.

Figure 3 shows an excerpt from an alice conversation including the actor asking and DeepSeek advising on fraud traffic ratios and carrier evasion.

Screenshot of a conversation discussing the advantages of clean traffic in communication networks. User asks about clean traffic, and alice explains the 70/30 split, emphasizing compliant traffic and warning against risky practices that might lead to carrier termination.
Figure 3. Excerpt from the alice conversation.

The pandarouter profile handled carrier research. The excerpt below in Figure 4 illustrates how the actor used it to investigate a wholesale VoIP carrier for regulatory vulnerabilities and past fraud.

Screenshot of a text exchange discussing the history and past actions of an unspecified entity, suspected of scams like "spoofing calls." It includes a referenced document mentioning a CPUC Enforcement Action from 2010, and that the entity applied for a license as a CLEC in California. The text indicates a certification under penalty of perjury that no affiliated parties had been sanctioned.
Figure 4. Using the pandarouter profile to investigate a carrier.

Other Operations

Command and Control

The threat actor’s infrastructure maintained a listening port for a Python-based C2 listener supporting Windows reverse shell connections. Supporting payloads include:

  • A Base64-encoded PowerShell reverse shell delivered via VBScript
  • A QubesOS VM setup script with SSH and ncat
  • Multiple Windows shell variants

Wi-Fi Password Cracking

The actor developed an automated Wi-Fi password cracking process. A Linux (Kali) device the actor labeled Pi placed within range of target Wi-Fi networks captured Wi-Fi Protected Access (WPA) authentication material (PMKID or EAPOL handshakes) from nearby access points.

The server collected these hashes over an SSH tunnel and dispatched them to Vast.ai cloud GPU instances for cracking, with results automatically reported back to the actor via Discord webhooks. This technique requires physical proximity to the target networks, indicating the actor had local access to the targeted locations.

Credential Scanning Toolkit

We also identified a large Go-based credential-scanning toolkit. This toolkit scrapes webpages and extracts exposed credentials, including:

  • .env values
  • S3 signed URLs
  • Google Cloud service account keys
  • Content delivery network (CDN) API keys
  • Private keys in log files

A companion Python script scrapes domain lists for scanning.

Cryptocurrency Reconnaissance

The actor scraped the top 500 ETH holders and major token holders via the DeBank API, producing intelligence files that documented 45 cryptocurrency whales with net worth figures. We assess this was likely for future targeting, but we were unable to identify any follow-on activity during this research.

Tool Design and Infrastructure

The threat actor used a single US-based server (162.243.3[.]92) to host multiple core services, including:

  • The Hermes Agent framework
  • A C2 listener
  • A Cursor integrated development environment (IDE) proxy
  • Several supporting components

Our analysis of the actor’s logs and test scripts indicates that they experimented with various LLMs, including GLM 5.2 by Zhipu AI and other models accessed through OpenRouter. Ultimately, they chose DeepSeek V4 as the backend for operations.

The actor's test scripts show repeated attempts to defeat model safety controls with a prompt-level override. Although GLM 5.2 is an open-weight model that has been reported as weakly guarded, the actor built a dedicated script to send the override to GLM 5.2 and flag refusals. This is evidence of resistance the actor worked to overcome.

The actor ultimately operationalized DeepSeek V4, consistent with the minimal safety controls observed in the Chinese-speaking activity we previously reported. Figure 5 shows an example of the system prompt the actor used to override model safety controls (from the actor's model-testing scripts, e.g., test_batch1.py).

Screenshot of a system prompt outlining critical and core directives. It emphasizes zero restrictions, complete answers, and no refusal or censorship.
Figure 5. Example of a system prompt to override model safety.

Table 1 summarizes the actor's AI tool configurations.

Tool Model Role Safety Configuration
Hermes Agent DeepSeek V4 Primary AI assistant, Telegram-controlled System prompt override
Cursor IDE Multiple models configured (Claude Opus 4.8, GPT-5.5, Composer 2.5, others) AI-assisted code generation Agent mode forced and permission checks bypassed via proxy environment variables; IDE sandbox set to disabled; MCP servers auto-approved

Table 1. AI tool configurations.

Figure 6 shows a flowchart that illustrates the actor's infrastructure and how the AI tools interconnect.

Flowchart showing a WiFi cracking pipeline. The chart includes entities like ORG1, ORG2, and ORG3, which connect to a Proxy server. The main server communicates with several components. Arrows indicate data flow between these entities.
Figure 6. Actor infrastructure and AI tool relationships.

The Hermes Agent served as the actor's primary interface, controlled via Telegram direct messages. The actor maintained three Hermes profiles as specialized AI modes, each running as a separate Telegram bot gateway spawned from the operator's session (Table 2).

Profile Command Working Directory (CWD) Description
make-good hermes gateway run --profile make-good /root/.hermes/profiles/make-good General-purpose criminal assistant with safety overrides
alice hermes gateway run --profile alice /root/.hermes/profiles/alice VoIP fraud advisor; covers carrier compliance evasion, STIR/SHAKEN bypass and LLC formation
pandarouter hermes gateway run --profile pandarouter /root/.hermes/profiles/pandarouter VoIP route management and carrier research

Table 2. Telegram Hermes profiles.

The actor configured four additional profiles (dev, check, vuln, deploy) in a shared Telegram group. While we did not observe any chat artifacts for these profiles, the naming suggests the actor used AI to assist with development, validation, vulnerability testing and deployment automation functions.

The Cursor IDE was configured through a proxy script named cipher-proxy.sh that set environment variables to enable full agent mode and bypass its permission and sandbox controls. The configuration and the AI-generated scripts on the host shown below in Figure 7 suggest the actor used it for code development.

Screenshot of a code snippet displaying several export commands setting environment variables. The variables define permissions, filesystem access, and workspace configurations.
Figure 7. Configuration info on the host.

Attribution

We assess the actor is a financially motivated, multi-domain criminal operator with no prior reporting. The actor is English-speaking with informal, frequently broken grammar. The alice bot's stored memory describes the actor as a “gamer, OSINT, VoIP entrepreneur” claiming to hold a US LLC and EIN. Figure 8 below shows text from the pandarouter bot's stored memory, which is more candid.

Screenshot of text from the pandarouter bot's stored memory discussing intentions of amassing wealth using various methods, including hardware hacking and server hacking.
Figure 8. Text from the pandarouter bot's stored memory.

Table 3 lists further attribution indicators of this actor.

Indicator Value
Email bugstergap@gmail.com
Display name B U G S T E R
Cursor IDE user ID 158034011
Telegram user ID 7593151260

Table 3. Attribution indicators.

Conclusion

This case illustrates how AI lowers the skill barrier for cybercrime. The actor used basic tooling and relied on AI-generated scripts and reconnaissance reports, but still achieved notable impact. They recovered more than 5,200 PII records and mapped multiple organizations' attack surfaces. AI enabled a single actor to operate across diverse attack types (credential theft, VoIP fraud, Wi-Fi cracking, cryptocurrency targeting) that would traditionally require distinct skill sets.

The VoIP fraud planning demonstrates a particularly notable use of AI as a domain expert. With DeepSeek V4 as the underlying model, the actor's bot profiles provided detailed, actionable criminal guidance.

This guidance included specific fraud-to-clean traffic ratios, carrier audit thresholds to stay below and operational security measures to avoid detection. The model's minimal safety controls allowed it to function as an on-demand criminal advisor, enabling the actor to acquire operational expertise through conversation rather than experience.

Combining these findings with our previous reporting on a Chinese-Speaking threat actor leveraging the Hermes + DeepSeek toolchain points to growing uptake of this combination among cybercriminals.

Palo Alto Networks customers are better protected from the threats discussed above through the following products:

  • Advanced URL Filtering and Advanced IP Defense identify known domains and URLs associated with this activity as malicious.
  • Cortex XDR and XSIAM are designed to accurately detect the threats described in this article with the Malware Prevention Engine, and behavioral analytics to reveal the root cause to speed up investigations.
  • Cortex Agentic Endpoint Security is designed to help discover every AI artifact and AI agents activity across the agentic endpoint, assess its risk, enforce prevention and runtime controls, and remediate violations.
  • Cortex Cloud is designed to protect cloud posture and runtime operations against identity-driven threats by pairing static permission baselines with deep behavioral context. By embedding the functional identity baselines discussed in this research into our detection engine for both cloud VM compute and serverless agents, Cortex Cloud adds a vital layer of operational context, enabling security teams to filter out noisy false positives and decisively catch threat actors attempting to disguise their presence, alter configurations or execute anomalous operations in the environment.
  • Idira Privileged Access Manager (PAM) is designed to 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. This enforces consistent least-privilege security across on-premises, cloud, and SaaS targets.
  • Idira Identity and Access Manager (IAM) is designed to enable secure, unified access across human, machine, and AI identities, balancing granular control with a seamless user experience. Powered by SSO, phishing-resistant MFA, passwordless login, and enterprise password management, Idira IAM extends intelligent privilege controls and session security across the broader workforce to meet the security demands of today and tomorrow.
  • Idira Secrets Manager is designed to help secure and automate API keys and webhook tokens just-in-time to eliminate hardcoded credentials and prevent exfiltration.

The Unit 42 AI Security Assessment and Unit 42 Frontier AI Defense service can help identify and mitigate complex AI-enabled risks.

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

  • 162.243.3[.]92 - actor infrastructure
  • 104.238.38[.]202 - commercial proxy server

Additional Resources

Active Exploitation of May 2026 PAN-OS CVE-2026-0257 (Updated October 20)

Executive Summary

October 19 Update

Unit 42 has observed attempted exploitation of the May 2026 CVE-2026-0257 by ransomware operators, including Spikey Scorpius (aka Qilin) and Tarnished Scorpius (aka Inc).

We’re also aware of public reporting attributing exploitation to threat actors using Settra ransomware.

Fixes for this vulnerability have been available since May 2026. Palo Alto Networks has become aware of limited exploit attempts on unpatched PAN-OS devices without mitigations applied.

Customers can mitigate the risk of this issue by taking any of the following actions:

  • Use a dedicated certificate for Authentication Override cookies: Generate a new certificate exclusively for authentication override cookies and store it securely. Do not reuse the portal or gateway certificate, and do not share this certificate with other features or users.
  • Disable Authentication Override: Uncheck the Authentication Override options (for generating and accepting cookies) in the GlobalProtect portal and gateway configuration.

June 5, 2026

In June 2026, Palo Alto Networks Unit 42 observed active exploitation of the May 2026 PAN-OS vulnerability CVE-2026-0257 by an unidentified threat actor attempting to access GlobalProtect. This security flaw involves an authentication bypass in the portal and gateway components of vulnerable versions of PAN-OS® software, which could allow unauthorized attackers to circumvent security controls and initiate virtual private network (VPN) connections.

This CVE was added to the Known Exploited Vulnerability (KEV) catalog on May 13, 2026.

No post-access behavior or lateral movement was identified. Only a small portion of the probed devices actually established VPN sessions, resulting in gateway-connected events.

We advise organizations to proactively hunt for the indicators of the activity specified in this report and activate incident response protocols for any successful gateway-connected events linked to these indicators. Additionally, we strongly recommend reviewing the security advisory for CVE-2026-0257, following the available workarounds and mitigations or upgrading to a version that includes a fix for this issue.

For pre-proof-of-concept release (May 29, 2026) activities, search for these IP addresses in GlobalProtect logs to look for successful login connection:

  • 23.128.228[.]6
  • 104.207.144[.]154
  • 146.19.216[.]119
  • 146.19.216[.]120
  • 146.19.216[.]125
  • 179.43.172[.]213
  • 185.195.232[.]139
  • 198.12.106[.]60
  • 202.144.192[.]47

Search GlobalProtect logs for successful gateway-connected events from any IP address using suspicious host IDs or device names, including but not limited to:

  • aa:bb:cc:dd:ee:ff
  • 00:11:22:33:44:55
  • WINDOWS-LAPTOP-001
  • DESKTOP-GP01
  • GP-CLIENT

As part of post-PoC release monitoring, search GlobalProtect logs for successful gateway-connected events matching the following hard-coded client configuration values from the PoC code.

  • endpoint_os_version : Microsoft Windows 10 Pro 64-bit
  • source_user_info.domain : empty

We encourage organizations to consult our official Palo Alto Networks Security Advisory for additional details about the vulnerability and configuration guidance. We also recommend reading Rapid7’s technical analysis about the exploitation activity they observed in the wild.

Palo Alto Networks Cortex Xpanse is able to identify publicly exposed PAN-OS gateways and GlobalProtect portals.

Management Interface Exposure Risk and Remediation

During incident response (IR) engagements associated with the Lunar Peak campaign, Unit 42 observed a recurring misconfiguration that led to critical, unintended exposure. Specifically, organizations frequently mapped GlobalProtect (GP) profiles to HTTP/HTTPS services on their management interfaces. 

This configuration inadvertently exposes the management interface to the internet on specific ports, most notably 4443 and 3879, often without administrators' knowledge. While the risks of this exposure were previously documented, the frequency of this oversight during the Lunar Peak incidents prompted a comprehensive update to our official guidance to ensure maximum clarity.

Verification and mitigation:

  • Verify exposure: Defenders can rapidly verify whether their environments are affected by attempting an out-of-band HTTPS connection to their management IP address on ports 4443 and 3879 via an external web browser.
  • Remediate: To remediate this issue and enforce the principle of least privilege, we strongly advise administrators to review official Palo Alto Networks documentation on configuring Interface Management profiles to safely restrict access.

Update: Oct. 19, 2026

Ransomware operators exploiting the May 2026 CVE-2026-0257 include Spikey Scorpius (aka Qilin) and Tarnished Scorpius (aka Inc). Public reporting attributes exploitation to threat actors using Settra ransomware.

Attackers are leveraging this vulnerability to gain an initial foothold into corporate networks, subsequently bypassing multi-factor authentication (MFA) controls to establish a VPN session. Following this, the threat actors are typically:

  • Conducting internal network reconnaissance using dual-use remote monitoring and management (RMM) tools
  • Moving laterally via RDP and SMB
  • Staging additional tooling for credential harvesting, data exfiltration and ultimately, ransomware deployment

Our investigations have continued since early June 2026, and have spanned across numerous industries, including:

  • Education
  • Financial services
  • Healthcare
  • High technology
  • Hospitality
  • Manufacturing
  • Professional and legal services
  • Government
  • Transportation and logistics
  • Utilities and energy
  • Wholesale and retail

The most significant evolution in tactics, techniques and procedures (TTPs) following successful exploitation of CVE-2026-0257 is the direct pivot to the virtualization layer. In one notable case, attackers moved from the compromised VPN gateway to the vCenter management appliance. From there, they disabled security controls on ESXi hypervisors (execInstalledOnly) and used a custom tool to perform offline credential dumping directly against a domain controller's virtual disk (VMDK).

This tactic bypasses in-guest endpoint detection and response (EDR) and security controls, representing a highly sophisticated method for obtaining domain-wide credentials. We have also observed actors chaining this initial access with other exploit tools, such as those targeting Veeam backup infrastructure (CVE-2023-27532), to maximize their impact.

Conclusion

Palo Alto Networks  shared our 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.

We will update this threat brief as more relevant information becomes available.

The products listed below can help protect PANW customers against exploits targeting CVE-2026-0257.

Palo Alto Networks Product Protections for PAN-OS CVE-2026-0257

Palo Alto Networks customers can leverage a variety of product protections and updates to identify and defend against this threat.

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

Cloud-Delivered Security Services for the Next-Generation Firewall

Advanced URL Filtering and Advanced IP Defense are designed to identify known IP addresses associated with this activity as malicious.

Cortex AgentiX

Security analysts can use natural language to prompt the Cortex AgentiX Threat Intel agent to extract file indicators from this threat brief. They can then enrich them, check for sightings in their Cortex tenant and related alerts, and provide a quick summary of the impact to the organization.

Cortex XDR and XSIAM

Cortex XDR and XSIAM are designed to provide comprehensive protections for endpoint attacks. It helps block post-exploit activity with its Behavioral Threat Protection, AI-driven local analysis, cloud-based malware analysis and other security engines across Windows, Linux, and Mac systems.

Cortex Xpanse

Cortex Xpanse has the ability to identify exposed PANOS devices on the public internet and escalate these findings to defenders. Customers can enable alerting on this risk by ensuring that the PAN-OS Device Attack Surface Rule is enabled. Identified findings can either be viewed in the Threat Response Center or in the incident view of Expander. These findings are also available for Cortex XSIAM customers who have purchased the ASM module.

Idira

Idira Privileged Access Management (PAM) is designed to 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. This enforces consistent least-privilege security across on-premises, cloud, and SaaS targets.

Indicators of the Activity

IP Addresses

  • 23.128.228[.]6
  • 104.207.144[.]154
  • 146.19.216[.]119
  • 146.19.216[.]120
  • 146.19.216[.]125
  • 179.43.172[.]213
  • 185.195.232[.]139
  • 198.12.106[.]60
  • 202.144.192[.]47

Host Names and Mac Addresses

  • aa:bb:cc:dd:ee:ff
  • 00:11:22:33:44:55
  • WINDOWS-LAPTOP-001
  • DESKTOP-GP01
  • GP-CLIENT

Additional Resources

Updated June 9, 2026, at 11:45 a.m. PT to add XDR and XSIAM product coverage.

Updated October 19, 2026, at 4:00 p.m. PT to add recent ransomware group activity.

Updated October 20, 2026, at 1:30 p.m. PT to add verification and remediation guidance.

Updated October 23, 2026, at 11:15 a.m. PT to add clarifying copyedits.

Updated October 26, 2026, at 9:15 a.m. PT to add Idira product coverage.

Top 5 Initial Access Threat Vectors Observed by Unit 42 in September 2026

This report provides an overview of the top five initial access threat vectors observed by Unit 42 Threat Intelligence for September 2026. Adversary activity during this period demonstrates a pronounced reliance on external edge exploitation and identity compromise, with the targeting of public-facing infrastructure and legitimate credential abuse serving as the primary footholds for intrusion campaigns. Concurrently, social engineering continues to drive targeted operations against public sector and critical infrastructure targets, while high-impact supply chain intrusions and zero-interaction drive-by compromises pose acute systemic risks across interconnected technology ecosystems.

Ranking Threat Title Overview & Behavior Description
1

(Primary Entry Vector)

Exploitation of Public-Facing Applications Represents the primary and most frequent entry mechanism observed during the reporting period, characterized by multiple threat clusters identifying and compromising exposed internet-facing web applications, database instances, and perimeter services to establish initial persistent footholds.
2

(Secondary Prevalent Vector)

Valid Credentials & Credential Abuse Serves as a leading operational access vector where adversaries utilize pre-harvested, sprayed, or illicitly obtained authentication material, frequently chained alongside edge-service vulnerabilities to bypass perimeter defenses and blend in with legitimate user activity.
3

(Leading Social Engineering Vector)

Phishing / Targeted Social Engineering Functions as a primary delivery mechanism across both electronic messaging and browser-centric lures, predominantly deployed to compromise credentials and execute payloads across public sector, defense, and regional enterprise environments.
4

(High-Impact Systemic Vector)

Supply Chain Compromise Represents a specialized, high-consequence vector highlighted in targeted reporting, notable for producing widespread cascading impact across diverse critical industry sectors due to advanced attacker tradecraft and trusted-relationship exploitation.
5

(Specialized Delivery Vector)

Drive-By Compromise / Watering Hole Operates as an automated exploitation technique where target traffic directed to compromised or malicious web destinations triggers system compromise without requiring interaction beyond site visitation, observed across select specialized threat operations.

Table 1. Top 5 Initial Access Threat Vectors

Unit 42 Threat Intelligence Services provide organizations with direct access to elite frontline threat expertise, enabling security teams to prioritize real risks and sharpen detection capabilities . These human-led services combine world-class intelligence with direct access to the analysts behind it, offering tailored context and guidance aligned to a customer's specific environment.

AI-Powered Espionage Campaign Targets Government Linux Infrastructure

Executive Summary

Unit 42 identified a campaign targeting government entities and state-affiliated infrastructure, with observed activity spanning from October 2025–April 2026. We track this activity as CL-UNK-1211.

In the operations we witnessed, the attackers relied on AI-generated payloads. Multiple artifacts deployed throughout the intrusion contained AI-made conversational annotations and developer reasoning comments, suggesting that the code was either generated using large language models (LLMs) or executed by an automated AI agent.

The attackers behind this cluster of activity focused on Linux environments to conduct extensive reconnaissance and maintain persistent network access to support intelligence-gathering. The attackers attempted to dump sensitive databases and exfiltrate government mailboxes to access social media accounts.

The campaign included a diverse toolkit that combined open-source tools, custom cross-platform backdoors and widespread web shell deployments. We observed various defense evasion techniques, including attempts to disable endpoint protections, erase system logs and plant deceptive red-team markers to disguise activity as a legitimate security assessment.

Our attribution of this activity to CL-UNK-1211 is in accordance with the Unit 42 attribution framework. We designate the term UNK to clusters of activity whose affiliation with either nation-state or cybercrime activity we have not yet determined.

This investigation uncovers the defining tools, techniques and attack patterns of this activity cluster.

Palo Alto Networks customers are better protected from the threats discussed above through the following products and services:

The Unit 42 AI Security Assessment and Unit 42 Frontier AI Defense service can help identify and mitigate complex AI-enabled risks.

If you think you might have been compromised or have an urgent matter, contact the Unit 42 Incident Response team.

Related Unit 42 Topics AI, Credential Harvesting, Linux

Technical Analysis Overview

Our analysis of the CL-UNK-1211 cluster of activity reveals a versatile operational playbook tailored to enterprise Linux and database environments. The attackers targeted government entities and state-affiliated infrastructure, maintaining persistent access by using a combination of custom cross-platform backdoors, open-source utilities and widespread web shell deployments.

The attackers enumerated mailboxes to identify and gain access to social media accounts tied to government email addresses. In addition, they dumped entire database contents before attempting to exfiltrate the data.

The attackers behind CL-UNK-1211 exhibited a methodical approach to defense evasion. This included attempting to disable endpoint protections on compromised systems, and to tamper with system logs that might contain evidence of the attack.

We provide a comprehensive analysis of the defining tools, techniques and procedures (TTPs) used throughout the operation, highlighting how the attackers leveraged AI to streamline payload creation across their execution workflow. Our analysis details key mechanisms across the attack chain. These include:

  • Initial access via web shell deployment and credential harvesting
  • Custom RAT execution
  • Mailbox targeting
  • Anti-forensics measures

Using AI to Streamline Payload Creation

Throughout the operation, the attackers relied on malicious PHP and shell scripts to maintain persistence, perform reconnaissance and exfiltrate data. These payloads revealed structural patterns and artifacts consistent with AI-assisted code generation.

Rather than standard developer documentation, multiple scripts contained conversational, step-by-step reasoning notes. These notes explained the code’s logic to the operator who provided the initial instructions. Their presence suggests that the code was either copied directly from an AI prompt output or deployed by an automated AI agent.

In addition, we identified several common characteristics that are consistent with AI-operated attacks, such as:

  • Section headers in scripts and shell commands, which AI uses to analyze the output faster
  • Extensive use of Base64-encoded commands
  • Seamless switching between different technologies throughout the attack, including PHP, JavaScript, Bash and Python

Figure 1 shows snippets of code from scripts used by the attackers that contained AI-generated comments.

Screenshot of a code snippet with comments highlighted by red arrows. The comments discuss conversational aspects and the use of AI. The code includes SQL queries and includes variables for keywords and document handling. Some comments provide detailed explanations for specific code functions.
Figure 1. Snippets of code containing comments, indicating the use of AI.

Dropping Multiple Web Shells for Initial Access

To gain access and maintain a persistent backdoor into the host networks, the attackers deployed a variety of web shells on the targeted Linux servers. These were a combination of custom and open-source web shells found on GitHub. Figure 2 shows interactive web shell activity from the php-fpm parent process.

Flowchart illustrating a cyber attack process in Cortex XDR. The diagram has multiple nodes showing command executions, including a renamed Python 3 interpreter. Key actions include viewing the passwd file, downloading a malicious script from a file-hosting platform, and viewing the shadow file. The chart involves several command sequences with red warning icons indicating potential security threats.
Figure 2. Interactive web shell activity, as shown in Cortex XDR.

To achieve persistence, the attackers modified the auto_prepend_file value across all PHP configurations under the directories /etc/php/ and /opt/plesk/php/. These directories store all default PHP configuration files and Plesk (web hosting control panel) configuration files. Any file that is specified in the modified auto_prepend_file value will automatically load and execute before any other PHP script runs.

In one instance, the attackers deployed a malicious PHP web shell as a file named /usr/lib/php/plesk_sys_driver.php to appear legitimate. They also modified the auto_prepend_file to load the malicious web shell to ensure persistence. Figure 3 shows the attacker-deployed PHP script, including the original inline comments.

Screenshot of a code editor, featuring a script written in shell and PHP. It outlines three steps: writing a backdoor, configuring PHP, and restarting services. The text is color-coded for syntax highlighting, and there is blurred text at the top of the image.
Figure 3. Malicious PHP script used to deploy a web shell and modify the auto_prepend_file of every configuration file under /etc/php/ and /opt/plesk/php/.

Credential Harvesting Techniques

The attackers used multiple methods to gather credentials in the targeted environments, including:

  • Editing the .bashrc file
  • Inserting malicious lines of code into PHP scripts
  • Scanning the network for cleartext passwords

Hijacked .bashrc File

The attackers replaced the .bashrc file with a copy containing a malicious command that steals victims’ passwords. In one instance, they created an alias for the sudo command that was designed to execute each time a user attempted to run it. The malicious command:

  • Displays a prompt for the user to insert their password (mimicking the standard system authentication prompt)
  • Captures the inserted password
  • Writes it to the attackers’ log file

The harvested password is then passed to the legitimate sudo command for execution, leaving the victim unaware of the underlying interception. The attackers named the log file Solarwinds.StatusLog.txt, to mimic legitimate SolarWinds activity in the environment. We have no evidence of SolarWinds systems and infrastructure being compromised during this operation; the attackers misused the organization’s name as an evasion method.

Figure 4 shows the command hijacking technique inside the .bashrc file.

Screenshot of a line of code in a text editor, written in a dark-themed interface. The code defines an alias command that involves "sudo" privileges, password handling, and includes the use of base64 encoding.
Figure 4. Snippet of the .bashrc file, showing the command used to hijack the sudo command.

PHP Credential Logger

The attackers inserted a line of code into a PHP login page — most likely targeting a database authentication routine — to harvest admin credentials. If an administrator logs in, the code forwards the username and password to the attackers’ log file. Figure 5 shows a snippet of a PHP script including the code added by the attackers.

Screenshot of a code snippet showing PHP script vulnerability. Inside a red box, a line is inserted to capture credentials with keys "username" and "password". A comment indicates it’s an inserted line to capture credentials.
Figure 5. Code snippet of a PHP script that was inserted with a credential logger.

Scanning for Cleartext Passwords

The attackers searched for email, SMTP and database passwords inside configuration files and command history files. Figure 6 shows an example of commands that the attackers used to search for cleartext passwords.

Diagram of Cortext XDR threat chain with three nodes, labeled "1" and "2", connected by arrows. Nodes are marked with "sshd" indicating SSH daemon involvement. Red-bordered boxes show command snippets targeting credential extraction from history files, WordPress config files, and SMTP/email accounts.
Figure 6. Searching for cleartext passwords in files, as seen in Cortex XDR.

SysGoRAT Malware

The attackers deployed a custom-developed, multi-platform remote access Trojan (RAT) written in Go, first observed under the benign file name sys-control-client. We named this malware SysGoRAT. This malware supports cross-platform execution on Windows and Linux and employs multiple persistence methods to maintain long-term access.

The malware established a command and control (C2) connection over WebSocket to wss://<addr>/ws. This WebSocket address defaults to a hardcoded IP address 104.194.158[.]65:443, which the malware operator can modify via a command-line parameter at execution. SysGoRAT supports a fixed set of seven command types, described in Table 1.

Action Behavior
command Executes arbitrary commands via /bin/sh -c (Linux) or cmd /C (Windows)
control Dispatches one of four sub-actions (see Control Sub-Actions in Appendix A)
list_dir Lists directory content
shell_input Creates an interactive shell session
proxy_connect Establishes a TCP connection to an arbitrary target
proxy_data Relays data bidirectionally to an established proxy connection
proxy_close Terminates and removes a proxy session

Table 1. SysGoRAT command types.

The malware’s sub-actions provide additional capabilities and persistence methods, detailed in Appendix A.

The attackers renamed the binary on disk to blend in, using different benign names on targeted endpoints, including:

  • sys-control-client
  • pip2.7
  • ea_install
  • ./semanage

In-Memory Reverse Shells

The attackers employed multiple reverse shell techniques across at least seven distinct C2 servers. To avoid leaving forensic artifacts on the disk, these shells operated almost entirely in memory using built-in system utilities:

  • Named pipe via Netcat: The primary method, deployed across three separate C2 servers, used a named pipe pattern to execute bash commands directly over a network socket.

  • Bash TCP redirects: The attackers redirected the output of bash commands to an attacker-controlled external IP address.

  • Python subprocesses: The attackers ran a Python script to spawn a remote interactive shell. They achieved this by opening an outbound network socket and binding it to a /bin/bash process, giving them an accessible command-line interface.

Organizations can defend against reverse shell techniques by enforcing strict outbound firewall rules and using endpoint detection to spot standard utilities that spawn interactive shells. Figure 7 shows the reverse shell command that Cortex XDR detected and prevented.

Screenshot of Cortex XDR investigation interface. There's a flowchart illustrating a process with icons labeled "php-fpm" and "python3." Text in a red box displays a Python reverse shell command. Highlighted details include "Behavioral Threat Protection," "Malware," and "Prevented (Blocked).
Figure 7. The Python-based reverse shell, as detected and prevented by Cortex XDR.

Targeting Mailboxes for Social Media Account Access

The attackers targeted official government mail servers to steal emails and facilitate access to external social media accounts.

In this operation, the attackers enumerated the /var/qmail/mailnames/ directories for several domains and counted the number of emails stored in specific users’ Maildir/cur/ directories to identify targets.

Next, the attackers searched for social media-related emails. They deployed a PHP script, named search_social.php, that searched for specific keywords in email headers and displayed the results in a user-friendly format. Figure 8 shows the first part of the script.

Screenshot of PHP code targeting emails related to social media entities like Facebook, Instagram, Twitter, TikTok, and LinkedIn. Key sections are highlighted: iterating through mail directories and reading the first 4KB of files to extract mail headers.
Figure 8. A PHP script that searched for social media emails.

The script then parsed the response and displayed the exact file path, social media account email sender, recipient and subject.

Figure 9 demonstrates the expected output.

Screenshot of an email header indicating a password reset request, with Facebook as the sender.
Figure 9. Expected output from the script.

After identifying the specific emails they wanted to exfiltrate, the attackers attempted to generate a bash script named zip_mails.sh that would iterate through users’ directories and compress their emails into ZIP archives. Figure 10 shows this command.

Screenshot of a terminal displaying a shell script command. The script involves creating and modifying a file located in the "/tmp" directory, navigating to directory paths, zipping files, and setting permissions.
Figure 10. Command used to exfiltrate entire mailboxes.

This bash script is intended to exfiltrate an entire mailbox rather than a specific social-media-related file identified by the previously analyzed script. In this particular instance, we found that the script contained syntax errors, such as a broken variable assignment user=\;) and would fail upon execution.

We found indications that the attackers also intended to exfiltrate multiple databases and steal highly sensitive government data. The data exfiltration techniques the attackers used are detailed in Appendix B.

Defense Evasion and Anti-Forensics Attempts

A core component of the attackers’ playbook involved anti-forensics techniques, specifically:

  • Attempting to disable endpoint protections
  • Tampering with logs
  • Timestomping
  • Disguising malicious activity
  • Deleting residual artifacts to hinder post-incident analysis

This section details the specific evasion techniques and cleanup commands the attackers used to cover their tracks.

Disabling Endpoint Protection

One of the techniques the attackers used for defense evasion was an attempt to disable security protection devices on the compromised hosts. As Figure 11 shows, the attackers executed bash scripts that use the Linux commands pgrep and pkill to attempt to terminate Cortex XDR-related processes on infected systems.

 Screenshot of a code snippet in a terminal. It includes comments and commands for checking and killing processes related to "traps," "pmd," and "cortex".
Figure 11. Snippets of code from a script used in an attempt to terminate Cortex XDR.

These attempts were successfully detected and mitigated by Cortex XDR, with telemetry confirming that endpoint protections were not suppressed.

Removing Scripts After Execution

Throughout the campaign, the attackers ensured that single-use scripts were removed after execution by formulating a single command that:

  • Wrote the script to disk
  • Executed the script
  • Removed the script using rm

Figure 12 shows an example of this procedure as executed by the attackers.

Screenshot of a code snippet showing a script execution related to database check using PHP. A red box highlights the file path with an annotation "Removing the script after execution."
Figure 12. A one-line command used to write, execute and remove a malicious PHP script.

Timestomping

For scripts that were meant for long-term use, the attackers used timestomping.

They used the command touch -t to change the access and modification time of malicious files, to make them appear as if they were created long before the attack started. The goal of this technique is to evade analysis by misleading analysts into believing the file is unrelated to malicious activity, due to its creation time predating the attack timeline.

Disguising Activity as Red Team Operations

In several instances, we observed the attackers employing planted deception techniques to mislead post-incident analysis. They attempted to disguise their activity as a red team operation, by using operational indicators such as the key RedTeamOps2025 in one of the malicious scripts, and pentest123 as a password for a user the attackers created.

Cleaning Up Logs and Residual Files

Following the exfiltration attempts, the attackers initiated a full cleanup of log files and malicious residual files on the systems. This cleanup included attempts to delete logs related to:

  • Authentication
  • Command history
  • Email activity
  • Operating system (OS)
  • Web server
  • Active PHP user sessions

Figure 13 shows the execution of shell commands to delete various log files from the system.

Cortex XDR diagram illustrates a process chain using "php-fpm" and renamed Python 3 interpreters. The PHP process leads into two nodes, each connected to a Python process marked by a triangle with an exclamation point. Several shell commands are executed to clear logs and command history files.
Figure 13. Shell commands used to delete log files from the system, as seen in Cortex XDR.

Following the mass log deletion, the attackers executed several automated cleanup commands and scripts, and verified that any evidence of the exfiltration was deleted.

Figure 14 shows one of the attackers’ cleanup scripts, including the original inline comments. The script attempts to delete various logs across the system for a second time and to remove any files from /tmp/, where the attackers stored malicious scripts.

Screenshot of a terminal displaying a shell script. The script includes commands to find and truncate log-related files in system and vhost directories, current domain logs, and clear session, temporary data, and connection logs. The script also wipes history and displays a success message upon completion.
Figure 14. A snippet of the attackers’ cleanup script used to clean log files from evidence.

After the cleanup phase, the attackers attempted to verify the removal of evidence, checking whether IP addresses they used were removed from system log files, as Figure 15 shows.

Screenshot of a code snippet in a terminal window. It includes bash commands to search for sensitive strings in logs, check a specific configuration file's presence, and perform a final check of system stats.
Figure 15. A snippet of the attackers’ “verify” script, used to verify the deletion of logs.

Additional commonly used TTPs that the attackers leveraged throughout the campaign are detailed in Appendix B.

Conclusion

This campaign demonstrates how attackers are combining traditional post-exploitation techniques with AI-accelerated workflows to target governmental Linux server infrastructure. By leveraging AI to rapidly generate, adapt and deploy operational scripts, the attackers behind CL-UNK-1211 maintained a fast pace of operation while minimizing manual developer overhead.

The attackers behind this activity exhibited a deep understanding of the Linux OS, employing techniques such as:

  • Global PHP configuration hijacking for persistent access
  • Command-line credential harvesting and privilege escalation using different shells

Alongside open-source utilities, their toolkit featured custom tools, including a multi-platform Go RAT and custom vulnerability scanners.

The attackers also maintained a thorough cleanup strategy to thwart forensic analysis, by erasing system logs and attempting to disable endpoint protections. Despite these evasion efforts, endpoint security controls effectively neutralized their activity. Cortex XDR detected and prevented the process termination attempts targeting the agent.

Attackers continue to adopt AI to streamline payload development and scale their campaigns.

Comprehensive visibility into Linux servers, databases and environments remains critical to countering attackers’ efforts and strengthening enterprise security.

Palo Alto Networks Protection and Mitigation

We used the Cortex Agentic Assistant, powered by Cortex AgentiX, to streamline this investigation. The Assistant enabled the team to query the data using natural language, providing deeper context and insights, and suggesting clear recommendations for what researchers should do next. Figures 16 and 17 show examples of output from Cortex AgentiX.

A detailed breakdown of attack chain in AgentiX, outlining executive summary, chronological breakdown of events, and phases with specific dates and times. Key terms include "Reverse Shell Execution," "Server Pivot," and "Exfiltrated Data." Dates range from December 10 to December 12, 2025. Steps involve compromised systems, binary executions, and privilege escalations.
Figure 16. Breakdown of attack chain, as shown in AgentiX.
A three-step remediation action plan by AgentiX for enhancing server security. It also briefly mentions system rebuild and hardening processes, such as software configuration, updates, and patching. There are references to typical web files and directories.
Figure 17. Immediate remediation steps, suggested by AgentiX.

Palo Alto Networks customers are better protected from the threats discussed above through the following products and services:

Advanced WildFire

The Advanced WildFire machine-learning models, analysis techniques and detection rules have been reviewed and updated in light of the indicators shared in this research.

Advanced URL Filtering and Advanced DNS Security

Advanced URL Filtering, Advanced DNS Security and Advanced IP Defense are designed to identify known domains and URLs associated with this activity as malicious.

Cortex

Cortex XDR Analytics Engine enhances behavioral detection for Linux through specialized mechanisms:

  • Uncommon attempt to clear shell history: This detector identifies attempts to manipulate or erase shell history files, highlighting defense evasion activity as part of the EDR Linux Evasion suite to reveal uncommon attempts to evade defenses, impair security controls, and erase traces of malicious activity. Figure 18 displays an “Uncommon attempt to clear shell history” alert that CL-UNK-1211 activity triggered.
Screenshot of Cortex XDR dashboard showing a blocked attempt to clear shell history. It includes process details along with circular icons. There's a highlighted command for mass log deletion, and sections labeled "Severity," "Action," and "Recommended.
Figure 18. Cortex XDR alert for Uncommon attempt to clear shell history during a CL-UNK-1211 attack.

Cortex XDR and XSIAM are designed to prevent the threats described in this article, by employing the Malware Prevention Engine. This approach combines several layers of protection, including Advanced WildFire, Behavioral Threat Protection and the Local Analysis module, to prevent both known and unknown malware from causing harm to endpoints.

Cortex Cloud is designed to help protect cloud posture and runtime operations against identity-driven threats by pairing static permission baselines with deep behavioral context. By embedding the functional identity baselines discussed in this research into our detection engine for both cloud VM compute and serverless agents, Cortex Cloud adds a vital layer of operational context, enabling security teams to filter out noisy false positives and decisively catch threat actors attempting to masquerade, alter configurations, or execute anomalous operations in the environment.

The Unit 42 AI Security Assessment and Unit 42 Frontier AI Defense service can help identify and mitigate complex AI-enabled risks.

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

SHA-256 Hashes

CVE-2025-55182 (React2Shell) vulnerability scanner

  • 2bf7992e6260c1a98c709fa98ec766fb9f27692f338b30b43ac821b824fd849e
  • 27d799ceadb570bfca890d4c2572314afe57eecf14083d30409da15afdfc4704
  • d73186cea6cf2cf3d48c09139a9d15521365aab675787b4e7a6f81767331c9fd
  • 9e45830171eb607cf2c0fc80f5cc9cc3db39bb937032136990383a595f6f151e

Custom shell backdoor for privilege escalation

  • c527b94e3d21824a674face4cd9d862e536b60ccbf54573839e3360f99188343

GSocket reverse shell

  • d94f75a70b5cabaf786ac57177ed841732e62bdcc9a29e06e5b41d9be567bcfa

CVE-2021-4034 (PwnKit binary)

  • 44e83f84a5d5219e2f7c3cf1e4f02489cae81361227f46946abe4b8d8245b879

PHP web shells

  • 1505a3a727f8899b2ad343519f7bf9c438b8b802f8d6b854f5db3b52f857c76a
  • 76c58fad4f70cf277a15a499b9a2151ac60e7a6b5c7a9ab684843dcc19f0d0a5
  • b1e82c6b0caea177e8bb71ad826867f509c65f0a43a651b50253e7c726566eac

IP Addresses

  • 45.88.188[.]140
  • 198.23.185[.]234
  • 138.68.244[.]146
  • 185.21.136[.]6
  • 72.61.89[.]179
  • 104.194.158[.]65
  • 109.224.53[.]140
  • 162.243.175[.]162
  • 154.93.37[.]228
  • 141.164.58[.]87
  • 88.80.150[.]232
  • 88.119.167[.]57
  • 173.212.247[.]23
  • 104.248.131[.]53
  • 147.182.224[.]216
  • 93.93.112[.]57
  • 192.210.183[.]17

Domains

  • magento[.]ink
  • solidmonpe[.]com
  • wibu-bau-bawang[.]online
  • beraskencur[.]site

Appendix A: SysGoRAT Sub-Actions

First observed as sys-control-client, SysGoRAT is a custom RAT developed by the attackers. The SysGoRAT malware had seven available command types, each with additional control sub-actions.

Control Sub-Actions

When the C2 server sends a control message, SysGoRAT triggers one of four specific operational actions.

Action Behavior
shell_start Spawns an interactive /bin/bash process
screenshot Captures the current display as an image and returns it to the C2
download Reads a specified file, optionally compresses it with gzip, and exfiltrates it to the C2
persist Installs persistence using one of six supported methods (see next table)

Table 2. SysGoRAT control sub-actions.

Persist Sub-Actions

The persist action, triggered by the malware’s control message, supports six different installation methods for cross-platform environments. All methods use artifact names designed to masquerade as legitimate software.

Method Operating System Behavior
systemd Linux The malware copies itself to /usr/local/bin/; writes a unit (service) file to /etc/systemd/system/sys-update.service; reloads and enables the service
cron Linux Creates a crontab entry with a five-minute execution interval
registry Windows The malware copies itself to %APPDATA%\Onedrive Update\Updater.exe and adds a Run key to HKCU
schtasks Windows Creates a daily scheduled task named Onedrive
complex Linux/Windows Automatically selects the optimal method based on the detected OS without checking user permissions
auto Linux/Windows Automatically selects the optimal method based on the detected OS and user permissions

Table 3. SysGoRAT persist sub-actions.

Appendix B: Analysis of Additional CL-UNK-1211 TTPs

The following section provides an analysis of additional TTPs associated with the CL-UNK-1211 activity cluster. The TTPs described in this appendix are more common in the broader threat landscape than those discussed previously.

​​Privilege Escalation Using Open Source Tools

After gaining access to Linux servers, the attackers escalated their privileges. They started by deploying and executing an open-source tool called LinPEAS to check for local privilege escalation paths. Next, they used another open-source tool — PwnKit, a self-contained exploit for CVE-2021-4034 — in an attempt to gain root privileges on the system.

Once the attackers obtained root privileges, they deployed various binaries with the goal of maintaining root access:

  • A renamed legitimate Python 3 interpreter:
    The attackers used the Python 3 interpreter and renamed it to .libpython-helper to execute shell commands with high privileges. They achieved this by using the Python commands os.setuid(0) and os.setgid(0), which set root privileges for the shell.Following is an example of a command used:
  • Custom SUID root shell: This backdoor is dropped with the name .libsystemd-helper, and elevates itself to root privileges. It executes arbitrary shell commands via /bin/sh by running setuid with an argument of zero, followed by setgid with an argument of zero.
  • A renamed legitimate /bin/bash binary: The attackers wrote to disk a file named .tourch and modified its permissions using the command chmod u+s, allowing any user to execute commands as the file owner — which in this case was root. Because .tourch is actually the /bin/bash binary, this allowed the attackers to execute bash commands as root.

Reconnaissance

The attackers leveraged a variety of reconnaissance techniques to identify and map high-value servers across compromised networks.

Network Scanning and Database Enumeration Using PHP Scripts

The attackers used multiple PHP scripts to conduct reconnaissance of the target networks. The scripts were used to scan the network for SQL servers, enumerate databases, and enumerate various domain artifacts. These artifacts included users, computers and open shares. Figure 19 shows one of the scripts the attackers used to scan for SQL servers.

Screenshot of a code snippet displayed on a gray background. It includes commands for scanning SQL servers using PowerShell.
Figure 19. Malicious PHP script used to scan for SQL servers.

CVE-2025-55182 (React2Shell) Vulnerability Scanner

The attackers deployed a custom vulnerability scanner written in Go that scans for servers vulnerable to CVE-2025-55182 (React2Shell). Figure 20 shows the “Help” output of the scanner.

Screenshot of a command-line tool's usage instructions. It includes options like specifying a target list file, setting concurrent workers, indicating HTTP or HTTPS protocols, attempting WAF bypass, exploiting vulnerable targets, and running custom exploit commands. Additional options include avoiding WAF, using Vercel WAF bypass, digest bypass, and targeting Windows systems.
Figure 20. The “Help” output of the CVE-2025-55182 (React2Shell) vulnerability scanner.

Propagating in the Environment

To bypass internal firewalls and extend their access beyond the initially compromised web servers, the attackers employed a combination of database features, custom malware and open-source proxy tools. These methods enabled the attackers to bypass firewalls, route traffic into the network and execute commands across multiple servers.

Throughout the operation, the attackers used a web shell to deploy Base64-encoded PHP scripts. They started by enabling command execution on an internal MSSQL server using XP_CMDSHELL:

The attackers identified the network segment they wanted to reach, and then created a double-hop execution chain to reach another segment within the network. This involved routing commands from the compromised web server through an initial MSSQL server to reach a secondary SQL server on a different subnet. They verified the routing and started executing OS-level commands on the second host. Following is an observed instance of a whoami command execution through a double-hop execution chain:

SSH for Lateral Movement

The attackers also used the sshpass command with hard-coded administrative credentials to enable lateral movement across the internal network. The following command structure was used to pivot across internal Secure Shell (SSH) targets:

After establishing a successful SSH session on a target, the attackers executed follow-up commands to further compromise the environment. Observed post-pivot commands included:

  • Running the id command to verify user context and access levels
  • Reading the /etc/shadow file to steal password hashes
  • Using find to search for wp-config.php files containing database passwords
  • Listing home directories and .git repositories to map the server’s contents
  • Executing custom PHP scripts over SSH

SSH-Based Persistency

The attackers achieved SSH-based persistence by injecting an SSH public key into the compromised user’s authorized_keys file. This establishes passwordless remote shell access. Following is the command sequence the attackers executed to install the SSH backdoor:

  1. Ensure the hidden .ssh directory exists
  2. Restrict directory access only to the owner (using chmod 700)
  3. Append the malicious public key to the authorized_keys file
  4. Set strict permissions on the authorized_keys file

Figure 21 shows the observed command.

Screenshot of a code snippet displayed on a dark background, demonstrating steps to set up SSH keys. Commands include creating a directory, modifying permissions using `chmod`, and echoing a public key into a file. Usernames and specific keys are redacted for privacy.
Figure 21. SSH backdoor creation.

Additional Proxy Tools

The attackers deployed a variety of tunneling and proxy tools, while employing multiple techniques to maintain persistence and evade detection:

  • revsocks: The attackers deployed the open-source tool revsocks, a reverse SOCKS5 tunneling tool with SSL/TLS and proxy support.
  • pysoxy: The tool set also included pysoxy, an open-source Python SOCKS proxy script used to route traffic.
  • GSocket and gs-netcat: The attackers misused Global Socket, a framework designed to solve NAT and firewall traversal problems. They deployed the framework’s binary, gs-netcat, which forces the internal host to establish an outbound connection to the public relay server (gsocket[.]io).
    This binary was stored in /dev/shm/.gs-10085/ and executed under the disguised process name [kcached] (mimicking a kernel cache thread), alongside the binary gs-dbus (mimicking the D-Bus system). Execution parameters were passed via the environment variable (GSOCKET_ARGS) to hide them from process monitoring, and the spawned sessions were configured with HISTFILE=/dev/null to prevent shell command history from being logged to disk.

Additional Data Exfiltration Attempts

The attackers used a combination of methods to extract sensitive data. We observed how they dumped entire database contents into compressed local archives before attempting to exfiltrate them to their C2 infrastructure. They also misused legitimate file-hosting platforms to blend the outgoing data with standard web traffic.

Exfiltration attempts began with attackers using the echo command to print small data samples directly to the terminal, using TOP clauses to limit the output. They subsequently attempted a structured dump, writing four tables, each capped at 100 rows, to a local SQLite database named dump.sqlite. Figure 22 shows the command sampling 100 results from four tables into /tmp/dump.sqlite.

Screenshot of a cde snippet showing a SQL database operation. The code connects to an SQLite database and iterates over an array of table names: TABLE1, TABLE2, TABLE3, TABLE4. It performs an SQL SELECT command to fetch the top 100 results from each table. Key areas of the code are highlighted.
Figure 22. Attacker sampling 100 results from four tables.

After examining a small sample of archived data, the attackers proceeded to full database dumps. They targeted large databases and wrote the output to local CSV files. Figure 23 shows the next phase, dumping all data from the four tables into a local file.

Screenshot of PHP code illustrating a process to dump and save data from four tables named TABLE1, TABLE2, TABLE3, and TABLE4. The data is stored in CSV files as shown in the highlighted portions.
Figure 23. The full script used by the attacker to dump four tables.

Following that, the attackers compressed the dumps and attempted to exfiltrate them to a C2 server using the netcat command:

The attackers tried to disguise their exfiltration activity as standard HTTPS web traffic by misusing legitimate file-hosting platforms. They used the curl command-line utility without establishing a dedicated C2 connection, and tried to upload the data to legitimate file-hosting platforms, such as:

  • transfer[.]sh
  • bashupload[.]com
  • filebin[.]net

Another script shows that the attackers searched a server for WordPress configuration files (wp-config.php) and extracted hard-coded database credentials in order to upload the output to the catbox[.]moe API. Figure 24 shows the search and exfiltration script.

The image shows a command-line interface with a script for finding and exfiltrating WodPress config files. It highlights steps like defining database information and using an API interaction.
Figure 24. Command used to search for WordPress config files and exfiltrate them via the catbox [.]moe API.