Skip to content

Response, New York. Noah Park: Check Point Patches Actively Exploited Management Server Path Traversal. Detection, Dallas. Ava Okello: Report Finds Nearly Half of Deployed Detections Need Attention Before SOCs Can Trust Them.

SOCtember

Always First. Fast SOC News.

ReversingLabs Researcher's Notebook header art: a glass laboratory chamber with red-lit bubbles rising past two translucent panels on a dark background.
Image: ReversingLabs (fair use). Researcher's Notebook header art from the ReversingLabs analysis of BubbleLoader, published Nov. 17, 2026.

Detection

ReversingLabs Says BubbleLoader Turns Real Copies of WinRAR, x64dbg and Windows Media Player Into Malware Carriers, Hiding Its Code in Two PNG Images and Changing Its Payload's Hash on Every Run

The loader rewrites a few instructions at a legitimate program's entry point and adds a gradient image that serves as a decryption key, plus a fake PNG that holds the next stage. ReversingLabs saw activity clusters in mid-September and early October and says entry-point checks and memory alerts will catch it more reliably than hashes.

Ava Okello, DetectionLondon6 min read

LONDON - A loader that ReversingLabs calls BubbleLoader converts ordinary Windows programs, including WinRAR, the x64dbg debugger, Windows Media Player, the Firefox launcher and virtiofs, into delivery vehicles for other malware by patching a handful of instructions at the program's entry point and appending two PNG images that carry the hidden code, the company said in an analysis published on Tuesday.

ReversingLabs researcher Robert Simmons wrote that the earliest BubbleLoader samples appeared in February 2026 and that the company tracked two distinct activity clusters in mid-September and early October, evidence that adversaries are actively using it. The final payload varies with the malware family a given sample distributes; ReversingLabs did not tie the loader to a named actor. The report lists 24 SHA256 hashes for BubbleLoader samples.

A small patch inside a real program

The patch sits at the exact address where Windows starts executing the host binary. Its prologue is padded with junk instructions, and it computes the program's real base address with a position-independent GetPC trick so it works under ASLR. Rather than importing anything of its own, it borrows the host's import table, building obfuscated calls to GetModuleHandleW and GetProcAddress out of moves and jumps. It even tries an ASCII "kernel32" string first and falls back to a wide string, which lets the operators reuse one static stub across hosts that import either version of the function.

Annotated disassembly from ReversingLabs showing the BubbleLoader entry-point patch calling VirtualAlloc with read-write-execute protection, copying an embedded PNG and jumping into it.
Image: ReversingLabs (fair use).Figure 8 from the ReversingLabs analysis, the patch allocating read-write-execute memory, copying the PNG and jumping to the shellcode offset.

The patch then calls VirtualAlloc for memory marked readable, writable and executable, copies both PNGs into it and jumps to an offset inside the second image. ReversingLabs flagged that executable allocation as a detection opportunity.

One real image, one fake

The first PNG is a valid image, a red-to-blue gradient of varying size, and it is the key: its bytes serve as a rolling XOR key for the next stage. The second file is not a real PNG. It starts with the correct magic bytes and an IHDR chunk that is cut off where the image width should be, and the encrypted data begins in that field. In the sample ReversingLabs compared, the first width byte was 0x55 rather than the 0x00 a normal image would carry, which would imply an implausibly wide picture for a resource inside a program. The company called that a simple check for spotting the fake.

ReversingLabs hex comparison of a BubbleLoader fake PNG, where encrypted data starts in the IHDR width field, beside a valid PNG whose width field begins with zero bytes.
Image: ReversingLabs (fair use).Figure 11 from the ReversingLabs analysis, the starting bytes of a BubbleLoader fake PNG compared with a valid PNG.

The gradient also makes a poor key. Its sparse data contains long runs of null bytes, so parts of the next stage are left unencrypted, and ReversingLabs found readable third-stage loader strings as a result. The decryption loop is laced with opaque predicates that always jump over junk code: a privileged instruction followed by garbage bytes meant to confuse disassembly.

A payload whose hash never repeats

The third stage includes a reentry guard for DLL payloads, reads the host's base address from the process environment block and resolves five functions through a generic resolver: ExitProcess, RtlAddFunctionTable, RtlPcToFileHeader, VirtualAlloc and VirtualProtect. While decrypting the payload, it searches for blocks of 0xCC compiler padding between functions and overwrites each padding byte, except the first, with a fresh value from the CPU timestamp counter. The result, ReversingLabs said, is runtime polymorphism: the in-memory hash of the unpacked payload differs every time BubbleLoader runs.

Debugger memory dumps from ReversingLabs showing a block of 0xCC compiler padding before and after BubbleLoader overwrites it with random bytes from the CPU timestamp.
Image: ReversingLabs (fair use).Figure 24 from the ReversingLabs analysis, compiler padding before and after the runtime polymorphism routine.

The loader then maps the payload the way the Windows loader would, with relocations, TLS callbacks, imports and section protections, and adds full structured exception handling support. It registers the payload's exception directory with RtlAddFunctionTable, uses VirtualProtect to make the memory holding RtlPcToFileHeader in ntdll.dll writable, and installs an inline hook there. Payloads that rely on exception handling for anti-analysis or control-flow tricks would fail without that step.

What to look for

ReversingLabs recommends strict application allowlisting and code-signing verification to flag tampered copies of common utilities such as WinRAR whose entry points have been altered. For EDR, it points to memory allocated as read-write-execute through VirtualAlloc and to runtime VirtualProtect calls aimed at ntdll exception-handling routines such as RtlPcToFileHeader. For static detection, it suggests rules for embedded PNGs whose IHDR chunk is truncated to hide shellcode. Because the payload hash changes on every run, it advises responders to rely on behavioral memory analysis and entry-point integrity checks rather than on payload signatures alone. In practice, that means comparing the copies of WinRAR, x64dbg and similar tools found on endpoints against the publishers' own builds and treating any unsigned or entry-point-modified copy as suspect.

About the Author

Ava Okello

Ava Okello covers detection engineering, EDR telemetry, and SOC hunting for SOCtember from London.

Related stories

Detection desk