Skip to content
EggStreme Malware: Rebuilt Under Scrutiny

EggStreme Malware: Rebuilt Under Scrutiny

Bitdefender • November 18, 2026

TL;DR: After we published our first EggStreme research in September 2025, we kept monitoring this malware family, and the development we have seen since justifies an update. Documenting advanced persistent threat (APT, a state-aligned intrusion team) operations matters because these operators depend on staying unseen: once their tooling is public, defenders can hunt for it and find intrusions before they reach their objective. After we published our research, the operators revised their malware architecture and infrastructure, and the timing suggests our report was a likely trigger.

Twelve days after our report, they changed how EggStremeFuel protects its configuration. The loader’s cryptography and payload format followed 14 days later, and they appear to have moved away from the single certificate authority that once linked their servers. Based on our analysis, we assess with high confidence that the operation continues to target Philippine government organizations, with multiple victims. Based on our analysis of the samples, Taiwan is targeted as well, at low to medium confidence. The attribution is unchanged from our first report: a suspected Chinese APT group. This is a technical assessment based on the evidence available to us, not a statement the involvement of any government.

EggStreme Since Our First Report: Rotation Versus Rebuild

Our first EggStreme analysis ( Bitdefender EggStreme research, September 2025 ) described a multi-stage fileless framework. “Fileless” means the malicious code runs mostly from memory and leaves little on disk for file scanners to find. The framework had six named components: EggStremeFuel, EggStremeLoader, EggStremeReflectiveLoader, EggStremeAgent (a backdoor with 58 commands), EggStremeWizard and EggStremeKeylogger. We kept tracking the operation after we published. This article covers what changed - it does not explain the framework again, so readers who want the baseline should start with the first piece.

An APT operation succeeds only while it stays unseen. The objective is long-term access: months of quiet collection, not a quick payoff. Public analysis threatens that. Once a framework is documented, security teams can hunt for it, find intrusions already underway, and end the operation before it achieves its objective. For operators, exposure puts the whole mission at risk, so they respond by changing what defenders now know.

When attackers are exposed, the cheap response is to rotate. A file hash changes with every recompile, a domain costs a few dollars, and a new IP address costs less. The EggStreme operators did more than rotate - the agent we now see uses a different network protocol, has an enhanced command set, and comes in a passive variant that never beacons out. The infrastructure appears to be moving away from the one certificate authority that tied its older servers together. Each change broke static signatures and heuristic detections built around the framework as we first described it.

David Bianco’s Pyramid of Pain is a useful way to think this ( David Bianco, “The Pyramid of Pain”, March 2013 ). The pyramid ranks indicators by how much it costs an attacker when defenders detect them. Hash values sit at the bottom, then IP addresses and domain names, then network and host artifacts, then tools, and tactics, techniques and procedures (TTPs) at the top. For readability, this article groups the bottom three tiers together as “trivial” indicators. Mapped onto those tiers, the EggStreme operators did three things. They rotated hashes, IPs and domains (trivial). They changed payload paths, configuration formats and a firewall rule name (artifacts). They reworked Fuel, the loader and the agent (tools). The behaviors stayed largely the same: DLL sideloading, lateral movement through file shares, in-memory execution and mutual TLS. In other words, the operators spent at the tools level and kept their methods.

Three things made this operation easy to track when we published our first article: the hashes of known samples, a payload decryption method that worked across intrusions, and a single certificate authority that led to the whole server fleet. The operators have since worked on all three.

Our first article went out on September 17, 2025. The first Fuel build with the new configuration format was compiled on 2025-09-29, twelve days later. The first loader build in the newer format followed 14 days after that, with a compile timestamp of 2025-10-13 07:35:48, and was observed in the wild the day. No new domains have appeared under the legacy certificate authority since.

We tracked some minor changes to the agent before our report, but most of the major changes, including the infrastructure, were first observed after it was published (compile timestamps on some agent builds are earlier, so we date them by first sighting, not by build date).

Some of this speed comes from how the framework is built. EggStreme is not runtime-pluggable: operators cannot load new capabilities into a running implant on the fly. Capabilities are compiled into each build. Our build artifacts show that, from one common codebase, the operators choose at build time which capabilities to include, omit, or swap. The keylogger is the clearest example: it is missing from every newer agent build we have analyzed. Ciphers are another. The loader moved from the RC4 stream cipher (which encrypts data one byte at a time) to the RC5 block cipher (which encrypts fixed-size blocks) in a build dated 2025-10-13, and to a custom cipher by 2025-10-28, two weeks later.

The agent’s transport differs between generations. Within a generation, builds the same architecture and protocol, while cryptography, configuration and capability change per campaign. This design is what makes the rework affordable. Changing the cipher or dropping a module does not require a new framework, only a new build.

The infrastructure changed as well. The older EggStreme servers could be mapped from a single certificate authority (CA, the entity that signs TLS certificates) generated in 2019. Searching for that CA’s key identifier returns 32 linked domains. Newer activity suggests a move toward campaign-specific certificate authorities, with certificates and keys embedded directly in each binary, removing that single pivot point. Some pivots remain. Development servers stage certificates for domains before they go live, one development IP is shared across a set of domains, and some legacy domains reappear in the newer setup.

Above: The EggStreme build timeline shows which changes came before and after our initial report.

EggStreme Attribution and Victimology

Our first article attributed the EggStreme operation to a suspected Chinese APT group ( Bitdefender EggStreme research, September 2025 ). This update makes no new attribution claim. The reason we treat the newer activity as the same operation is technical continuity, which is documented in the sections that follow.

Several domains from the legacy infrastructure appear again in the newer setup. One of them, mepintei[.]com, connects the EggStremeFuel activity to the loader and agent activity. Before, we tracked those as two separate clusters. Older-format loader containers, the kind the first article described, are still in use and now carry the newer agent builds, so the two generations meet inside single samples. Delivery still relies on DLL sideloading, the same pattern the first article documented. Within the newer generation, every loader variant uses the same plaintext string KERNEL32 as both key and initialization vector (IV, the starting value a block cipher chains from) in its cryptography.

On victimology, we assess with high confidence that the operation continues to target Philippine government organizations, and that there are multiple victims. Based on our analysis of the samples, we also assess with low to medium confidence that Taiwan is targeted. Readers should treat that finding as a lead, not an established fact. We do not name victim organizations, and we do not publish a victim count. This broadens the target description from the first article, which covered a single Philippine military company.

EggStreme Lateral Movement: Same Strategy, New Mechanics

In the first article, lateral movement relied on Impacket-like tooling and on EggStremeAgent itself. Impacket is an open-source Python toolkit for remote Windows administration that attackers often use to execute commands ( What Is Impacket, TechZone ).

The operators also used the Stowaway proxy, an open-source multi-hop proxy tool that routes traffic through compromised hosts. They gained execution by injecting a Netlogon script, a logon script that domain-joined machines fetch from a shared folder, into a compromised . The overall strategy has not changed: stage the payload on shared storage that the targets already reach, then trigger execution remotely. What changed is the mechanics.

In the more recent case, the operators staged on an unmanaged system: a machine outside the organization’s endpoint management that other workstations could still reach easily. That system hosted Visual Basic Script (VBS) files, small scripts run by Windows’ built-in script host, along with an EggStremeFuel package. The package had three parts: a legitimate executable, a malicious DLL (dynamic-link library, a code module that Windows programs load at run time) for that executable to sideload ( T1574.002 DLL Side-Loading ), and a configuration file.

What is DLL Sideloading?

DLL sideloading places a malicious library to a legitimate, often signed, program that loads a library of that name at startup. The program runs normally and loads the attacker’s code with it, which helps the malicious code blend into expected process activity. Bitdefender’s explainer on the topic is What Is DLL Sideloading, TechZone .

The operators ran the script remotely over SMB (Server Message Block, the Windows file-sharing protocol) ( T1021.002 SMB/Windows Admin Shares ). The script copied the Fuel package to the target ( T1570 Lateral Tool Transfer ) and set persistence through a run key, a registry value that Windows executes automatically at user logon ( T1547.001 Registry Run Keys / Startup Folder ). Execution itself went through the Windows Script Host ( T1059.005 Visual Basic ) and a batch file ( T1059.003 Windows Command Shell ).

These are the elements we observed in the command activity:

Each name was chosen to look routine. StandaloneUpdater.exe imitates the naming of OneDrive’s own updater component. The genuine file is OneDriveStandaloneUpdater.exe , which sits under C:\Program Files\Microsoft OneDrive\ on a per-machine installation and directly under %LOCALAPPDATA%\Microsoft\OneDrive\ on a per-user one. The staged copy uses a shorter name and sits two folders deeper, in setup\logs , which is the mismatch to watch for ( T1036.005 Match Legitimate Resource Name or Location ). prncnfg.vbs is a real Windows printer administration script, documented by Microsoft under System32\Printing_Admin_Scripts ( Microsoft Learn, “prncnfg” ). Officelog.bat suggests Office logging. Toggling the hidden attribute ( T1564.001 Hidden Files and Directories ) keeps the staged files out of default directory listings when they are not in use.

We saw the same method on multiple machines in the same network. The pattern suggests that valid credentials ( T1078.002 Domain Accounts ) and a reachable were enough. The hashes in the indicator of compromise (IOC) tables will be stale by the campaign. The pattern will probably still apply: an unmanaged host serving scripts, SMB-triggered execution, a run key under a familiar-looking vendor path.

Abo ve: EggStreme lateral movement flow.

Defender action: Alert on WScript.exe or cmd.exe running scripts from C:\Users\Public\ , and on run-key values that point into %LOCALAPPDATA%\Microsoft\OneDrive\setup\logs\ or any OneDrive subfolder that is not the vendor’s installed updater path.

EggStreme v1 and v2: What Changed and What Varies

Two kinds of change are easy to confuse in what follows. One is the step from the framework we described in the first article (v1) to the newer generation (v2). The other is the variation we see between campaigns within v2, where builds of the same generation differ from each other. The following table helps clarify what changed and what varies.

Almost everything that defenders could key on at the file, protocol and infrastructure levels changed between v1 and v2, and keeps changing between campaigns. The behaviors stayed constant across both.

EggStremeFuel: Configuration Encryption Upgraded, C2 Unchanged

EggStremeFuel is mostly unchanged. However, one significant change is how it protects its configuration, and the first build with the new configuration format has a compile timestamp of 2025-09-29, twelve days after our first article.

The earlier Fuel decrypted its configuration with RC4, using the configuration filename as the key. The newer builds use AES-256-CBC, with the key and IV embedded in the binary. The IV is stored in plaintext in several places in the binary as 1234567890ABCDEF . The key is hidden by a custom obfuscation routine and recovers to:

15c7ab53f7cfec92512844244fb09c2f07c2e9aea42b604c31fb78633248a825

The newer configuration we recorded sits at %LOCALAPPDATA%\Microsoft\Windows\Notifications\wpndatabase.dat (MD5 8ad958676e67ff70d1b2b95851de6d5d ). The name imitates the Windows notification database in the same folder, which is wpndatabase.db , a SQLite database that Windows keeps under that path on current builds. The malicious file differs from the genuine one only in its extension. Moving from a filename-derived RC4 key to an embedded AES key means that knowing a configuration file’s name no longer helps decrypt it. The analyst needs the specific binary. The loader changes, described , follow the same pattern across components: decryption keys now travel with the build, not with anything an investigator can see on disk.

Fuel’s C2 traffic still uses RC4, with a key generated randomly on each run. Without the per-run key captured from memory, recorded Fuel traffic cannot be decrypted from static analysis alone, so packet captures will show sessions but not their content.

The newer Fuel configurations and binaries point to C2 infrastructure that includes mepintei[.]com, along with 45[.]115[.]225[.]73, 109[.]248[.]24[.]84 and 149[.]104[.]109[.]230. mepintei[.]com also appears in our records of the agent’s original infrastructure.

Defender action: Treat any non-Windows process that reads or writes %LOCALAPPDATA%\Microsoft\Windows\Notifications\wpndatabase.dat as suspicious, and when an EggStremeFuel infection is suspected, capture process memory before remediation, because the per-run RC4 traffic key exists only there.

EggStremeLoader: New Ciphers and a New Payload Format

The loader has one main job: stealth. It decrypts the stage and places it in memory without leaving a readable payload on disk. We identified four new loader samples soon after the first article, each with major structural changes and a different cryptographic algorithm. The IOC list shows one RC5 build dated 2025-10-13 and three custom-cipher builds dated 2025-10-28, which is six weeks after publication.

The first build in the newer format has a compile timestamp of 2025-10-13 07:35:48 UTC, 14 days after the first new Fuel build. We observed it in the wild the day, so we consider that timestamp reliable. In this build, string protection moved from XOR (a simple bitwise scrambling with a repeating key, easy to reverse) to RC5-32, the variant of RC5 that uses 32-bit words. It runs in CBC mode (cipher block chaining, where each block is mixed with the encrypted block before encryption) with PKCS#7 padding (a standard scheme that fills the last block to full length). Both the key and the IV are hardcoded in plaintext as KERNEL32 .

two weeks later, the scheme changed again. The builds stamped 2025-10-28 replace RC5 with a custom 8-byte block cipher, still in CBC mode with PKCS#7 padding. We call this first custom cipher variant A. In variant A, each byte of a block goes through a simple position-dependent transform, and the result is XORed with the ciphertext block. The payload path is still decrypted with KERNEL32 as both key and IV. Payload files work the same way, except that the key is the first 8 bytes of the file itself, stored unencrypted, and those bytes also serve as the IV. The file layout also varies within variant A: in one of the four builds, the block after the key holds a skip count instead of the payload size, and that many junk bytes, which the loader skips without decrypting, sit before the DLL. A decryptor therefore has to match both the cipher variant and the file layout.

Variant A stayed in use unchanged for at least a week. All four builds from 2025-10-28 to 2025-11-05 use the same algorithm, so one decryption routine covers them all. By mid-December 2025 the operators had replaced it with a second custom cipher, variant B. Variant B decrypts each block with four rounds of byte-wise subtraction, byte rotation and byte swapping, and undoes the chaining by subtracting the ciphertext block instead of XORing it. Both builds we have, from 2025-12-16 and 2026-05-14, use the same algorithm, and variant B handles keys and IVs the same way as variant A.

Neither custom variant offers real protection. Because the key and the IV are identical, variant A's key cancels out: every block except the first of each encrypted message decrypts with the same fixed constant (01 04 07 0A 0D 10 13 16) and no secret at all. In payload files, all of the DLL except its first 8 bytes therefore decrypts without any key, and those 8 bytes are the standard start of a PE (Portable Executable, the Windows executable format) header. Variant B looks more complex, but mathematically it reduces to a fixed byte rotation plus an 8-byte constant, so a single known 8-byte block is enough to decrypt the entire payload. For both variants, even that is unnecessary: brute-forcing each byte position separately (2,048 trials in total) recovers the payload from the ciphertext alone. In practice, none of this is needed, because both variants store the key to the data it protects: each payload file begins with its own key, so it contains everything needed to decrypt it. What the cipher swaps defeat is detection and tooling tied to a specific routine, not analysis.

The thread through all of this is the operators’ move from RC4, which the earlier loader builds used to decrypt payloads, to RC5 and then to the custom ciphers. Every variant in the newer format shares three traits: CBC chaining, a key-scheduling step (the routine that expands the short key into per-round values), and PKCS#7 padding removal.

Three builds stamped within 95 minutes of each other on 2025-10-28 suggest active iteration. They look like a short development session producing variants, not a single release.

These cipher changes map to obfuscation of the stored payload ( T1027 Obfuscated Files or Information ) and its in-memory reversal at run time ( T1140 Deobfuscate/Decode Files or Information ).

New Payload File Structure

The newer loader also reads a new payload file layout, and that layout has stayed the same since October 2025: