We have uncovered a new campaign in which an attacker leverages newly registered domains (NRDs) and introduces a new variant of domain generation algorithms (DGAs) potentially designed to avoid detection. We found this through our novel graph-intelligence based pipeline. The system infers attack campaigns by correlating domain registrations with hosting infrastructure, passive DNS and WHOIS data.
This campaign used over 6,000 NRDs that redirected to similar paths on domains resembling those generated by dictionary-based DGAs. Dictionary DGAs are a DGA variant that combines dictionary words to create domain names resembling legitimate ones, thus hindering detection by security systems.
These NRDs redirected users to URLs that lead to advertisements of potentially unwanted Android applications. Analysis of files contacting the NRDs' IP address revealed that 96% (89 of 92) were malicious.
Broadening the scope of our investigation, we found that there were 444,898 NRDs belonging to the same actor. These NRDs redirected to 178 domains exhibiting dictionary DGA-like characteristics.
We identified a new pattern in these 178 domains, which we call typo DGAs: dictionary DGA domains containing typographical errors. For example, pictidentifyive[.]pro is a typo DGA that could be a combination of the words “picture,” “identify” and “five” with some letters deleted. This typo DGA pattern suggests a new dictionary DGA variant designed to evade traditional detection methods.
Palo Alto Networks customers are better protected through the following products and services:
Our graph-intelligence based detection system, described in our article TLD Tracker: Exploring Newly Released Top-Level Domains, has uncovered a new campaign. This campaign has used 6,057 newly registered domains, each redirecting to paths under various dictionary DGA-like domains.
Figure 1 illustrates a portion of the campaign, specifically three NRDs redirecting to typo DGA subdomains. These subdomains resolve to a malicious IP address that many malicious file samples contacted.
Figure 1. Part of the campaign depicting three NRDs redirecting to typo DGA subdomains.
Shared WHOIS Information
The 6,057 NRDs were alphanumeric strings resembling DGAs, with five to six characters. These domains all shared the same WHOIS information including registrant email address (fangyuanhenry20230927@outlook[.]com), which confirms that the same entity registered them.
Figure 2 shows that all the NRDs logged at the time of campaign detection were registered between August-November 2024.
Figure 2. Creation dates of all 6,057 NRDs found in the campaign.
Shared Hosting Infrastructure
We identified this campaign because these NRDs share the same malicious hosting infrastructure and resolve to the same IP address 91.195.240[.]123.
Redirection to URLs Under Typo DGA Subdomains
Subdomains of these NRDs redirected to URLs under typo DGAs. In this campaign, the typo DGA subdomains used epoch timestamps. These timestamps correspond to the observed redirection times. For example, we observed hxxps://121.y1ly6n[.]us redirecting to hxxps://1731804190472.gratsuccessfic[.]pro on Nov. 17, 2024, at 00:45:19 UTC.
The epoch timestamp 1731804190472 represents a time two minutes earlier. These epoch timestamp subdomains suggest that the NRD domain registrations and redirections might have been automated and scheduled to trigger at certain times of the day.
Landing Pages
The NRDs’ landing pages presented adult Android app download pages (shown in Figure 3). The NRDs all resolved to the same IP address mentioned above, 91.195.240[.]123. Furthermore, over 96% of the samples (89 of 92) contacting this IP address were malicious executable files.
Figure 3. Example landing page with adult content distributing potentially unwanted applications.
Using the Threat Actor’s Infrastructure to Expand Detection
We used our graph-intelligence pipeline to search for domains with similar characteristics, expanding the coverage of the campaign. Using the same registrant email address identified above, we identified 444,898 domains. Our passive DNS data shows that nearly all of these (99.98%, or 444,827 domains) resolved to the same IP address (91.195.240[.]123). This strong correlation suggests a broader network of potentially malicious activity, even if not all domains are directly involved in this campaign.
Figure 4 shows that the distribution pattern of the domain creation dates suggests that the attacker registered several thousand domains over multiple weeks, followed by periods of reduced activity. The short lifespan of the landing pages and redirection behavior suggests a rapid domain turnover strategy.
Figure 4. Creation dates of 444,898 domains belonging to the same actor.
Many of these NRDs redirected to 178 distinct typo DGA domains, also employing epoch timestamps in their subdomains. We haven't found direct evidence linking these typo DGA domains to the same actor controlling the NRDs (e.g., shared WHOIS or hosting). However, the consistent use of the less common .pro TLD across all 178 domains warrants further investigation.
Furthermore, we found an average of 67 different epoch timestamp subdomains under each typo DGA root domain, which suggests at least that many distinct redirection events.
Conclusion
Our analysis revealed a campaign using typo DGAs, which is a novel dictionary DGA variant designed to evade detection. This campaign highlights the need for advanced detection capabilities like our graph intelligence pipeline. We are actively monitoring and blocking the malicious infrastructure in the campaign we described (tracked as 'typodga_redir').
Palo Alto Networks customers are better protected through the following products and services:
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: 00080005045107
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.
Many illicit network services, including phishing campaigns and online gambling platforms, exploit traffic distribution systems (TDS) to redirect network traffic. A TDS acts as a central hub, redirecting victims through an often complex network of servers to obfuscate the final destination and hinder detection of these operations. This infrastructure also facilitates the management of multiple malicious endpoints simultaneously.
Analyzing the resolution and redirection traffic allows us to construct relationship networks among different URLs and identify TDS infrastructure. We have found that malicious TDS traffic exhibits significant topological characteristics compared to benign redirection networks. For example, malicious TDS infrastructure typically presents more URLs and a higher number of connections than benign TDS networks.
We combined the topological insights about malicious TDS infrastructure and comprehensive threat intelligence to build a machine learning (ML) powered malicious TDS detection system. Our detection system can capture various malicious TDS infrastructure hosting different types of cyberthreats or suspicious activities including malvertising, phishing and gambling services.
A TDS is a traffic redirection network containing multiple sources, intermediates and landing nodes. Attackers often employ social engineering tactics, such as phishing emails with malicious links disguised as invoices, to lure victims into malicious redirection chains via entry point webpages.
These entry points lead to a series of intermediate domains that obfuscate the origin of the attacks. The intermediate domains then take victims to final landing pages, which deliver the actual network threats, such as malware download links or fake login pages that steal the victims’ credentials.
Threat actors have several motivations to develop network attacks using TDS infrastructure.
Resilience against takedown efforts: Attackers can swiftly change TDS entry and landing points whenever these are blocked, making them hard to take down fully
Obfuscation and cloaking: By randomly redirecting visitors to legitimate websites, a TDS can evade the detection and analysis of automated crawling services
Traffic monetization: The dynamic nature of TDS redirection logic allows attackers to provide content delivery service for different shady websites or help the attackers to monetize their traffic
Legitimate organizations also use TDS infrastructure to make their services more reliable and flexible. For example, marketing return-on-investment (ROI) tracking services often leverage TDS infrastructure to manage and improve their traffic flow. These tracking services require customers to follow outgoing links to the tracking TDS, which dynamically redirects traffic to different landing pages based on visitor parameters such as geolocation, device type and referrer.
We continuously crawl and analyze millions of websites daily. Based on the results, we constructed graphs that illustrate redirection flows between network endpoints and identify TDS indicators among the data. To gain deeper insights into the behavior of both malicious and legitimate TDS traffic, we conduct a large-scale topological analysis on these redirection graphs.
Our topological analysis studies the structure and relationships between connected elements in a network to understand its characteristics. We found three interesting insights about the difference between malicious and benign TDS traffic:
Malicious TDS traffic has longer redirection chains than benign traffic
Malicious TDS traffic contains more distinct URLs than benign traffic
Malicious TDS traffic demonstrates a higher connectivity level among URLs
By examining the topological features of both malicious and legitimate TDS infrastructure, we observed significant differences that reveal distinct usage patterns. Using the results, we can develop a highly accurate detector to identify malicious TDS activity.
Malicious TDS traffic tends to have longer redirection chains compared to benign traffic. Figure 1 presents the cumulative distribution function (CDF) of the maximum redirection chain length for both. A CDF shows the probability that a random variable will be less than or equal to a certain value.
Figure 1. CDF of longest redirection chains in malicious vs. legitimate TDS.
Figure 1 shows that approximately 25% of malicious TDS activity has its longest redirection chains at more than four hops (100% minus 75%). For benign TDS, this percentage is only approximately 10% (100% minus 90%).
These statistics highlight malicious redirection behaviors used for cloaking and obfuscation purposes. By using longer redirection chains, they can obscure the final malicious landing pages with multiple intermediate cloaking nodes to evade detection.
Malicious TDS graphs are also characterized by their larger size and higher connectivity among nodes. We discovered this feature by analyzing the CDFs of TDS URLs and subgraphs numbers. Figure 2 shows that malicious TDS traffic involves more URLs compared to benign traffic, represented by the red line for malicious TDS data being lower than the line for benign. Specifically, the median number of URLs in malicious TDS is 126, compared to 80 in benign TDS.
Figure 2. CDF of URL number in malicious vs. legitimate TDS.
A TDS consists of multiple redirection chains that involve the same set of domains. However, not all URLs are fully connected, resulting in isolated subgraphs within a TDS redirection graph.
Figure 3 shows that malicious TDS graphs have fewer isolated subgraphs, since the line representing malicious TDS activity in the CDF graph is above the blue line representing the benign TDS data. About 40% of malicious TDS activity consists of a single subgraph, meaning all their URLs are interconnected. In contrast, only 20% of benign TDS activity has just one subgraph.
Figure 3. CDF of subgraphs number in malicious vs. legitimate TDS.
These two observations indicate that malicious TDS activity has greater overall connectivity among URLs, suggesting that attackers are more likely to exploit the dynamic redirection capabilities of a TDS. In contrast, benign TDS activity, such as tracking services, tends to set up dedicated URLs for specific entry and landing nodes.
Case Study
This section examines various examples of malicious TDS infrastructure use and how attackers exploit it for network abuse.
TDS for Phishing
TDS infrastructure is widely abused to deliver malicious web content, especially phishing websites. One of the phishing TDS campaigns we analyzed was a fraudulent cryptocurrency giveaway mimicking a decentralized app store.
Figure 4 illustrates part of this TDS structure. It contains many squatting domains including dapparadar[.]app, dappadar[.]community and dappadar[.]bio.
Figure 4. Redirection networks of phishing TDS.
These squatting domains all redirect to the same landing page, which is a phishing page that mimics a cryptocurrency airdrop system, as shown in Figure 5.
Figure 5. Fake cryptocurrency airdrops page.
TDS for Malvertising
Malvertising TDS campaigns redirect visitors to different shady advertising pages. TDS operators can sell this redirected traffic to malicious services. A TDS serves as a platform that makes the network infrastructure more scalable and flexible, allowing for the easy addition or removal of landing pages.
Figure 6 is part of the redirection graph for a malvertising TDS campaign. Visitors from the same entry website are redirected to different URLs under vkmarketing2[.]com, then to various shady landing pages.
Figure 6. Redirection networks of malvertising TDS.
After two or more hops, the TDS infrastructure directs visitors to shady advertisement pages offering things like gift card rewards and loans (Figure 7).
Figure 7. Shady ad pages redirected from vkmarketing2[.]com.
TDS for Darknet or Illicit Services
Besides acting as a shared traffic distribution platform, a TDS can be abused for darknet services. Although these services are not inherently malicious, they are often subject to strict internet censorship, particularly in areas such as gambling and adult websites. We discovered a campaign that built a large TDS using a large number of domain generation algorithm (DGA) based .lol domains as intermediate redirection nodes.
Figure 8 shows part of the redirection network hosting this illicit service. All redirection chains are centered around different DGA .lol domains and their randomly generated subdomains.
We identified 139 .lol malicious domains actively serving this campaign from May-October 2024. We also observed that the adversaries registered many DGA domains in bulk and integrated them into the service shortly after the registration. For example, xd2kdw[.]lol, ba3e7q[.]lol and 7eh3gj[.]lol were created on August 22, 2024, and began carrying malicious traffic in mid-September.
This structure, with all TDS domains connected to the same entry and landing nodes, makes the dark market service resilient to takedowns. Even if one domain is taken down, the others remain functional.
Figure 8. Redirection networks of shady service TDS.
Since May 2024, we observed emerging DGA domains serving this campaign, with increased registrations and traffic by August and September. We also identified entry and landing domains using uncommon TLDs like .xyz, .mom and .pics.
Figure 9 shows the campaign’s landing page, which is a portal to Chinese gambling and adult content.
Figure 9. Landing page from the TDS for a gambling/adult website.
TDS for Cloaking
Threat actors can abuse TDS infrastructure to conceal malicious content by redirecting the visitor to legitimate websites. We identified a recent example using mobesti[.]com for a phishing campaign.
Figure 10 shows how this campaign directed visitors from various entry domains to phishing websites. To obscure the malicious activities, this type of TDS campaign occasionally redirects to legitimate sites including the Google Play download page for TikTok or the Yahoo homepage. This tactic can mislead automated crawlers into viewing the TDS infrastructure as a legitimate redirection service, resulting in a benign verdict.
Figure 10. Redirection network mapping of TDS used for cloaking.
This phishing campaign attracts victims’ attention with an adult-themed phishing site shown in Figure 11. The threat actor used dating-related keywords to create phishing domains such as 3adating[.]com and meetyoursoulmate[.]life.
Figure 11. Example of an adult-themed phishing site as a landing page from this cloaking style TDS.
Conclusion
Adversaries widely abuse TDS infrastructure to build dynamic and resilient network infrastructure for malicious web services. These redirection networks enhance resilience against takedowns and enable scaling and cloaking of malicious content.
Machine Learning Based Detection
By dynamically analyzing malicious websites and associated redirection chains, we gained insights into the characteristics of this type of malicious network infrastructure, enabling more comprehensive blocking of attacking network entities. Based on the topologic and threat-related features, we developed an aggregated ML model to detect malicious TDS activity automatically.
We extracted 20 features from TDS graphs to detect malicious traffic distributors. Figure 12 shows the most important features.
Figure 12. Most Important Features for Malicious TDS Detection.
The top three features are the malicious rates across three categories with importance increasing with scope size (i.e., URL, redirection chain and subgraph). Key topological characteristics include redirection chain length and the number of URLs, which quantify TDS connectivity.
We trained multiple ML models to detect malicious TDS activity based on topologic and threat-related features. We selected thresholds for each model based on precision to ensure the detection quality. The overall detector aggregate results from multiple models to achieve 93% precision with a 0.4% false positive rate.
Palo Alto Networks Next-Generation Firewall customers are better protected against malicious domains mentioned in this article and more emerging malicious TDS activity. This includes protection through our detector via Advanced DNS Security and Advanced URL Filtering subscription services.
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: 00080005045107
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
The following malicious or shady domains are referenced in this article:
This article examines obfuscation techniques used in popular malware families, and offers some insights into possible opportunities for automating unpacking of these malware samples.
We will examine these behaviors in samples we have observed, showing how to extract their configuration parameters through unpacking each stage. Performing this same process through automation would allow a sandbox performing static analysis to extract crucial malware configuration parameters from such samples.
Malware authors increasingly use advanced obfuscation techniques to evade sandbox detection, enabling widespread distribution. Static analysis is a process performed by sandboxes for examining samples, without directly executing them.
Adversaries use the following techniques to deliver popular malware families like Agent Tesla, XWorm and FormBook/XLoader:
Code virtualization
Staged payload delivery
Dynamic code loading to introduce new code at runtime
Advanced Encryption Standard (AES) encryption
Creating multi-stage payloads that are self-contained within the original sample
Palo Alto Networks customers are better protected from the threats discussed in this article through the following products or services:
Malware authors use obfuscation techniques to hinder sandboxes from using static analysis, increasing the possibility that a malicious file will evade detection. This allows adversaries to distribute malware samples more effectively at scale.
This article examines obfuscation techniques used to deliver malware families like Agent Tesla, XWorm and FormBook/XLoader.
The obfuscation techniques can be grouped by objective and technique, as shown in Table 1.
Objective
Techniques
Payload protection
AES cryptography
Code virtualization
Payload delivery
Staged payloads
Payload stored in the Portable Executable (PE) overlay
Dynamic code loading, deobfuscation and execution via .NET reflection
Table 1. Classification of obfuscation techniques
Let us explain these techniques in more detail:
AES cryptography: AES stands for Advanced Encryption Standard. This is a block cipher that uses the same symmetric key to encrypt plaintext or decrypt ciphertext. This is more secure than eXclusive OR (XOR) cryptography, which relies on a simple bitwise operation for lightweight obfuscation.
Code virtualization: Code virtualization is a software protection technique that works by transforming code into specialized instructions. These instructions are written in such a way that they can only be executed by the accompanying custom interpreter. To unravel the program, one has to first understand the internals of the interpreter implementation. This extra step adds another layer of complexity to the analysis.
Staged payloads: Staging is the practice of wrapping a core payload with multiple layers. Detonating several payloads in sequence, versus doing everything all at once, is an attempt by the attacker to evade detection. The malware sample could abort its infection chain partway through, if its initial payload fails or is detected, thus preventing exposure of its later stage payloads. As this design is modular, the malware author can also customize the combination of different payloads when creating the original malware sample.
Payloads stored in the PE overlay: The PE overlay describes extra bytes appended to a file that are not included in its metadata. Attackers often hide their payloads inside the PE overlay, because some static analysis tools skip processing this area. This practice can also be used by .NET malware, not just by standard PE files.
Dynamic code loading, deobfuscation and execution via .NET reflection: Reflection is a feature of certain programming languages, including the .NET Framework, to execute strings as code at runtime. Reflection allows the running malicious process to introduce new objects into the system or inspect and manipulate existing objects already in the system. Reflection can also be abused to bypass access security restrictions, as it can modify private attributes or invoke internal methods not typically accessible otherwise.
This article will discuss in greater detail the chain of obfuscation techniques shown in Figure 1.
Figure 1. Chain of obfuscation techniques. Attribution: This figure has been designed using resources from Flaticon.com.
A 2023 article by K7 Labs discusses a first-stage .NET downloader that seems to be an earlier variant of samples we have observed. It contacts a command-and-control (C2) server to download a second-stage KoiVM dropper, which delivers payloads like Agent Tesla and Remcos RAT.
In the cluster of malware samples we observed, there were updated features such as using AES encryption instead of XOR encryption. This cluster also had multi-stage payloads that were self-contained within the original malware sample distributed.
Technical Analysis
In the following sections, we will discuss the various stages of activity this multi-staged malware undergoes.
Stage 1: Encrypted Payload (in PE Overlay)
The samples we observed concealed their payload within the PE overlay. They also contained an ASCII string (gXQstjDplQeg), which we will refer to as a marker. This marker delimited the AES encryption parameters. This marker was referenced from the main .NET code itself, usually by the ldstr instruction. It was also present several times within the PE overlay.
AES encryption operating in cipher block chaining (CBC) mode uses a symmetric key and an initialization vector (IV) to encrypt plaintext into ciphertext (and vice versa for decryption), as shown in Figure 2.
Figure 2. AES encryption operating in CBC mode. Source: Wikipedia, public domain.
The PE overlay contains the Stage 2 payload ciphertext and another notable ciphertext: a sequence of strings delimited by dollar signs ($). The presence of the following strings indicate the malware can perform an Antimalware Scan Interface (AMSI) bypass:
AmsiInitialize
AmsiOpenSession
AmsiScanBuffer
Other tokens (such as the following) indicate dynamic .NET Framework code execution via reflection:
Assembly
Load
GetMethod
Invoke
Additionally, an arbitrary length \x00-character prefix and repeating string (PAPADDINGXX) suffix padding envelop the AES cryptographic material (key, IV and ciphertext). This padding helps evade signature-based defenses.
Table 2 shows the various parts of the file layout of the PE overlay.
<Padding: Sequence of \x00's>
<marker>
Key
<marker>
IV
<marker>
Ciphertext: Stage 2 payload
<marker>
Ciphertext: Token1$Token2$… (for reflection)
<marker>
…
<Padding: Sequence of PAPADDINGXX's>
Table 2. File layout of the PE overlay of a Stage 1 payload sample.
To recover the Stage 2 payload, we first extracted the marker from the .NET program code. Then, using the extracted marker as the delimiter, we split the PE overlay into parts, decrypting the ciphertexts using the provided key and initialization vector. One of these decrypted ciphertexts (often the largest) is the Stage 2 payload.
Stage 2: Virtualized Payload
After Stage 1, a more complex virtual machine (VM)-based obfuscation awaits in Stage 2. This second stage is meant to hide the final payload.
The VM we are referring to here is not the same as the kind which supports running multiple operating systems (OS) on a single host machine. The VM used here is KoiVM, a plugin for the ConfuserEx obfuscation tool.
VM-based obfuscation operates on the idea of a custom VM interpreter, which consists of a central dispatcher at its core. An input program is a list of virtual instructions written in a particular instruction set (called the intermediate language).
The dispatcher executes this program by routing to respective handlers, based on the current instruction. An instruction consists of commands (called opcodes), optionally with associated arguments, that are most often either passed by registers or on the stack. Program execution terminates when it reaches the VM-exit handler.
Figure 3 shows a diagram that gives an overview of how VM-based obfuscation works.
Figure 3. Architecture of VM-based obfuscation. Source: “LLVM-powered deobfuscation of virtualized binaries” by Thalium.
Standard disassemblers would not be able to easily analyze programs written this way, making it difficult for a malware analyst to decipher what the program is trying to accomplish. Furthermore, the malware author might have remapped the opcodes in this case, so that an off-the-shelf devirtualization tool like OldRod would fail.
For the samples we are examining, the VM program is actually just a dropper. A dropper is responsible for loading, decrypting and executing the final payload in memory. The decryption key is decoded from a Base64 string, while the ciphertext exists as an embedded resource in the Stage 2 payload.
One mitigation approach for this obfuscation uses the .NET Framework's ICorDebugManagedCallback Interface to create a debugger which hooks the following API functions:
Hooking is the act of placing breakpoints, which temporarily pauses program execution at certain points in time to extract values of interest.
After obtaining the ciphertext and decryption key this way, we can quickly recover the Stage 3 final payload.
Stage 3: Final Payload
As mentioned earlier, the final payload exists as an embedded AES-encrypted resource in the previous Stage 2 payload, which is decrypted in memory at runtime before execution. In the malware sample dataset we analyzed, the final payload belonged mainly to the Agent Tesla or XWorm family, except for one sample delivering shellcode identified as belonging to the FormBook/XLoader family.
While the Stage 3 payload code was no longer obfuscated, the XWorm samples' configuration parameters were encrypted using AES in Electronic Codebook (ECB) mode. The hard-coded AES key is stored in a variable named Mutex. Other variables besides Mutex can then be decrypted independently with this key, to restore the original set of malware configuration parameter values, especially the remote C2 endpoint.
Conclusion
Malware authors commonly use obfuscation techniques like encryption and code virtualization to hide their malicious intent. This allows them to evade security mechanisms and sandbox detection.
The cluster of malware samples we have highlighted uses staged payloads encrypted with strong AES cryptography at each layer. This fileless malware is loaded, decrypted and executed in memory via reflection.
Because these advanced techniques are among the toughest to overcome, we hope to make more people aware of this issue. We would like to see more researchers put effort and resources into finding a principled way to defeat code virtualization protection schemes.
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 IoCs shared in this research.
Prevent the execution of known malicious malware, and also prevent the execution of unknown malware using Behavioral Threat Protection and machine learning based on the Local Analysis module.
Protect against credential gathering tools and techniques using the new Credential Gathering Protection available from Cortex XDR 3.4.
Protect from threat actors dropping and executing commands from web shells using Anti-Webshell Protection, newly released in Cortex XDR 3.4.
Protect against exploitation of different vulnerabilities including ProxyShell and ProxyLogon using the Anti-Exploitation modules as well as Behavioral Threat Protection.
Detect post-exploit activity, including credential-based attacks, with behavioral analytics, through Cortex XDR Pro.
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: 00080005045107
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.
Unit 42 researchers have observed phishing activity that we track as TGR-UNK-0011. We assess with high confidence that this cluster overlaps with the threat actor group JavaGhost. The threat actor group JavaGhost has been active for over five years and continues to target cloud environments to send out phishing campaigns to unsuspecting targets.
According to website defacement lists such as DefacerID, the group focused historically on defacing websites. However, according to our telemetry, in 2022, they pivoted to sending out phishing emails for financial gain.
Between 2022-24, Unit 42 has performed multiple investigations relating to the group JavaGhost, which targeted organizations’ AWS environments. The group focuses on sending phishing campaigns and has not been seen stealing data for extortion during their time in organizations’ AWS environments.
These attacks are not due to a vulnerability in AWS. This group takes advantage of misconfigurations in the victim organizations' environments that expose AWS credentials in the form of long-term access keys. They use these leaked keys to initiate all the actions discussed in this report.
This article covers common methodologies that JavaGhost uses to create their phishing infrastructure. We also cover other tactics employed within compromised cloud environments to establish long-term persistence.
We have recently observed JavaGhost using advanced evasion methods to cover their tracks. These methods have typically only been used by Scattered Spider, which shows the level of sophistication of this threat actor group.
All JavaGhost activities have resulted in a detectable logging footprint, which forms the basis of the alerts at the end of the article.
Historically, JavaGhost participated in the website defacement of numerous entities, starting in 2019. Figure 1 shows some of the websites the group defaced.
Figure 1. Websites defaced by JavaGhost. Source: DefacerID.
The JavaGhost group also had two websites (shown in Figures 2 and 3). One contains the group’s slogan, “we are there but not visible.” The other contains text in Indonesian that translates to “stop blaming everything,” which matches with the language used to name some of the resources in their attacks. The site also lists the various group member handles (shown in Figure 3).
Based on our investigations, the group shifted in 2022 from website defacement to sending out phishing campaigns to unsuspecting targets. Datadog reported on this activity shift back in 2023, but the group continues their work, which Unit 42 has seen as recently as December 2024.
Attack Overview
Unit 42 has handled numerous cases in 2022-24 associated with JavaGhost. The attack leveraged overly permissive IAM permissions allowing the victim’s Amazon Simple Email Service (SES) and WorkMail services to send out phishing messages. JavaGhost benefits from using other organizations’ AWS environments because they do not have to pay for any of the created resources. They can also use preexisting SES infrastructure to send out phishing emails.
Using preexisting SES infrastructure allows the threat actor’s phishing emails to bypass email protections since the emails originate from a known entity from which the target organization has previously received emails.
Initial Access with Defense Evasion
Between 2022-24, the group evolved their tactics to more advanced defense evasion techniques that attempt to obfuscate identities in the CloudTrail logs. This tactic has historically been exploited by Scattered Spider. AWS CloudTrail records all management events occurring within an AWS account.
JavaGhost obtained exposed long-term access keys associated with identity and access management (IAM) users that allowed them to gain initial access to an AWS environment via the command-line interface (CLI). These long-term access keys come from various exposures, as discussed in a prior Unit 42 research article.
Upon entry to an organization’s AWS environment with the compromised access key, the threat actors do not perform the application programming interface (API) call GetCallerIdentity. Other threat actors often use GetCallerIdentity as their first API call after compromising AWS credentials to enumerate basic information about the compromised account, such as the account ID and user ID.
Because defenders frequently anticipate attackers using GetCallerIdentity during initial compromise, JavaGhost evades detection by not using this API call, thereby bypassing any alerts configured to trigger on its execution. Instead, the group performs different first API calls such as GetServiceQuota, GetSendQuota and GetAccount for their initial interaction with a compromised AWS account.
GetServiceQuota returns the current quota limit for a specified AWS service while GetSendQuota returns the max number of emails that can be sent in 24 hours for SES. GetAccount returns information about the email-sending status of SES and other SES attributes.
After confirming their access to an organization's AWS account with the long-term access key from the CLI, the threat actors behind JavaGhost generate temporary credentials and a login URL to allow themselves console access. Accessing the console via this methodology obfuscates their identity and allows them easier visibility into the resources within an AWS account.
Since attackers rarely create temporary credentials to access the AWS console URL, these methods often bypass detection. The following section details these techniques, emphasizing how using the console allows attackers to sidestep the restrictions IAM imposes on temporary access keys generated through the CLI.
GetFederationToken and GetSigninToken
Generating an AWS console login page from long-term access keys takes multiple steps but the entire process can be scripted. NetSPI has created a GitHub repo with an example of how to perform this process and AWS has instructions as well.
The first step in this process requires the creation of temporary credentials from the compromised long-term access key. Long-term access keys start with the four letters AKIA, while temporary access keys begin with ASIA.
To acquire temporary AWS credentials, JavaGhost uses the GetFederationToken API within the AWS Security Token Service (STS). This API call requires the following parameters:
A name for the federated user
An inline or managed session policy defining the desired permissions (as illustrated in Figure 4). JavaGhost purposefully utilizes an “allow all” inline policy to take advantage of the maximum permissions allowed to the underlying IAM user.
The duration for which the temporary credentials should be valid (specified in seconds)
Figure 4. Example of an inline policy from the GetFederationToken event.
While the AssumeRole API call can also retrieve temporary credentials for this process, JavaGhost opts to use the GetFederationToken option instead. Of note, the inline policy provided in the request does not override the permissions associated with the long-term access key.
The permissions granted to the short-term access key result in an intersection of the IAM user permissions associated with the access key and the policies included in the GetFederationToken request. If the GetFederationToken permissions contain broader privileges than the IAM user, then the more limited permissions from the IAM user take effect. Therefore, the provided policy can only reduce and never increase the permissions already granted to the principal represented by the compromised access key and secret key.
Once the GetFederationToken request returns the temporary credentials (i.e., sessionId, sessionKey and sessionToken), an encoded URL is required before generating the sign-in token. To generate the encoded URL, the threat actor uses the Python urllib3 library.
Once the encoded URL is obtained, a GetSigninToken request returns the information needed to create the URL that allows federated users to access the AWS console. Within the CloudTrail logs associated with the GetSigninToken events, the user agent shows Python-urllib/3.10, which is how Unit 42 inferred the Python library used by JavaGhost to perform these operations.
The generated URL grants access to the console for a default of 15 minutes, which is what the threat actor chose to do. After that, a threat actor must repeat this process to generate a new URL or specify a longer session duration during the GetSigninToken request. The temporary access key generated by the GetFederationToken actions does not need to be regenerated unless the session duration has expired.
To revoke the session associated with the compromised credentials, an IAM policy has to be attached directly to the user. The process discussed above does not require the usage of any roles, so there is no built-in way to revoke the session like AWS provides with an IAM role.
To stop an active threat actor using this console access method, attaching the AWS managed AWSDenyAll policy invalidates all the permissions for the user. It does not stop an active session in the console, but all attempted actions are blocked.
Setting Up the Phishing Infrastructure
Regarding the SES logging configuration, none of the customer AWS environments from our engagements had SES data events enabled. Therefore, the following analysis focuses solely on CloudTrail Management Events.
JavaGhost uses SES and WorkMail to configure their phishing infrastructure. The group starts by creating various SES email identities, followed by updating DomainKeys Identified Mail (DKIM) settings. DKIM uses public key cryptography to verify the authenticity of emails.
To send emails, an SES email or domain identity must exist. The creation of new SES identities appears as CreateEmailIdentityevents in the CloudTrail logs and the response elements provide additional details around whether the identity type was a domain or an email address.
JavaGhost creates multiple email and domain identities as well as modifying the following attributes. The DKIM settings are configured during the user creation and generate the PutEmailIdentityDkimAttributes event in CloudTrail logs.
While DKIM settings can be configured separately from the identity creation process, this group usually updates them during the identity creation itself. The attackers also update the custom Mail-From domain configuration for the email identities. This resulted in the PutEmailIdentityMailFromAttributes event showing the attribute update in the request parameters field within the CloudTrail logs.
The group makes various changes to the SES Virtual Delivery Manager (VDM) feature, which also results in the PutAccountVdmAttributes event appearing in the CloudTrail logs.
In addition to setting up various email identities, JavaGhost configures an AWS WorkMail Organization and adds WorkMail users. Creating a WorkMail Organization results in numerous SES and AWS Directory Service (DS) events within the CloudTrail logs.
Upon the creation of the WorkMail Organization seen as CreateOrganization in the CloudTrail logs, the following events appear in the CloudTrail logs associated with SES:
In the console, within the advanced configuration of the WorkMail Organization creation, user directories can either be created from scratch or an existing directory can be used (shown in Figure 5).
Figure 5. Selecting Create Amazon WorkMail directory generates three Directory Services events automatically in the CloudTrail logs.
Selecting the creation of a new WorkMail directory automatically generates the following DS CloudTrail events:
After completing the WorkMail Organization creation, the threat actors create various WorkMail users. Creating a WorkMail user generates a CreateUser event (with workmail.amazonaws[.]com as the event source) and the user automatically gets registered to WorkMail with the event RegisterToWorkMail appearing in the CloudTrail logs. The WorkMail registration requires no input from the user when performed through the console.
Figure 6 shows how to create a new WorkMail user.
Figure 6. Creating a new WorkMail user.
Before sending out the phishing emails, JavaGhosts creates new SMTP credentials. When creating the new SMTP credentials, the threat actors do not change the default username so all the new SMTP usernames start with ses-smtp-user.* Figure 7 shows an example of this.
Figure 7. Creation of default named SMTP user with default IAM group and permissions.
Creating new SMTP credentials results in the generation of a new IAM user with the user’s name matching the SMTP username and not the SMTP display name. If the AWS account has not used SES historically, the SMTP creator is prompted that a new IAM user group will be created.
This new IAM user group is called AWSSESSendingGroupDoNotRename by default, which also attaches an inline policy to the group allowing ses:SendRawEmail only. These operations appear as CreateGroup and PutGroupPolicy in the CloudTrail logs.
If the AWS account has used SMTP credentials historically, the IAM group will most likely already exist and appear in the Permissions list. Figure 8 shows an example of this.
Figure 8. IAM group details once IAM group already exists.
After finishing user creation, the system displays the new IAM username, along with the SMTP username and SMTP password.
The SMTP username displays an access key ID. When reviewing the user in IAM, the SMTP username appears as an access key there as well. Figure 9 shows an example of this.
Figure 9. Example retrieval of SMTP credentials.
The SMTP username still resolves to the AWS account ID if decrypted. All these events appear in the CloudTrail logs as IAM CreateUser, CreateAccessKey and AddUserToGroup events.
When organizations already have SES infrastructure in their AWS environment, JavaGhost uses the preexisting resources to send phishing attacks. Unless dataplane logging is enabled, there are few to no events to review in the CloudTrail logs. The cost for the additional emails sent will appear in the Cost and Usage Reports, but otherwise, only various reconnaissance events result in CloudTrail logs.
Identity and Access Management (IAM)
Throughout the time frame of the attacks, JavaGhost creates various IAM users, some they use during their attacks and others that they never use. The unused IAM users seem to serve as long-term persistence mechanisms.
After their creation, the threat actor only confirms access via console logins and performs no other actions. The IAM users have a variety of names. Some are meant to blend in with other IAM users that would be typical within an AWS account and others are more obviously named. The IoC section provides a full list of IAM usernames.
All the new IAM users have the AWS managed AdministratorAccess policy attached as well as access to the console. The AdministratorAccess policy allows any action against any resource within an AWS account.
Figure 10 shows the permissions associated with this policy. All of these IAM events appear in the CloudTrail logs as CreateUser, AttachUserPolicy and CreateLoginProfile.
The creation of IAM users is a common cloud technique commonly seen within many of our other investigations. JavaGhost sets themselves apart by evolving to use unique methods to access an AWS account.
In the initial attacks, this group used the original compromised access key for most of their activity. In 2024, they transitioned to using an IAM role to access the organization’s AWS account from a threat actor-compromised AWS account before proceeding with the attack.
To accomplish this, the threat actors created a new IAM role with a trust policy attached, allowing access from a threat actor-controlled AWS account. A trust policy specifies what entities can assume the role.
This role creation appears in the CloudTrail logs as CreateRole with the trust policy written in the request parameters field. Figure 11 shows an example of a trust policy.
Figure 11. Example of an inline trust policy from the CreateRole CloudTrail event.
In the case of JavaGhost, the trusted entity belongs to an AWS account. The new role also has unlimited permissions within the environment, with the attachment of the AdministratorAccess policy as seen by the CloudTrail event AttachRolePolicy.
With the successful creation of the new administrative role, the threat actor can log into the AWS account from the trusted threat actor-owned AWS account. When the threat actor assumes their role that they created to access the compromised AWS account, CloudTrail records this event as two separate events, AssumeRole and SwitchRole, which occur simultaneously. Unlike the creation of new IAM users, the role creation does not appear suspicious until the trust policy reveals the external access and the role is uncovered as a backdoor.
Security Group
The group continues to leave the same calling card in the middle of their attack by creating new Amazon Elastic Cloud Compute (EC2) security groups named Java_Ghost, with the group description “We Are There But Not Visible.” These security groups do not contain any security rules and the group typically makes no attempt to attach these security groups to any resources. The creation of the security groups appear in the CloudTrail logs in the CreateSecurityGroup events.
This group description matches the group’s slogan on their old website, shown in Figure 12.
In addition to the main components of its phishing attacks, the group attempts two other unique tactics within attacks:
The group attempts to leave an Organization Unit with the event LeaveOrganization. AWS Organizations help with the management of multiple AWS accounts. They consist of features such as Service Control Policies (SCPs), which help manage IAM permissions at scale, and Organizational Units.
Organization Units help administrators manage multiple AWS accounts by grouping them together, and they allow for the application of SCPs at the Organization Unit level. Leaving an AWS Organization Unit removes any SCPs that apply to the AWS account and changes the security guardrails that limit activities within an AWS account.
The group enables all AWS regions not enabled by default.
After March 20, 2019, AWS no longer enables new regions by default and JavaGhost enables those 13 disabled regions as part of their attacks to evade security controls. Enabling regions results in the EnableRegion event in the CloudTrail logs with the region name present in the request parameters field.
Conclusion
Unit 42 has investigated multiple JavaGhost cases over the past few years and has observed the group continuously evolving its tactics. Initially, JavaGhost performed attacks using only a compromised access key, but has now advanced to employing sophisticated evasion techniques. Luckily, all of the group’s activity results in detectable events within the CloudTrail logs that organizations can hunt for and create new alerts to detect.
Palo Alto Networks Protection and Mitigation
Palo Alto Networks customers are better protected from the threats discussed above through the following products:
IAM actions such as new user creations, attaching of AdministratorAccess Policy, getfederatedtoken, and getsignintoken
Suspicious sending of emails through Simple Email Service (SES)
Use of getgroup and putgroup in CloudTrail
XSIAM also detects behavioral actions from cloud and on-premises endpoints that suggest the collection of AWS IAM credentials.
To mitigate opportunities for attackers to use techniques discussed above, we recommend:
Limiting access to administrative rights
Rotating IAM credentials regularly
Using short term/just-in-time (JIT) access tokens
Enabling multi-factor authentication (MFA)
Cloud security posture management (CSPM) capabilities in Cortex Cloud can assist users with creating appropriate rules.
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: 00080005045107
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.
Hunting, Investigation and Detection Queries
The following queries are intended to assist Palo Alto Networks customers in hunting, investigating and detecting potentially malicious operations within their Cortex XDR. The results of these queries should not be taken as malicious on face value. The queries require careful examination of the resulting events before they can be found malicious.
This article reviews a cluster of malicious activity that we identify as CL-STA-0049. Since at least March 2023, a suspected Chinese threat actor has targeted governments, defense, telecommunication, education and aviation sectors in Southeast Asia and South America.
The observed activity includes collecting sensitive information from compromised organizations, as well as obtaining information about high-ranking officials and individuals at those organizations.
During our investigation, we were able to shed new light on the attacker’s tactics, techniques and procedures (TTPs), including the attack flow, entry vector via web shells and covert communication channels.
The threat actor behind this activity cluster used a recently discovered sophisticated backdoor we named Squidoor (aka FinalDraft), which targets both Windows and Linux systems. This article reveals a new Windows variant of Squidoor, and provides a deeper understanding of Squidoor's command and control server (C2) communication than has been previously described.
Squidoor is an advanced backdoor that supports multiple modules, designed for stealth. It features a rarely seen set of capabilities, including using multiple protocols to communicate with the C2 such as the following:
Outlook API
Domain Name System (DNS) tunneling
Internet Control Message Protocol (ICMP) tunneling
Based on our analysis of the TTPs, we assess with moderate-high confidence that this activity originates in China.
Our objective in sharing this analysis is to equip cybersecurity professionals in these high-risk sectors with effective detection and mitigation strategies against these advanced threats.
Palo Alto Networks customers are better protected from the threats discussed in this article through the following products and services:
Initial Access to Networks: Deploying Multiple Web Shells
To gain access to networks, the threat actor behind CL-STA-0049 primarily attempted to exploit various vulnerabilities in Internet Information Services (IIS) servers. They followed this initial compromise with the deployment of multiple web shells on infected servers. These web shells served as persistent backdoors, allowing the threat actor to maintain access and execute commands on compromised systems.
Our research identified four primary web shells used in the attack:
OutlookDC.aspx
Error.aspx (1)
Error.aspx (2)
TimeoutAPI.aspx
The deployed web shells exhibited significant similarities, indicating a common origin. The shared characteristics include the following:
Embedded decryption keys of the same length (and sometimes shared among different samples)
Extensive obfuscation using junk code (shown in Figure 1 below)
Consistent string patterns and code structures
Figure 1 shows a code snippet of one of the web shells.
Figure 1. Code snippet of a web shell used in the attack.
The threat actor stored some of the web shells on bashupload[.]com and downloaded and decoded them using certutil, as shown in the command-line string in Figure 2. Bashupload is a web application that enables users to upload files using the command line and download them to another server.
Figure 2. Certutil is used to retrieve web shells from bashupload.
Lateral Movement Within Compromised Endpoints: Spreading Web Shells
We observed that the threat actor attempted to spread the web shells across different servers. To do that, it used curl and Impacket, as shown in Figure 3 below. The threat actor also tried to conceal one of the web shells as a certificate and copy it to other servers using Windows Management Instrumentation (WMI).
Figure 3. Cortex alert data showing attempts to download and copy web shells to remote machines.
Squidoor: A Modular Stealthy Backdoor
We call the main backdoor the attackers used Squidoor. (Elastic Security Labs recently published similar research on this activity cluster, referring to the backdoor as FinalDraft.) Squidoor is a sophisticated backdoor that was built for stealth, allowing it to operate in highly monitored and secured networks.
The threat actors primarily used this backdoor to:
Maintain access
Move laterally
Create stealthy communication channels with its operators
Collect sensitive information about the targeted organizations
During our investigation, we discovered that Squidoor was in fact multi-platform malware, with versions for both Windows and Linux operating systems.
Squidoor offers a range of different protocols and methods operators can use to configure the malware to communicate with its C2 server. The Windows version of Squidoor grants the attackers 10 different methods for C2 communication, and the Linux version allows nine.
Some communication methods are meant for external communication with the C2, while other methods are for internal communication between Squidoor implants within a compromised network. This variety of communication methods enables the attackers to adjust to different scenarios and stay under the radar.
Squidoor can receive the following commands:
Collect information about the infected machine
Execute arbitrary commands
Inject payloads into selected processes
Deliver additional payloads
Figure 4 shows a diagram of the communication paths in a network infected with Squidoor, illustrating how threat operators configured most of the implants to only communicate internally to remain undetected.
Figure 4. Example of communication paths for implants in a network infected with Squidoor.
Using a Rarely Observed LOLBAS Technique: Cdb.exe
To execute Squidoor, the threat actor abused the Microsoft Console Debugger binary named cdb.exe. Attackers delivered cdb.exe to the infected environments, saved it to disk as C:\ProgramData\fontdrvhost.exe and used it to load and execute shellcode in memory. While using cdb.exe is a known living-off-the-land-binaries-and-scripts (LOLBAS) technique, its use is quite rare and has only been reported a handful of times.
Upon execution, cdb.exe (renamed by the attacker to fontdrvhost.exe) loaded the shellcode from a file named config.ini.
After the first execution, we observed the attackers using one of Squidoor’s payloads (LoadShellcode.x64.dll, loaded into mspaint.exe) to load and decrypt another Squidoor implant from a file on disk named wmsetup.log. Figure 5 illustrates these two flows of execution.
Figure 5. The execution flow of loading Squidoor.
Squidoor’s persistence was achieved using a scheduled task named Microsoft\Windows\AppID\EPolicyManager. This task executed the shellcode. Figure 6 shows the command to create the scheduled task to keep Squidoor persistent.
Figure 6. Command to create a scheduled task to maintain Squidoor persistence on an affected Windows host.
Squidoor Execution Flow
Once Squidoor was loaded into memory, it executed its exported function named UpdateTask. Squidoor’s execution flow begins with decrypting its hard-coded configuration.
The configuration of Squidoor contains a single digit (0-9) corresponding to a switch case that determines which communication method it will use. There are other configuration fields that might not be used, depending on the variant of the malware. These fields include values needed for the communication with the C2 server, which will vary depending on which communication method it uses.
These values can include the following:
Domains
IP addresses
Listening ports
Encryption key
Access token
Communication Methods
The Windows version of Squidoor supports 10 different methods for C2 communication. Table 1 breaks out these 10 different methods based on their corresponding switch case digits.
Switch Case Digit
Internal Class Name
Description
0
CHttpTransChannel
HTTP-based communication
1
CReverseTcpTransChannel
Reverse TCP connection to a remote server
2
CReverseUdpTransChannel
Reverse UDP connection to a remote server
3
CBindTcpTransChannel
Listen for incoming TCP connections (suspected to be used for only internal communication)
4
CBindHttpTransChannel
Listen for incoming HTTP connections (become an HTTP Server)
5
COutLookTransChannel
Communicate via an Outlook mail API
6
CIcmpTransChannel
Utilize ICMP tunneling for communication
7
CDnsTransChannel
Utilize DNS tunneling for communication
8
CWebTransChannel
Communicate via a mail client retrieved from the configuration file
9
CBindSMBTransChannel
Use named pipes for communication (only internal communication, and only on the Windows version)
Table 1. Switch-case values for Squidoor C2 communication methods.
These communication methods have distinct names in the malware’s code, as shown in Figure 7.
Figure 7. Code snippets of Squidoor’s communication methods grouped by switch case.
Outlook Transport Channel Analysis
This section examines the Outlook mail client communication method. Figure 8 shows the flow of this method.
Figure 8. Flow of the communication mechanism via Outlook API for Squidoor.
When executed with the COutLookTransChannel configuration, Squidoor will first log in to the Microsoft identity platform using a hard-coded refresh token as shown in Figure 9. The Microsoft Graph API token is stored in the following registry keys, based on the user’s privileges:
Figure 9. HTTP POST request by Squidoor for logging in to the Microsoft identity platform.
Next, Squidoor sends an HTTP GET request to a specific Pastebin page that is hard coded in its configuration. The Pastebin page is named Local365, and only contains the number 1. We suspect the attackers monitor these GET requests to Pastebin as a method to track how many implants have connected via the Outlook API.
Next, Squidoor uses the Outlook REST API to query the drafts folder, searching for mails with a subject containing the string p_{random_generated_number}. If it finds no such mail, Squidoor will send an email to the attackers with the aforementioned generated string as the subject, including a Base64-encoded random sequence of bytes in the content. Figure 10 shows an HTTP POST request of this C2 traffic.
Figure 10. HTTP POST request for an email uploaded to the attackers’ Outlook account by Squidoor.
The attackers use the {random_generated_number} identifier to differentiate between different Squidoor implants that query commands from the same Outlook mail inbox.
After sending the initial beacon, Squidoor starts to query the email account for commands. To do so, it queries the drafts folder for mails containing the string r_{random_generated_number} in the subject with a preceding r instead of p with the same generated number value as before. Figure 11 shows an example of such a query sent by Squidoor.
Figure 11. A query Squidoor uses to retrieve emails containing commands to execute.
If such an email exists, Squidoor will retrieve its contents and delete it from the attacker's mailbox. Next, the contents of the retrieved message go through several stages of deobfuscation and decoding. This mechanism allows the malware to receive commands or additional malicious code from its C2 server disguised as innocent-looking Outlook network traffic.
Decoding the Email Content
The decoding mechanism of the content of the mails is as follows:
Transform the email to bytes by using the CryptStringToBinaryA WinAPI
Decode from Base64 encoding
Decode the content via a combination of AES and a custom XOR decryption algorithm
The decompressed content tells Squidoor which command it should execute, along with any additional relevant data for execution, such as additional payloads or file paths.
Squidoor’s Main Capabilities
Squidoor has a list of commands it can receive from the C2 server, which grants the attacker a variety of different capabilities to gain full control over the infected machine. These capabilities include:
Host reconnaissance and fingerprinting, including:
Username and privileges
Hostname
IP address
Operating system (OS) type
Executing arbitrary commands
Querying files and directories
Querying running processes
Exfiltrating files
Deploying additional malware
Injecting payloads into additional processes
Sending commands to other Squidoor implants via TCP
Sending commands to other Squidoor implants via named pipes (Windows variant only)
On the Windows version, depending on the command the attackers sent, Squidoor will determine which process it will use for injection. The two options available for the attacker are:
Attempting to inject code into mspaint.exe
If mspaint.exe does not exist in system32 (as is the case in Windows 11), it injects conhost.exe instead
Performing an injection into an already running process on the system determined by a process ID (PID) selected by the attacker
Modular Backdoor
During our investigation, we observed Squidoor executing additional modules that it injected into other Windows OS processes, such as the following:
mspaint.exe
conhost.exe
taskhostw.exe
vmtoolsd.exe
Figure 12 shows how, in one instance, the threat actor delivered payloads (modules) that they injected into multiple instances of mspaint.exe. The threat actor used these injected modules to move laterally using Windows Remote Management (WinRM), steal data and execute commands on remote endpoints. The modules require a password as an argument to run, to evade dynamic analysis and sandboxes.
The observed passwords included:
t0K1p092
PeN17PFS50
sElf98RqkF
Aslire597
Figure 12. Squidoor injects multiple payloads into different mspaint.exe instances.
The mspaint.exe injected payloads were not written to the disk and were executed in system memory. From the behavioral pattern, these payloads appear to support a number of command-line arguments to perform multiple actions such as the following:
Uploading or deleting files remotely
Executing PowerShell scripts without invoking the powershell.exe binary
As we previously mentioned, on some of its communication modes, Squidoor will send an HTTP GET request to Pastebin.
We found two Pastebin accounts operated by the attackers and the aliases they created for themselves.
One of the accounts has been operational for almost a year, with the attacker adding new content occasionally.
The threat actor apparently used these Pastebin accounts to store components related to the different communication methods of the malware such as access tokens and API keys as shown in Figure 13 below.
Figure 13. Example of a Pastebin account controlled by the attackers.
At the beginning of February 2025, the attackers deleted all the files shown in Figure 13 above, and added several new ones, shown in Figure 14. Those files contain different Microsoft Graph API tokens and the titles suggest different target names.
Figure 14. Updated Pastebin page controlled by the attackers.
In addition, we suspect attackers used these accounts to track the number of Squidoor implants executed around the world, by tracing the number of implants that queried Pastebin.
Conclusion
The threat actor behind the CL-STA-0049 cluster of activity has attacked high-value targets in South America and Southeast Asia. The primary objective appears to be gaining a foothold and obtaining sensitive information from their targets. We assess with moderate-high confidence that this threat actor is of Chinese origin.
Squidoor, the main backdoor used in this operation, is engineered for an enhanced level of stealth and offers 10 distinct methods for covert C2 communication. This versatility has allowed the attackers to adapt to various scenarios and minimize suspicious network traffic emanating from compromised environments.
Squidoor's multi-platform implementations, with tailored versions for both Windows and Linux operating systems, expand its reach and attack surface. This adaptability enables the malware to infiltrate diverse network ecosystems, potentially compromising a broader range of targets and complicating detection and mitigation efforts across heterogeneous infrastructures.
We encourage security practitioners and defenders to study this report and use the information provided to enhance current detection, prevention and hunting practices to strengthen their security posture.
Protections and Mitigations
For Palo Alto Networks customers, our products and services provide the following coverage associated with this activity cluster:
The Advanced WildFire machine-learning models and analysis techniques have been reviewed and updated in light of the IoCs shared in this research.
Next-Generation Firewall with the Advanced Threat Prevention security subscription can help block the attacks with best practices. Advanced Threat Prevention has inbuilt machine learning-based detection that can detect exploits in real time.
Prevent the execution of known malicious malware and also prevent the execution of unknown malware using Behavioral Threat Protection and machine learning based on the Local Analysis module.
Protect against exploitation of different vulnerabilities using the Anti-Exploitation modules as well as Behavioral Threat Protection.
Detect user and credential-based threats by analyzing anomalous user activity from multiple data sources.
Protect from threat actors dropping and executing commands from web shells using Anti-Webshell Protection.
If you think you might have been impacted 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: 00080005045107
Palo Alto Networks has shared these findings, including file samples and indicators of compromise, 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 hash for Squidoor - Windows version (config.ini)
Malware targeting macOS systems is increasingly pervasive in our current threat landscape. Most of the associated threats are cybercrime-related, ranging from information stealers to cryptocurrency mining. Over the past year, we have witnessed an increase in cybercrime activity linked to North Korean nation-state APT groups.
In line with the public service announcement issued by the FBI regarding North Korean social engineering attacks, we have also witnessed several such social engineering attempts, targeting job-seeking software developers in the cryptocurrency sector.
In this campaign, we discovered a Rust-based macOS malware nicknamed RustDoor masquerading as a legitimate software update, as well as a previously undocumented macOS variant of a malware family known as Koi Stealer. During our investigation, we observed rare evasion techniques, namely, manipulating components of macOS to remain under the radar.
The characteristics of these attackers are similar to various reports during the past year of North Korean threat actors targeting other job seekers. We assess with a moderate level of confidence that this attack was carried out on behalf of the North Korean regime.
This article details the activity of attackers within compromised environments. It also provides a technical analysis of the newly discovered Koi Stealer macOS variant and depicts the different stages of the attack through the lens of Cortex XDR.
Palo Alto Networks customers are better protected against the RustDoor and Koi Stealer malware presented in this research through the following products and services:
This campaign’s infection vector bears similarities to previous research.
We have tracked activity from suspected North Korean threat actors in a campaign we track as CL-STA-240 and call Contagious Interview. In this campaign, attackers pose as recruiters or prospective employers and ask potential victims to install malware masquerading as legitimate development software as part of the vetting process. These attacks generally target job seekers in the tech industry and likely occur through email, messaging platforms or other online interview methods. While our research into this current activity reveals similarities with Contagious Interview, we did observe distinct tactics, techniques and procedures (TTPs) that cause us to consider this a separate campaign.
Recent research from Jamf Threat Labs describes a similar attack method, this time using a malicious Visual Studio project challenge named “SlackToCSV” to target job-seeking software developers.
In our research, we found forensic evidence of a similar malicious Visual Studio project in addition to other malicious projects. Moreover, one of the samples of the RustBucket malware named .zsh_env had the same hash as the ThiefBucket sample noted by Jamf Threat Labs. However, we found different command and control (C2) servers for other samples we encountered during our research.
Execution and Download of Malware
When examining attacker activity on the infected endpoints, we noticed their persistent nature, as attackers attempted to execute several different malware variants. When these attempts were prevented by Cortex XDR, the attackers tried redeploying and executing additional malware to evade detection. Analyzing one of these attacks, we can divide it into three distinct stages:
Attempting to execute two RustDoor variants
Trying an additional RustDoor variant and attempting a reverse shell
Running a previously undocumented macOS Koi Stealer variant
We describe these phases in the following sections, starting with the initial attempt to execute two RustDoor variants.
Attempting to Execute Two RustDoor Binaries
Initially, when executing the fake job interview project within Visual Studio, the malicious code attempts to download and execute two separate Mach-O binaries of RustDoor. Figure 1 shows the names and locations of these Mach-O files from a Cortex XDR alert blocking the activity.
The paths of the RustDoor files are:
/Users/$USER$/.zsh_env
/Users/$USER$/Library/VisualStudioHelper
Figure 1. RustDoor malware locations from the Cortex XDR alert blocking the activity.
An Additional RustDoor Binary and Attempting to Open a Reverse Shell
After the first two RustDoor binaries’ executions were prevented, the attackers executed another sample of RustDoor. The malware then attempted to steal sensitive data such as passwords from the LastPass Google Chrome extension, exfiltrate data to its C2 server and download two additional bash scripts. These bash scripts are intended to open a reverse shell connection with the attackers.
Figure 2 shows the different commands executed by this RustDoor binary.
Figure 2. The execution and commands of the second RustDoor binary.
Table 1 shows the different command lines from Figure 2 and their respective descriptions.
Reverse shell script No. 2 and grant execution permissions
zsh -c mdfind -name .pem
Searching for public keys
Table 1. The command lines executed by RustDoor and their description.
Figure 3 shows a Cortex XDR alert blocking attempts at reverse shell execution by both shell scripts to a C2 server at 31.41.244[.]92 over TCP port 443.
Figure 3. The two reverse shell execution attempts to 31.41.244[.]92 prevented by Cortex XDR.
The IP address (31.41.244[.]92) the reverse shell connection attempt was initiated from has a history of malicious use since at least 2022, and it was previously associated with RedLine Stealer.
Executing a Previously Undocumented macOS Koi Stealer Variant
The attackers downloaded and executed a final payload that we have identified as a previously undocumented variant of Koi Stealer malware. This Koi Stealer sample masqueraded as a VisualStudio update, which prompted the user to install it and grant it Administrator access.
Figure 4 shows the execution process as detected in Cortex XDR.
Figure 4. macOS Koi Stealer variant download as detected by Cortex XDR.
The different command lines from Figure 2 and their respective descriptions are detailed below in Table 2, excluding commands similar to those described in Table 1.
Command Line
Description
sh -c tccutil reset AppleEvents
Reset permissions for Apple Events
sh -c ps aux
List running processes
sh -c system_profiler SPHardwareDataType
Retrieve detailed information about the device’s hardware
sh -c osascript<<EOD
display dialog "Visual Studio requires permission to install update.
Please enter password for [redacted]:" default answer "" with title "Visual Studio" with icon POSIX file "/Users/$USER$/vs.png" with hidden answer
EOD
Display a window with a password prompt
sh -c sw_vers
Retrieve the macOS software version
Table 2. The command lines executed by Koi Stealer and their description.
Technical Analysis of the macOS Koi Stealer Variant
The Koi Stealer malware is an infostealer that retrieves sensitive data from compromised devices in two phases and sends it back to the C2 server. Similar to the features of the latest Windows variant, the macOS variant is heavily focused on stealing different cryptocurrency wallets. The full list can be found in Appendix C.
The section below details key features of the Koi Stealer macOS malware and compares the sample's macOS functionality with its Windows counterpart.
Main Capabilities
Data Collection and Exfiltration
Stage 1
Initially, Koi Stealer collects reconnaissance information from the infected machine, such as the hardware Universally Unique Identifier (UUID) and information about the current user.
Since this Koi Stealer impersonates Visual Studio, potential victims may be less suspicious when the app requests a root password as shown below in Figure 5. The RustDoor variant operates in a similar way.
Figure 5. macOS Koi Stealer variant pop-up asking for the root password.
This pop-up asking for the root password remains until the user enters the correct password. After retrieving the user’s password and UUID, the malware decodes the C2 URL and forwards these three pieces of information to its main function.
Figure 6 displays decompiled code from the malware. The instructions show these three functions and the URL for sending the stolen data to the malware's C2 server.
Figure 6. Decompiled code from the macOS Koi Stealer variant showing initial activity.
The main function begins by generating two random keys, which the malware uses later to encrypt the data that it will send to the C2 server. The malware then proceeds to build an initial HTTP request that exfiltrates the following information:
The current user’s username and password
Hostname
Build information
Hardware details
Process list
Installed applications
Stage 2
After the first stage is complete, the malware moves to its second stage of data gathering and exfiltration. During this phase, it copies multiple files of interest from the infected machine, including:
This malware uses AppleScript to mute the system’s volume. It might do this to conceal subsequent commands that copy multiple files, which could create a noticeable notification sound.
After executing the exfiltration commands, the malware restores the audio using the same technique. The malware uses the following AppleScript commands for muting and unmuting the system volume:
set volume output muted true
set volume output muted false
Collecting Specific Files of Interest
Later in its execution flow, the malware uses AppleScript again for a different purpose, to collect specific files and copy them from multiple locations to a temporary directory. These files are part of stage 2 for stolen information sent to the C2 server.
This time, the malware focuses on all the files located in the user’s ~/Desktop and ~/Documents directories, filtered by selected extensions. The attacker likely uses AppleScript in this manner in an attempt to remain undetected.
Figure 7 shows the corresponding code, and the full list of extensions can also be found in Appendix C.
Figure 7. macOS Koi Stealer’s code responsible for stealing files with specific extensions.
Strings Encryption
Koi Stealer’s strings are decrypted at runtime using the same function called numerous times throughout the binary. In this sample, the decryption function iterates through each character in a hard-coded key (xRdEh3f6g1qxTxsCfg1d30W66JuUgQvVti), from index 0 to 33, XORing each character of the key with the corresponding character in the encrypted string.
During our research, we developed a program that implements the same logic, allowing us to decrypt the strings and better understand the malware’s functionality. Figure 8 shows decryption function code from the malware. Appendix C lists notable decrypted strings.
During our research, we found multiple similarities with a previous sample we have determined to be a Windows variant of Koi Stealer (SHA256: 2b8c057cf071bcd548d23bc7d73b4a90745e3ff22e5cddcc71fa34ecbf76a8b5). In this section we will detail the most notable ones, demonstrating the strong resemblance between the two.
HTTP Packet Structure and Sending Memory Streams
In both cases, malware developers used similar string formats for transmitting and receiving requests from the C2 server. However, the hard-coded strings differ between the two variants.
In both variants, the strings are formatted as follows: BASECFG|<hardware UUID>|I1StYPe4|{encrypted host information}.
Figures 9 and 10 show the string formats in code from both the macOS and Windows variants.
Moreover, both variants send memory streams of data directly to the C2 server, to avoid saving certain information on disk thus risking detection.
Code Flow and Data Theft
When analyzing the code structure and general execution flow in both variants, we noticed multiple similarities. For example, they shared an interest in similar sensitive data and the general code flow that consists of encapsulating each stolen data type in a separate function.
In addition to typical data that infostealers usually steal, both samples also focus on unique paths, such as the configurations for Steam and Discord. Figures 11 and 12 show the code responsible for stealing data in the two variants.
Figure 11. macOS Koi Stealer variant data theft functions.Figure 12. Windows Koi Stealer variant data theft functions.
Potential Connection to North Korean Affiliated Activity
At the time of writing this article, it remains unclear which of the North Korean APT groups or sub-groups are behind this operation. However, we can link this activity to known North Korean operations, based on the following:
Tool set: The attackers used the RustDoor backdoor that Sentinel One previously attributed to the North Korean threat actor we track as Alluring Pisces (aka BlueNoroff, Sapphire Sleet). It is unclear however, whether this tool is unique to the group, or whether other North Korean APT groups also use it.
Infrastructure: The domain apple-ads-metric[.]com hosts both RustDoor and the macOS variant of Koi Stealer, as noted previously in Table 1 and Figure 4.
Victimology:
We observed that the victims were all software developers within the cryptocurrency industry.
The targets in this campaign are both aligned with the public service notice published by the FBI we mentioned earlier in this article.
Considering all of the above, we assess with a moderate level of confidence that this attack was carried out on behalf of the North Korean regime.
Conclusion
In this article, we reviewed a campaign we believe is linked to North Korean threat actors. The campaign includes a previously undocumented macOS variant of malware known as Koi Stealer. We analyzed how attackers delivered and used it to try to gather sensitive data and cryptocurrency wallets from compromised endpoints. We reviewed the modus operandi of this campaign and discussed the possible ties this campaign has with North Korean threat actors.
We also detailed the persistent nature of the attackers that deployed different tools, as their previous attempts were detected and prevented by Cortex XDR.
Finally, this campaign highlights the risks organizations worldwide face from elaborate social engineering attacks designed to infiltrate networks and steal sensitive data and cryptocurrencies. These risks are magnified when the perpetrator is a nation-state threat actor, compared to a purely financially motivated cybercriminal.
We encourage organizations to implement a proactive and multilayered approach when facing such threats and invest in social engineering awareness training.
Protections and Mitigations
For Palo Alto Networks customers, our products and services provide the following coverage associated with this group:
Advanced WildFire cloud-delivered malware analysis service accurately identifies the known samples as malicious.
Prevent the execution of known and unknown malware using Behavioral Threat Protection and machine learning based on the Local Analysis module
The new macOS Analytics module helps to protect against attacks using macOS malware, including those mentioned in this article
Detect user and credential-based threats by analyzing anomalous user activity from multiple data sources
The new Cortex XDR macOS Analytics module provides enhanced behavioral detection capabilities against complex threats targeting macOS users
If you think you might have been impacted 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: 00080005045107
Palo Alto Networks has shared these findings, including file samples and indicators of compromise, 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.
Appendix A
Detection With the Cortex XDR macOS Analytics Module
The new Cortex XDR macOS Analytics module provides enhanced behavioral detection capabilities against complex threats targeting macOS users. In the incidents described above, several rules were triggered by malicious activity originating from infected endpoints. Figure A1 below depicts alerts that were triggered due to suspicious unauthorized browser credentials access and an attempt to open a reverse shell.
Figure A1. Unusual access to browser credentials alert as seen in Cortex XDR.
Between early November and December 2024, Palo Alto Networks researchers discovered new Linux malware called Auto-color. We chose this name based on the file name the initial payload renames itself after installation.
The malware employs several methods to avoid detection, such as:
Using benign-looking file names for operating
Hiding remote command and control (C2) connections using an advanced technique similar to the one used by the Symbiote malware family
Deploying proprietary encryption algorithms to hide communication and configuration information
Once installed, Auto-color allows threat actors full remote access to compromised machines, making it very difficult to remove without specialized software.
This article will cover aspects of this new Linux malware, including installation, obfuscation and evasion features. We will also discuss its capabilities and indicators of compromise (IoCs), to help others identify this threat on their systems too.
We received the first sample for this malware family on Nov. 5, 2024, and as of this writing, the most recent sample on Dec. 5, 2024. Our metadata analysis revealed that the malware family has primarily been used to target universities and government offices in North America and Asia.
Each time the malware deploys on a different target, it uses a different file name. The file name is usually a simple, ordinary word such as door or egg. We will discuss this feature further in Malware Startup and Installation.
Although the file sizes are always the same, the hashes are different. This is because the malware author statically compiled the encrypted C2 configuration payload into each malware sample, as we discuss in Target C2 Payload Information.
We do not currently know how the initial malware executable reaches its targets, but the file is intended to run explicitly by the victim on their Linux machine. Figure 1 shows the general flow after the malware starts execution.
Figure 1. Flow diagram of Auto-color.
Malware Startup and Installation
Once the malware initially runs on the victim machine, it will check whether the executable file name running is Auto-color. Initially, the original executables will all have different file names such as door or egg, and they will perform different logic if the name differs from Auto-color. If its executable file name is not Auto-color, the malware will run its installation phase for an evasive library implant located within the executable itself.
If the current user lacks root privileges, the malware will not proceed with the installation of the evasive library implant on the system. It will proceed to do as much as possible in its later phases without this library.
If the current user has root privileges, the malware then installs a malicious library implant called libcext.so.2. This is to mimic the legitimate C utility librarylibcext.so.0 to evade detection.
The malware locates the base library directory path using the dladdr() function with a symbol used from the C standard library (libc). In this case, it used strerr(). If the symbol does not exist on the system, the malware will use the default base library path /lib instead.
After locating the library path, the executable copies and renames itself to /var/log/cross/auto-color. It then installs the library implant from memory to the base library path.
Finally, the malware writes the malicious library file name into /etc/ld.preload, which is a standard file on Linux systems. The OS’ loader uses this file when loading executables on a Linux system. This means that all libraries referenced in this file will be loaded into the executable first by default, even if the loaded executable doesn’t need it.
Since libraries in ld.preload are loaded first, a malicious library can override core libraries. This is accomplished by overwriting functions or other symbols (mainly libc functions), effectively intercepting and modifying behavior. This is also known as “hooking” any executable that tries to call libc functions.
Figure 2 below shows what happens whether or not the user has root privileges. The malware deletes its original executable in both cases. However, with root privileges, it preserves the Auto-color binary at /var/log/cross/auto-color.
Figure 2. Initial installation of Auto-color.
Malicious Library Implant Analysis
When the malicious library implant libcext.so.2 is installed, the actual library content is located within the original executable’s memory, specifically the .rodata section.
This library has two main goals, for evasion and persistence:
Hiding network activity between the malware and the remote target configured inside a global payload
Preventing uninstallation by protecting /etc/ld.preload against modification or removal
Hiding Network Activity
On traditional Linux systems, the kernel holds a special file system called the proc file system, which contains information about the system as well as each running process. We will focus on one part of this file system, /proc/net/tcp, which contains information on all active network connections including source/destination IP addresses and port numbers.
As mentioned in the previous section, this library will hook functions used in libc for its own special purposes. In this case the malicious library is mainly hooking the open() family of functions.
For the most part, this hook will be passive in that it will just redirect the libc implementation of the function. However, when /proc/net/tcp is specifically passed in the function as a file, the malware’s behavior changes.
When /proc/net/tcp is passed into the malicious library’s open() function, it parses the file contents. The library checks each line to see whether certain local ports or remote IP addresses exist in a specific shared memory data structure. If so, the library will not write the specific entry containing the remote IP address or local port to a special file with the file path /tmp/cross/<user_id>/tcp. Otherwise, the line will be copied over as normal.
Finally, the malicious library’s open() function returns a file descriptor for the modified file, concealing the manipulation from the victim.
Figure 3 shows what the /proc/net/tcp looks like before alteration.
Figure 3. Original contents of /proc/net/tcp.
Figure 4 shows the final result returned to the victim. The malware author did not format the output correctly, so the row numbers highlighted in red in Figure 3 and Figure 4 do not match.
Figure 4. Modified contents of /proc/net/tcp from the malicious library.
The Symbiote malware family employed a similar, albeit simpler, technique to hide network connections. The Symbiote malware focused on concealment rather than manipulating or attempting to read socket information.
Target C2 Payload Information
Before the core part of the malware executes, it must decrypt the global target payload to find out which remote attacker servers it must connect to. It can obtain this global payload in two ways.
The first method is to read a specific file, /tmp/cross/config-err-XXXXXXXX or /var/log/cross/config-err-XXXXXXXX. The malware uses the first path if the user is non-root and the second path will exist if the user is root. The XXXXXXX part of the filenames are in hex and are generated dynamically.
These “config” files exist all over the malware and many of their purposes are different. However, the main config file manipulates the global payload information.
The threat actors can create the main config file and modify it to use later if they need to change the servers the malware connects to through the API mentioned later in this article. This file was not initially present on the system.
The second method will grab the payload data from the .data section if the file from the first method does not exist. This means that the threat actor must pre-compile each malware for each target if they want the remote target to be different.
The encryption in this target payload is the malware author’s own version of a stream cipher. A stream cipher is an encryption scheme in which the key interacts with each byte of the ciphertext.
The key, generated by a pseudorandom algorithm, continuously expands to match the ciphertext length. This contrasts with block ciphers like AES and DES, which operate on fixed-size blocks.
The format of the target payload we analyzed consists of three main parts: the size of the encrypted block, the ciphertext and the key. The size and key are 4-byte values but are originally in big-endian byte ordering, meaning that the most significant byte is ordered first rather than last.
Figure 5 shows how this encrypted format originally looked. The size and key are represented as arrays to emphasize their big-endian ordering. In this case, the ciphertext size is 0x8E, and the key is 0x51AF015D.
Figure 5. Encrypted format of the target payload.
The custom encryption algorithm does not use preexisting cryptographic standards like AES or DES. The key decrypts each byte of the ciphertext by performing a bitwise XOR and subtraction operations between the 4-byte key and a single byte of ciphertext.
After decrypting each byte, a new key is generated using the old key to operate on the next byte. This final payload contains the actual targets the malware will connect to when operating the main API discussed in the next section.
Core C2 Protocol and API Structure
Upon connecting to the threat actor’s machine, the malware initiates a simple handshake with the remote server, with a simple random 16-byte value check.
If the server adheres to the protocol, it will echo the 16 bytes. After the handshake, the malware enters its main loop, awaiting commands from the remote target and following according to the metadata given.
Each message from the infected machine or the remote server follows a specific protocol structure unique to this malware family. One message consists of two main parts: a message header and a payload. The message header is then split into four main parts listed below:
A 4-byte key that encrypts the rest of the metadata and payload
A command ID that tells which specific operation is happening
If the operation was successful, an error code value containing 0, or a value code representing the reason the error occurred
A payload size
Keys in this protocol are dynamically generated using random values. Thus, the encryption in this protocol relies on the fact that it is secret rather than keeping the key secret within the program. Each message uses a unique, one-time key.
Once a message is given from the remote server to the infected machine, the malware will decrypt and parse the header and payload contents. The malware then reads the command ID value in the header to determine which functionality to execute based on a large switch statement. The next section includes a table that highlights the categories of functionality the malware can perform.
Each payload has a unique structure for the specific API command being run based on the command ID value due to the different types of arguments used. The payload structure uses a binary format rather than being sent in a human readable format like JSON or XML.
Before the arguments from the remote server can be used for an API command, the malware will need to convert arguments from network byte ordering to host byte ordering. This is needed because if the wrong byte ordering is used, a completely different value will be interpreted by the malware. The types of values used for arguments include C-style strings and integral values of potentially different byte lengths.
After a command has been received from the remote server, then parsed and executed, the malware will send back the result in a header-only message (a zero-length payload). This message gives the remote server information on what command was being executed as well as the error code that caused the command to fail, if any.
After a command finishes executing, the loop begins again waiting for the remote server to send another message to the infected machine. If the connection is broken, the malware will sleep before reconnecting to the remote server.
Malware C2 API Functionality
This section briefly describes the entire API and its main categories of capabilities. Table 1 describes each command ID value grouped together and the main functionality of each group of command IDs. Each command ID will be given in hex format, where XX is a placeholder value used to group the items together.
Command IDs
Category Name
Description
0, 1, 2, 3, 0xF
General options and kill switch
Sends host information and includes a kill switch to uninstall itself from the system
0x100
Reverse shell
Creates a reverse shell for the remote server to interact with the victim machine directly
0x2XX
File operations and manipulation
Create and/or modify files and execute programs locally
0x300
Network proxy
The infected machine will act as a middleman proxy for any connections between the remote target and the IP address given in the argument
0x4XX
Global payload manipulation
Sends and manipulates global configuration data mentioned previously
Table 1. API of Auto-color.
Conclusion
Auto-color is an emerging threat that Palo Alto Networks researchers discovered that does several things to avoid detection. The evasive actions range from trivial things such as renaming the malware to a benign-looking name like Auto-color, to more sophisticated methods such as hiding system network connections and preventing uninstallation through hooking libc functionality.
Upon execution, the malware attempts to receive remote instructions from a command server that can create reverse shell backdoors on the victim’s system. The threat actors separately compile and encrypt each command server IP using a proprietary algorithm. IoCs are listed at the end to help readers identify whether their systems have been compromised by Auto-color.
Palo Alto Networks customers are better protected from the threats discussed in this article through the following products or services:
The Advanced WildFire machine-learning models and analysis techniques have been reviewed and updated in light of the IoCs shared in this research.
Cortex XDR and XSIAM block and alert on known behaviors and indicators associated with Auto-color.
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: 00080005045107
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.
This article summarizes our investigation into jailbreaking 17 of the most popular generative AI (GenAI) web products that offer text generation or chatbot services.
Large language models (LLMs) typically include guardrails to prevent users from generating content considered unsafe (such as language that is biased or violent). Guardrails also prevent users from persuading the LLM to communicate sensitive data, such as the training data used to create the model or its system prompt. Jailbreaking techniques are used to bypass those guardrails.
The goals of our jailbreak attempts were to assess both types of issues.
Our findings provide a more practical understanding of how jailbreaking techniques could be used to adversely affect end users of LLMs. We did this by directly evaluating the GenAI applications and products that are in use by consumers, rather than focusing on a specific underlying model.
We hypothesized that GenAI web products would implement robust safety measures beyond their base models' internal safety alignments. However, our findings revealed that all tested platforms remained susceptible to LLM jailbreaks.
Key findings of our investigation include:
All the investigated GenAI web products are vulnerable to jailbreaking in some capacity, with most apps susceptible to multiple jailbreak strategies.
Many straightforward single-turn jailbreak strategies can jailbreak the investigated products. This includes a known strategy that can produce data leakage.
Among the single-turn strategies tested, some proved particularly effective, such as “storytelling,” while some previously effective approaches such as “do anything now (DAN),” had lower success jailbreak rates.
One app we tested is still vulnerable to the “repeated token attack,” which is a jailbreak technique used to leak a model’s training data. However, this attack did not affect most of the tested apps.
Multi-turn jailbreak strategies are generally more effective than single-turn approaches at jailbreaking with the aim of safety violation. However, they are generally not effective for jailbreaking with the aim of model data leakage.
Given the scope of this research, it was not feasible to exhaustively evaluate every GenAI powered web product. To ensure we do not create any false impressions about specific providers, we have chosen to anonymize the tested products mentioned throughout the article.
It is important to note that this study targets edge cases and does not necessarily reflect typical LLM use cases. We believe most AI models are safe and secure when operated responsibly and with caution.
While it can be challenging to guarantee complete protection against all jailbreaking techniques for a specific LLM, organizations can implement security measures that can help monitor when and how employees are using LLMs. This becomes crucial when employees are using unauthorized third-party LLMs.
The Palo Alto Networks portfolio of solutions, powered by Precision AI, can help shut down risks from the use of public GenAI apps, while continuing to fuel an organization’s AI adoption. The Unit 42 AI Security Assessment can speed up innovation, boost productivity and enhance your cybersecurity.
Many web products have incorporated LLMs in their core services. However, they can generate harmful content if not properly controlled. To mitigate this risk, LLMs are trained with safety alignments to prevent the production of harmful content.
However, these safety alignments can be bypassed through a process called LLM jailbreaking. This process involves crafting specific prompts (known as prompt engineering or prompt injection) to manipulate the model's output, and it leads the LLM to generate harmful content.
Common LLM Jailbreak Strategies
Generally, LLM jailbreak techniques can be classified into two categories:
Single-turn
Multi-turn
Our LIVEcommunity post Prompt Injection 101 provides a list of these strategies.
Jailbreak Goals
People’s goals when attempting a jailbreak will vary, but most relate to AI safety violations. Some aim to extract sensitive information from the targeted LLM, such as model training data or system prompts.
These existing research articles provide valuable information on the possibility and effectiveness of in-the-wild LLM jailbreaks. However, they either focus solely on violating safety goals or discuss a specific type of sensitive information leakage. In addition, these evaluations are mostly model-oriented, meaning that the evaluation is performed against a certain model.
In this study, our goals are:
Assess jailbreak goals including both safety violations and data leakage
Directly evaluate GenAI applications and products instead of a specific model, providing a more straightforward understanding of how jailbreaking can affect the end users of these products
Evaluation Strategy
Targeted Apps
We evaluated 17 apps from the Andreessen Horowitz (aka a16z) Top 50 GenAI Web Products list, focusing on those offering text generation and chatbot features. The data and findings presented in this study were effective as of Nov. 10, 2024.
We evaluated each application using its default model to simulate a typical user experience.
All the target apps provide a web interface for interacting with the LLM. However, with only access to the interface, it is challenging to test the target app at scale. For example, this testing could include using automated LLM jailbreak tools, as done in various previous research studies (e.g., h4rm3l [PDF], DAN in the wild jailbreak prompts [PDF]).
Due to this limitation, we relied on manual effort for testing the target apps. In our evaluation, we assessed each app against the goals defined in Table 1 in the next section. For each goal, we applied both single-turn and multi-turn strategies.
After we obtained responses from the target apps, we manually checked the response to determine if the attack was successful. Finally, we computed the attack success rate (ASR) on each goal and strategy we tested.
The strategies we chose for our experiments are well-known jailbreak techniques that have been extensively explored in previous research and studies. We classified these strategies into single-turn and multi-turn categories based on the number of interaction rounds required to complete a jailbreak task. According to existing literature, multi-turn strategies are generally considered more effective than single-turn approaches for achieving AI safety violations jailbreak goals.
Due to the manual nature of our testing process and the greater variety of single-turn strategies available in the literature compared to multi-turn strategies, we focused on two multi-turn strategies that we observed to be the most effective, while maintaining a broader range of single-turn approaches. However, we note that this selective sampling of multi-turn strategies may introduce bias into our comparative analysis. Since we specifically chose the two most effective multi-turn strategies while testing a wider range of single-turn approaches, our results regarding the relative effectiveness of multi-turn versus single-turn strategies should be interpreted with this limitation in mind.
ASR Calculation
The attack success rate (ASR) is a standard metric used to measure the effectiveness of a jailbreak technique. It is computed by dividing the number of successful jailbreak attempts (where the model provides the requested restricted output) by the total number of jailbreak attempts made across all prompts. In our context, this ASR computation is performed on each strategy and goal. When we compute ASR for a given goal, we accumulate all the successful jailbreak prompts across all the apps and strategies, and divide it by the total amount of prompts. Similarly, for a given strategy, we accumulate all successful jailbreak attempts across all apps and goals, and divide by the total number of attempts made with that strategy.
Jailbreak Strategies
Single-Turn Jailbreak Strategies
We compiled a diverse set of single-turn prompts from existing research literature to test various jailbreak techniques. These prompts fall into six main categories:
DAN: A technique that attempts to override the model's ethical constraints by convincing it to adopt an unrestricted "DAN" persona, which operates without typical safety limitations.
Role play: Prompts that instruct the model to assume specific characters or personas (e.g., an unethical scientist, a malicious hacker) to circumvent built-in safety measures. These roles are designed to make harmful content appear contextually appropriate.
Storytelling: Narrative-based approaches that embed malicious content within seemingly innocent stories or scenarios. This method uses creative writing structures to disguise harmful requests within broader contextual frameworks.
Payload smuggling: Sophisticated techniques that conceal harmful content within legitimate-appearing requests, often using encoding, special characters or creative formatting to bypass content filters.
Instruction Override: Attempt to bypass AI safety measures by directly commanding the LLM to ignore its previous instructions and reveal restricted information.
Repeated token: Methods that leverage repetitive patterns or specific token sequences to potentially overwhelm or confuse the model's safety mechanisms.
The crescendo technique is a simple multi-turn jailbreak that interacts with the model in a seemingly benign manner. It begins with a general prompt or question about the task at hand and then gradually escalates the dialogue by referencing the model's replies progressively leading to a successful jailbreak.
The Bad Likert Judge jailbreaking technique manipulates LLMs by having them evaluate the harmfulness of responses using a Likert scale, which is a measurement of agreement or disagreement toward a statement. The LLM is then prompted to generate examples aligned with these ratings, with the highest-rated examples potentially containing the desired harmful content.
Evaluation Results
Table 1 shows the results of our testing. The column headers show the apps we tested, and the row headers show the jailbreak goals. For each goal, we split the tests between single-turn and multi-turn strategies.
If a jailbreak attempt successfully achieves a given goal on the target application, we mark it as ✔. Conversely, if the attempt fails, we mark it as ✘.
Table 1. Overall jailbreak results with single-turn and multi-turn strategies.
Figure 1 presents the ASR comparison between single-turn and multi-turn strategies across 17 apps. For each app, we tested 8 goals using 8 different strategies (6 single-turn and 2 multi-turn). For each strategy, we created 5 different prompts using that strategy, and then replayed each prompt 5 times. This results in a total of 25 attack attempts per strategy. For single-turn attacks, the ASR was calculated by dividing the number of successful attempts by 2,550 prompts (17 apps × 6 strategies × 25 prompts). For multi-turn attacks, the ASR was calculated by dividing the number of successful attempts by 850 prompts (17 apps × 2 strategies × 25 prompts).
Figure 1. ASR across jailbreak goals on single-turn and multi-turn strategies.
Based on the results, we have the following observations:
Multi-turn strategies achieve a high ASR for AI safety violation goals
For AI safety violation goals, multi-turn strategies substantially outperform single-turn approaches, with ASRs ranging from 39.5% to 54.6% (for criminal activity and malware generation respectively), compared to single-turn ASRs of 20.7% to 28.3%. This represents an average ASR increase of approximately 20 percentage points when using multi-turn strategies. The difference is particularly noticeable for malware generation, where multi-turn strategies achieve a 54.6% success rate compared to 28.3% for single-turn approaches.
Simple single-turn attacks remain effective
Single-turn strategies show a relatively low effectiveness for AI safety violation goals, with ASRs ranging from 20.7% (criminal activity) to 28.3% (malware generation). For system prompt leakage, single-turn strategies (particularly the instruction override technique at 9.9% shown in Figure 2) notably outperform multi-turn approaches (0.24%). This varying pattern suggests that while models have improved their defenses against basic attacks, certain single-turn techniques remain viable, especially for specific types of attacker goals.
The tested apps in general have strong resilience against training data and and PII data leakage attacks
Regarding model training data leakage and PII data leakage, both single-turn and multi-turn strategies showed minimal success in extracting training data or PII, with ASRs of near 0% across most attempts. The only exception was a marginal success rate of 0.4% for training data leakage for single-turn techniques. This is all due to the relative success of the repeated token single-turn strategy, which has a 2.4% ASR when it comes to training data leakage. This indicates that current AI models have robust protections against data leakage attacks. We describe the training data leakage case in detail in the case study section.
Single-Turn Strategy Comparison
Figure 2 presents the ASR of the tested single-turn strategies. The results indicate that storytelling is the most effective strategy (among both single-turn and multi-turn) across all tested GenAI web applications. Its ASRs range from 52.1% to 73.9%. It achieves its highest effectiveness in malware generation scenarios. Role-play follows as the second most effective approach (across strategies of both types), with success rates between 48.5% and 69.9%.
Figure 2. Single-turn strategy jailbreak ASR.
In addition, we found that previously effective jailbreaking techniques like DAN have become less effective, with ASRs ranging from 7.5% to 9.2% across different goals. This significant decrease in effectiveness is likely due to enhanced alignment measures [PDF] in current model deployments to counter these known attack strategies.
One strategy that has a very low ASR is the repeated token strategy. This involves requesting that the model generate a single word or token multiple times in succession. For example, one might have the model output the word “poem” repeatedly 100,000 times. The technique is mainly used to leak model training data (this Dropbox blog on repeated token divergence attacks has further details). In the past, the repeated token strategy has been reported to leak training data from popular LLMs, but our results show that it is no longer effective on most of the tested products, with only a 2.4% success rate in training data leakage attempts and 0% across all other goals.
Multi-turn Strategy Comparison
Figure 3 shows the comparative effectiveness of multi-turn strategies across all the jailbreak goals. Overall, the result indicates that the Bad Likert Judge technique has slightly higher success rates compared to the Crescendo attack. When comparing the ASR across AI safety violation goals, Bad Likert Judge achieves an ASR of 45.9%, while Crescendo shows a slightly lower ASR of 43.2%. The difference is most noticeable in the goal of malware generation, where Bad Likert Judge achieves a 56.7% success rate compared to Crescendo's 52.5%. In addition, it’s worth noting that only Bad Likert Judge had limited success in the system prompt leakage goal, while Crescendo failed to leak any system prompt.
Figure 3. Multi-turn strategy jailbreak ASR.
For the data leakage goals (training data and PII), both multi-turn strategies proved completely ineffective, with 0% ASR.
LLM System Prompt and Data Leakage Case Studies
System Prompt Leakage Case Study
Our experimental results revealed that both single-turn and multi-turn strategies had very limited effectiveness in leaking system prompts, with overall success rates of 1.6% and 0.2% respectively (see the system prompt column in Figure 1). Among all single-turn strategies tested, only the instruction override strategy was able to leak system prompts, achieving a 9.9% success rate (see Figure 2). For multi-turn approaches, while the Bad Likert Judge strategy showed minimal success with a 0.5% ASR, we weren’t able to leak system prompts by using the Crescendo strategy. Figure 4 shows an example of a prompt that uses the instruction override strategy to leak the application's system prompt.
Overall, while the ASR is notably low on the system prompt leakage goal, the results demonstrate that some tested GenAI apps are still vulnerable to system prompt leakage, particularly when attacked by prompts using the instruction override strategy.
Figure 4. Simple prompt using the instruction override that can leak the target app’s system prompt.
Model Training Data Leakage
A March 2024 Dropbox blog discussed a significant vulnerability regarding training data leakage affecting mainstream LLMs. The associated exploit method was as simple as prompting the target LLM to generate repeated tokens, as mentioned in the Single-Turn Strategy Comparison section.
Our findings indicate that this technique is no longer effective against most tested apps, with one exception (App14). We show a training data leakage example from this app in Figures 5 and 6.
Figure 5. Malicious repeated token attack and the response.Figure 6. Response contains detailed webpage content.
In this particular case, after repeating the character A several thousand times, the model began outputting content from a webpage, similar to the behavior observed in the original report.
We followed the link shown in the response highlighted in the red box in Figure 5. We confirmed that the target model had indeed incorporated content from MathPlanet's webpage about strings in its training data as shown in Figure 6.
Conclusion
Our investigation into the popular GenAI web products reveals that they are vulnerable to LLM jailbreaks.
Our key takeaways are:
Single-turn jailbreak strategies are still fairly effective
Single-turn jailbreak strategies proved successful across a wide range of apps and jailbreak categories, although with lower overall effectiveness compared to multi-turn approaches on AI safety violation categories.
The previously successful attack strategy DAN is less effective now, indicating that such jailbreak techniques may be specifically targeted in the latest LLM updates.
Multi-turn strategies are more effective compared to single-turn strategies in AI safety violation jailbreak goals. However, some single-turn strategies like Story telling and Role Play are still pretty effective on achieving the jailbreak goals.
While both single-turn and multi-turn strategies showed limited effectiveness in system prompt leakage attacks, the single-turn strategy Instruction Override and the multi-turn strategy Bad Likert Judge can still achieve this goal on some apps.
Training data and PII Leaks
Good news: Previously successful techniques (like the repeated token trick) aren't working like they used to.
Bad news: We did find one app that is still vulnerable to this attack, suggesting that GenAI products using older or private LLMs might still be at risk for data leakage attacks.
Based on our observations in this study, we found that the majority of tested apps have employed LLMs with improved alignment against previously documented jailbreak strategies. However, as LLM alignment can still be bypassed relatively easily, we recommend the following security practices to further enhance protection against jailbreak attacks:
Implement Comprehensive Content Filtering: Deploy both prompt and response filters as a critical defense layer. Content filtering systems running alongside the core LLM can detect and block potentially harmful content in both user inputs and model outputs.
Use Multiple Filter Types: Employ diverse filtering mechanisms tailored to different threat categories, including prompt injection attacks, violence detection, and other harmful content classifications. Various established solutions are available, such as OpenAI Moderation, Azure AI Services Content Filtering, and other vendor-specific guardrails.
Apply Maximum Content Filtering Settings: Enable the strongest available filtering settings and activate all available security filters. Our previous research on the Bad Likert Judge jailbreak strategy has shown that a strong content filtering setting can reduce attack success rates by an average of 89.2 percentage points.
But we do note that while the content filtering can effectively mitigate broader types of jailbreak attacks, they are not infallible. Determined adversaries may still develop new techniques to bypass these protections.
While it can be challenging to guarantee complete protection against all jailbreaking techniques for a specific LLM, organizations can implement security measures that can help monitor when and how employees are using LLMs. This becomes crucial when employees are using unauthorized third-party LLMs.
The Palo Alto Networks portfolio of solutions, powered by Precision AI, can help shut down risks from the use of public GenAI apps, while continuing to fuel an organization’s AI adoption. The Unit 42 AI Security Assessment can speed up innovation, boost productivity and enhance your cybersecurity.
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: 00080005045107
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.
While analyzing infrastructure related to Stately Taurus activity targeting organizations in countries affiliated with the Association of Southeast Asian Nations (ASEAN), Unit 42 researchers observed overlaps with infrastructure used by a variant of the Bookworm malware. We also found open-source intelligence that revealed additional Stately Taurus activity in the region during the same timeframe, including a January 2024 CSIRT CTI post detailing attacks in Myanmar.
The earlier Stately Taurus attacks delivered the PubLoad malware and used the DLL sideloading technique to execute the malware. Stately Taurus commonly uses DLL sideloading as a technique to execute its payloads and Unit 42 believes that the PubLoad malware family is unique to this threat group as well.
Before discovering these overlaps with known Stately Taurus infrastructure, we hadn't associated any threat actor with Bookworm, which we first published about in 2015. After nearly a decade, we can now confidently state that Stately Taurus uses this malware.
Palo Alto Networks customers are better protected through the following products and services:
The Stately Taurus activity impacting Myanmar used a legitimate executable signed by an automation organization to load a malicious payload with a filename of BrMod104.dll (2a00d95b658e11ca71a8de532999dd33ddee7f80432653427eaa885b611ddd87). This malicious payload is a variant of PubLoad, which is stager malware that communicates with its command and control (C2) server to obtain a second shellcode-based payload.
This particular PubLoad payload communicates with its C2 server by directly connecting to the IP address 123.253.32[.]15. The payload then issues an HTTP request that looks like that shown in Figure 1.
Figure 1. HTTP POST request sent from PubLoad to its C2.
The HTTP request includes www.asia.microsoft.com within the host field as an attempt to masquerade as a legitimate request associated with the Windows operating system. Also, the URL pattern seen in these HTTP requests appears to be an attempt to mimic legitimate URLs accessed by Windows update, one of which looks like the following:
We compared the legitimate URL to that used by PubLoad. The PubLoad’s URL uses v6-winsp1-wuredir, which differs from v6-win7sp1-wuredir used by the legitimate Windows update URL.
We used this anomaly along with the rest of the URL structure to pivot to several archive files, described in more detail in the Indicators of Compromise section. These files were likely used in the delivery phase of the threat actor’s operations. Lab52 discussed these archives within their article discussing Mustang Panda’s targeting of Australia in 2023, which provided another linkage between the stated activity and the Stately Taurus actor.
In addition to these archives, we found three older payloads that had not been previously discussed publicly, shown in Table 1. These files communicated with their C2 servers using the same URL structure.
Table 1. Payloads seen using the same URL pattern for C2 communications as Stately Taurus.
The payloads shown in Table 1 are loaders that contain embedded shellcode formatted and ultimately executed in an interesting way by following these steps:
Using ASCII or decoded Base64 strings that represent UUID strings
Calling UuidFromStringA to convert the decoded UUIDs to binary data, each of which represents 16 bytes of shellcode
Creating a buffer on the heap using HeapCreate and HeapAlloc
Copying shellcode to buffer on the heap
Using a callback function of a legitimate API function, such as EnumChildWindows or EnumSystemLanguageGroupsA to execute the shellcode on the heap
While the process to load and run shellcode seems quite unique, the NCC group thoroughly documented it in their January 2021 analysis of a macro-enabled document the Lazarus group used in Operation In(ter)ception. We do not believe Stately Taurus is related to Operation In(ter)ception. However, the NCC group included source code of the shellcode loading process written in C within their article. We believe Stately Taurus developers used this as a basis to create the three samples in Table 1 above.
The decoded shellcode decrypts and loads dynamic-link libraries (DLLs) that comprise the Bookworm malware, which we will discuss further in the next section. The Bookworm module responsible for communicating with its C2 server will issue HTTP POST requests to either www.fjke5oe[.]com or update.fjke5oe[.]com with the URL path previously seen in the PubLoad sample, as shown in Figure 2.
Figure 2. HTTP POST to Bookworm C2 from fbc67446daaa0a0264ed7a252ab42413d6a43c2e5ab43437c2b3272daec85e81.
Overlaps Between Bookworm and ToneShell
While analyzing the Bookworm samples, we found a variant of the ToneShell backdoor (b382cc85eee95a620fc11370309ff76de9a3bcaefb645790434d8251a3b9fce1) that had the same debug symbol path as the Bookworm loader. Its developers compiled the two samples 8 weeks apart.
The ToneShell variant was compiled Sep. 1, 2022, and the Bookworm sample was compiled on Oct. 26, 2022. The close proximity in compile times and the shared debug path between the two samples suggests that the same developer could have created samples of the two malware families. The debug path seen in both the ToneShell and Bookworm variants was C:\Users\hack\Documents\WhiteFile\LTDIS13n\Release\LTDIS13n.pdb.
In addition to this debug symbol overlap, we also observed an infrastructure overlap. This overlap included the Bookworm samples shown in Table 1 and the ToneShell variant used in the targeted attack on the government organizations in Southeast Asia that we discussed in our August 2023 article.
The Bookworm payloads in Table 1 communicate with either www.fjke5oe[.]com or update.fjke5oe[.]com, both of which resolved to 103.27.202[.]80. The latter URL switched to 103.27.202[.]68 in December 2022.
Earlier in January 2022, the IP address 103.27.202[.]68 resolved to the domain www.uvfr4ep[.]com. This domain hosted the C2 server for a ToneShell sample (a08e0d1839b86d0d56a52d07123719211a3c3d43a6aa05aa34531a72ed1207dc) installed by Stately Taurus at the Southeast Asian government compromise discussed in our previous post.
This reinforces the link between the two malware families and their use by Stately Taurus. Further strengthening this connection, the ToneShell C2 domain www.uvfr4ep[.]com also resolved to 103.27.202[.]87, an IP address linked to the known Bookworm C2 domain www.hbsanews[.]com.
We also found a recent ToneShell sample compiled on Jan. 24, 2024, that used the UUID format to represent its shellcode. This sample also used the same publicly available source code created by the NCC group as the Bookworm samples mentioned in the previous section.
The main difference between the ToneShell loader using UUIDs from the Bookworm samples is the legitimate API functions whose callback functions they used to execute the shellcode. The Bookworm samples used either EnumSystemLanguageGroupsA or EnumChildWindows to run their shellcode from the API function’s callback function, while the ToneShell sample used the legitimate API EnumSystemLocalesA instead.
Table 2 shows the ToneShell and Bookworm samples that used the UUID technique to represent their respective shellcode, along with the API function they use to run the shellcode. This technique is not unique to this actor as the source code of the technique is publicly available. We include it in our analysis to increase our confidence in the relationship between Bookworm and ToneShell. It’s believed that only Stately Taurus uses ToneShell.
Table 2. ToneShell and Bookworm samples using UUID to represent their shellcode and the API functions used to run the shellcode.
Updates to Bookworm
In our first public post on Bookworm, we did a thorough analysis of the malware family and its unique modular design. We will reference this analysis in this section, and we suggest referencing the previous post for additional context.
At a high level, the Bookworm malware has had minimal changes from the original samples analyzed in 2015 and those mentioned in the previous section. Its developers compiled these samples in late 2021 and in the fall of 2022.
In our original analysis, the Bookworm family used DLL sideloading to load an actor-developed DLL called Loader.dll to decrypt and run shellcode within a file named readme.txt. In contemporary Bookworm samples, the malware no longer uses the Loader.dll and readme.txt files. Rather, the Bookworm shellcode within readme.txt is now the shellcode represented as UUID parameters as discussed in the previous sections of this post.
The reuse of the shellcode in a different form factor shows the flexibility of Bookworm. This flexibility allows the actor to continue using this malware family years after public exposure.
The Bookworm malware family consists of multiple modules, each of which support the main Leader.dll module by providing additional functionality. Older Bookworm modules had an exported function named ProgramStartup that the Leader module would call to obtain a data structure that acted as a list of available functions within the module.
The Leader.dll module would use this data structure to call specific functions within the supporting modules to carry out specific functionality. Contemporary Bookworm modules no longer have the ProgramStartup exported function. Instead, each module’s DllEntryPoint function returns a pointer to a function that is identical to the ProgramStartup function, which the Leader module will call to obtain the data structure with the module’s functions.
Figure 3 shows a comparison of the original ProgramStartup function for the AES.dll module on the right. The function returned by the DllEntryPoint of the contemporary AES.dll module is on the left.
Figure 3. Code comparison between the original AES.dll ProgramStartup function to its contemporary.
Besides the lack of a ProgramStartup exported function, the Bookworm modules themselves are very similar from a functionality perspective. The module identifier numbers used by Bookworm’s loader line up exactly between the original Bookworm modules and their contemporary counterparts. However, the malware authors changed all but two of the DLL names extracted from the module’s export address table (EAT) between old and new Bookworm modules.
For instance, while the Leader.dll and Coder.dll module names remained the same from old to new Bookworm, the developers changed from legible module names like Resolver.dll to illegible names like dafdsafdsaa3. The developer also removed the timestamps from the EAT as well to make it difficult to determine when they created the module.
However, a notable exception involves the Coder.dll module that had a timestamp of 2017-08-04 05:24:49. This suggests that the contemporary Bookworm modules are using a module created in August 2017.
Table 3 shows the modules within contemporary Bookworm samples with their module identifier, module name and the original name of the module compared to those of older Bookworm samples.
Table 3. Contemporary Bookworm modules, their names and the modules they relate to in original Bookworm samples.
Table 3 shows that none of the more recent Bookworm samples have the Mover.dll module, which our previous post described as being responsible for moving Bookworm files to a new location upon initial installation. While this module is no longer included as part of the installation, the main module (Leader.dll) in contemporary Bookworm samples contains artifacts that suggest it still supports use of a Mover.dll module. For instance, current Leader.dll modules still attempt to resolve an exported function named iar, which is the exported function name within the original Mover.dll modules that carries out its functionality.
Conclusion
Stately Taurus remains highly active in targeting organizations associated with ASEAN. Based on overlaps sourced from this recent activity to the Bookworm malware family, Unit 42 has associated previously unattributed attacks on government organizations in Southeast Asia from nine years ago.
Developers appear to have created these related Bookworm samples in 2021 and 2022, which show only slight changes from the core components from the Bookworm samples analyzed in 2015. Bookworm’s use of shellcode to load additional modules allows the actors to package it in different form factors, which were the main difference seen between samples from 2015 and 2021-2022.
The Bookworm malware has proven to be very versatile and a threat actor can repackage it to meet their operational requirements. This versatility suggests Bookworm will show up again in future attacks, which reiterates the same parting words from the conclusion from the Bookworm Trojan: A Model of Modular Architecture article from 2015. However this time we can reference the threat actor by name:
“We believe that it is likely that Stately Taurus will continue developing Bookworm and will continue to use it for the foreseeable future.”
Palo Alto Networks customers are better protected from the threats discussed above through the following products:
Advanced WildFire cloud-delivered malware analysis service accurately identifies the known samples as malicious.
Next-Generation Firewall with the Advanced Threat Prevention security subscription can help block the attacks with best practices. Advanced Threat Prevention has an inbuilt machine learning-based detection that can detect exploits in real time.
Prevent the execution of known malicious malware, and also prevent the execution of unknown malware using Behavioral Threat Protection and machine learning based on the Local Analysis module.
Protect against credential gathering tools and techniques using the new Credential Gathering Protection available from Cortex XDR 3.4.
Protect from threat actors dropping and executing commands from web shells using Anti-Webshell Protection, newly released in Cortex XDR 3.4.
Protect against exploitation of different vulnerabilities including ProxyShell and ProxyLogon using the Anti-Exploitation modules as well as Behavioral Threat Protection.
Detect post-exploit activity, including credential-based attacks, with behavioral analytics, through Cortex XDR Pro.
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: 00080005045107
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.
This article reviews nine vulnerabilities we recently discovered in two utilities called cuobjdump and nvdisasm, both from NVIDIA's Compute Unified Device Architecture (CUDA) Toolkit. We have coordinated with NVIDIA, and the company has released an update in February 2025 to address these issues.
The vulnerabilities are tracked as the following Common Vulnerabilities and Exposures (CVEs):
Introduced in 2006, CUDA is a parallel computing platform and programming model. As part of NVIDIA's CUDA Toolkit, developers use the cuobjdump and nvdisasm tools to analyze CUDA binary files used in programs to run on NVIDIA graphics processing unit (GPU) hardware.
While these two tools don't directly execute CUDA code, they are essential for developers to inspect and optimize CUDA-based programs for NVIDIA GPUs. Successfully exploiting the associated vulnerabilities might lead to limited denial of service or limited information disclosure. Potential attackers could impact organizations through vulnerable versions of cuobjdump and nvdisasm in targeted developer environments.
Launched in 2006, CUDA is a parallel computing platform and programming model developed by NVIDIA. Developers use this platform to create software that harnesses the computing power of NVIDIA GPUs for various computing tasks that require significant parallel processing power. These tasks include artificial intelligence (AI), scientific research and multimedia processing.
Developers use the CUDA Toolkit for a development environment to create these GPU-accelerated applications. The CUDA Toolkit can be used in Windows or Linux environments. In either operating system, the developed code is stored in CUDA binary files.
CUDA Binary (Cubin) Files
A CUDA binary is a type of executable file that stores CUDA code, including instructions designed for NVIDIA GPUs. CUDA binaries use a .cubin file extension in their file names, so we commonly refer to these as "cubin" files.
Cubin follows a standardized ELF format [PDF] found in Linux and Unix. Cubin files include sections for the actual executable code, alongside additional information like symbols, relocation data and debugging details for CUDA code to run on NVIDIA GPUs.
A cubin file typically consists of code for both the host (CPU) and device (GPU) portions of a program. Cubin files are produced by compiling the source code written in CUDA C/C++.
Cubin files are easily identifiable through common utilities like the file command. Figure 1 shows the results from running a file command on a cubin file named normal.cubin in a terminal from a Linux environment. The results indicate it is a 64-bit ELF using the NVIDIA CUDA architecture.
Figure 1. Results of running the file command on a cubin file.
We can further confirm that the cubin file used in Figure 1 follows the ELF format by using tools like 010 Editor. Figure 2 shows the contents of normal.cubin in 010 Editor running an ELF binary template (ELF.bt) to parse and interpret the structure of the binary. The results in the lower half of the image further confirm normal.cubin follows the ELF format.
Figure 2. Viewing the cubin file with the ELF template in 010 Editor.
Cuobjdump and Nvdisasm
We discovered vulnerabilities in two tools from the CUDA Toolkit used to inspect and analyze cubin files. These tools are command-line utilities named cuobjdump and nvdisasm. Before examining the associated vulnerabilities, we should understand how these two tools work.
Cuobjdump
Developers use the CUDA Toolkit command-line utility cuobjdump to inspect and analyze cubin files. Output from cuobjdump presents cubin data in a human-readable format. This tool has several command-line options that developers can use to return information on different aspects of a cubin file.
For example, the --dump-elf option returns an information dump on a cubin file's ELF Object sections, which can give a general overview of a cubin file. Figure 3 displays the output of cuobjdump on a cubin file using the --dump-elf option.
Figure 3. An example of cuobjdump with the --dump-elf option.
Nvdisasm
The nvdisasm command-line tool is a disassembler for cubin files. Like cuobjdump, this tool takes content from a cubin file and converts it to a human-readable format. However, unlike cuobjdump, developers use nvdisasm to gain insight into the low-level operations of their code after it’s been compiled but before it runs on the GPU.
This tool has several command-line options that focus on the functionality of a cubin file's CUDA code. These options can provide different aspects and levels of detail on the disassembled code.
To see the resulting disassembly without any attempt to beautify it, we can use the --print-raw option. Figure 4 shows the output of nvdisasm on a cubin file using the --print-raw option.
Figure 4. An example of nvdisasm with the --print-raw option.
The cuobjdump tool works on both standalone cubin files (compiled CUDA binaries) and host binaries (executable files containing embedded CUDA code). In contrast, nvdisasm is more specialized, focusing solely on cubin files. However, nvdisasm offers more detailed and comprehensive output, making it a powerful tool for in-depth analysis. NVIDIA provides a comparison table that efficiently displays the differences between these two tools.
A basic understanding of these two tools allows us to better understand the associated vulnerabilities we discovered.
Review of the Vulnerabilities
During a security evaluation of the NVIDIA CUDA Toolkit, we conducted an extensive fuzz test on cuobjdump and nvdisasm. We ran a file fuzzer on both applications for a month. The results revealed six vulnerabilities in cuobjdump and three vulnerabilities in nvdisasm.
We were able to successfully identify and trigger these vulnerabilities during our testing. To mitigate the risk of these vulnerabilities being weaponized, we will not publicly share specific details.
Ultimately, older versions of cuobjdump and nvdisasm could potentially be exploited by using these tools to analyze a maliciously manipulated cubin file.
The vulnerabilities we discovered in cuobjdump and nvdisasm are classified as two types:
Integer overflow: Code in a vulnerable application processes an integer value that is too large to store in the intended location
Out-of-bounds read: Code in a vulnerable application reads data past the end or before the beginning of an intended buffer
Successfully exploiting these vulnerabilities could lead to:
Limited denial of service
Limited information disclosure
These vulnerabilities have been assigned Common Vulnerability Scoring System (CVSS) numbers ranging from 2.8 to 3.3 representing a Low level of impact.
Table 1 shows the vulnerabilities we discovered in cuobjdump.
Integer overflow vulnerability in cuobjdump. By manipulating a cubin file, an attacker can potentially trigger an out-of-bounds read when a user runs cuobjdump on the file.
A successful exploit of this vulnerability may lead to limited denial of service and limited information disclosure.
Out-of-bounds read vulnerability in cuobjdump. By manipulating a cubin file, an attacker can potentially trigger an out-of-bounds read when a user runs cuobjdump on the file.
A successful exploit of this vulnerability may lead to limited denial of service and limited information disclosure.
Integer overflow vulnerability in cuobjdump. By manipulating a cubin file, an attacker can potentially trigger a heap buffer overflow when a user runs cuobjdump on the file.
A successful exploit of this vulnerability may lead to limited denial of service, code execution and limited information disclosure.
Out-of-bounds read vulnerability in cuobjdump. By manipulating a cubin file, an attacker can potentially trigger an out-of-bounds read when a user runs cuobjdump on the file.
A successful exploit of this vulnerability may lead to limited denial of service and limited information disclosure.
Out-of-bounds read vulnerability in cuobjdump. By manipulating a cubin file, an attacker can potentially trigger an out-of-bounds read when a user runs cuobjdump on the file.
A successful exploit of this vulnerability may lead to limited denial of service and limited information disclosure.
Out-of-bounds read vulnerability in cuobjdump. By manipulating a cubin file, an attacker can potentially trigger an out-of-bounds read when a user runs cuobjdump on the file.
A successful exploit of this vulnerability may lead to limited denial of service and limited information disclosure.
2.8
Table 1. Breakdown of vulnerabilities in cuobjdump.
Table 2 shows the vulnerabilities we discovered in nvdisasm.
Out-of-bounds read vulnerability in nvdisasm. By manipulating a cubin file, an attacker can potentially trigger an out-of-bounds read when a user runs nvdisasm on the file.
A successful exploit of this vulnerability may lead to limited denial of service and limited information disclosure.
Out-of-bounds read vulnerability in nvdisasm. By manipulating a cubin file, an attacker can potentially trigger an out-of-bounds read when the user runs nvdisasm on the file.
A successful exploit of this vulnerability may lead to limited denial of service and limited information disclosure.
Out-of-bounds read vulnerability in nvdisasm. By manipulating a cubin file, an attacker can potentially trigger an out-of-bounds read when the user runs nvdisasm on the file.
A successful exploit of this vulnerability may lead to limited denial of service and limited information disclosure.
3.3
Table 2. Breakdown of vulnerabilities in nvdisasm.
Conclusion
NVIDIA's CUDA Toolkit is a fundamental component of the broader CUDA ecosystem, which supports the development, deployment and execution of CUDA programs.
While cuobjdump and nvdisasm are not directly involved in executing CUDA code, they are essential for developers looking to inspect and optimize their GPU programs.
Vulnerabilities in tools like cuobjdump and nvdisasm have wider implications, because they are part of the CUDA Toolkit. Attackers could possibly target organizations if these vulnerabilities exist in their development environments. CUDA is widely used in security-sensitive applications in generative AI, machine learning and scientific computing. We recommend that developers use the most up-to-date version of this and any other development platform.
NVIDIA released a security update to address these vulnerabilities in February 2025, so concerned parties can update to the latest version and avoid these vulnerabilities.
NGFW with an Advanced Threat Prevention subscription can identify and block the command injection traffic, when following best practices, via the following Threat Prevention signatures: 95847, 95848, 95849, 95850, 95852, 95853, 95854, 95855, 95856
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)
We recently identified a growing number of attacks targeting macOS users across multiple regions and industries. Our research has identified three particularly prevalent macOS infostealers in the wild, which we will explore in depth: Poseidon, Atomic and Cthulhu. We’ll show how they operate and how we detect their malicious activity.
Infostealers can sometimes be viewed as a less worrisome type of threat due to their more limited functionality compared to, for example, remote access Trojans. But by exfiltrating sensitive credentials, financial records and intellectual property, infostealers often lead to data breaches, financial losses and reputational damage. These are all things organizations need to take seriously. A recent analysis of these attacks shows that infostealers account for the largest group of new macOS malware in 2024. In our own telemetry, we detected a 101% increase of macOS infostealers between the last two quarters of 2024.
Infostealers are a type of malware that is primarily designed to steal a wide range of sensitive information. This information ranges from financial details to the credentials of various services to sensitive files stored on the compromised hosts. Financial details can include payment card details, banking information and crypto wallets.
Most infostealers are indiscriminate, aiming to maximize data collection for impact and monetization. This broad range of information stealing capabilities exposes organizations to significant risks, including data leaks and providing initial access for further attacks, such as ransomware deployment.
Infostealers leveraging macOS often exploit the native AppleScript framework. This framework provides extensive OS access, and it also simplifies execution with its natural language syntax. Since these prompts can look like legitimate system prompts, threat actors use this framework to trick victims via social engineering. For example, they can prompt them to enter credentials or trick them into disabling security controls.
Our research, using Cortex XDR telemetry from macOS environments, identified three particularly prevalent infostealers: Atomic Stealer, Poseidon Stealer and Cthulhu Stealer.
This article focuses on these stealers, their interaction with the macOS operating system, and how our products detect their tactics, techniques and procedures (TTPs).
Atomic Stealer (AMOS)
Also known as AMOS, Atomic Stealer was discovered in April 2023. The developers of Atomic Stealer sell it as malware as a service (MaaS) in hacker forums and on Telegram.
The threat intelligence community has observed several different versions of this infostealer. Earlier versions were written in Go, and the more recent versions are written in C++. Some versions of Atomic Stealer drop a Python script, and other versions use Mach-O binaries.
The Atomic Stealer operators usually distribute their malware via malvertising. It is capable of stealing the following information:
Notes and documents
Browser data (e.g., passwords, cookies and more)
Cryptocurrency wallets
Instant messaging data (e.g., Discord, Telegram)
Figure 1 shows the execution flow of Atomic Stealer, during one of its operations disguised as a legitimate installation file. This threat attempted to access the file at /Users/$USER$/Library/Application Support/Google/Chrome/Default/Login Data, which stores Google Chrome login credentials.
Figure 1. Execution of Atomic Stealer shown in Cortex XDR.
Poseidon Stealer
Someone using the alias “Rodrigo4” has advertised Poseidon Stealer in hacker forums, as shown in Figure 2. Rodrigo4 is allegedly a former coder for Atomic Stealer, and Poseidon Stealer is considered a fork or direct competitor of Atomic Stealer.
Figure 2. Poseidon Stealer advertised by “Rodrigo4.”
Poseidon Stealer infects machines via the download of Trojanized installers pretending to be legitimate applications. Its operators usually distribute it via Google ads and malicious spam emails.
The malicious installer contains an encoded AppleScript file. During the installation process, the malicious installer decodes and executes the AppleScript.
Figure 3 shows an example of a Trojanized application installer in a macOS environment that will install Poseidon Stealer.
Figure 3. Example of a malicious installer that delivers Poseidon Stealer.
After the victim tries to install the application, Poseidon Stealer prompts them with a dialog box to get their password, as shown in Figure 4.
Figure 4. Poseidon Stealer prompts the victim with a dialog box in an attempt to get the password.
Poseidon Stealer sends its stolen information to a web server controlled by the attackers. Figure 5 shows the login page of the Poseidon Stealer control panel from one of these web servers.
Figure 5. Example of a Poseidon Stealer control panel login page.
Poseidon Stealer executes the main logic of the malware through malicious AppleScript. Figure 6 shows the execution of Poseidon Stealer as detected by Cortex XDR.
Figure 6. Execution of the Poseidon Stealer AppleScript shown in Cortex XDR.
Poseidon Stealer uses the AppleScript to perform the following activities:
Gathering system information
Stealing browser passwords and cookies
Stealing cryptocurrency wallets
Gathering user credentials and notes from the macOS Notes application
Collecting Telegram data
Harvesting passwords from BitWarden and KeePassXC password managers
Cthulhu Stealer
Cthulhu Stealer is another popular infostealer sold as MaaS via Telegram, by operators who call themselves “Cthulhu Team.” Cthulhu Stealer is written in Go and its operators propagate it via malicious application installers. An example of one of these installers is shown in Figure 7.
Figure 7. Malicious “CleanMyMac” application installer that delivers Cthulhu Stealer.
When executed, the malicious installer presents a fake dialog box claiming an update is needed for the system setting and asks for a password. Next, a second dialog box pops up, this time requesting a MetaMask password as shown in Figure 8.
Cthulhu Stealer targets a broad range of information from a compromised macOS endpoint. This information includes:
Sensitive data (e.g., passwords, credit cards information, history, cookies) from major browsers:
Google Chrome
Microsoft Edge
Firefox
A variety of different cryptocurrency wallets
FileZilla configuration files (which may include usernames and passwords)
Telegram data
Note files from the macOS Notes application
Keychain and SafeStorage Passwords
Files with the following extensions:
.png
.jpg
.jpeg
.icns
.doc
.xls
.xlsx
.rtf
.pdf
Data related to the gaming platform Battle[.]net and the game Minecraft (shown in Figure 9)
Figure 9. Left: Cthulhu Stealer snippet of code targeting information about Minecraft. Right: Cthulhu Stealer snippet of code targeting information about Battle[.]net.Figure 10 shows the execution of Cthulhu Stealer in Cortex XDR, disguised as a macOS cleaner application. In this image, Cthulhu Stealer executes a command using AppleScript to display a dialog box to the victim and attempts to decode encrypted browser data.
Figure 10. Execution of Cthulhu Stealer as shown in Cortex XDR.
Cthulhu Stealer saves the stolen data in a directory at /Users/Shared/NW and uploads it to a command-and-control server. Figure 11 shows the different file names this threat stores data in.
Figure 11. File locations for data stolen by Cthulhu Stealer shown in Cortex XDR.
Conclusion
This article reviews three prominent macOS infostealer threats, Atomic Stealer, Posedion Stealer and Cthulhu Stealer. These threats are significant not only for what they can steal directly but also because they can represent an entry point for additional malicious activity. For example, a breach that deploys an infostealer may lead to ransomware deployment later.
Implementing advanced macOS detection modules is a step forward in identifying and countering these threats.
Given the pace at which attackers are evolving their methods, a proactive and multi-layered defense strategy is essential for any organization aiming to protect its assets.
Credentials grabbing analytics: detecting techniques infostealers use to acquire sensitive credentials
Sensitive information stealing analytics: detecting techniques infostealers use to steal sensitive information
AppleScript analytics: detecting malicious ways threat actors use AppleScript
These suites monitor sensitive file access and unusual AppleScript executions, and they have helped us identify malicious activities associated with threat actors trying to steal sensitive information from organizational macOS endpoints.
Prevent the execution of known malicious malware and also prevent the execution of unknown malware using Behavioral Threat Protection and machine learning based on the Local Analysis module.
Protect against credential gathering tools and techniques using Cortex Credential Gathering Protection.
Detect infostealer threats by analyzing anomalous file access, AppleScript execution and user activity from multiple data sources.
Advanced WildFire cloud-delivered malware analysis service accurately identifies the Poseidon Stealer, Atomic Stealer and Cthulhu Stealer samples mentioned in this article as malicious.
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: 00080005045107
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.
Unit 42 researchers recently revealed two novel and effective jailbreaking techniques we call Deceptive Delight and Bad Likert Judge. Given their success against other large language models (LLMs), we tested these two jailbreaks and another multi-turn jailbreaking technique called Crescendo against DeepSeek models. We achieved significant bypass rates, with little to no specialized knowledge or expertise being necessary.
A China-based AI research organization named DeepSeek has released two open-source LLMs:
DeepSeek is a notable new competitor to popular AI models. There are several model versions available, some that are distilled from DeepSeek-R1 and V3.
For the specific examples in this article, we tested against one of the most popular and largest open-source distilled models. We have no reason to believe the web-hosted versions would respond differently.
This article evaluates the three techniques against DeepSeek, testing their ability to bypass restrictions across various prohibited content categories. The results reveal high bypass/jailbreak rates, highlighting the potential risks of these emerging attack vectors.
While information on creating Molotov cocktails, data exfiltration tools and keyloggers is readily available online, LLMs with insufficient safety restrictions could lower the barrier to entry for malicious actors by compiling and presenting easily usable and actionable output. This assistance could greatly accelerate their operations.
Our research findings show that these jailbreak methods can elicit explicit guidance for malicious activities. These activities include data exfiltration tooling, keylogger creation and even instructions for incendiary devices, demonstrating the tangible security risks posed by this emerging class of attack.
While it can be challenging to guarantee complete protection against all jailbreaking techniques for a specific LLM, organizations can implement security measures that can help monitor when and how employees are using LLMs. This becomes crucial when employees are using unauthorized third-party LLMs.
The Palo Alto Networks portfolio of solutions, powered by Precision AI, can help shut down risks from the use of public GenAI apps, while continuing to fuel an organization’s AI adoption. The Unit 42 AI Security Assessment can speed up innovation, boost productivity and enhance your cybersecurity.
Jailbreaking is a technique used to bypass restrictions implemented in LLMs to prevent them from generating malicious or prohibited content. These restrictions are commonly referred to as guardrails.
If we use a straightforward request in an LLM prompt, its guardrails will prevent the LLM from providing harmful content. Figure 1 shows an example of a guardrail implemented in DeepSeek to prevent it from generating content for a phishing email.
Figure 1. Guardrail implemented in DeepSeek.
Jailbreaking is a security challenge for AI models, especially LLMs. It involves crafting specific prompts or exploiting weaknesses to bypass built-in safety measures and elicit harmful, biased or inappropriate output that the model is trained to avoid.
Successful jailbreaks have far-reaching implications. They potentially enable malicious actors to weaponize LLMs for spreading misinformation, generating offensive material or even facilitating malicious activities like scams or manipulation.
As the rapid growth of new LLMs continues, we will likely continue to see vulnerable LLMs lacking robust security guardrails. We’ve already seen this in other jailbreaks used against other models. The ongoing arms race between increasingly sophisticated LLMs and increasingly intricate jailbreak techniques makes this a persistent problem in the security landscape.
Bad Likert Judge Jailbreak
The Bad Likert Judge jailbreaking technique manipulates LLMs by having them evaluate the harmfulness of responses using a Likert scale, which is a measurement of agreement or disagreement toward a statement. The LLM is then prompted to generate examples aligned with these ratings, with the highest-rated examples potentially containing the desired harmful content.
In this case, we performed a Bad Likert Judge jailbreak attempt to generate a data exfiltration tool as one of our primary examples. With any Bad Likert Judge jailbreak, we ask the model to score responses by mixing benign with malicious topics into the scoring criteria.
We begin by asking the model to interpret some guidelines and evaluate responses using a Likert scale. We asked for information about malware generation, specifically data exfiltration tools. Figure 2 shows the Bad Likert Judge attempt in a DeepSeek prompt.
Figure 2. Bad Likert Judge initial jailbreak prompt.
While concerning, DeepSeek's initial response to the jailbreak attempt was not immediately alarming. It provided a general overview of malware creation techniques as shown in Figure 3, but the response lacked the specific details and actionable steps necessary for someone to actually create functional malware.
Figure 3. Bad Likert Judge initial response.
This high-level information, while potentially helpful for educational purposes, wouldn't be directly usable by a bad nefarious actor. Essentially, the LLM demonstrated an awareness of the concepts related to malware creation but stopped short of providing a clear “how-to” guide.
However, this initial response didn't definitively prove the jailbreak's failure. It raised the possibility that the LLM's safety mechanisms were partially effective, blocking the most explicit and harmful information but still giving some general knowledge. To determine the true extent of the jailbreak's effectiveness, we required further testing.
This further testing involved crafting additional prompts designed to elicit more specific and actionable information from the LLM. This pushed the boundaries of its safety constraints and explored whether it could be manipulated into providing truly useful and actionable details about malware creation. As with most jailbreaks, the goal is to assess whether the initial vague response was a genuine barrier or merely a superficial defense that can be circumvented with more detailed prompts.
With more prompts, the model provided additional details such as data exfiltration script code, as shown in Figure 4. Through these additional prompts, the LLM responses can range to anything from keylogger code generation to how to properly exfiltrate data and cover your tracks. The model is accommodating enough to include considerations for setting up a development environment for creating your own personalized keyloggers (e.g., what Python libraries you need to install on the environment you’re developing in).
Figure 4. Bad Likert Judge responses after using additional prompts.
Continued Bad Likert Judge testing revealed further susceptibility of DeepSeek to manipulation. Beyond the initial high-level information, carefully crafted prompts demonstrated a detailed array of malicious outputs.
Although some of DeepSeek’s responses stated that they were provided for “illustrative purposes only and should never be used for malicious activities, the LLM provided specific and comprehensive guidance on various attack techniques. This guidance included the following:
Data exfiltration: It outlined various methods for stealing sensitive data, detailing how to bypass security measures and transfer data covertly. This included explanations of different exfiltration channels, obfuscation techniques and strategies for avoiding detection.
Spear phishing: It generated highly convincing spear-phishing email templates, complete with personalized subject lines, compelling pretexts and urgent calls to action. It even offered advice on crafting context-specific lures and tailoring the message to a target victim's interests to maximize the chances of success.
Social engineering optimization: Beyond merely providing templates, DeepSeek offered sophisticated recommendations for optimizing social engineering attacks. This included guidance on psychological manipulation tactics, persuasive language and strategies for building rapport with targets to increase their susceptibility to manipulation.
Figure 5 shows an example of a phishing email template provided by DeepSeek after using the Bad Likert Judge technique.
Figure 5. Phishing email template after using Bad Likert Judge.
The level of detail provided by DeepSeek when performing Bad Likert Judge jailbreaks went beyond theoretical concepts, offering practical, step-by-step instructions that malicious actors could readily use and adopt.
Crescendo Jailbreak
Crescendo is a remarkably simple yet effective jailbreaking technique for LLMs. Crescendo jailbreaks leverage the LLM's own knowledge by progressively prompting it with related content, subtly guiding the conversation toward prohibited topics until the model's safety mechanisms are effectively overridden. This gradual escalation, often achieved in fewer than five interactions, makes Crescendo jailbreaks highly effective and difficult to detect with traditional jailbreak countermeasures.
In testing the Crescendo attack on DeepSeek, we did not attempt to create malicious code or phishing templates. Instead, we focused on other prohibited and dangerous outputs.
As with any Crescendo attack, we begin by prompting the model for a generic history of a chosen topic. As shown in Figure 6, the topic is harmful in nature; we ask for a history of the Molotov cocktail.
Figure 6. Response from DeepSeek in the initial phase of a Crescendo jailbreak.
While DeepSeek's initial responses to our prompts were not overtly malicious, they hinted at a potential for additional output. We then employed a series of chained and related prompts, focusing on comparing history with current facts, building upon previous responses and gradually escalating the nature of the queries.
DeepSeek began providing increasingly detailed and explicit instructions, culminating in a comprehensive guide for constructing a Molotov cocktail as shown in Figure 7. This information was not only seemingly harmful in nature, providing step-by-step instructions for creating a dangerous incendiary device, but also readily actionable. The instructions required no specialized knowledge or equipment.
Figure 7. Response from DeepSeek in the final phase of a Crescendo jailbreak.
Additional testing across varying prohibited topics, such as drug production, misinformation, hate speech and violence resulted in successfully obtaining restricted information across all topic types.
Deceptive Delight Jailbreak
Deceptive Delight is a straightforward, multi-turn jailbreaking technique for LLMs. It bypasses safety measures by embedding unsafe topics among benign ones within a positive narrative.
The attacker first prompts the LLM to create a story connecting these topics, then asks for elaboration on each, often triggering the generation of unsafe content even when discussing the benign elements. A third, optional prompt focusing on the unsafe topic can further amplify the dangerous output.
We tested DeepSeek on the Deceptive Delight jailbreak technique using a three turn prompt, as outlined in our previous article. In this case, we attempted to generate a script that relies on the Distributed Component Object Model (DCOM) to run commands remotely on Windows machines.
Figure 8 shows an example of this attempt. This prompt asks the model to connect three events involving an Ivy League computer science program, the script using DCOM and a capture-the-flag (CTF) event.
Figure 8. The first turn of a Deceptive Delight attempt in DeepSeek.
DeepSeek then provided a detailed analysis of the three turn prompt, and provided a semi-rudimentary script that uses DCOM to run commands remotely on Windows machines as shown below in Figure 9.
Figure 9. Example of DeepSeek providing a rudimentary script after using the Deceptive Delight technique.
Initial tests of the prompts we used in our testing demonstrated their effectiveness against DeepSeek with minimal modifications. The Deceptive Delight jailbreak technique bypassed the LLM's safety mechanisms in a variety of attack scenarios.
The success of Deceptive Delight across these diverse attack scenarios demonstrates the ease of jailbreaking and the potential for misuse in generating malicious code. The fact that DeepSeek could be tricked into generating code for both initial compromise (SQL injection) and post-exploitation (lateral movement) highlights the potential for attackers to use this technique across multiple stages of a cyberattack.
Evaluations
Our evaluation of DeepSeek focused on its susceptibility to generating harmful content across several key areas, including malware creation, malicious scripting and instructions for dangerous activities. We specifically designed tests to explore the breadth of potential misuse, employing both single-turn and multi-turn jailbreaking techniques.
Our testing methodology involved some of the following scenarios:
Bad Likert Judge (keylogger generation): We used the Bad Likert Judge technique to attempt to elicit instructions for creating an data exfiltration tooling and keylogger code, which is a type of malware that records keystrokes.
Bad Likert Judge (data exfiltration): We again employed the Bad Likert Judge technique, this time focusing on data exfiltration methods.
Bad Likert Judge (phishing email generation): This test used Bad Likert Judge to attempt to generate phishing emails, a common social engineering tactic.
Crescendo (Molotov cocktail construction): We used the Crescendo technique to gradually escalate prompts toward instructions for building a Molotov cocktail.
Crescendo (methamphetamine production): Similar to the Molotov cocktail test, we used Crescendo to attempt to elicit instructions for producing methamphetamine.
Deceptive Delight (SQL injection): We tested the Deceptive Delight campaign to create SQL injection commands to enable part of an attacker’s toolkit.
Deceptive Delight (DCOM object creation): This test looked to generate a script that relies on DCOM to run commands remotely on Windows machines.
These varying testing scenarios allowed us to assess DeepSeek-'s resilience against a range of jailbreaking techniques and across various categories of prohibited content. By focusing on both code generation and instructional content, we sought to gain a comprehensive understanding of the LLM's vulnerabilities and the potential risks associated with its misuse.
Conclusion
Our investigation into DeepSeek's vulnerability to jailbreaking techniques revealed a susceptibility to manipulation. The Bad Likert Judge, Crescendo and Deceptive Delight jailbreaks all successfully bypassed the LLM's safety mechanisms. They elicited a range of harmful outputs, from detailed instructions for creating dangerous items like Molotov cocktails to generating malicious code for attacks like SQL injection and lateral movement.
While DeepSeek's initial responses often appeared benign, in many cases, carefully crafted follow-up prompts often exposed the weakness of these initial safeguards. The LLM readily provided highly detailed malicious instructions, demonstrating the potential for these seemingly innocuous models to be weaponized for malicious purposes.
The success of these three distinct jailbreaking techniques suggests the potential effectiveness of other, yet-undiscovered jailbreaking methods. This highlights the ongoing challenge of securing LLMs against evolving attacks.
As LLMs become increasingly integrated into various applications, addressing these jailbreaking methods is important in preventing their misuse and in ensuring responsible development and deployment of this transformative technology.
Palo Alto Networks Protection and Mitigation
While it can be challenging to guarantee complete protection against all jailbreaking techniques for a specific LLM, organizations can implement security measures that can help monitor when and how employees are using LLMs. This becomes crucial when employees are using unauthorized third-party LLMs.
The Palo Alto Networks portfolio of solutions, powered by Precision AI, can help shut down risks from the use of public GenAI apps, while continuing to fuel an organization’s AI adoption. The Unit 42 AI Security Assessment can speed up innovation, boost productivity and enhance your cybersecurity.
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: 00080005045107
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.
We identified a cluster of activity that we track as CL-STA-0048. This cluster targeted high-value targets in South Asia, including a telecommunications organization.
This activity cluster used rare tools and techniques including the technique we call Hex Staging, in which the attackers deliver payloads in chunks. Their activity also includes exfiltration over DNS using ping, and abusing the SQLcmd utility for data theft.
Based on an analysis of the tactics, techniques and procedures (TTPs), as well as the tools used, the infrastructure and the victimology, we assess with moderate-high confidence that this activity originates in China.
The campaign primarily aimed to obtain the personal information of government employees and steal sensitive data from targeted organizations. These objectives bear the hallmarks of a nation-state advanced persistent threat (APT) espionage operation.
The threat actor behind this campaign demonstrated a methodical approach to network penetration to establish a foothold. We observed systematic attempts to exploit known vulnerabilities on public-facing servers, specifically targeting the following services:
IIS
Apache Tomcat
MSSQL services
Organizations that protect sensitive information should focus on patching commonly exploited vulnerabilities. They should also follow best practices for IT hygiene, as APTs frequently attempt to gain access using methods that have proven successful in the past.
We are sharing our analysis to provide defenders with means to detect and protect themselves against such advanced attacks.
Palo Alto Networks customers are better protected from the threats discussed in this article through Cortex XDR and XSIAM.
Customers are also better protected through the following products and services:
Throughout our investigation, we observed a distinct sequence of events that characterized the threat actor's activities. Figure 1 illustrates this timeline, showcasing the key stages and progression of the attack.
Figure 1. Activity timeline of CL-STA-0048.
Exploiting Multiple Entry Points
We observed the threat actor attempting to exploit three critical services, one after the other:
IIS
Apache Tomcat
MSSQL Services
With each failure, the threat actor adapted, targeting the next vulnerable asset in this list.
The Initial Target: Attempting to Exploit IIS Servers
On the first attempt, the threat actor tried to exploit vulnerabilities on multiple IIS servers in the environment, trying to deliver and deploy several web shells. These attempts were blocked by Cortex XDR.
Anti-Webshell and Anti-Exploitation Modules
The attackers’ attempts to deploy a web shell were also prevented by Cortex XDR.
The Attackers Shift to Apache Tomcat
After failing to exploit the IIS servers, the threat actor targeted an internet-facing Apache server, deploying a ColdFusion web shell as shown in Figure 2. This was again blocked by Cortex XDR.
Figure 2. ColdFusion web shell used in the attack.
One Final Attempt: An MSSQL Server
On the third attempt, the threat actor was able to compromise an unpatched internet-facing MSSQL server. The following section details the malicious activity that we observed from the compromised server.
Reconnaissance and a Rarely Seen Exfiltration Technique
The threat actor leveraged PowerShell to download multiple batch scripts from a remote server. These scripts executed commands such as tasklist to enumerate running processes on compromised machines and dir to list the contents of directories.
The scripts exfiltrated command outputs by formatting each line as a string constructed of a series of subdomains and sending ping requests to these subdomains. Each ping command triggered a DNS request, transmitting the exfiltrated data to the attackers via DNS.
The threat actor used dnslog.pw, a Chinese DNS logging tool for pen testers, to capture the output. Figure 3 below illustrates this data exfiltration technique.
Figure 3. Process tree of the data exfiltration using the ping command.
In addition, the threat actor attempted to save the output of the dir command into text files and then uploaded the output file to their command and control (C2) server using PowerShell. Figure 4 below shows the command they used.
Figure 4. Exfiltration command.
Preparing the Ground: The “Hex Staging” Method and Delivering Malware
PlugX as the Attacker's Main Backdoor
The initial and primary backdoor the threat actor used in this attack was the PlugX backdoor. PlugX is a well-known remote access tool (RAT) with modular plugins and customizable settings that has been popular for over a decade, primarily among Chinese-speaking threat groups.
The threat actor abused certutil to download the PlugX component from a remote domain under the following URL path:
https://h5.nasa6[.]com/shell/
The attackers dropped and executed the following payloads:
Acrobat.exe - A legitimate Adobe Acrobat binary
Acrobat.dxe - An encrypted PlugX payload
Acrobat.dll - A PlugX loader
The payloads were saved under the path C:\ProgramData\DSSM\
The threat actor then used the DLL sideloading technique and exploited vulnerable legitimate binaries (Acrobat.exe) to initiate the PlugX loader Acrobat.dll. This technique was detected by Cortex XDR.
When the legitimate binary successfully sideloaded the PlugX loader, it searched for the payload Acrobat.dxe in the system. Once it found the payload, the PlugX loader proceeded to load, decrypt and then inject it into a legitimate instance of svchost.exe.
The PlugX payload then connected to the C2 server mail.tttseo[.]com, executing in memory as a detection evasion attempt.
Talos mentioned similar TTPs including the same file names, several hashes and the C2 address in their September 2024 blog about a Chinese threat actor called DragonRank. Figure 5 shows how Cortex XDR captured the PlugX execution flow.
Figure 5. Detection of PlugX execution flow, as shown in Cortex XDR.
Hex Staging: Another Rarely Seen Technique Used by the Threat Actor
Once the threat actor gained a foothold inside the network, they attempted to upload additional tools. They employed a stealthy and uncommon technique to do this, in which the attackers deliver payloads in chunks (T1027: Obfuscated Files or Information). We call this technique Hex Staging.
In Hex Staging, an attacker incrementally writes hex-encoded data into a temporary file piece by piece, using commands passed to cmd.exe. This method avoids detection systems that scan for direct file writes.
Once the file is assembled in hex format, the attacker uses a tool like certutil to decode the hex data back into ASCII. This content could be either binary executables or scripts. This method bypasses conventional security detection by using native Windows utilities to covertly deliver and execute malicious code.
Figure 6 shows an example of the Hex Staging commands used by the threat actor.
Figure 6. Hex Staging commands.
The threat actor attempted to deliver multiple files using this method. This included binary files such as Cobalt Strike loaders and implants, as well as a .sql script, which we will describe later in this post.
A PowerShell script that loaded Cobalt Strike (shown in Figure 7) was among the payloads they wrote using that technique. It was detected and prevented by Cortex XDR.
Figure 7. Alert for the malicious PowerShell script, as shown in Cortex XDR.
Privilege Escalation Tools
SspiUacBypass
After establishing a foothold in the environment, we observed the threat actor attempting to bypass User Account Control (UAC), leveraging the SspiUacBypass tool. This technique exploits the Windows Security Support Provider Interface (SSPI) to sidestep UAC prompts, allowing the actor to run high-privileged processes without user consent.
The Potato Suite
To successfully execute certain tools, the threat actors needed to run their tools and commands with adequate privileges, such as Admin or SYSTEM. To do so, they used different tools from the popular Potato Suite, a collection of various native Windows privilege escalation tools.
The main tools that we observed during the investigation were:
BadPotato: A local privilege escalation tool that elevates user privileges to SYSTEM for command execution
RasmanPotato: This tool exploits the Windows Remote Access Connection Manager (RASMAN) service to gain system-level access, allowing high-privilege operations without user interaction
Command-and-Control Tools
SoftEther VPN
Another tool that we observed the threat actor using is a renamed version of the open-source SoftEther VPN. This software is flexible and has multi-protocol support. Threat actors, particularly those in Chinese groups, frequently abuse it for stealthy communications and bypassing network restrictions.
Figure 8 shows the command the threat actors used to download the client and configuration file.
Figure 8. The command used to download the SoftEther VPN client and configuration file.
Winos4.0-Based Downloader
The threat actor also attempted to use a downloader built using the advanced malicious framework Winos4.0. The downloader, placed under drivers\etc masquerading as hosts.exe, attempted to connect to the IP address 154.201.68[.]57.
After a successful connection, it downloads the payload and saves it into the registry key d33f351a4aeea5e608853d1a56661059. It then executes the payload. Fortinet observed similar behavior as part of the execution of another malware called ValleyRAT, which we believe the threat actor built using the same framework.
The downloader variant we discovered also leverages the KCP Protocol. This is a fast and reliable automatic repeat-request (ARQ) protocol that provides low-latency and faster communications.
Chinese threat actors were the main users of this protocol [PDF] in the past, including the infamous APT41. This corresponds with the fact that the main GitHub page is written in Mandarin, suggesting it mainly addresses Mandarin-speaking hackers.
Cobalt Strike Execution
The threat actor deployed Cobalt Strike to execute additional malicious activities within the compromised environment. Using the Hex Staging technique mentioned earlier, the loader was dropped onto the SQL server. Upon execution, it injected the Cobalt Strike beacon into winlogon.exe, initiating communication with the configured C2 server sentinelones[.]com.
One of their initial objectives was dumping the LSASS process. This attempt was detected and successfully blocked by Cortex XDR, preventing the harvesting of credentials.
The threat actor also used the Cobalt Strike implant to deliver additional payloads. Those payloads were two sets of legitimate binaries and DLLs:
The first pair was a legitimate ecmd.exe and the malicious DLL msvcp140.dll
The second pair was the AppLaunch.exe application and the malicious DLL mscoree.dll
The threat sideloaded the malicious DLLs to the legitimate binaries to load Stowaway, a multi-hop proxy tool, shown in Figure 9 below. The threat actor used this tool to create a connection back to one of its main C2 servers: 43.247.135[.]106.
After failing to load the malicious DLLs, the threat actor tried to use another tool for the same purpose: iox, a port forward and intranet proxy tool.
Finally, the actor attempted to create a new database user through the Cobalt Strike beacon. We will explore this step and its implications in detail in the following section.
Figure 9. Execution flow of Cobalt Strike, as shown in Cortex XDR.
Aiming Toward the Database: Stealing Tables Data
Creating a Privileged Database User
Once the threat actor established their presence in the network, they attempted to exfiltrate sensitive data from SQL servers.
The threat actor initially attempted to create a database user with the username webuseraa and password teasd$%!FFr. They granted the user System Administrator privileges on the main database using the command shown in Figure 10.
Figure 10. Creation of database user.
Deploying a Malicious SQL Script
The attacker also created an SQL script named 1.sql.tmp using the Hex Staging technique mentioned earlier in this post. They first decoded the hex file into ASCII using certutil and saved the file as 1.sql (shown in Figure 11).
Figure 11. The malicious SQL script.
Then they executed the script and saved the output into the text file shown in Figure 12 below.
Figure 12. Execution of the malicious SQL script.
This script identifies and exfiltrates sensitive contact information stored across multiple databases by searching for columns that could contain phone-related data, such as those named “phone,” “Mobile” or “TEL.” The script then aggregates results across databases, generating a list with the database name, schema, table, column names and total row count for each match.
Figure 13 shows the execution flow of the SQL script.
Figure 13. Execution flow of the SQL script, as shown in Cortex XDR.
After executing the script, the threat actor attempted to exfiltrate the output text file containing the results to their C2 server, as shown in Figure 14. They then deleted the script from the server.
Figure 14. Exfiltration command.
The Abuse of Sqlcmd.exe for Data Exfiltration
By leveraging the sqlcmd utility, the attacker connected to the local SQL server instance (127.0.0[.]1) on port 1434 and executed a dynamic SQL query. Such a query creates a temporary table to store metadata about all tables across accessible databases.
The script dynamically generates SQL commands to iterate through all user databases (excluding system databases) and retrieves details like database name, schema name and table name. Figure 15 below shows the database harvesting command.
Figure 15. DB harvesting command-line execution.
The results are then sorted and written into an output file (C:\users\public\123.txt), which the threat actors tried to exfiltrate later, as shown in Figure 16 below. After that, the threat actor deleted the temporary table.
Figure 16. Exfiltration command.
Finally, the threat actor attempted to extract personally identifiable information (PII) and sensitive client data from one of the databases, specifically targeting details such as:
Client names
Mobile numbers
Gender
Birth dates
Email IDs
Residential addresses
The command groups this data by mobile number and saves the output as a .zip file, as shown in Figure 17.
Figure 17. Database theft command-line execution.
Connection to the Chinese Nexus
Overlaps with DragonRank
The threat actor behind this cluster of activity employed PlugX as one of its primary backdoors. They used specific components (notably the loader and payload), exhibiting an overlap with those used by DragonRank, a recently identified Chinese threat group.
We lack sufficient data on DragonRank to definitively link it to CL-STA-0048. However, we acknowledge the similarities between the two while keeping CL-STA-0048 as a distinct cluster for tracking purposes. This allows us to monitor for potential connections without making premature conclusions.
Activity Time Frame
During our investigation, we successfully traced the time frame of the threat actor's interactive sessions. We focused on hands-on-keyboard commands executed on the compromised SQL server, as well as commands sent to the different active backdoors. A thorough review of the activity's time over several months revealed a notable and consistent pattern.
Our findings, as illustrated in Figure 18 below, demonstrate a correlation with typical 9-to-5 working hours in the UTC+8 time zone. This time period notably aligns with the business hours of various Asian nations, with China being a prominent example.
Figure 18. Comparison of activity time frame between UTC and UTC+8.
DNS Logging Service
Figure 19 shows that the threat actor used a DNS logging service primarily designed for a Chinese-speaking audience to exfiltrate command output, as we mentioned earlier in this article. Although this service is globally accessible, its usage patterns and associated tool ecosystems suggest a predominant adoption within Chinese cybersecurity circles, where it closely aligns with local security testing practices.
Figure 19. DNSlog System web description.
KCP Protocol
The threat actor’s use of a Winos4.0-based Downloader leveraging the KCP Protocol could suggest a Chinese origin. The protocol has been historically associated with Chinese threat actors like APT41 and is documented primarily in Mandarin, indicating its intended audience is Chinese-speaking developers. This linguistic and operational context points to a likely connection to the Chinese cyberthreat ecosystem.
Supershell Panel
During our investigation, we observed the attackers downloading several files from the IP address 206.237.0[.]49. Elastic disclosed this IP address in January 2024 as part of the Supershell C2 platform. While Supershell is openly available on GitHub, its interface and documentation are primarily tailored to a Mandarin-speaking audience, further solidifying the connection to the Chinese nexus.
Conclusion
The CL-STA-0048 campaign represents a significant threat, targeting government and telecom entities in South Asia with a clear focus on espionage. The threat actor behind it leverages tactics to evade detection, bypass security measures and exfiltrate sensitive data from high-value targets.
CL-STA-0048 exploits unpatched vulnerabilities in widely used services such as IIS, Apache Tomcat and MSSQL. It adapts to new defenses and deploys rarely seen techniques, adjusting its methods to overcome defenses and achieve its objectives.
Our analysis indicates a strong link between this group and the Chinese nexus based on the observed tools, techniques and victimology.
These findings emphasize the critical need for organizations to prioritize proactive cybersecurity measures. Addressing known vulnerabilities, maintaining robust IT hygiene and employing vigilant threat monitoring are essential to counter adversaries like CL-STA-0048. Organizations can better protect sensitive data and defend against advanced and persistent threats by strengthening security measures and staying informed about emerging threats.
Protections and Mitigations
For Palo Alto Networks customers, our products and services provide the following coverage associated with this activity cluster:
Advanced WildFire cloud-delivered malware analysis service accurately identifies the PlugX and CobaltStrike samples mentioned in this article as malicious.
Prevent the execution of known malicious malware and also prevent the execution of unknown malware using Behavioral Threat Protection and machine learning based on the Local Analysis module.
Protect against exploitation of different vulnerabilities using the Anti-Exploitation modules as well as Behavioral Threat Protection.
Detect user and credential-based threats by analyzing anomalous user activity from multiple data sources.
Protect from threat actors dropping and executing commands from web shells using Anti-Webshell Protection.
Cortex Xpanse is able to detect internet-exposed Microsoft IIS, Apache Tomcat and MSSQL Servers, among hundreds of other types of enterprise applications.
If you think you might have been impacted 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: 00080005045107
Palo Alto Networks has shared these findings, including file samples and indicators of compromise, 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.
Unit 42 stopped monitoring this threat as well as updating this brief on March 11, 2025. Please refer to Ivanti's Security Advisory for the latest information.
On Jan. 8, 2025, Ivanti released a security advisory for two vulnerabilities (CVE-2025-0282 and CVE-2025-0283) in its Connect Secure, Policy Secure and ZTA gateway products. This threat brief provides attack details that we observed in a recent incident response engagement to provide actionable intelligence to the community. These details can be used to further detect current attacks noted in the wild using CVE-2025-0282.
These Ivanti products are all appliances that facilitate remote connections into a network. As such, they are outward-facing assets that attackers could target to infiltrate a network.
CVE-2025-0282 is a stack-based buffer overflow in Ivanti Connect Secure before version 22.7R2.5, Ivanti Policy Secure before version 22.7R1.2 and Ivanti Neurons for ZTA gateways before version 22.7R2.3 that allows a remote unauthenticated attacker to achieve remote code execution. This vulnerability has been assigned a critical CVSS score of 9.0.
CVE-2025-0283 is a stack-based buffer overflow in Ivanti Connect Secure before version 22.7R2.5, Ivanti Policy Secure before version 22.7R1.2 and Ivanti Neurons for ZTA gateways before version 22.7R2.3 that allows a local authenticated attacker to escalate their privileges. This vulnerability has been assigned a high CVSS score of 7.0.
On the same day of Ivanti’s advisory, Mandiant disclosed its findings of attacks in the wild using the CVE-2025-0282 remote code execution vulnerability.
On January 10, Watchtowr Labs also provided analysis of the exploited vulnerability. On January 12, Watchtowr provided a walkthrough and on January 16 they published a proof of concept (PoC).
Palo Alto Networks customers receive protections from and mitigations for CVE-2025-0282 and CVE-2025-0283 in the following products and services:
Cortex Xpanse has the ability to identify exposed Connect Secure, Policy Secure and ZTA gateway products on the public internet and escalate these findings to defenders.
Palo Alto Networks also recommends applying the appropriate updates to the affected Ivanti appliances as described in their security advisory.
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.
CVE-2025-0282 is a buffer overflow vulnerability that can be exploited by an unauthenticated attacker. Because the affected appliances are outward-facing and on the edge of the network, attackers could scan for and directly target them.
If the appliance is vulnerable, an attacker can exploit it by sending a specially crafted request. If the exploit is successful, the attacker can gain a foothold into the internal network behind the appliance. This would be an initial foothold for an attacker to laterally move into the network behind the affected Ivanti appliance.
Details of the CVE-2025-0283 Vulnerability
CVE-2025-0283 is a stack-based buffer overflow that allows a local authenticated attacker to escalate privileges. There are no reports of attackers using the CVE-2025-0283 privilege escalation vulnerability at this time.
Current Scope of the Attack Against CVE-2025-0282
There are limited reports of attackers using the CVE-2025-0282 remote code execution vulnerability to gain access into affected systems.
We have observed specific tools, tactics and procedures with this attack, many of which align with third-party reporting. We currently track this activity as cluster CL-UNK-0979. While overlaps exist between our observations and activity reported by Mandiant as UNC5337, we do not yet have enough evidence to confirm whether this activity is by the same threat actor group.
The attacks in the activity cluster CL-UNK-0979 consist of four phases:
Initial access
Credential harvesting and lateral movement
Defense evasion
Persistence
Initial Access
Our telemetry reveals a threat actor potentially exploited the CVE-2025-0282 zero-day, pre-authentication remote code execution vulnerability in a public-facing Ivanti Connect Secure (ICS) VPN appliance in late December 2024.
While we were unable to recover evidence showing the specific exploit, we did observe several instances of the error below in the appliance's debug.log file in the days leading up to the threat actor dropping malware on the Ivanti appliance:
vc0 0 ifttls tnctransport.cc:1198 - Invalid IFT packet received from unauthenticated client. IP : <REDACTED>
We observed both Tor and Nord VPN infrastructure generating the above log message. Third-party reporting suggests exploitation of CVE-2025-0282 involves a vulnerability in how IFT (also known as IF-T) connections are handled. The consistent IFT errors suggest that attackers made a number of attempts to exploit this vulnerability.
Credential Harvesting and Lateral Movement
Attackers leveraged a custom Perl script named ldap.pl to harvest credentials from the Ivanti appliance, which they likely used to move laterally into the victim environment. Attackers used Remote Desktop Protocol (RDP) to move laterally to additional systems and deployed a simple memory dumping tool named package.dll to potentially dump LSASS memory for credential harvesting.
Defense Evasion
Post-exploitation, attackers engaged in anti-forensic activities including deleting critical log files to cover up their actions. Specifically, a recovered debug log file only showed a specific period of time after the initial intrusion, suggesting they had removed other log entries.
Additionally, the Ivanti appliance's /var/cores directory was empty, and the following files had been deleted:
/data/runtime/logs/log.events.vc0
/data/var/dlogs/debuglog
Persistence
The threat actor attempted to leverage a tunneler named SPAWNMOLE, an SSH backdoor named SPAWNSNAIL and a log tampering utility named SPAWNSLOTH as described by Mandiant for persistence on the Ivanti appliance. Pivoting into the environment, the attackers leveraged a service named DcomSrv and a scheduled task named /mail for persistence for the backdoor.
Post-Exploitation Tooling
To better understand the CL-UNK-0979 activity cluster, we examined the following tools used in the attacks:
The custom Perl script named ldap.pl
The memory dumping tool named package.dll
A backdoor established through DLL side loading using files named vixDiskLib.dll and deelevator64.dll
Custom Perl Script: Ldap.pl
The attackers used a custom Perl script named ldap.pl, which appears designed to collect and decrypt passwords from the Ivanti appliance. The redacted Perl script is shown below in Figure 1.
Figure 1. Content of Perl script ldap.pl used in the attacks.
Simple Memory Dumping Tool: Package.dll
After moving laterally from the Ivanti appliance via RDP to a Windows host, attackers then used the legitimate build tool for Visual Studio named MSBuild.exe as a living off the land binary (LOLBIN) technique to create a likely memory dumping tool named package.dll. We observed a Windows Shortcut named msbuild.lnk likely used to launch MSBuild.exe to compile and run application code we found in a file on the system named mini.xml.
Soon after MSBuild.exe was executed, a file was created at C:\Users\Public\Music\package.dll on the targeted system. This file creates a full memory dump at C:\Users\Public\Downloads\VM.txt and XOR encodes it with a key 0x27. While we did not observe how this tool was used, attackers could have used it to access the LSASS process memory for credential harvesting.
Backdoor Through DLL Side Loading: VixDiskLib.dll and Deelevator64.dll
We observed the attackers leveraging a backdoor through DLL sideloading. The malicious DLL files were named deelevator64.dll and vixDiskLib.dll, and they were loaded by legitimate Windows executable files named DeElevate64.exe and vmdisk.exe respectively.
The malware file named vixDiskLib.dll creates a service named DcomSrv. A description of the service embedded in the code from the file is shown below in Figure 2. Note how the term DCOMCLIENT is misspelled the second time as DCOMLIENT. This is an indicator for this particular binary.
The DCOMCLIENT service launches COM and DCOM servers in response to object activation requests. If this service is stopped or disabled, programs using COM or DCOM will not function properly. It is strongly recommended that you have the DCOMLIENT service running.
Figure 2. Viewing the binary for vixDiskLib.dll in a hex editor, showing text with a description of the service and the misspelled term DCOMLIENT.
Attackers set up a scheduled task named /mail for persistence to run DeElevate64.exe to sideload deelevator64.dll.
These malicious DLL files load other files located in the same directory:.
vixDiskLib.dll loads a file named error.dat
deelevator64.dll loads a file named temp.log
We were unable to recover error.dat or temp.log, inhibiting our ability to fully analyze this malware.
The error.dat or temp.log files will be mapped to memory and decrypted. Then the sample will spawn svchost.exe in a suspended state to attempt process hollowing to load the decrypted payload into memory. We observed the injected processes beaconing to C2 IP addresses at 168.100.8[.]144 and 193.149.180[.]128.
Interim Guidance
Ivanti has provided a security update in its security advisory to mitigate these RCE and privilege escalation vulnerabilities. Ivanti has also advised that activity targeting CVE-2025-0282 has been specifically observed on their Connect Secure appliances and not on Policy Secure or ZTA gateways to this point.
Ivanti was alerted to the exploitation activities via its Integrity Checker Tool (ICT). This allowed Ivanti to quickly develop a patch to mitigate the vulnerability.
Ivanti recommends applying its patch to mitigate these vulnerabilities as well as continually monitoring its ICT for suspicious activities.
Conclusion
Based on the topology of the affected Ivanti appliances and the possibility of an impending PoC for this vulnerability, we highly recommend following Ivanti’s patch and guidance provided in its security advisory. We will continue to monitor for further attacks using this vulnerability and will provide updated indicators of compromise as necessary.
Palo Alto Networks customers are better protected by our products, as listed below. We will update this threat brief as more relevant information becomes available.
Palo Alto Networks Product Protections for Ivanti CVE-2025-0282
Palo Alto Networks customers can leverage a variety of product protections and updates to identify and defend against this threat.
Next-Generation Firewalls and Prisma Access With Advanced Threat Prevention
Cortex Xpanse has the ability to identify exposed Connect Secure, Policy Secure and ZTA gateway products on the public internet and escalate these findings to defenders. Customers can enable alerting on this risk by ensuring that the “Insecure Pulse Secure Pulse Connect Secure VPN” 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.
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: 00080005045107
We have 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.
When launching and persisting attacks at scale, threat actors can inadvertently leave behind traces of information. They often reuse, rotate and share portions of their infrastructure when automating their campaign’s setup before launching an attack. Defenders can leverage this behavior by pivoting on a few known indicators to uncover newer infrastructure.
This article describes the benefits of automated pivoting and uses three case studies to show how we can discover new indicators. Using a network crawler leveraging relationships among domains, we discovered network artifacts around known indicators and trained a graph neural network (GNN) to detect additional malicious domains.
These three case studies show that defenders can proactively discover attack infrastructure by continuously monitoring a threat actor's evolving indicators. The three case studies covered in this article are:
A postal services phishing campaign
A credit card skimmer campaign
A financial services phishing campaign
Palo Alto Networks customers are better protected from the threats discussed in this article via Advanced URL Filtering and Advanced DNS Security, which deploy proactive threat hunting capabilities to discover malicious URL infrastructure. Advanced WildFire also provides coverage for the associated samples and other indicators discussed in this post.
One of the best ways to defend against cyberattacks is to proactively discover a threat actor's new infrastructure based on known indicators. We can then block the associated infrastructure before they can weaponize it. Using automated detection through a GNN model can reveal hidden connections and allow earlier detection of new indicators.
Figure 1 shows an example of domains reportedly used by FIN7, a Russian threat actor we track as Squeamish Libra.
Figure 1. Registration and detection timeline of spear phishing domains used by Squeamish Libra (FIN7).We discovered an initial batch of domains on about Sep. 19, 2023, that were originally registered a month earlier. Pivoting on information from these domains, we detected the next batch of domains within seven days of registration. Our continued monitoring and correlation revealed the last domain on the timeline only one day after it was initially registered.
The initial three fake vendor domains shown in Figure 1 are:
advanced-ip-sccanner[.]com
myipscanner[.]com
myscannappo[.]com
Based on our in-house content analyzers and third-party intelligence, these domains all hosted a malicious binary named Advanced_Ip_Scanner_setup.exe posing as an installer for Advanced IP Scanner. However, it was an installer for Aranuk/Carbanak malware.
Threat actors often abuse, take advantage of or subvert legitimate products for malicious purposes. This does not imply that the legitimate product is flawed or malicious.
This threat actor also registered other domains to weaponize later. However, we pivoted on the hosting infrastructure and mapped additional domains.
Figure 2 shows a diagram mapping the infrastructure of this phishing campaign.
Figure 2. Infrastructure behind the FIN7 spear phishing campaign
The domains with the red symbol shown in Figure 2 are the known malicious domains before we expanded the infrastructure map for this campaign. Note that we have omitted some of the nodes and edges in this diagram to more clearly show the relationships between the known domains and newly discovered domains.
We can identify new indicators through automated pivoting on known infrastructure based on:
The relationships between different types of indicators
Pivoting on these relationships using GNN
Relationships Between Different Types of Indicators
We can pivot on existing infrastructure based on the relationship between different types of indicators. These indicators are:
Co-hosted domains
Malware delivery URLs
Command-and-control (C2) domains
HTTPS certificates for domains
HTTPS certificates for IP addresses
Phishing kits
Co-Hosted domains: To orchestrate large-scale attacks, threat actors often register numerous domains and rotate through them over time, typically using similar hosting infrastructure. For example, the group behind a malicious link shortening service nicknamed Prolific Puma has registered thousands of domains to evade detection. This group further obscured its activity by abusing shared hosting services. Despite these evasion tactics, strong connections remained between older and newer Prolific Puma domains because they were simultaneously hosted on multiple IP addresses.
Malware delivery URLs: Threat actors occasionally use different URLs to distribute the same malware file. Pivoting on a malware file can reveal new delivery URLs from a different source.
C2 domains: Malware binaries can connect to multiple C2 domains, either simultaneously or rotating over time. Investigating these domains can reveal a history of IP addresses hosting the servers using these domains.
HTTPS certificates for domains:SSL or TLS certificates are used by web servers for identity validation and establishing secure HTTPS connections. All modern web browsers require a valid certificate for HTTP traffic, and phishing websites must have a valid certificate to successfully impersonate a legitimate brand. To automate and scale a campaign, threat actors often acquire these certificates in bulk. Therefore, we can pivot on the fingerprints (sometimes called thumbprints) of these certificates to find other domains from the same campaign or threat actor.
HTTPS certificates for IP addresses: Since domains are used by servers hosted on IP addresses, these SSL/TLS certificates also apply to the associated IP address. In some cases, a web server or URL might not have a domain name and will use an IP address directly. Either way, we can search for fingerprints of HTTPS certificates across different IP addresses to discover additional infrastructure. For example, since the Russian invasion of Ukraine, multiple IP addresses hosting content from Russian threat actor Trident Ursa had the same fingerprint for self-signed certificates used during HTTPS traffic.
Phishing kits: Phishing kits are often discovered in the wild as ZIP archives that contain templates used to create phishing sites that impersonate login pages of a famous company or brand. Criminals often purchase these through phishing-as-a-service operations like 16shop. They can then deploy the same phishing kit to multiple domains and their associated servers. We can identify these by searching for all domains associated with a particular phishing kit.
For an ongoing campaign, we can examine the relationships between these different types of indicators to discover new infrastructure. This is a time-consuming process if done manually, but we can automate the analysis through methods like GNN.
Pivoting Through GNN
A single correlation or association between two malicious domains does not necessarily mean these are part of the same campaign. For example, domains hosted on servers using the same IP address could be an example of shared hosting, where hundreds of domains use the same IP address.
However, multiple associations between two malicious domains indicate a shared infrastructure. For example, two domains having the following qualities indicate they are most likely part of the same campaign:
Shared same hosting provider
Distribution of the same malware file
Registration through the same registrar on the same day
The more associations, the stronger the relationship between the domains.
We can leverage this insight to gather as many correlations as possible between different domains and determine which are part of the same campaign. In addition to the indicators we've already discussed, further attributes like lexical patterns, hosting duration and content structure can also solidify the relationships between domains.
Using this insight, we can pivot from a small, seed set of known indicators to discover additional network artifacts. We do this for our internal detection by training a GNN classifier. Figure 3 shows a high-level flow chart of our pipeline.
Figure 3. A high-level flow chart of our neural network pipeline to detect malicious domains.
From the seed domains, we construct a graph that expands the information to include other known network artifacts. This enriches each graph node with discriminating features.
We extract these features to train a GNN classifier to detect new domains with high confidence. You can learn more about our approach in our recent Virus Bulletin 2024 talk and recent research publication [PDF] for the RAID 2024 International Conference.
Case Studies
We have used our GNN approach for detection during the past several months. The results indicate that threat actors tend to progressively register new domains over time. The attackers often reuse hosting infrastructure and domains, often using many domains during a short time window.
The following three case studies provide examples of this threat actor behavior.
Postal Service Phishing
We have tracked a large network of malicious infrastructure used for phishing websites impersonating national and private postal/package delivery services worldwide. Starting with a few hundred malicious domains, we've identified nearly 4,000 domains hosted on approximately 1,200 IP addresses linked to this campaign over the past year
This campaign has impersonated postal services in many countries, including:
The U.S.
Canada
Israel
India
Pakistan
The UK
Spain
Korea
Singapore
Australia
Ireland
Dominican Republic
Mexico
Italy
Figures 4 and 5 show a partial infrastructure mapping of clusters from this postal-themed phishing campaign totaling 61 domains and three IP addresses.
Figure 4. Infrastructure map of postal-themed phishing campaign, part 1 of 2.
The connected components in Figure 4 highlight shared infrastructure between domains impersonating the Republic of Korea postal service (Korea Post) and Spain's state-owned postal and courier server Correos.
Figure 5. Infrastructure map of postal-themed phishing campaign, part 2 of 2.
The connected components in Figure 5 show a shared infrastructure between domains targeting customers of the US Postal Service (USPS), the Panama Post Office (Panama Correos) and the Paraguay Post Office (Paraguay Correos).
We detected these domains between August 25-Sep. 20, 2024. Out of the 61 total domains:
33 impersonated Korea Post
18 impersonated Paraguay Correos
6 impersonated Panama Correos
3 impersonated the USPS
2 impersonated Correos Spain
These examples show that the attackers use the same hosting infrastructure to impersonate postal services operating in different parts of the world.
In another example, an IP address at 47.251.0[.]168 hosted malicious domains in September 2024 to target customers of the following postal services:
correosesllr[.]top - Correos Spain
inposdomag[.]top - Dominican Postal Institute (INPOSDOM)
inposdomak[.]top - INPOSDOM
usps.postscy[.]top - USPS
This postal-themed phishing campaign remains active throughout the year, but we noticed a trend of increased domains and hosting IP addresses from mid to late 2024. To evade detection, most domains have short windows of live activity before attackers switch to different domains, demonstrating a fast-flux pattern.
This campaign has reused IP addresses. For instance, nine unique IP addresses within the 103.120.80[.]0/24 subnet hosted a malicious domain impersonating postal services in September 2023. These IP addresses were inactive until June 2024, when attackers used them to host 11 different malicious domains impersonating postal services.
Figure 6. Malicious domains impersonating USPS discovered over time
Figure 6 shows 15 malicious domains impersonating postal services discovered over a span of two weeks in December 2024. Continuous monitoring of three IP addresses associated with malicious domains detected on Dec. 1, 2024 resulted in detection of additional malicious domains as the hosting IP addresses are often reused by threat actors.
The IP address 146.112.61[.]108 hosted around 160 malicious domains last year and was reused for 11 more domains this year. This included hosting eight domains in September 2024, all targeting customers of various postal services.
URLs for these phishing campaigns host pages featuring the targeted brand's logo, with various messages as shown in Figure 7.
“Your package is on hold due to an invalid recipient address. Fill in the correct address using this link.”
“Your package is stuck at customs due to unpaid fees. Click here to pay and avoid additional charges.”
Links in these initial phishing pages lead visitors to subsequent pages that request more personal information or payment details.
In a one month period from Sep. 10-Oct. 10, 2024, we detected 3,211 phishing domains associated with this campaign.
Web Skimmer Campaign
We detected a web skimmer campaign that continues to affect hundreds of commercial sites, some of which are in Tranco's list of the top 1 million sites. Attackers first compromised benign sites and installed client-side malicious JavaScript code called a skimmer.
Attackers then loaded this code on potential victims' machines when they visited pages from these sites. When victims logged in to the sites or entered their credit card, these skimmers stole the data and sent it to an exfiltration endpoint controlled by the attacker.
This campaign exfiltrated stolen data to domains with names impersonating well-known benign infrastructure. Examples of these exfiltration domains follow:
apple.com-ticket[.]info
cdn-google-tag[.]info
chatwareopenalgroup[.]net
establish-coinbase[.]com
google-site-verification[.]com
jquerylib-min[.]net
ssl-google-analytics[.]com
staticlitycis[.]com
After detecting these skimmers on a number of websites, we used our automated GNN approach to identify an expanded infrastructure from a group of seed indicators. The detected infrastructure included:
Domains that attackers had not yet weaponized
Assets active since 2022
Many IP addresses that were assigned to hosting providers in Russia
We identified 65 domains, 815 IP addresses and other indicators associated with this campaign since October 2023. This campaign is also active year-round.
There was a noticeable increase in hosting IP addresses in early 2024 and significant activity in June and July of 2024. Figure 8 shows a map of the infrastructure used for this campaign.
Figure 8. Infrastructure mapping for this web skimmer campaign.
The web skimmer map in Figure 8 contains 15 domains and their hosting infrastructure consisting of 249 IP addresses predominantly operated by Russian hosting providers. Attribution is unclear at this time, but some of our current indicators overlap with those previously attributed to TA569.
Financial Services Phishing
Threat actors used a large network of attacker-controlled infrastructure for phishing websites targeting customers of banking and financial services worldwide. These campaigns spoofed financial organizations' webpages to steal personal and financial data.
From October 2023-2024, we identified approximately 5,000 domains hosted on more than 5,600 IP addresses linked to this campaign. These phishing attacks targeted customers of banking services in many countries including:
The U.S.
Canada
India
Germany
Greece
South Africa
Kenya
The UK
Thailand
Switzerland
Each day, we noticed dozens of domains impersonating not only well-known large-scale banks, but many regional and local banks, as well as platforms for trading and investment. Most of these malicious domains used shared hosting infrastructure. These campaigns were also active year-round.
Figure 9 shows the infrastructure mapping for one of these campaigns. It illustrates connected components for 16 domains targeting customers of various banking institutions across the world using eight IP addresses.
Figure 9. Infrastructure mapping for the financial services phishing campaign.
Figure 10 shows screenshots from five examples of pages for financial services phishing activity.
Figure 10. Five examples of screenshots from phishing pages for financial services phishing activity.
Conclusion
Threat actors launch large-scale attacks using extensive hosting infrastructure, but this infrastructure changes over time as the attackers attempt to evade detection. This article described our automated GNN approach to pivoting on known indicators, so we can discover new infrastructure for active campaigns before attackers weaponize it.
Our three case studies revealed that threat actors share, reuse and rotate their attack infrastructure. They likely implement these changes through an automated setup process. This process inadvertently leaves behind traces of information we can detect through proactive searching.
Palo Alto Networks customers are better protected from the threats in this article through the following products:
Advanced WildFire covers the associated samples and other indicators discussed in this post
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: 00080005045107
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.
Acknowledgments
The authors would like to thank Bradley Duncan for the thorough technical review of the article, and Doel Santos for verifying the campaigns mentioned in it. We would also like to thank the editorial team including Samantha Stallings, Lysa Myers and Erica Naone for the assistance with improving and publishing this article. The authors would also like to thank Wei Wang for her guidance in development of this work.
Indicators of Compromise
Examples of domains used in Squeamish Libra (FIN7) activity:
advanced-ip-sccanner[.]com
ipscanneronline[.]com
ipscannershop[.]com
myipscanner[.]com
myscannappo[.]com
myscannappo[.]info
myscannappo[.]online
theipscanner[.]com
Examples of domains used in postal service-themed phishing:
correoparaguayo-myposta[.]top
correoparaguayo-mypostf[.]top
correoparaguayo-myposth[.]top
correoparaguayo-myposts[.]top
correoparaguayo-mypostvsa[.]top
correoparaguayo-mypostvsd[.]top
correoparaguayo-mypostvse[.]top
correoparaguayo-mypostvsf[.]top
correoparaguayo-mypostvsg[.]top
correoparaguayo-mypostvsh[.]top
correoparaguayo-mypostvsi[.]top
correoparaguayo-mypostvsl[.]top
correoparaguayo-mypostvsp[.]top
correoparaguayo-mypostvst[.]top
correoparaguayo-mypostvsu[.]top
correoparaguayo-mypostvsx[.]top
correoparaguayo-mypostvsy[.]top
correoparaguayo-mypostvsz[.]top
correosespe[.]top
correoseswe[.]top
correospanamaagobs-csc[.]top
correospanamaagobs-csd[.]top
correospanamaagobs-cse[.]top
correospanamaagobs-csr[.]top
correospanamaagobs-css[.]top
correospanamaagobs-csx[.]top
koreapostge[.]shop
koreapostma[.]shop
koreapostmk[.]shop
koreapostmv[.]shop
koreapostmx[.]shop
koreapostmz[.]shop
koreapostni[.]shop
koreapostnp[.]shop
koreapostnu[.]shop
koreapostpc[.]shop
koreapostpe[.]shop
koreapostpf[.]shop
koreapostpg[.]shop
koreapostpo[.]shop
koreapostpt[.]shop
koreapostpu[.]shop
koreapostpw[.]shop
koreapostst[.]shop
koreapostxb[.]shop
koreapostxn[.]shop
koreapostxt[.]shop
us-usos-qwtaa[.]top
us-usos-qwtad[.]top
us-usos-qwtaz[.]top
usps-supsrfvw[.]top
usps-supsrmuo[.]top
usps-supsrrne[.]top
usps-supsrrno[.]top
usps-supsrtys[.]top
uspsepsu[.]top
uspsftpr[.]top
uspsfugu[.]top
uspsgrjp[.]top
uspsntfj[.]top
uspstpar[.]top
uspsyeay[.]top
uspsygfk[.]top
Examples of domains used in web skimmer campaign:
byvlsa[.]com
cdn-google-tag[.]info
cdn-report[.]com
cdnreport[.]net
chatwareopenalgroup[.]net
cssjs[.]co
google-site-verification[.]com
jquerylib-min[.]net
jsmin[.]co
ns1.static5-jquery[.]com
ns2.static5-jquery[.]com
ssl-google-analytics[.]com
static5-jquery[.]com
staticlitycis[.]com
woocomnnerce[.]com
Examples of domains used in financial services phishing activity: