First-hand analysis. We sourced these samples ourselves from publicly accessible YouTube videos and examined them in our own lab. Specific hashes and IOCs are withheld — this infrastructure rotates fast enough that publishing stale indicators does more harm than good.

Background

Search YouTube for "Fortnite aimbot free download" and you will find exactly what you would expect: videos with fabricated gameplay footage, a Mega or MediaFire link in the description, and a pinned comment reassuring viewers the file is safe. The target audience — mostly younger gamers — is already willing to run an unsigned executable from an unknown source. That is the entire social engineering chain. No phishing email, no exploit kit. Just a kid who wants to cheat at Fortnite.

We pulled executables from videos advertising three categories of "cheat": Fortnite aimbots, Roblox script executors, and Call of Duty unlock tools. None of them were cheats. The payload across all three was Lumma Stealer.

For background on Lumma itself — the MaaS model, pricing tiers, ClickFix delivery, dead-drop resolvers, and the 2025 takedown — see our companion writeup. This page covers what we found when we actually ran the samples.

Toolchain

Samples ran in isolated Windows guests on our in-house Type-1 VT-x hypervisor — a custom research hypervisor we develop internally for this kind of work. It virtualises every logical processor, supports snapshotting, variable hardware configurations, and environment spoofing (hardware identifiers, timing sources) to reduce the artifacts that anti-VM checks look for. Ghidra handled static triage before execution, and Wireshark sat on a tap capturing everything leaving the guest. The point was a repeatable, controlled environment where we could reset between runs and change one variable at a time.

Static triage

We loaded each binary into Ghidra before detonating anything. The filenames were theatrical (FortniteAimbot_v3.2.exe, RobloxExecutor_FINAL.exe, that sort of thing) but the internals told a different story.

All of the samples shared a few traits:

  • Heavy obfuscation — API-hashing, encoded strings, indirect jumps. The decompiler output was a mess, which is itself a signal. A real game cheat has no reason to hide its import table.
  • Imports well beyond what any cheat needs: file enumeration, credential-store access, process injection primitives, outbound socket calls.
  • A loader structure — the initial binary was a wrapper. The actual stealer payload was packed or fetched at runtime, making the first-stage binary look relatively sparse on its own.

None of this is unique to Lumma — plenty of malware families look similar under static triage. But it told us enough to know these were not game cheats, and to proceed with dynamic analysis carefully.

The interesting part: anti-VM behaviour

This is where it got good. We detonated one of the samples in a stock VM config and… nothing happened. No file-system activity beyond the initial write. No network calls. No browser-store access. The process launched, sat for a few seconds, and exited cleanly. On paper, it looked benign.

We knew it was not benign. The static analysis had already shown us the credential-harvesting logic and the C2 comms buried in the binary. So the question became: what did it see that we did not want it to see?

Because our hypervisor gives us direct control over the guest's hardware identity and timing sources, we could methodically cycle through configurations — changing hardware strings, adjusting memory and vCPU counts, spoofing identifiers, modifying guest registry keys that commonly betray virtualisation. On some configs, the sample produced partial activity: it would touch a few browser directories but never phone home. On others, it stayed completely dormant. The behaviour was tiered, not all-or-nothing, which suggests the sample runs multiple environment checks and gates different stages behind different thresholds.

Back in Ghidra, we found candidate code paths — CPUID leaf checks, timing loops that look like RDTSC-based VM detection, and what appeared to be registry probes for common hypervisor artifacts. We could not conclusively pin the dormancy to a single check; in practice it is probably a combination. Worth noting: inactivity alone is not proof of anti-VM. A dead C2, a missing dependency, or a wait timer that outlasts your patience all look the same from the outside. We are confident the evasion is real based on the disassembly, but we are honest that we did not fully defeat it in every config.

Dynamic execution & network capture

The samples that did fire gave us what we expected. Within seconds of execution, we saw file-system reads targeting Chromium and Gecko browser profile directories — the credential stores, cookie databases and autofill data. Shortly after, Wireshark lit up.

The sequence was textbook steal-and-exfil: harvest locally, then push it out. DNS queries resolved domains with no connection to any legitimate game infrastructure. TLS connections went to IPs that showed up on threat-intel feeds associated with Lumma C2 infrastructure. The timing was tight — browser-store access and the first outbound connection were seconds apart, not minutes.

One detail worth flagging: the file-hosting infrastructure (the Mega/MediaFire links from the YouTube videos) was completely separate from the post-execution C2. Different domains, different IPs, different registrars. The download site delivers the loader. The C2 receives the stolen data. Mixing them up produces bad IOCs.

Findings

Question Assessment
Is this Lumma? High confidence. Code structure, runtime behaviour and network indicators all line up with documented Lumma builds.
Does it steal credentials? Yes. Direct observation of browser credential-store and wallet-directory access during execution.
Does it phone home? Yes. Captured outbound traffic to IPs matching known Lumma C2 infrastructure.
Does it detect VMs? Probably. Dormant in some configs, partially active in others. Candidate evasion code found in disassembly but not conclusively pinned to a single check.
Are the three lure themes related? Probably. Shared code-level patterns and delivery structure suggest a common operator or builder kit, but we cannot prove a single actor.

Limitations

VMs cannot perfectly replicate bare metal — if a payload gates hard on a hardware check we cannot spoof, we will miss it. The multi-stage delivery chain means later stages may have been encrypted or hosted on infrastructure that was already dead by the time we looked. Wireshark shows connection metadata, not encrypted payload contents. And C2 infrastructure rotates, so anything we captured is a snapshot, not a permanent indicator.

So what?

Game-cheat videos on YouTube are a commodity delivery vector for infostealers, and the audience self-selects for people who will run unsigned binaries without thinking twice. Lumma is the payload today; it will be something else tomorrow. The delivery mechanism is the constant.

From an analysis perspective, the anti-VM behaviour was the most useful finding. A sample that goes dormant in your sandbox is not clean — it is suspicious in a different way. The answer is not to trust the silence but to vary the environment and correlate static analysis with whatever runtime behaviour you can coax out of it. This is exactly why we develop our own hypervisor rather than relying on off-the-shelf virtualisation: when a sample detects the environment, we can identify the specific check and close the gap. Ghidra shows what the code can do, the hypervisor shows what it does do, and Wireshark shows where it sends the results. Confidence comes from the overlap.

If you have reason to believe Lumma ran on a machine: assume every credential in every browser is burned, rotate all sessions, move crypto to hardware wallets, and reissue tokens. Do not wait for confirmation that specific data was exfiltrated. By the time you can confirm it, it has already been sold.

Related