ESET Research has identified a sophisticated cyber-espionage framework named Cereal, designed to compromise and operate within Microsoft Exchange environments.
The investigation began on November 28, 2025, when ESET discovered suspicious components on a compromised Exchange server belonging to a governmental organization in Kazakhstan. Further analysis identified another compromised government organization in Romania on December 23, 2025.
The Romanian deployment was configured to identify emails sent to or received from NATO and European Union (EU) institutional addresses, demonstrating a specific intelligence-collection objective.
ESET attributes the Cereal toolset with high confidence to Turla, also known as Snake, based on the simultaneous use of another component publicly associated with the group and conceptual similarities to previously documented Turla malware.
The framework consists of multiple specialized .NET components, including:
CerealLoader: Loads and executes encrypted .NET assemblies from disk.
CerealRunner: Packages and executes encrypted commands and additional malware components.
CerealSprinter: Loads and executes other components.
CerealNeuron: A passive backdoor that receives commands through incoming web requests.
CerealHermit: A CerealNeuron variant that processes encrypted command files locally without network functionality.
CerealIron: Injects .NET assemblies into non-.NET processes.
CerealBox: Intercepts and collects selected emails from Microsoft Exchange's transport pipeline.
CerealMoth: Loads an assembly and executes a specified method.
The framework stands out for its ability to operate inside legitimate Exchange and Windows processes, execute commands in memory, and use the victim's own Exchange server as its command-and-control infrastructure.
Unlike conventional malware that periodically communicates with attacker-controlled servers, CerealNeuron passively waits for specially crafted incoming requests. This significantly reduces the external network indicators available to defenders.
Threat Actor Profile and Victimology
Turla – Russia-Aligned Cyber-Espionage Group
Turla, also tracked as Snake, is a long-running cyber-espionage group active since at least 2004.
The group is widely assessed to be associated with Russia's Federal Security Service (FSB). Its historical targeting includes:
Government organizations.
Diplomatic missions.
Defense institutions.
Military-related organizations.
Strategic and geopolitical entities.
Its operations have primarily focused on Europe, Central Asia, and the Middle East.
ESET's attribution of Cereal to Turla is assessed with high confidence, supported by overlapping tools and similarities to previously documented malware. This attribution should be distinguished from independently confirmed government sponsorship.
Identified Victims
ESET identified two government organizations compromised by the Cereal framework.
Kazakhstan – Government Organization
Initial discovery: November 28, 2025.
ESET discovered previously undocumented components on a compromised Microsoft Exchange server.
The activity revealed a modular malware framework designed for long-term espionage and email collection.
Romania – Government Organization
Compromise identified: December 23, 2025.
CerealBox was configured to collect messages involving NATO and EU institutional email addresses.
The collection criteria indicate a specific interest in diplomatic, political, and military-related communications.
ESET also reported that approximately 70% of countries targeted by Turla since 2022 were former Soviet republics or European countries previously closely aligned with the Soviet Union.
The geographical distribution and targeting patterns are consistent with Turla's historical intelligence-gathering activities.
Technical Description
Cereal is a modular .NET malware framework built around encrypted payload delivery, in-memory execution, process injection, and abuse of Microsoft Exchange internals.
Rather than deploying one large backdoor containing all functionality, the operators use multiple specialized components. Each component performs a particular task and can load additional encrypted assemblies.
The framework follows several operational principles:
Keep most payloads encrypted while stored on disk.
Execute malware components in memory wherever possible.
Reuse legitimate Windows and Microsoft Exchange processes.
Deliver individual commands as separate .NET executables.
Use the compromised Exchange server as an operational command channel.
Collect targeted email communications from within the Exchange transport pipeline.
This architecture provides flexibility to the operators while reducing the number of obvious malicious files and external infrastructure indicators.
Attack Overview
1. Initial Compromise and Malware Deployment
ESET identified Cereal components on compromised government Exchange servers in Kazakhstan and Romania.
However, the research does not establish the initial access method used to compromise these organizations.
The available investigation focuses primarily on post-compromise deployment, execution, command delivery, and intelligence collection.
The discovered components were distributed across encrypted files, nested .NET assemblies, and DLLs loaded by legitimate Windows and Exchange processes.
The framework uses a chain of loaders and execution components to unpack and run additional payloads.
2. CerealLoader – Encrypted Payload Execution
CerealLoader is the primary component responsible for loading and executing .NET assemblies from encrypted files on disk.
It is the only Cereal component that ESET identified as being stored on disk in a recognizable, unencrypted .NET file format.
The loader uses an unusual .NET execution technique involving Vtable Fixups.
Under normal circumstances, .NET applications execute through the Common Language Runtime (CLR). CerealLoader instead executes native machine code before the CLR begins its normal execution process.
This native entry point establishes a hidden bridge to a .NET method that does not appear to be called through conventional application logic.
Consequently, analysts inspecting the application through ordinary .NET decompilation tools may see an apparently inactive entry point while the malicious functionality has already executed.
3. CerealRunner and CerealSprinter – Modular Command Execution
CerealRunner and CerealSprinter provide the framework with modular execution capabilities.
CerealRunner contains encrypted .NET programs and the arguments required to execute them.
When launched, it:
Unpacks encrypted payloads.
Loads additional .NET assemblies.
Executes commands in memory.
Collects command output.
Returns the results through the malware's execution pipeline.
Rather than using a single executable with a large collection of hardcoded commands, operators deliver individual programs for specific tasks.
ESET identified numerous CerealRunner binaries with similar structures but different task-specific code.
This suggests the existence of an internal framework that automates the compilation, packaging, and delivery of commands.
CerealSprinter performs a similar loading and execution role, but is primarily used to load and run other components.
4. CerealNeuron – Passive Exchange Backdoor
CerealNeuron is one of the most significant components of the framework.
Unlike conventional backdoors, it does not periodically initiate outbound connections to an attacker-controlled server.
Instead, it operates as a passive backdoor on the compromised Exchange server and waits for incoming HTTP/HTTPS requests containing specially crafted, encrypted data.
ESET observed the following request paths:
/owa/sdds/
/AUTODISCOVER/PROXYSERVICE/
/MICROSOFT-SERVER-ACTIVESYNC/INTEGRATED/API/These paths resemble legitimate Microsoft Exchange services, including Outlook Web Access, Autodiscover, and ActiveSync.
When a request reaches one of these paths, CerealNeuron checks whether the request contains correctly encrypted data and satisfies its integrity validation requirements.
If validation succeeds:
The incoming data is decrypted.
The contents are interpreted as a command.
The requested functionality is executed.
Results are encrypted.
The response is returned to the operator.
If the request does not pass validation, the backdoor redirects the client to a legitimate-looking Exchange error page.
This design allows malicious requests to blend into normal Exchange web traffic.
Why this matters:
No dedicated external C2 server is required.
Conventional outbound beacon detection may not identify the backdoor.
Malicious requests use paths associated with legitimate Exchange services.
The compromised Exchange server becomes the operator-accessible control point.
Network-based tracking is significantly more difficult.
ESET reported that it could not identify the ingress IP addresses used by the operators.
5. CerealHermit – Offline Command Execution
CerealHermit is a variant of CerealNeuron that does not include network communication functionality.
Instead of waiting for incoming web requests, it reads encrypted command files from disk and writes encrypted execution results back to files.
This provides an alternative command-execution mechanism when network-based access is unavailable or unnecessary.
ESET observed cases where CerealNeuron and CerealHermit were deployed together, giving operators two independent methods of interacting with compromised systems.
6. CerealIron – Injection into Non-.NET Processes
CerealIron is an injector designed to load and execute .NET assemblies from processes that are not normally .NET applications.
This capability allows the operators to execute malicious assemblies inside legitimate Windows processes.
It is particularly important in the delivery chain for CerealBox, which requires execution within Microsoft Exchange's transport service.
By abusing legitimate process execution and memory-loading mechanisms, the framework reduces the visibility of standalone malicious executables.
7. Abuse of Windows Components and the .NET Native Image Cache
ESET identified additional execution techniques involving legitimate Windows components and the .NET native image cache.
In one observed execution chain, CerealLoader was placed under:
C:\Windows\System32\wbem\ncobjapi.dllIn another case, it impersonated:
C:\Windows\System32\wbem\wbemcomn.dllThese files are located in the Windows Management Instrumentation (WMI) directory.
The malicious DLLs forward legitimate function calls so the affected process continues to operate normally while the malicious native entry point executes.
ESET also identified abuse of the .NET native image cache.
The operators placed malicious CerealLoader files in the cache using names such as:
Microsoft.Exchange.Search.Mdb.ni.dllWhen Exchange requested the corresponding library, the .NET runtime loaded the malicious file from the cache.
The malicious component executes its native entry point before the runtime falls back to the legitimate library for normal functionality.
In one sample, the malicious functionality activated only when the parent process was the Exchange search service.
These techniques demonstrate a detailed understanding of Windows internals, .NET execution behavior, and Exchange service architecture.
8. CerealBox – Exchange Email Collection Module
CerealBox is the framework's primary email collection component and one of its most technically significant capabilities.
It is designed to intercept email communications directly from Microsoft Exchange's transport pipeline.
The component is injected into:
EdgeTransport.exeThis is the Microsoft Exchange process responsible for handling email transport.
Traditional Exchange transport agents are registered through legitimate Exchange configuration mechanisms. Their presence can therefore be identified through administrative inspection.
CerealBox uses a different approach.
Instead of registering a new transport agent, it injects into the existing Exchange process and locates the handlers used by legitimate transport agents.
It then wraps these handlers with malicious code.
The malicious logic executes before control is returned to the original handler, allowing normal email processing to continue.
This means:
No new transport agent is registered.
Existing Exchange transport functionality continues operating.
Email messages can be inspected during processing.
Selected messages are collected without obvious changes to the normal mail flow.
9. Targeted Email Collection
CerealBox uses predefined filtering criteria to identify messages of intelligence value.
A message is selected when it contains a .doc, .docx, or .pdf attachment and matches at least one configured collection criterion.
The criteria include:
Sender email addresses.
Recipient email addresses.
Subject-line substrings.
Attachment filenames.
Hardcoded ignore lists used to exclude unwanted matches.
The selected messages are compressed, encrypted, and staged in files on the compromised system.
Operators subsequently use CerealNeuron commands to retrieve the staged data and delete the files.
In the Romanian government compromise, CerealBox was configured to identify messages involving NATO and EU institutional addresses.
This provides evidence of targeted intelligence collection rather than indiscriminate mailbox theft.
10. Additional Post-Compromise Capabilities
ESET identified CerealRunner commands used for reconnaissance, credential access, and information collection.
The observed functionality includes:
| Capability | Description |
|---|---|
| Mailbox access | Retrieving mailboxes and specific messages through Exchange Web Services |
| Active Directory reconnaissance | Querying computers, users, groups, and DNS records |
| WMI queries | Enumerating processes and active TCP connections |
| Credential extraction | Extracting LSA Secrets stored by Windows |
| Volume discovery | Listing volume snapshots |
| File operations | Listing, reading, and deleting files |
| Data retrieval | Accessing staged email collections and other files |
The ability to execute separate task-specific assemblies allows operators to perform targeted operations without deploying a single large executable containing every capability.
Indicators of Compromise (IOCs)
ESET has published a comprehensive IOC collection through its GitHub repository and the associated technical white paper.
The public blog post does not reproduce the complete hash, filename, and network indicator list. Therefore, this article does not invent or substitute IOC values.
Official IOC repository:
https://github.com/eset/malware-ioc/tree/master/turla
Host-Based Investigation Indicators
| Indicator | Type | Description |
|---|---|---|
CerealLoader | Malware component | Encrypted .NET payload loader |
CerealRunner | Malware component | Modular command and payload execution |
CerealSprinter | Malware component | Additional assembly loader |
CerealNeuron | Malware component | Passive Exchange backdoor |
CerealHermit | Malware component | File-based offline backdoor |
CerealIron | Malware component | .NET assembly injector |
CerealBox | Malware component | Exchange email collection module |
CerealMoth | Malware component | Assembly and method execution |
EdgeTransport.exe | Process | Exchange transport process targeted by CerealBox |
ncobjapi.dll | Filename | Malicious DLL name observed in WMI directory |
wbemcomn.dll | Filename | Impersonated Windows component |
Microsoft.Exchange.Search.Mdb.ni.dll | Filename | Malicious native image cache filename |
Network Investigation Indicators
Review incoming Exchange web traffic involving the following paths:
/owa/sdds/
/AUTODISCOVER/PROXYSERVICE/
/MICROSOFT-SERVER-ACTIVESYNC/INTEGRATED/API/These paths are not inherently malicious. They are legitimate-looking Exchange service paths abused by CerealNeuron.
Detection should be based on request characteristics, cryptographic validation behavior, associated process execution, and endpoint telemetry rather than blocking the paths themselves.
Potential Impact
Successful deployment of Cereal may result in significant compromise of government and enterprise Exchange environments.
Sensitive Email Disclosure: CerealBox can collect selected email communications, including messages exchanged between government organizations and strategic institutions.
Diplomatic and Military Intelligence Exposure: The Romanian deployment's focus on NATO and EU institutional addresses demonstrates the potential for collecting sensitive diplomatic, political, and defense-related communications.
Credential Compromise: The framework's ability to extract LSA Secrets may expose credentials that can support further unauthorized access.
Active Directory Reconnaissance: Queries involving users, computers, groups, and DNS records can provide operators with an understanding of the victim's internal environment.
Exchange Server Compromise: Injection into EdgeTransport.exe and other legitimate Exchange-related processes can allow malicious code to operate within critical email infrastructure.
Stealthy Command Execution: The passive backdoor and encrypted command delivery mechanism reduce the visibility of conventional C2 traffic.
Long-Term Espionage: The modular architecture, multiple execution mechanisms, and ability to use the compromised server as an operational hub support sustained intelligence collection.
Internal Network Exposure: The framework's reconnaissance and command-execution capabilities may provide operators with information useful for subsequent activity within the compromised organization.
Recommendations
Immediate Actions
Investigate Exchange Server Integrity: Review Exchange servers for unexpected DLLs, unauthorized modifications, suspicious modules, and abnormal process activity involving Exchange services.
Inspect EdgeTransport.exe: Investigate unexpected code execution, suspicious memory activity, and unusual modules associated with
EdgeTransport.exe.Review Exchange Transport Configuration: Examine transport agents and their configurations. Remember that CerealBox does not register a new transport agent, so a clean configuration listing does not rule out compromise.
Inspect WMI Directories: Investigate unexpected DLLs in
C:\Windows\System32\wbem\, particularly suspicious files using names such asncobjapi.dllandwbemcomn.dll.Review .NET Native Image Cache: Look for suspicious assemblies or DLLs with Exchange-related native image names, including
Microsoft.Exchange.Search.Mdb.ni.dll.Monitor Exchange Web Requests: Investigate unusual requests involving
/owa/sdds/,/AUTODISCOVER/PROXYSERVICE/, and/MICROSOFT-SERVER-ACTIVESYNC/INTEGRATED/API/. Correlate them with endpoint process activity and request contents.Hunt for Credential Access: Review telemetry for unexpected access to LSA Secrets and suspicious interactions with Windows security-related processes.
Investigate Active Directory Queries: Identify unusual enumeration of users, groups, computers, and DNS records originating from Exchange servers or unexpected processes.
Review Email Collection Activity: Investigate suspicious mailbox access through Exchange Web Services, unexpected email staging files, and unusual file compression or encryption activity.
Preserve Forensic Evidence: Collect Exchange logs, endpoint telemetry, suspicious DLLs, memory evidence, file metadata, and relevant authentication records before attempting remediation.
Rotate Exposed Credentials: If compromise is confirmed, rotate privileged credentials, review service accounts, invalidate exposed authentication material, and investigate suspicious authentication activity.
Review the Official IOC Repository: Import verified indicators from ESET's repository into relevant SIEM, EDR, and threat intelligence platforms after validating their applicability.
Preventive Actions
Harden Exchange Infrastructure: Keep Microsoft Exchange servers updated and apply Microsoft's recommended security configurations.
Restrict Administrative Access: Limit Exchange management interfaces and privileged administrative access to trusted networks and authorized accounts.
Implement Application Control: Monitor and restrict unauthorized DLL loading and execution from sensitive system directories.
Monitor Exchange Process Integrity: Establish baselines for
EdgeTransport.exeand other Exchange processes, including their loaded modules and child processes.Strengthen Endpoint Detection: Configure EDR monitoring for process injection, unusual in-memory .NET assembly execution, suspicious DLL loading, and native image cache modifications.
Improve Active Directory Monitoring: Detect unusual enumeration of users, groups, computers, DNS records, and privileged accounts.
Monitor Credential Access: Implement detections for unexpected access to LSASS-related resources and LSA Secrets.
Strengthen Email Security: Review Exchange transport configurations, audit mailbox access, and monitor unusual collection or staging of email attachments.
Improve Network Visibility: Monitor incoming Exchange requests for abnormal payloads, unusual encrypted content, and suspicious request patterns, rather than relying solely on outbound C2 detection.
Conduct Regular Threat Hunting: Search historical telemetry for Cereal components, suspicious Exchange process behavior, and indicators published by ESET.
Conclusion
The Cereal framework demonstrates Turla's continued investment in sophisticated cyber-espionage capabilities targeting government email infrastructure.
Its most distinctive feature is the combination of passive command execution through compromised Exchange servers and direct interception of email communications from inside the Exchange transport pipeline.
By injecting into legitimate processes, abusing .NET execution mechanisms, and using the victim's own infrastructure as a command channel, Cereal reduces reliance on conventional malware files and attacker-controlled external servers.
The CerealBox component is particularly significant because it can intercept selected emails without registering a new Exchange transport agent, allowing normal mail delivery to continue while sensitive communications are collected.
Organizations operating Microsoft Exchange should prioritize process integrity monitoring, DLL and memory inspection, Active Directory auditing, credential-access detection, and investigation of unusual Exchange web requests.
The absence of dedicated external C2 infrastructure should not be interpreted as evidence that an Exchange environment is clean. Host-level and application-level monitoring are essential for identifying this type of intrusion.
