Bitdefender's latest technical reporting confirms what many of us in the incident response community suspected after the original EggStreme disclosure in 2025: the suspected Chinese advanced persistent threat group behind the framework did not retreat after being exposed — they re-engineered. The rebuilt EggStreme variant is now actively deployed against government organizations in the Philippines, and its defining characteristic is silence. The operators have retooled their loaders, backdoors, and command-and-control logic specifically to defeat the detection assumptions that defenders built after the first public analysis.
Bitdefender's framing is worth internalizing because it describes the economics of modern APT tradecraft precisely: "When attackers are exposed, the cheap response is to rotate. A file hash changes with every recompile, a domain costs a few dollars." The EggStreme operators went further than cheap rotation. They rebuilt the toolkit's architecture so that the behavioral fingerprints — not just the static indicators — changed. If your detection strategy for this actor is a blocklist of hashes and C2 domains from the 2025 reporting, you are defending against an adversary that no longer exists.
This matters well beyond the Philippines. Government targeting in Southeast Asia is a proving ground. The same rebuilt loaders, sideloading chains, and low-noise C2 channels that are running against Philippine agencies today will be pointed at defense contractors, telecommunications providers, and allied government networks tomorrow. If you run a SOC with any exposure to APAC geopolitical collection interests, this is your threat brief.
Technical Analysis: What Changed and Why It Works
The Original EggStreme Architecture
The first-generation EggStreme framework, attributed with moderate confidence to a Chinese state-nexus actor, was a multi-stage toolset built around a few core design principles:
- Staged delivery: A small first-stage loader (tracked as EggStremeFuel) established initial execution and pulled down follow-on components, keeping the initial footprint minimal.
- DLL sideloading through trusted, signed binaries: EggStreme stages were typically executed by placing a malicious DLL alongside a legitimate, digitally signed executable. When the signed binary launched, it loaded the attacker's DLL from its own directory — inheriting the trust, allow-list coverage, and parental lineage of a known-good Microsoft or third-party signed process.
- Reflective in-memory loading: Later stages (EggStremeAgent, EggStremeWizard) were reflectively loaded into memory, minimizing on-disk artifacts and blunting signature-based AV scanning.
- Injection into high-entropy system processes: The keylogging component was injected into
explorer.exe, letting keystroke capture ride inside a process every environment expects to be running and talking. - Low-and-slow C2: Command-and-control leveraged legitimate-looking TLS sessions, including gRPC-based channels, which blend into the sea of HTTP/2 traffic that most network sensors treat as benign web traffic.
The 2026 Rebuild: Engineering for Silence
Per Bitdefender's reporting on the new variant, the operators specifically attacked the observability surface that defenders used against the first generation:
- Reduced on-disk footprint. Fewer artifacts touch disk, and those that do are staged in locations and with naming conventions that mimic legitimate software caches and application data. The defenders' file-hash pivot is dead on arrival.
- Rebuilt loader chain. The sideloading and reflective-loading logic has been reworked so that the parent-child process relationships and module load sequences observed in 2025 no longer match. Detections keyed to the old chain will not fire.
- Quieter C2. The communication layer has been tuned to produce less distinctive traffic — longer beacon intervals, more convincing protocol mimicry, and infrastructure rotation that stays ahead of threat-feed propagation.
- Sustained targeting of Philippine government entities. This is a deliberate, resourced campaign against a specific victim set, consistent with strategic intelligence collection rather than opportunistic intrusion.
Attack Chain (Defender's View)
From a blue-team perspective, the current intrusion lifecycle looks like this:
- Initial access — consistent with prior campaigns, spearphishing and exploitation of internet-facing services remain the likely entry vectors for this actor class.
- Staging — a legitimate signed executable and a malicious companion DLL are placed together in a user-writable directory (
%APPDATA%,%LOCALAPPDATA%,%PROGRAMDATA%, or application cache paths). - Execution via sideloading — the signed binary is launched (often via scheduled task or Run key for persistence), loading the malicious DLL into a trusted process context.
- Reflective staging — the sideloaded DLL decrypts and reflectively maps the next stage in memory; minimal new files appear on disk.
- Injection — capability modules (keylogger, shell handler, file operations) are injected into long-lived system processes such as
explorer.exeorsvchost.exevia remote thread creation. - C2 — outbound TLS, frequently HTTP/2/gRPC-style, to attacker infrastructure, often fronted or hosted on cloud providers to inherit reputation.
- Collection and exfiltration — keystrokes, documents, and credentials staged and exfiltrated over the same low-noise channel.
Exploitation Status
- Active exploitation: Confirmed. Bitdefender observed the rebuilt variant in live intrusions against Philippine government organizations. This is not a theoretical or proof-of-concept capability.
- CVEs: None are associated with this reporting. EggStreme is a post-compromise framework; its delivery relies on social engineering and valid access, not a single patchable vulnerability. Do not wait for a CVE to act — there isn't one.
- Attribution: Suspected Chinese state-nexus APT, consistent with the victimology (Philippine government) and regional collection priorities.
The Strategic Lesson: Rotation Economics
The Bitdefender quote deserves a second read because it should reshape how you budget detection engineering. Hashes are free for the attacker to change. Domains cost a few dollars. Even infrastructure rotation is cheap. What is expensive for an attacker to change is behavior: the need to sideload through signed binaries, to inject into system processes, to persist, and to talk outbound. Your detection program should spend its budget on behavioral chokepoints that survive recompilation. Everything below is built on that principle.
Detection & Response
The detections below target the behaviors that are structurally hard for the EggStreme operators to abandon: DLL sideloading from user-writable paths, injection into explorer.exe, persistence masquerading as maintenance tasks, and non-browser processes holding long-lived outbound TLS sessions.
Sigma Rules
---
title: Signed Binary Loading Unsigned DLL from User-Writable Path
tid: 3f8a1c2e-7b4d-4e9a-b6c1-9d2e5f8a0b3c
status: experimental
description: Detects a Microsoft-signed or otherwise trusted executable loading an unsigned DLL from user-writable directories, consistent with EggStreme DLL sideloading tradecraft used against Philippine government targets.
references:
- https://thehackernews.com/2026/11/eggstreme-hackers-rebuild-malware-with.html
- https://attack.mitre.org/techniques/T1574/002/
author: Security Arsenal
date: 2026/11/15
tags:
- attack.defense_evasion
- attack.t1574.002
- attack.t1218
logsource:
category: image_load
product: windows
detection:
selection_path:
ImageLoaded|contains:
- '\AppData\Local\'
- '\AppData\Roaming\'
- '\ProgramData\'
- '\Users\Public\'
selection_signed_loader:
Signed: 'true'
SignatureStatus: 'valid'
filter_dll_signed:
ImageLoaded|contains: '.dll'
detection_condition: selection_path and selection_signed_loader
falsepositives:
- Legitimate portable applications that bundle plugins in AppData
- Electron-based apps (Teams, Slack, Discord) loading modules from user paths
level: high
---
title: Remote Thread Injection into Explorer.exe
id: 8b2d4f6a-1c3e-4a5b-9d7f-2e6a8c0b4d1f
status: experimental
description: Detects remote thread creation targeting explorer.exe, a technique EggStreme uses to host its keylogging component inside a trusted, long-lived system process.
references:
- https://thehackernews.com/2026/11/eggstreme-hackers-rebuild-malware-with.html
- https://attack.mitre.org/techniques/T1055/001/
author: Security Arsenal
date: 2026/11/15
tags:
- attack.defense_evasion
- attack.privilege_escalation
- attack.t1055.001
logsource:
category: create_remote_thread
product: windows
detection:
selection:
TargetImage|endswith: '\explorer.exe'
filter_legit:
SourceImage|endswith:
- '\explorer.exe'
- '\svchost.exe'
- '\Windows\System32\sihost.exe'
- '\Windows\System32\taskhostw.exe'
condition: selection and not filter_legit
falsepositives:
- EDR and DLP agents injecting into explorer.exe (tune by SourceImage hash in your environment)
- Application compatibility shims
level: high
---
title: Scheduled Task or Run Key Persistence Pointing to User-Writable Paths
id: c5e7a9b1-2d4f-4e6a-8b0c-3f5d7a9e1b2c
status: experimental
description: Detects persistence mechanisms (scheduled tasks or Run keys) launching executables or scripts from user-writable directories, matching the EggStreme staging pattern of co-locating a signed binary and malicious DLL.
references:
- https://thehackernews.com/2026/11/eggstreme-hackers-rebuild-malware-with.html
- https://attack.mitre.org/techniques/T1053/005/
- https://attack.mitre.org/techniques/T1547/001/
author: Security Arsenal
date: 2026/11/15
tags:
- attack.persistence
- attack.t1053.005
- attack.t1547.001
logsource:
category: process_creation
product: windows
detection:
selection_engine:
Image|endswith:
- '\schtasks.exe'
- '\reg.exe'
CommandLine|contains:
- '/create'
- 'add'
selection_path:
CommandLine|contains:
- '\AppData\Local\'
- '\AppData\Roaming\'
- '\ProgramData\'
- '\Users\Public\'
selection_runkey:
CommandLine|contains:
- '\CurrentVersion\Run'
- 'CurrentVersion\Run'
condition: selection_engine and selection_path and selection_runkey
falsepositives:
- Software updaters registering per-user tasks (Chrome, Edge, OneDrive)
- IT provisioning scripts
level: medium
A note on tuning before you deploy: the image-load rule will light up on Electron applications and legitimate portable software. In a government or enterprise environment with a managed software catalog, that is a feature — per-user, self-installed software loading DLLs is exactly what you want surfaced. Tune by publisher and path, not by disabling the rule.
KQL — Microsoft Sentinel / Defender
This query hunts the core EggStreme execution primitive: trusted, signed processes loading DLLs from user-writable locations, enriched with outbound network activity from the same host. Run it as a scheduled hunt over 7–14 days in environments with APAC exposure.
// Hunt: EggStreme-style DLL sideloading from user-writable paths + correlated outbound C2
let Lookback = 14d;
let SuspiciousLoads =
DeviceImageLoadEvents
| where TimeGenerated > ago(Lookback)
| where FolderPath has_any (@"\AppData\Local\", @"\AppData\Roaming\", @"\ProgramData\", @"\Users\Public\")
| where FileName endswith ".dll"
| join kind=inner (
DeviceFileEvents
| where TimeGenerated > ago(Lookback)
| where FileName endswith ".dll"
| project DeviceId, SHA256, FolderPath, Signer = "", FileName
) on DeviceId, FileName
| summarize DllLoadCount = count(),
LoadingProcesses = make_set(InitiatingProcessFileName),
DllPaths = make_set(FolderPath)
by DeviceId, InitiatingProcessFileName, InitiatingProcessSigner = InitiatingProcessVersionInfoCompanyName;
SuspiciousLoads
| join kind=leftouter (
DeviceNetworkEvents
| where TimeGenerated > ago(Lookback)
| where RemotePort in (443, 8443, 8080)
| where RemoteUrl !has_any ("microsoft.com", "windowsupdate.com", "office.com", "live.com")
| summarize C2CandidateConnections = count(),
RemoteEndpoints = make_set(RemoteIP),
RemoteHosts = make_set(RemoteUrl)
by DeviceId, InitiatingProcessFileName
) on DeviceId, InitiatingProcessFileName
| project DeviceId, InitiatingProcessFileName, DllLoadCount, LoadingProcesses, DllPaths,
C2CandidateConnections, RemoteEndpoints, RemoteHosts
| order by C2CandidateConnections desc;
For injection hunting, pivot on Defender's DeviceEvents with ActionType == "CreateRemoteThreadApiCall" targeting explorer.exe, or equivalent Sysmon Event ID 8 forwarded via the AMA connector into the Event table. The key analytic is source-process rarity: baseline which processes legitimately inject into explorer.exe in your fleet (EDR agents, shell extensions), then alert on first-seen source images.
Velociraptor VQL
For IR teams with Velociraptor deployed, this hunt sweeps the fleet for the EggStreme on-disk footprint: DLLs with recent creation timestamps in user-writable directories, co-located with signed executables — the tell-tale sideloading pair — plus processes holding unusual outbound connections.
-- EggStreme Sideloading Pair Hunt
-- Finds DLLs in user-writable dirs co-located with EXEs, plus live outbound connections
LET dll_hits = SELECT FullPath, Size, Mtime, Btime
FROM glob(globs=[
'C:/Users/*/AppData/Local/**/*.dll',
'C:/Users/*/AppData/Roaming/**/*.dll',
'C:/ProgramData/**/*.dll',
'C:/Users/Public/**/*.dll'
])
WHERE Btime > now() - 60 * 86400 -- created in last 60 days
LET paired = SELECT FullPath AS SuspiciousDLL, Size, Btime,
dirname(path=FullPath) AS Directory,
{
SELECT FullPath AS CoLocatedExe
FROM glob(globs=dirname(path=FullPath) + '/*.exe')
} AS CoLocatedExes
FROM dll_hits
SELECT SuspiciousDLL, Size, Btime, Directory, CoLocatedExes
FROM paired
WHERE length(list=CoLocatedExes) > 0
-- Correlate: live processes with non-browser outbound 443 sessions
LET net_hits = SELECT Pid, Name, Path, Status, Family, Type,
Laddr, Raddr
FROM netstat()
WHERE Raddr.IP =~ '.'
AND Raddr.Port in (443, 8443)
AND Status = 'ESTABLISHED'
AND NOT Name =~ '(?i)(chrome|msedge|firefox|brave|safari|teams|onedrive|outlook)'
SELECT Pid, Name, Path, Raddr.IP AS RemoteIP, Raddr.Port AS RemotePort, Status
FROM net_hits
Triaging the results: legitimate hits will cluster around known per-user software (update caches, Electron apps). Investigate anything where the co-located EXE is a system binary copied out of System32 — that is the classic sideloading pattern, because attackers must place the signed host binary next to their DLL when the binary's DLL search order favors its own directory.
Remediation and Hunt Script
The following PowerShell performs a point-in-time sweep on a single host (or via your RMM/Intune across the fleet) for EggStreme-consistent artifacts: recent unsigned DLLs in user-writable paths, suspicious Run key entries, and scheduled tasks pointing at user directories.
# EggStreme-style artifact sweep — run elevated per host or via RMM
$Report = @()
$WritablePaths = @("$env:ProgramData", "$env:PUBLIC")
$UserDirs = Get-ChildItem 'C:\Users' -Directory -ErrorAction SilentlyContinue | ForEach-Object { $_.FullName }
$UserDirs | ForEach-Object {
$WritablePaths += Join-Path $_ 'AppData\Local'
$WritablePaths += Join-Path $_ 'AppData\Roaming'
}
# 1) Recent DLLs in user-writable paths, unsigned or invalidly signed
foreach ($p in $WritablePaths) {
if (Test-Path $p) {
Get-ChildItem $p -Recurse -Filter *.dll -ErrorAction SilentlyContinue |
Where-Object { $_.CreationTime -gt (Get-Date).AddDays(-60) } |
ForEach-Object {
$sig = Get-AuthenticodeSignature $_.FullName
if ($sig.Status -ne 'Valid') {
$Report += [PSCustomObject]@{
Type = 'UnsignedRecentDLL'
Path = $_.FullName
Created = $_.CreationTime
SigStatus = $sig.Status
Signer = $sig.SignerCertificate.Subject
}
}
}
}
}
# 2) Run keys pointing at user-writable locations
$RunKeys = @(
'HKLM:\SOFTWARE\Microsoft\Windows\CurrentVersion\Run',
'HKLM:\SOFTWARE\Microsoft\Windows\CurrentVersion\RunOnce',
'HKCU:\SOFTWARE\Microsoft\Windows\CurrentVersion\Run',
'HKCU:\SOFTWARE\Microsoft\Windows\CurrentVersion\RunOnce'
)
foreach ($key in $RunKeys) {
if (Test-Path $key) {
(Get-ItemProperty $key).PSObject.Properties |
Where-Object { $_.Value -match 'AppData|ProgramData|Users\\Public' } |
ForEach-Object {
$Report += [PSCustomObject]@{
Type = 'SuspiciousRunKey'
Path = "$key :: $($_.Name)"
Created = ''
SigStatus = ''
Signer = $_.Value
}
}
}
}
# 3) Scheduled tasks with actions in user-writable paths
Get-ScheduledTask | ForEach-Object {
foreach ($action in $_.Actions) {
if ($action.Execute -match 'AppData|ProgramData|Users\\Public' -and
$action.Execute -notmatch 'OneDrive|Teams|MicrosoftEdgeUpdate|GoogleUpdate') {
$Report += [PSCustomObject]@{
Type = 'SuspiciousScheduledTask'
Path = $_.TaskPath + $_.TaskName
Created = ''
SigStatus = ''
Signer = $action.Execute + ' ' + $action.Arguments
}
}
}
}
$Report | Format-Table -AutoSize
$Report | Export-Csv ".\EggStreme_Sweep_$(hostname)_$(Get-Date -Format yyyyMMdd_HHmm).csv" -NoTypeInformation
Remediation and Hardening
There is no patch for EggStreme — it is a post-compromise framework, not a vulnerability. Remediation is architectural and operational:
- Deploy Attack Surface Reduction (ASR) rules immediately. The highest-leverage control against this tradecraft is blocking unsigned/unsigned-trusted DLL loads. Enable these Microsoft Defender ASR rules in block mode after an audit window:
- Block executable files from running unless they meet a prevalence, age, or trusted list criterion (
01443614-cd74-433a-b99e-2ecdc07bfc25) - Block process creations originating from PSExec and WMI commands (
d1e49aac-8f56-4280-b9ba-993a6d77406c) - Block Office applications from creating child processes (
d4f940ab-401b-4efc-aadc-ad5f3c50688a) — covering the phishing entry vector.
- Block executable files from running unless they meet a prevalence, age, or trusted list criterion (
- Constrain DLL search order exposure. Where operationally feasible, enable
SafeDllSearchMode(on by default on modern Windows, but verify it has not been weakened) and audit for copied system binaries outsideSystem32/SysWOW64— a copied signed EXE in a user directory is a near-certain sideload staging artifact. - Application control. WDAC or AppLocker policies that restrict DLL loading to signed publishers and known paths are the structural counter to this entire technique family. Start in audit mode on server and VDI fleets; prioritize workstations in government, legal, and executive functions.
- EGress filtering for gRPC/HTTP2 abuse. EggStreme's C2 rides TLS that looks like web traffic. Enforce TLS inspection at the proxy for non-browser user agents where privacy policy permits, and alert on long-lived (>6 hour) outbound TLS sessions from non-browser processes — beaconing survivability drops sharply when sessions must be short.
- Block child processes and injection into shell processes. Modern EDR should be configured to alert on any
CreateRemoteThreadintoexplorer.exefrom non-allowlisted sources. Validate your EDR actually logs cross-process thread creation — many default configurations do not. - If compromised: assume depth. EggStreme is a multi-stage framework with keylogging capability. A confirmed detection means credentials in memory and at the keyboard are burned. Your IR plan must include enterprise-wide credential reset (prioritizing accounts used on affected hosts), Kerberos ticket invalidation (
krbtgtdouble-reset for domain compromise), and forensic imaging before remediation — reflective, in-memory stages evaporate on reboot and you will lose attribution-quality evidence. - Threat intel hygiene. Subscribe to Bitdefender's technical advisories and ensure your TI pipeline tags this actor cluster so that new IoCs (which will rotate) are ingested as context for behavioral detections, not as your primary detection layer.
For organizations in the Philippines and allied government ecosystems: treat this as an active, ongoing campaign, not a news event. Assume probing of your perimeter and phishing surface is happening now, and validate your sideloading and injection detections with a purple-team replay before the adversary validates them for you.
Related Resources
Security Arsenal Penetration Testing Services AlertMonitor Platform Book a SOC Assessment vulnerability-management Intel Hub
Is your security operations ready?
Get a free SOC assessment or see how AlertMonitor cuts through alert noise with automated triage.