Don't run it. Dissect it.

Every layer and every branch, including the ones a sandbox never triggers. In seconds, with nothing to escape.

View a real report →

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.

// live dissection

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.

  1. 01
    VBScript 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, True
    
    Sandbox

    Runs it, in one environment, and reports what happened that day.

    Dissection

    Resolves the encrypted names statically. The next layer is the result.

  2. 02
    VBScript 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) + 100
    
    Sandbox

    Sees processes start. Never sees this source.

    Dissection

    The code an analyst can read, search and quote in a ticket.

  3. 03
    VBScript 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, True
    
    Sandbox

    Less than 500 MB of RAM, no explorer.exe or no network, and this script sees a different machine. The checks themselves stay invisible.

    Dissection

    Reads the checks, the copy to AppData\Local\Photo Studio and the task named PhotoStudioVBS, whatever the machine.

  4. 04
    PowerShell 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 }
    
    Sandbox

    Sees PowerShell start, maybe a network call. The key schedule and the payload layout stay opaque.

    Dissection

    Finds two arrays of 323 and 465 integers XORed with these keys, and rebuilds them.

  5. 05
    PowerShell 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... }
    
    Sandbox

    Only reaches this stage if every earlier check passed and the sleeps ran out.

    Dissection

    The final stage in clear text, with the technique it uses. Nothing ran, nothing left.

// what this chain does
  • 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 →

// Formats & capabilities

50+ file formats analyzed, with no execution

PE / .NET & ELF executables Office documents PDF VBA macros JS / VBS / WSF scripts AutoIt executables PowerShell LNK shortcuts MSI packages XPS 50+ file formats
High-fidelity VBA decompilation VBA Stomping & Purging detection Multi-layer deobfuscation Malware configuration & IOC extraction YARA rule matching MITRE ATT&CK mapping AI summaries (MalvaGPT) REST API Collections & team workspaces Median analysis time under 7 seconds Encryption at rest & in transit EU hosting SOC analysts CERTs & CSIRTs Threat researchers Threat intelligence

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.

Malva.RE - Our mission
Malva.RE
// Who we are

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.

// Decapsulation

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.

  1. 01 Office document · VBA macro
  2. 02 VBS script
  3. 03 Obfuscated PowerShell
  4. 04 AutoIt executable
  5. ✕ Malicious core
// Flagship feature

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.

vbaDNA high-fidelity VBA decompiler with VBA Stomping and Purging detection
// The platform

Malva.RE features

Malva.RE Decompiles VB5/VB6 with VBReFormer Gen 2
Malva.RE Decompiles VB5/VB6 with VBReFormer Gen 2

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.

Static UPX Unpacking: Rebuilding the Original PE Without Running It
Static UPX Unpacking: Rebuilding the Original PE Without Running It

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.

Advanced AutoIt Executable Decompilation with Malva.RE
Advanced AutoIt Executable Decompilation with Malva.RE

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

Understanding VBA Stomping and Purging: Why High-Fidelity Decompilation is Critical
Understanding VBA Stomping and Purging: Why High-Fidelity Decompilation is Critical

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.

Malware Configuration Extraction
Malware Configuration Extraction

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

High-Fidelity VBA Decompiler - VBA Stomping & VBA Purging Detection Tool
High-Fidelity VBA Decompiler - VBA Stomping & VBA Purging Detection Tool

Accurate VBA decompilation and advanced detection of obfuscation techniques like VBA stomping and purging, all fully integrated into Malva.RE's automated analysis workflow.

// For your teams

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
Try for free

CERTs & CSIRTs

Nested infection chains that must be documented precisely.

  • Multi-layer deobfuscation
  • Malware configuration & IOC extraction
  • EU hosting
Request a demo

Threat researchers

Tracking malware families and configurations at scale.

  • High-fidelity VBA decompilation
  • VBA Stomping & Purging detection
  • Malware configuration & IOC extraction
Try for free

Vendors & integrators

Embedding deep analysis into your products and pipelines.

  • Proven integration (MalwareBazaar)
  • On-premise deployment
  • Encryption at rest & in transit
Request a demo
// Plans

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

Teams & enterprise

Custom quote

  • Custom volumes and integrations
  • On-premise deployment
Contact us

Prices and full plan details are on the pricing page. See plans & pricing →

// News & insights

The News

Stay Informed with the Latest in Cybersecurity Innovation and Insights

Malva.RE Decompiles VB5/VB6 with VBReFormer Gen 2
Malva.RE Decompiles VB5/VB6 with VBReFormer Gen 2

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

Sylvain Bruyère

6 min read
Malva.RE now powers MalwareBazaar with deep static reports
Malva.RE now powers MalwareBazaar with deep static reports

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

Malware Research Team

2 min read
Ransomware in space: evaluating a new attack vector against LEO satellites
Ransomware in space: evaluating a new attack vector against LEO satellites

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

Malware Research Team

4 min read
Navigating the Complexity of Multi-Level Malware
Navigating the Complexity of Multi-Level Malware

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

Malva.RE Team

3 min read
Revolutionizing Malware Analysis with Cutting-Edge Static Analysis Technology
Revolutionizing Malware Analysis with Cutting-Edge Static Analysis Technology

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

Malva.RE Team

2 min read

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