Don't run it. Dissect it.
Every layer and every branch, including the ones a sandbox never triggers. In seconds, with nothing to escape.
Malva.RE unpacks a suspicious file layer by layer, deobfuscates its scripts and macros, and extracts the malware family and its C2 configuration. Nothing is ever executed. Measured from 16 October to 15 November 2026: 8 in 10 malicious scripts and documents came back as readable code, with a median analysis time under 7 seconds.
A real sample, read layer by layer
VBScript dropper from the public feed, analysed on 17 November 2026 in 1 min 26 s: 18 layers in 3 branches. Nothing was executed; every line below comes from the public report, addresses defanged.
- 01VBScript root · 1,441 lines
Obfuscated dropper, as received
Object names are encrypted strings. This is what a sandbox would run.
Read this layer
- Type
- VBScript, root file, 1,441 lines
- YARA
- Contains_VBScript
- MITRE
- T1027 · T1059.005 · T1105 · T1053.005
' object names decrypted at run time Set FlatLength2534 = CreateObject(DeepConfig2423("?<@(?YST\T5WQ>>*OL<T.IX729", "l_2AO-::;zs>=[mS<8Y9a+2RQM")) Set FlatNotice9504 = CreateObject(DeepConfig2423("x}Q2[9*yc\XE(", "/.2@2I^W04=)D")) FlatNotice9504.Run RemoteRecord7720, 0, TrueSandboxRuns it, in one environment, and reports what happened that day.
DissectionResolves the encrypted names statically. The next layer is the result.
- 02VBScript deobfuscated · 4,018 lines
Same script, readable
Strings folded, names resolved: a shell, a file system, a short random sleep.
Read this layer
- Type
- VBScript, deobfuscated with vbSparkle, 4,018 lines
- YARA
- Contains_VBScript
- MITRE
- T1059.005
''' Deobfuscated with vbSparkle shellId = "WScript.Shell" fsId = "Scripting.FileSystemObject" Set wshShell = CreateObject(shellId) Set fso = CreateObject(fsId) WScript.Sleep Int(Rnd * 300) + 100SandboxSees processes start. Never sees this source.
DissectionThe code an analyst can read, search and quote in a ticket.
- 03VBScript written at line 311 · 53 KB dormant branch
The script it writes and launches
Scores its environment first: RAM, a desktop session, a live network adapter. Then persists as a scheduled task.
Read this layer
- Type
- VBScript written by the parent at line 311, launched at line 315, 53 KB, recovered by bounded evaluation
- YARA
- Contains_VBScript
- MITRE
- T1047 · T1053.005 · T1027 · T1105 · T1059.005
' three checks before anything happens envScore = 0 Set wmiService = GetObject("winmgmts:\\.\root\cimv2") Set osInfo = wmiService.ExecQuery("SELECT * FROM Win32_OperatingSystem") sysInfo = osItem.TotalVisibleMemorySize If sysInfo > 500000 Then envScore = envScore + 1 Set procList = wmiService.ExecQuery("SELECT * FROM Win32_Process WHERE Name='explorer.exe'") If procList.Count > 0 Then envScore = envScore + 1 Set netAdapter = wmiService.ExecQuery("SELECT * FROM Win32_NetworkAdapter WHERE NetEnabled=True") If netAdapter.Count > 0 Then envScore = envScore + 1 WScript.Sleep Int(Rnd * 2000) + 1500 ' ... then persistence wshShell.Run "schtasks.exe /create /tn ""PhotoStudioVBS"" /xml """ & manifestPath & """ /f", 0, TrueSandboxLess than 500 MB of RAM, no explorer.exe or no network, and this script sees a different machine. The checks themselves stay invisible.
DissectionReads the checks, the copy to AppData\Local\Photo Studio and the task named PhotoStudioVBS, whatever the machine.
- 04PowerShell written at line 853 · 462 KB
A PowerShell stage with its own key schedule
Home-made rotate, absorb and mix functions derive the keys that protect the payload.
Read this layer
- Type
- PowerShell written by the parent at line 853, 462 KB, 226 lines
- YARA
- Contains_PowerShell
- MITRE
- T1059.001 · T1027 · T1140 · T1218.009
function Invoke-ArchiveRotl([uint64]$x, [int]$n) { ... } function Invoke-ArchiveAbsorb($s, [byte[]]$data, [uint64]$tag) { ... } function Invoke-ArchiveMix($s, [uint64]$tag) { ... } Invoke-ArchiveAbsorb $s $pw 17 Invoke-ArchiveAbsorb $s $salt 39 for ($r = 0; $r -lt 12; $r++) { Invoke-ArchiveMix $s $r }SandboxSees PowerShell start, maybe a network call. The key schedule and the payload layout stay opaque.
DissectionFinds two arrays of 323 and 465 integers XORed with these keys, and rebuilds them.
- 05PowerShell rebuilt from 323 integers XOR key final
The payload, rebuilt without running anything
A reflective loader: code loaded in memory through the current AppDomain.
Read this layer
- Type
- PowerShell rebuilt from $r1 (323 integers) XOR $rk1 at script offset 459,209, then deobfuscated
- YARA
- Contains_PowerShell
- MITRE
- T1620 · T1059.001 · T1027
param($lb) $d = [AppDomain]::CurrentDomain $lm = $null foreach ($m in $d.GetType().GetMethods()) { $p = $m.Get... }SandboxOnly reaches this stage if every earlier check passed and the sleeps ran out.
DissectionThe final stage in clear text, with the technique it uses. Nothing ran, nothing left.
- Scores its environment before acting: more than 500 MB of RAM, an explorer.exe session, a live network adapter.
- Copies itself to AppData\Local\Photo Studio\PhotoStudio.vbs and registers a scheduled task named PhotoStudioVBS from an XML manifest.
- Writes a 462 KB PowerShell stage whose home-made key schedule protects two XORed arrays.
- Rebuilt from those arrays: a reflective loader that loads code in memory. Nothing ran to find this out.
Every line comes from the public report of one sample from the MalwareBazaar feed. Addresses are defanged. Nothing was executed. Open the full report →
50+ file formats analyzed, with no execution
Powering deep static reports on MalwareBazaar (abuse.ch)
8 in 10
malicious scripts and documents decoded into readable code
56 %
of them reveal the next stage
7 s
median analysis time
0
files executed
7
layers unpacked, at most
18,000+
public reports on malicious files
Measured in production from 16 October to 15 November 2026, on 10,101 analyses.

Our mission
Attackers rarely send a bare executable any more. They wrap the payload in layers: an archive, a document, a macro, an obfuscated script, a loader. A sandbox can be detected and evaded, and a multi-scanner returns a verdict, not an explanation.
Our mission is to make what a file hides readable. Malva.RE peels every layer statically and shows the deobfuscated code, the infection chain, the malware family and its command-and-control configuration, so analysts can decide and document without detonating anything.
A threat nested like a Russian doll
Modern malware hides its intent behind several layers of encapsulation: documents, scripts and executables nest into each other to evade defenses. Malva.RE automatically strips away that encapsulation in known formats — with no execution, within seconds — until the malicious core is exposed.
- 01 Office document · VBA macro
- 02 VBS script
- 03 Obfuscated PowerShell
- 04 AutoIt executable
- ✕ Malicious core
vbaDNA - A high-fidelity VBA decompiler with stomping detection
vbaDNA is a high-fidelity VBA decompiler and stomping detection tool. It restores the original source code with high fidelity and accurately detects malicious modifications, so cybersecurity specialists can quickly identify threats and take the necessary steps to protect their systems.
The free plan includes basic vbaDNA decompilation (limited to 3 modules). VBA Stomping and Purging detection and deobfuscation are available on paid plans.

Malva.RE features

What support for Visual Basic 5/6 executables changes in a Malva.RE report: sources reconstructed with VBReFormer Gen 2 (7.x), browsable procedure by procedure, and, for DarkCloud, an exfiltration configuration read in the code rather than guessed from strings. The DarkCloud 4.9 case serves as the example.

A technical walkthrough of the UPX format and of how Malva.RE detects, decompresses and rebuilds UPX-packed PE files (NRV2B/D/E, LZMA, call/jump filters, imports, relocations, resources) without execution, emulation or sandbox, so the real payload reaches YARA, configuration extractors and family detection.

Malva.RE now supports AutoIt executable detection and decompilation, providing deep insights into complex malware attack chains with no execution risk.

Learn about the advanced techniques of VBA Stomping and VBA Purging, and discover how Malva.RE, powered by vbaDNA technology, offers the most effective solution for detecting and analyzing these sophisticated threats hidden within Microsoft Office macros.

Extract configurations like C2 servers, encryption keys, and more from various malware families with Malva.RE’s unique static analysis approach.

Accurate VBA decompilation and advanced detection of obfuscation techniques like VBA stomping and purging, all fully integrated into Malva.RE's automated analysis workflow.
Built for your workflow
SOC analysts
Too many alerts, not enough time for every suspicious file.
- Median analysis time under 7 seconds
- Reports designed for SOC and malware analysts
- 50+ file formats
CERTs & CSIRTs
Nested infection chains that must be documented precisely.
- Multi-layer deobfuscation
- Malware configuration & IOC extraction
- EU hosting
Threat researchers
Tracking malware families and configurations at scale.
- High-fidelity VBA decompilation
- VBA Stomping & Purging detection
- Malware configuration & IOC extraction
Vendors & integrators
Embedding deep analysis into your products and pipelines.
- Proven integration (MalwareBazaar)
- On-premise deployment
- Encryption at rest & in transit
Start free, go private when you need it
Free
6 analyses / week
- Public submissions and reports
Essential
20 analyses / week
- Private submissions and reports
- AI summaries (MalvaGPT)
Premium
200 analyses / week
- Team management
- API access
Prices and full plan details are on the pricing page. See plans & pricing →
The News
Stay Informed with the Latest in Cybersecurity Innovation and Insights

What support for Visual Basic 5/6 executables changes in a Malva.RE report: sources reconstructed with VBReFormer Gen 2 (7.x), browsable procedure by procedure, and, for DarkCloud, an exfiltration configuration read in the code rather than guessed from strings. The DarkCloud 4.9 case serves as the example.
Sylvain Bruyère

As of August 2025, Malva.RE provides deep static reports directly integrated into MalwareBazaar. This partnership highlights the resilience of our lightweight, execution-free malware analysis engine.
Malware Research Team

A novel ransomware attack method targeting Low Earth Orbit (LEO) satellites has been demonstrated in a recent academic study. This article breaks down the technical details, potential consequences, and mitigation strategies for securing space systems.
Malware Research Team

Explore the sophisticated world of multi-level malware and discover how Yneos' Malva.RE provides an innovative, AI-enhanced solution for detecting and analyzing complex threats hidden in various file formats. Understand the importance of advanced static analysis in the modern cybersecurity landscape.
Malva.RE Team

Discover Malva.RE, Yneos' groundbreaking malware analysis platform, blending state-of-the-art static analysis with AI for unparalleled efficiency and precision in detecting and analyzing cybersecurity threats.
Malva.RE Team
Try Malva.RE on a real malware sample
Understand malware structure and behavior without execution
- Median analysis time under 7 seconds
- VBA, PowerShell and AutoIt deobfuscation, included in the free plan
- Reports designed for SOC and malware analysts
Free plan: submissions and reports are public. Private from the Essential plan.
Stay Ahead with Malva.RE: Subscribe for Exclusive Updates and Insights
Thanks! Your subscription is confirmed.
Subscription failed. Please try again or reach us through the contact form. contact@yneos.fr