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 about the involvement of any government.
| I’d like to thank my colleagues, Victor Vrabie, Adrian Schipor, and Martin Zugec, for their invaluable contributions to this research. |
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 about 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 next 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, about two weeks later.
The agent’s transport differs between generations. Within a generation, builds share 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 share. 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 next 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:
| Observed Element | Detail | Purpose |
| reg add run value | Value StandaloneUpdater under HKEY_CURRENT_USER\Software\Microsoft\Windows\CurrentVersion\Run, pointing to %LOCALAPPDATA%\Microsoft\OneDrive\setup\logs\StandaloneUpdater.exe | Persistence at logon, for the logged-on user only |
| attrib (hide and unhide) | .tmp files and StandaloneUpdater.exe on a network share under Users\Public | Hide staged files between uses |
| Batch file | C:\Users\Public\Officelog.bat | Execution wrapper |
| WScript.exe | Running C:\Users\Public\prncnfg.vbs | Script-based execution and copy |
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 share were enough. The hashes in the indicator of compromise (IOC) tables will be stale by the next campaign. The pattern will probably still apply: an unmanaged host serving scripts, SMB-triggered execution, a run key under a familiar-looking vendor path.

Above: 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.
| Component | v1 (first article) | v2 (newer generation) | Varies between campaigns within v2 |
| EggStremeFuel | Configuration encrypted with RC4, filename as key | Configuration encrypted with AES-256-CBC, key embedded in the binary and obfuscated; C2 traffic still RC4 with a per-run random key | C2 addresses and the configuration file |
| EggStremeLoader | Payload decrypted with RC4, keyed from part of a consistent file path | RC5-32 CBC, then a custom CBC cipher; KERNEL32 as key and IV; new payload file layout with the key in the first 8 bytes | The decryption routine (two variants so far), the payload hiding location, the sideloaded DLL name; each payload file carries its own key |
| EggStremeAgent | gRPC over mutual TLS; 58 commands; keylogger injected per user session | Raw TCP with mutual TLS (wolfSSL) plus an AES-256-CBC layer; certificates embedded; streamlined configuration; command IDs 21 to 88 with Active Directory reconnaissance and in-memory PowerShell; no keylogger | Configuration encryption (RC4 or RC5), which commands are compiled in and what each ID means, active or passive mode |
| Infrastructure | One 2019 certificate authority linking 32 domains | A newer certificate authority; certificates embedded in the binary; staged development and operational IP pairs | Domains, IP addresses and certificates; campaign-specific certificate authorities are suggested, not confirmed |
| Behavior | DLL sideloading, share-based lateral movement, in-memory execution | The same | The same |
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 next, 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 next 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 about six weeks after publication.
Cipher Progression
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 next 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 previous 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.
About 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 previous 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 previous 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 next 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.
| MD5 | Filename | Compile timestamp | Scheme |
| a363c1529033fb6017985ce07ab0ad57 | iscsiexe.dll | 2024-05-15 07:35:43 | RC4, key google (original variant) |
| 5e21c73c6e055b67ce1d3311092e09f1 | DevicesPlatform.dll | 2025-06-09 13:54:20 | RC4, key Windows (older format) |
| b89966529371bd7585c83267ea6d17d6 | xwizards.dll | 2025-07-09 08:42:01 | RC4, key svchost (older format) |
| 0f2404810a20ad1c265a94cf7643e38f | advapi32.dll | 2025-10-13 07:35:48 | RC5-32 CBC, PKCS#7 (newer format) |
| 2848d5f1a827b70827e4e17497e33946 | advapi32.dll | 2025-10-28 13:57:10 | Custom CBC, PKCS#7 (newer format) |
| fac380128a04ffc5b8f175071622e885 | advapi32.dll | 2025-10-28 15:29:11 | Custom CBC, PKCS#7 (newer format) |
| 6f920aa7d2e48d1c2a201eb119ba20f1 | advapi32.dll | 2025-10-28 15:31:16 | Custom CBC, PKCS#7 (newer format) |
| 467566ff6573d84b927baf37acf11047 | dbghelp.dll | 2025-11-05 00:41:20 | Custom CBC, PKCS#7 (newer format) |
| 197be742fc81bbc87e5f66d1a4a9af92 | dwmapi.dll | 2025-11-11 07:23:49 | RC4, host-bound key (older format) |
| a1da36e1225a3d08ae647980250f43d0 | advapi32.dll | 2025-12-16 09:03:34 | Custom CBC, PKCS#7 (newer format) |
| cd030f106eada108715e99a4661f7fd4 | advapi32.dll | 2026-05-14 08:33:39 | Custom CBC, PKCS#7, contains debug strings (newer format) |
Three builds stamped within about 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:
Offset Length Content
0x00 8 Decryption key, plaintext
0x08 8 Encrypted; decrypts to the size of the embedded payload
0x10 N Encrypted embedded payload, ending with the EggStremeAgent component
The key sits in the first eight bytes of the payload file, in plaintext, rather than hidden inside the loader. Because the file carries its own key, one payload can be opened by any loader build that uses the same routine: variant A covers four builds. That adds resilience for the operators, who can swap out a loader build without re-encrypting the payload it carries. The plaintext key is a design choice, not carelessness, and as shown above, the cipher adds little protection on its own.
What the Payload Encryption Does and Does Not Protect
With the earlier loader, a consistent file path and an RC4 key derived from part of that path unlocked payloads across intrusions. An analyst who had reversed one loader could decrypt payloads recovered from other environments. The newer format looks different but offers little more protection. Each payload is encrypted with a routine that differs between variant A and variant B, so a decryptor or signature written for one does not match the other. But every payload file carries its own key, so an analyst who has the file and identifies the variant has what is needed to decrypt it.

Above: Decryption in v1 versus v2: one method opened payloads from every intrusion; in v2 the routine differs between variants, but each payload file carries its own key.
In incident response, when you find a suspicious file in one of the hiding locations below, preserve the DLL that loads it, from the same host, in the same response.
Payload Hiding Locations
Payload files sit in paths chosen to look like ordinary Windows data files. The table lists the paths from our IOC set. Hashes appear only where we recorded one for that path.
| Path | MD5 | Format |
| %SYSTEMROOT%\Media\Alarm00.wav | 8b88eb038251be49b1ae78406d817610 | Newer |
| %LOCALAPPDATA%\Microsoft\Feeds\Feeds.tmp | (no hash recorded) | Newer |
| %PROGRAMFILES%\Common Files\Microsoft Shared\msinfo\msinfo32.dll | cbd2d377a041a31bdf94ff95bf37d352 | Newer |
| %SYSTEMROOT%\apppatch\appmain.sdb | (no hash recorded) | Older |
| %SYSTEMROOT%\apppatch\expmain.sdb | 4cfb49f749b75941f1cff59b7cf92e53 | Older |
| %SYSTEMROOT%\Globalization\ICU\systemZones.res | five distinct hashes (see IOC section) | Older |
| %LOCALAPPDATA%\ConnectedDevicesPlatform\CDPGlobalSettings.cdpresource | (no hash recorded) | Older |
Each file type fits its folder: a .wav in the Media folder, an .sdb (application compatibility database) in apppatch, a .res in the ICU globalization folder. A file listing will not reveal them. Two things do: content that does not match the extension, and a non-system process reading them at startup. systemZones.res alone accounts for five distinct payload hashes, so the operators reused that path across intrusions even as the contents changed.
Old and New Formats in the Wild Together
The older format has not disappeared. We still see older-format containers, which hold the payload size, EggStremeReflectiveLoader and the agent, carrying newer agent builds. They are encrypted with RC4 under keys that differ from the first article’s: Windows, svchost and, in one case, a key built from the first four bytes of the C: volume serial number. That last variant makes the payload (MD5 197be742fc81bbc87e5f66d1a4a9af92) harder for a researcher to decrypt, because its key depends on the machine it was built for.
The two formats running side by side support the compile-time modularity reading. The operators did not migrate everything at once. They chose the container format and cipher per build.
To help other analysts, we are publishing a Python implementation of the custom cipher used by the newer-format loaders. It takes KERNEL32 as key and IV, derives an 8-byte schedule from them, and decrypts in CBC mode with PKCS#7-style padding removal. It implements variant A. Treat it as a reference for that variant: variant B uses a different routine, and for payload files the key and IV are the first 8 bytes of the file, not KERNEL32.
def key_setup(key, iv):
ks = bytearray(8)
for idx in range(8):
ks[idx] = ((3 * idx + 1) ^ iv[idx] ^ key[idx & 7]) & 0xFF
return ks
def decrypt(data):
key = b"KERNEL32"
iv = b"KERNEL32"
assert len(data) % 8 == 0
ks = key_setup(key, iv)
out = bytearray()
prev = bytes(iv) # IV seeds the chaining
for off in range(0, len(data), 8):
ct = data[off:off + 8]
# inner transform
vec = bytearray(8)
for idx in range(8):
k = ks[idx & 7]
temp = (idx + k + 7) & 0xFF
vec[idx] = ((ct[idx] ^ temp) - k) & 0xFF
# XOR with previous block (CBC chaining)
out += bytes(vec[i] ^ prev[i] for i in range(8))
prev = ct # save ciphertext for next block
# PKCS-style padding removal
pad = out[-1]
if 1 <= pad <= 8 and all(b == pad for b in out[-pad:]):
out = out[:-pad]
return bytes(out)
Defender action: Hunt for processes that read Alarm00.wav, appmain.sdb, expmain.sdb, systemZones.res, Feeds.tmp or msinfo32.dll from the paths above when the reading process is not the expected Windows component, and during incident response, always collect the sideloaded DLL together with any payload file found.
EggStremeAgent: Rebuilt Networking, Leaner Configuration, More Commands
EggStremeAgent is the backdoor at the end of the chain. The newer builds differ from the first article’s agent in four areas: how the configuration is stored, how the agent talks to its operators, which commands it accepts, and which modules it carries. Several of these builds carry compile timestamps between March and May 2025, but we first observed them after our first publication. This section therefore describes how the agent differs from what we first documented.
Configuration
Configuration decryption varies between samples, which fits the per-build approach seen in the loader. Some samples still use RC4 keyed from the configuration file’s full path, but with a changed configuration format. Others use RC5-32/12 (32-bit words, 12 rounds) in CBC mode with PKCS#7 padding. In those, the key and IV come from the eight-character filename without its extension. For example, the configuration at %USERPROFILE%\AppData\Local\Comms\Unistore.db is keyed with Unistore. Most of the newer configuration files we recorded sit at %SYSTEMROOT%\system32\config\systemprofile\AppData\Roaming\Microsoft\Crypto\Crypto.db, a location that looks like part of the system’s cryptographic store. We recorded seven distinct hashes for that one path.
The decrypted configuration has fewer fields than before. It holds a six-character uppercase victim ID, a sleep interval, the C2 (command-and-control, the attacker server the implant talks to) domain and the port, separated by ###:
<victim id>###50###fsstore[.]org###443
When no configuration file is present, the agent uses a hardcoded fallback configuration. TLS certificates are now embedded only in the binary. The agent no longer fetches them from an external configuration. That small change also feeds the infrastructure story: each binary carries its own trust material, which is what makes per-campaign certificate authorities practical.
Transport
The first article’s agent communicated over gRPC, a remote procedure call framework that runs over HTTP/2. The newer builds drop gRPC. They use raw TCP sockets (T1095 Non-Application Layer Protocol) wrapped in mutual TLS through the wolfSSL library, a compact open-source TLS implementation often embedded in small software.
What is mutual TLS?
In ordinary TLS, only the server proves its identity with a certificate. In mutual TLS, the client presents a certificate too, and each side rejects the connection unless the other’s certificate is signed by an expected authority. For an implant, this means a scanner or researcher who connects to the C2 server without the implant’s client certificate gets no response worth analyzing.
On top of TLS, the agent adds a second encryption layer: AES-256-CBC (the Advanced Encryption Standard with a 256-bit key, in chaining mode) with keys and IVs hardcoded in the binary (T1573.001 Symmetric Cryptography, alongside the TLS layer’s T1573.002 Asymmetric Cryptography). Because of the double wrapping, intercepting the TLS session (for example, with a TLS-inspecting proxy that holds a trusted certificate) still leaves the analyst looking at AES ciphertext.
Expanded Command Set
The core command set from the first article remains. We see command IDs from 21 to 88, and the same ID can mean different things in different samples, which is another sign that each build is compiled to its own specification. The table lists the commands that are new compared with the first article.
| ID | Category | Behavior | Key Windows APIs |
| 24 | AD reconnaissance | Enumerate domain users | NetGetAnyDCName, NetUserEnum, NetUserGetInfo |
| 25 | AD reconnaissance | Enumerate groups | NetLocalGroupEnum, NetQueryDisplayInformation |
| 26 | AD reconnaissance | Enumerate servers, similar to net view /domain | NetServerEnum |
| 76 | Proxying | TCP proxy forwarder, 0x1000-byte buffer | Sockets over the existing TLS channel |
| 77 | Proxying | TCP proxy forwarder, 0x2000-byte buffer, thread safe | Sockets over the existing TLS channel |
| 79 | Execution | WMI query with supplied credentials | WMI |
| 80 | Execution | Token impersonation | WTSQueryUserToken, ImpersonateLoggedOnUser |
| 83 | Execution | Load embedded .NET assembly, resolve Microsoft.Windows.Runner | CLR hosting |
| 84 | Execution | In-memory PowerShell command | Hosted PowerShell runspace |
| 85 | Execution | In-memory PowerShell script | Hosted PowerShell runspace |
| 86 | Execution | Check for a PE payload | (staging) |
| 87 | Execution | Stage a PE payload | (staging) |
| 88 | Execution | Reflectively execute the staged PE (export werfault) | Reflective loader |
Active Directory reconnaissance. Commands 24 to 26 let the operator map a Windows domain without running any separate tool. Command 24 calls NetGetAnyDCName, which locates a domain controller to query. It then calls NetUserEnum, which lists user accounts, and NetUserGetInfo, which returns the details of one account (T1087.002 Domain Account). Command 25 uses NetLocalGroupEnum to list the local groups on a machine (T1069.001 Local Groups) and NetQueryDisplayInformation to return display lists of users, computers or groups from the domain (T1069.002 Domain Groups). Command 26 calls NetServerEnum, which lists computers visible on the network, much as net view /domain does (T1018 Remote System Discovery). These are the same calls the built-in net commands make. Running them inside the agent avoids the net.exe process creation that many detections watch for.
Proxying. Commands 76 and 77 turn the implant into a TCP forwarder. Traffic is tunneled over the agent’s existing encrypted TLS channel (T1090.001 Internal Proxy). Command 77 adds thread safety, so it can carry concurrent sessions.
Credentialed execution. Command 79 runs WMI (Windows Management Instrumentation, Windows’ built-in management interface, often used for remote queries and execution) queries with credentials the operator supplies (T1047 Windows Management Instrumentation). Command 80 calls WTSQueryUserToken, which obtains the access token of a logged-on user’s session, and then ImpersonateLoggedOnUser, which lets a thread act with that user’s identity (T1134.001 Token Impersonation/Theft).
Keylogger Absence and In-process PowerShell
EggStremeKeylogger does not appear in any of the newer samples we analyzed. We assess that the agent described in the first article was a distinct variant built for surveillance, and that the keylogger was a capability compiled into that build for that target. The newer builds are compiled without it. This is the most concrete evidence for build-time capability selection: the same framework, with a whole module missing because a build did not call for it.
Some newer builds carry something the earlier one did not: an embedded .NET assembly. The agent loads it through the CLR (Common Language Runtime, the engine that executes .NET code) entirely in memory. Command 83 resolves a type named Microsoft.Windows.Runner from it. The assembly then creates a custom PowerShell runspace, an execution environment for PowerShell that a program can host internally. Commands 84 and 85 run PowerShell commands and scripts inside the agent’s own process (T1059.001 PowerShell), with weakened authorization checks (bypassing the execution policy). powershell.exe is never started. Detections that depend on PowerShell process creation, or on command lines passed to powershell.exe, see nothing.
Commands 86, 87 and 88 make up a three-step PE stager. A PE (Portable Executable) is the standard Windows executable format. The stager checks whether a payload is present, stages it, and then executes it reflectively through an export named werfault (T1620 Reflective Code Loading). Reflective loading maps an executable into memory and runs it without the Windows loader, so it never exists as a file on disk. The export name echoes the Windows Error Reporting process, WerFault.exe.
Passive Mode Variant
Two of the newer builds, stamped 2025-09-02 and 2025-11-05, run in passive mode. Instead of beaconing out to a C2 server, they open a listening port and wait for the operator to connect in.
Above: Beaconing versus passive agent: the passive agent never calls out, and the operator reaches in through a firewall rule named like a Windows built-in
These builds still contain a C2 configuration, but it is dead residue from the shared codebase. The commands for getting and setting the C2 port and domain remain, though passive mode never uses them. Leftovers like these come from compiling many variants from one source tree, where code paths are disabled rather than removed.

Above: The EggStremeAgent configuration initialization in passive mode still includes the unused C2 fields
On startup, the passive agent opens TCP port 5060. It then creates an inbound allow rule through the COM firewall API. COM (Component Object Model) is Windows’ interface for program-to-program calls, and INetFwPolicy2 and INetFwRule are the COM interfaces Windows exposes for reading and writing firewall rules from a program (T1562.004 Disable or Modify System Firewall). The rule is named “Core Networking - SIP”. It applies to the domain, private and public profiles, and edge traversal is enabled, which lets traffic that arrives through a NAT device (network address translation, the router function that shares one public address among many internal hosts) reach the port. Port 5060 is the standard port for SIP (Session Initiation Protocol, used by VoIP telephony), and the rule name copies the “Core Networking” rule group that ships with Windows.

Above: The firewall rule creation and port 5060 listener binding
The handshake is close to EggStremeFuel’s. The agent receives 32 bytes. The first 16 are encrypted and the last 16 are the expected plaintext. It decrypts the first half with RC4 a key hardcoded in the binary, which we can share with vetted defenders and incident responders on request. If the result matches the second half, that value becomes the session key. Anything else connecting to the port fails the check.
In segmented or closely monitored networks, an implant that beacons out at regular intervals is the thing most likely to be flagged. A listener that sits idle until the operator connects produces no outbound traffic. The trade-off is that the operator must be able to reach the host, which is why the rule opens all three profiles with edge traversal.
Defender action: Alert on creation of any firewall rule named “Core Networking - SIP” that is not part of your Windows baseline, on listeners on TCP 5060 on hosts that are not VoIP endpoints, and on CLR loading (clr.dll, System.Management.Automation) inside processes that are not normally .NET hosts.
EggStreme Infrastructure: From One Certificate Authority to Many
Infrastructure is one way defenders track a framework once its hashes go stale, by pivoting from one server or certificate to others. The changes below affect that pivot.
The Legacy Certificate Authority
The older EggStreme servers were tied together by one certificate authority generated in 2019. Searching certificate data for that CA’s key identifier, 51655e8e97fc7265b1aaa4265d94e2f7cae9c913, returns 32 linked domains. The full list of original-infrastructure domains is in the IOC section. For defenders, this was an unusually good pivot: one value in a certificate search led to the whole server fleet, including domains not yet seen in any intrusion.
No new domains have been added under that CA since our first article. We assess that it has been abandoned or phased out.
The Newer Certificate Authority
The newer setup runs under a different certificate authority. It did not start from scratch, though. Some domains from the legacy infrastructure were reused in the new setup, and those reused domains link the two generations. Our IOC set flags readyui[.]net and hostkbc[.]com as original-infrastructure domains seen with the newer agent builds.

Above: The relationship between the legacy and newer certificate authorities
The IOC section lists three certificate subject key identifiers (SKIs, fingerprints that uniquely identify a certificate’s public key) associated with the agent’s CA certificates. We do not yet attribute each SKI to a specific CA generation.
mepintei[.]com and the Two EggStreme Clusters
Until now, we had tracked two clusters separately: the EggStremeFuel activity and the loader-and-agent activity. Newer Fuel configurations and binaries use the same new infrastructure as the agent, including mepintei[.]com, which also appears among the agent’s original-infrastructure domains. That overlap joins the two clusters: the Fuel activity and the loader and agent activity use common infrastructure, which is why we now track them as one operation. Any defender who split the two in their own tracking should merge them.
Development and Operational IP Pairs
The certificate authority stopped being a useful pivot. Server behavior took its place. The operators appear to stage new domains on a development server before using them operationally (T1583.001 Domains), and that staging is visible.
In one case, osaweb[.]org resolved to two IP addresses. One of them looked like a development host: it exposed ports 8443, 8444, and 8445, each serving a certificate for a different domain, namely rodosdeals[.]com, osaweb[.]org and eusurvey[.]org. At that point, only osaweb[.]org was in active use. A later agent sample hardcoded rodosdeals[.]com as its C2 domain, which confirmed that the other domains on the development host had been staged for future use.
Around June 2026, the pattern repeated with three more domains: precontact[.]org, siliconmetal[.]net and dalkeys[.]com. Each resolved to two IP addresses. One address was shared by all three, consistent with a development and testing host, and the other was a separate operational IP ready for use.
Our IOC set includes two development IPs: 45[.]221[.]112[.]129, observed in February 2026, and 221[.]128[.]249[.]228, observed more recently in June 2026. Both exposed three ports.
Domains and IP addresses are listed because we observed them in connection with this activity during the period described. Hosting providers and later registrants of these resources may be unrelated to the operation, and names that resemble legitimate services (for example eusurvey[.]org) do not indicate any involvement of those services or their owners.
This pivot worked in these cases, but it appears to come from an operator mistake, not from a deliberate pattern, so it should not be relied on. A development server that presents certificates for domains not yet in use shows the operators’ next domains before any implant connects to them.
Toward Campaign-specific Certificate Authorities
The newer activity suggests a further change: a separate certificate authority for each campaign, generated by the operators themselves (T1587.003 Digital Certificates). Combined with the agent’s binary-embedded certificates, a build would carry its own trust chain, valid for one campaign and useless for linking to another. If this holds across the operation, pivoting from one cluster to the next through certificate data will get progressively harder, and each build will look disposable and single-purpose. We are describing a direction suggested by the activity we can see. We have not confirmed that every campaign has its own CA.
Some things still connect the generations: certificates staged on development IPs, one development IP shared across a domain set, and legacy domains reused in the newer setup. Each depends on operators keeping habits they have maintained so far. Defenders who track this operation should watch those habits, not the certificate authority itself.
Defender action: In internet scan data, track hosts that serve certificates for several unrelated domains on consecutive high ports (8443 to 8445), and treat any domain first seen on such a host as a lead for your watchlists. This depends on operator mistakes, so do not make it your only source.
EggStreme Constants: What Defenders Can Still Detect
The changes above move the bottom of the pyramid and part of the middle. The list below covers what has stayed the same across the builds and intrusions we analyzed, along with a way to hunt for each. If the operators rebuild again, these traits are most likely to survive.
- CBC with key scheduling and PKCS#7 removal. The cipher changes, but the structure around it does not. Code that runs a key schedule, decrypts in CBC chaining and then strips PKCS#7 padding, inside a DLL named after a system library, gives a structural pattern that survives cipher swaps.
- Mutual TLS in the agent. The agent requires its client certificate. On the network, TLS sessions to rare domains where the client presents a certificate, which is uncommon for ordinary workstation traffic, are a useful hunting filter. Our first article describes the same property: the earlier agent ran gRPC over mutual TLS.
- RC4 with per-run keys for Fuel C2. Fuel traffic content cannot be decrypted statically, but Fuel’s network behavior is still regular.
- DLL sideloading under system library names. The loader ships as advapi32.dll, dbghelp.dll, dwmapi.dll, iscsiexe.dll, DevicesPlatform.dll and xwizards.dll. As a detection heuristic, a Windows system library name loaded from outside the system directories is a strong signal.
- Share-based lateral movement. Staging on file shares that the targets already reach, then triggering execution remotely, appeared in both cases with different mechanics: a Netlogon script injected into a compromised share in the first article’s case, and SMB-launched VBS plus a run key in the recent one.
- In-memory execution. Reflective PE loading, CLR hosting and in-process PowerShell all keep code off disk. Memory scanning and module-load telemetry catch them where file scanning cannot.
Defender action: Build at least one detection per constant above, because a rule tied to a constant is likely to outlive the next rebuild, while a rule tied to a hash from this article probably will not.
MITRE ATT&CK Mapping
| Tactic | Technique | Name | Observed |
| Resource Development | T1583.001 | Domains | Domain sets staged on development hosts before operational use |
| Resource Development | T1587.003 | Digital Certificates | Operator-generated CAs; certificates embedded per binary |
| Initial Access / Persistence / Privilege Escalation / Defense Evasion | T1078.002 | Domain Accounts | One set of compromised credentials apparently reused across multiple machines |
| Execution | T1059.005 | Visual Basic | WScript.exe running C:\Users\Public\prncnfg.vbs |
| Execution | T1059.003 | Windows Command Shell | C:\Users\Public\Officelog.bat |
| Execution | T1059.001 | PowerShell | Commands 84 and 85 run PowerShell in a hosted runspace, no powershell.exe |
| Execution | T1047 | Windows Management Instrumentation | Command 79 runs WMI queries with supplied credentials |
| Persistence | T1547.001 | Registry Run Keys / Startup Folder | StandaloneUpdater run value |
| Privilege Escalation/Defense Evasion | T1134.001 | Token Impersonation/ Theft | Command 80: WTSQueryUserToken plus ImpersonateLoggedOnUser |
| Persistence / Privilege Escalation / Defense Evasion | T1574.002 | DLL Side- Loading | Loader DLLs named after system libraries sideloaded by legitimate executables |
| Defense Evasion | T1036.005 | Match Legitimate Resource Name or Location | OneDrive-styled paths, prncnfg.vbs, Alarm00.wav, wpndatabase.dat |
| Defense Evasion | T1564.001 | Hidden Files and Directories |
attrib hide and unhide on staged files |
| Defense Evasion | T1027 | Obfuscated Files or Information | RC5 and custom-cipher payloads; obfuscated Fuel AES key |
| Defense Evasion | T1140 | Deobfuscate/De code Files or Information | Loader decrypts payload in memory at runtime |
| Defense Evasion | T1620 | Reflective Code Loading | Commands 86 to 88 reflectively execute a PE via export werfault; in-memory .NET assembly |
| Defense Evasion | T1562.004 | Disable or Modify System Firewall | “Core Networking - SIP” inbound rule via INetFwPolicy2/INetFwRule |
| Discovery | T1087.002 | Domain Account | Command 24: NetUserEnum, NetUserGetInfo |
| Discovery | T1069.001 | Local Groups | Command 25: NetLocalGroupEnum |
| Discovery | T1069.002 | Domain Groups | Command 25: NetQueryDisplayInformation |
| Discovery | T1018 | Remote System Discovery | Command 26: NetServerEnum |
| Lateral Movement | T1021.002 | SMB/Windows Admin Shares | Scripts executed on targets over SMB |
| Lateral Movement | T1570 | Lateral Tool Transfer | EggStremeFuel package copied from the staging host |
| Command and Control | T1095 | Non-Application Layer Protocol | Agent moved from gRPC to raw TCP |
| Command and Control | T1573.002 | Asymmetric Cryptography | Mutual TLS via wolfSSL |
| Command and Control | T1573.001 | Symmetric Cryptography | AES-256-CBC inner layer; RC4 per-run keys for Fuel C2 |
| Command and Control | T1090.001 | Internal Proxy | Commands 76 and 77 forward TCP over the TLS channel |
| Command and Control | T1571 | Non-Standard Port | Passive agent listens on TCP 5060 and authenticates the operator with an RC4 handshake. |
| NEW | -- | Compile-time variant selection | Capabilities and ciphers chosen per build from one codebase; no ATT&CK technique describes build-time tailoring |
EggStreme Conclusion and Recommendations
Read through the Pyramid of Pain, the EggStreme operation shows what public exposure costs a mature operator. After our first article, the operators rotated what anyone would rotate. They also changed the framework itself: the way Fuel protects its configuration, the loader’s cipher and payload format within weeks, and, in the agent builds we first saw after our report, the network protocol and the command set. The cipher swaps were cheap for the operators, because the new ciphers add little real protection, yet they still broke detections tied to the old routine. The new agent protocol and the infrastructure move are the larger changes. The speed of the loader changes says as much about the operators’ maturity as about the cost of exposure. The build-time design appears to be what makes rebuilds this fast. What they did not change is how they operate: sideloaded DLLs under system library names, staging through file shares, running from memory, and requiring mutual TLS. Build detection logic around those behaviors, because the hashes in this article will go stale.
Exposing an APT operation can cost the operators far more than one victim or one campaign, because the tooling and infrastructure behind it tend to be shared across operations. In this case, the loader, the Fuel configuration, and the infrastructure changed after our report, and we first saw the newer agent builds after it as well, although some were compiled earlier. Once shared tooling is documented, every operation built on it inherits exposure. That raises a question about handing APT-grade operations to autonomous, AI-operated tooling, where the chance of discovery is high: each discovery would burn shared capability across every operation that depends on it. The data in this article does not test that question.
Recommendations for defenders, whether or not they run Bitdefender products:
- Restrict the built-in tools your environment does not need. The recent intrusion ran on tools Windows already ships: WScript.exe and cmd.exe to execute, reg.exe to write the run key, attrib.exe to hide staged files. Attackers rely on built-in tools like these (living off the land: abusing legitimate system utilities instead of bringing their own) because they are trusted by default and hard to block everywhere. Reduce the attack surface by disabling or restricting, per user group and per machine, the utilities a given role never uses. GravityZone PHASR, TechZone is Bitdefender’s implementation of this layer.
- Detect DLL sideloading by name and location. Signature-based detection will not keep up with a loader that changes its cipher every few weeks. The constant is a system library name (advapi32.dll, dbghelp.dll, dwmapi.dll) loaded from a directory where Windows would never place it, by an executable that has no reason to be there. Runtime behavioral monitoring that observes module loads and the actions that follow catches the pattern regardless of the payload inside. Bitdefender GravityZone’s Process Protection, TechZone covers Advanced Threat Control, which is Bitdefender’s implementation of this layer.
- Inventory unmanaged assets and watch SMB-launched scripts. The staging host in the recent intrusion was reachable from workstations but outside endpoint management. Find machines on your network that reach workstations over SMB but are not under endpoint management. GravityZone’s Network Protection, TechZone (Network Attack Defense) and EDR, XDR and MDR Overview, TechZone cover the network and endpoint sides of this layer.
- Monitor host firewall rules and inbound listeners on workstations. A workstation that suddenly accepts inbound connections on TCP 5060 under a rule called “Core Networking - SIP” is behaving like a server. Baseline your firewall rules, alert on new allow rules created programmatically by non-administrative tooling, and alert on new listening ports on endpoints that should not host services. The passive agent never beacons, so this is one of the few places it shows up.
- Detect in-process PowerShell and CLR loading. Blocking or logging powershell.exe does not stop PowerShell running inside another process. Watch for System.Management.Automation and CLR modules loaded into processes that are not normally .NET hosts, and capture PowerShell script block logging, which records hosted runspaces as well as the console. GravityZone’s Fileless Protection, TechZone addresses the PowerShell side of this: its AMSI provider (the Antimalware Scan Interface, a Windows hook that lets security software inspect scripts before they run) scans script content, and its command-line scanner inspects suspicious command lines.
- Hunt infrastructure by behavior, not by certificate authority alone. The legacy CA pivot is gone, and per-campaign CAs will narrow what a single certificate search returns. Treat development hosts that serve certificates for multiple unrelated domains on adjacent ports as an occasional lead, since they come from operator mistakes, and treat TLS sessions where the client presents a certificate to a rare domain as a hunting lead. Bitdefender IntelliZone, described on Threat Intelligence, TechZone, gives access to Bitdefender’s threat intelligence for this kind of tracking.
Related reading:
- EggStreme Malware: Unpacking a New APT Framework Targeting a Philippine Military Company
- What Is DLL Sideloading, TechZone
- What Is Impacket, TechZone
IOCs and How to Follow Our Research
The full indicator set for this research is available from our GitHub IOC repository to support other researchers and the wider defender community. The same indicators are also delivered through Bitdefender IntelliZone, our threat intelligence platform, along with broader context on this activity.
This research is part of Ctrl-Alt-DECODE, Bitdefender’s threat intelligence initiative.
- Subscribe to the newsletter: original research, advisories, and threat intelligence from Bitdefender Labs and our MDR teams. Subscribe here.
- Watch the live series: we break down each investigation on a live Ctrl-Alt-DECODE stream, then archive it on YouTube. Watch the Eggstreme episode or browse the archive of previous episodes.
Disclaimer
- Purpose. This article is published for informational and defensive cybersecurity purposes only, to help security teams detect, investigate and respond to malicious activity. It is not legal, regulatory or professional advice and does not create any contractual or advisory relationship with Bitdefender.
- Assessments, not established facts. Findings, attributions and confidence levels reflect Bitdefender’s technical assessment based on the data available to us at the time of writing. Attribution to a suspected threat group is an analytical judgment and does not state or imply the involvement, direction or responsibility of any government, state body, organization or individual. Statements about the operators’ motives, timing or reactions are inferences from observed activity. Our assessments may change as new information becomes available, and we are under no obligation to update this article.
- Third-party infrastructure and names. Domains, IP addresses, certificates, file names and other indicators are listed because we observed them in connection with this activity during the period described. Their current owners, registrants, hosting providers or users may be unrelated to the activity, and indicators may since have been reassigned or remediated. Names that resemble legitimate products, services or organizations do not indicate any involvement by them. Third-party trademarks and product names are used only to identify the relevant software and remain the property of their respective owners; their use does not imply endorsement or affiliation.
- Victims and personal data. We do not identify affected organizations or individuals. Technical indicators are published on the basis of the legitimate interest in network and information security. Anyone who believes that this article contains information relating to them may contact us, and we will review the request in line with applicable data protection law.
- Code and indicators. Code samples, decryption routines and indicators of compromise are provided “as is”, without warranty of any kind, for lawful research, detection and incident response only. They must not be used to access, interfere with or control any system without authorization. Some sensitive technical details have been intentionally withheld and are shared only with vetted defenders. Test any detection or tooling in a controlled environment before use in production.
- Products and recommendations. Defensive recommendations apply regardless of the security products in use. References to Bitdefender products describe how they address the techniques discussed; actual protection depends on product version, configuration and environment, and no security product can guarantee detection or prevention of every threat.
- Limitation of liability. To the fullest extent permitted by law, Bitdefender is not liable for any direct or indirect loss or damage arising from the use of, or reliance on, this article, its code or its indicators. Nothing in this disclaimer limits liability that cannot be limited under applicable law.


