Skip to content

MZ.exe · .dll · .sys

PE Parser

Headers, sections, imports, resources, Rich header, Authenticode, .NET metadata, strings and hashes of Windows executables — with plain-language indicators. Static parsing in your browser with WebAssembly: the file is never uploaded and never run.

FIG. 0awaiting specimen

Drop .exe, .dll or .sys files here

One file or a whole batch: folders and ZIP collections (Velociraptor, a zipped folder) work as-is. Files are recognised by their MZ header, so renamed payloads are found too. Nothing is executed — the bytes are only read.

Five harmless PE files from a fictional intrusion: four hand-built ones whose code is a single `ret`, and wupd.exe, a real UPX-packed build of a program that only prints a greeting. Tip: compare the two m64.exe builds, open the signed DLL, then open wupd.exe to watch it get unpacked.

100% client-side and static: files are parsed by WebAssembly in your browser, never uploaded, never executed.

How to get the files

Full collection guide

Take the suspicious binaries off the machine without running them, keeping their folder so each one stays attributed, then drop the files, the folder or a ZIP here. Nothing needs to be installed.

  1. Copy the binaries (never run them)
  2. Drop the files, folder or ZIP here
  3. Parsed in your browser, never uploaded

Already have the file? Drag it straight onto this page: it is read, not executed.

To sweep a live machine, paste this into Windows PowerShell run as administrator. It copies executables (.exe, .dll, .sys, .scr, .cpl, .ocx) written in the last 14 days under ProgramData, Users and Windows\Temp, keeping their paths. Adjust the roots and the number of days to your case.

PowerShell · Admin
$dst = 'C:\triage\pe'
$roots = 'C:\ProgramData', 'C:\Users', 'C:\Windows\Temp'
Get-ChildItem -Path $roots -Recurse -Force -File -Include *.exe, *.dll, *.sys, *.scr, *.cpl, *.ocx -ErrorAction SilentlyContinue |
  Where-Object { $_.LastWriteTime -gt (Get-Date).AddDays(-14) -and $_.Length -lt 200MB } |
  ForEach-Object {
    $to = Join-Path $dst $_.FullName.Substring(3)
    New-Item -ItemType Directory -Force -Path (Split-Path $to) | Out-Null
    Copy-Item -LiteralPath $_.FullName -Destination $to -Force
  }

Result: C:\triage\pe\ProgramData\…, C:\triage\pe\Users\<user>\… Drop the C:\triage\pe folder here (drag it, or use Choose a folder).

Analysing on another machine? Pack it into one ZIP with the tar.exe built into Windows 10 1803 and later. Antivirus may quarantine files while you copy them: add an exclusion for C:\triage or collect from an image.

PowerShell / cmd
tar -a -c -f C:\triage\pe.zip -C C:\triage pe

Gotchas

  • Antivirus can delete or quarantine samples during collection. Exclude the destination folder or work from an image.
  • Password-protected ZIPs (the usual "infected" archives) can't be opened in the browser: extract them first, then drop the folder.
  • Files over 512 MB are skipped: the browser reads each file whole into memory.

What is a PE file?

PE (Portable Executable) is the file format of Windows programs: .exe, .dll, .sys drivers, .scr, .cpl, .ocx and EFI binaries. It starts with an MS-DOS header ("MZ"), then a PE signature, a COFF file header, an optional header with 16 data directories, and a section table that maps the file into memory.

Static analysis reads that structure without running anything: what the file imports, when and with what it was built, whether it is signed, what it carries in its resources and overlay. It is the first, safe step of malware triage.

What this tool reads

  • Headers: DOS, COFF and optional header (PE32 and PE32+), data directories, section table with raw/virtual sizes, flags and entropy per section, checksum recomputed.
  • Imports (ordinals of ws2_32, wsock32 and oleaut32 named), delay-load and bound imports, exports and forwarders, imphash.
  • Resources: version information, manifest, icons, string tables, dialogs, embedded files; overlay detection.
  • Rich header decoded to Visual Studio releases, debug directory (PDB path, GUID, age), TLS callbacks, load configuration (CFG, SafeSEH), relocations.
  • Authenticode: signer, certificates, timestamp, file hash versus signed digest and RSA signature check. .NET: CLR header, metadata streams, assembly, references, P/Invoke, types.
  • Strings (ASCII and UTF-16LE) with categories, MD5 / SHA-1 / SHA-256 / TLSH, packer and compiler heuristics, and a batch table to spot families.
  • Unpacking: UPX-packed files are rebuilt with their original imports, and executables hidden inside a file (stored as-is, XOR-encoded, or compressed with LZNT1, aPLib, zlib, gzip or LZMA) are extracted and analysed as child files.
  • YARA: run your own rules (or the example set) on every file, unpacked children included, with the pe, dotnet, hash, math and string modules; matches open in the hex view.
  • MITRE ATT&CK: capabilities recognised from imports, strings and unpacking results, grouped by tactic with their evidence, exportable as an ATT&CK Navigator layer.
  • Disassembly: x86 / x64 code from the entry point, TLS callbacks, exports or any address, with imported functions named and branches you can follow.
  • Toolchain metadata: Go build info and function names, Rust crates and source paths, Nim modules, Delphi forms, PyInstaller contents, .NET methods.
  • Malware configurations decoded statically: Cobalt Strike beacons, Metasploit / Cobalt Strike shellcode stagers, AsyncRAT, DcRat, VenomRAT, QuasarRAT, njRAT and Remcos (C2 servers, keys, sleep, install paths).
  • Code analysis: functions discovered in the x86 / x64 code, capabilities recognised from what each function calls and computes (anti-debugging, injection, crypto constants, API hashing…) mapped to ATT&CK and MBC, and strings recovered by emulation that a plain strings pass can't see (stack, tight-loop and decoded strings).
  • .NET: IL disassembly of every method with names resolved, and detection of obfuscators and protectors (ConfuserEx, SmartAssembly, Dotfuscator, Agile.NET, Costura…).
  • IOCs: network indicators, host artefacts and hashes, defanged, exported as CSV, MISP event or STIX 2.1; a YARA rule can be drafted from a file and tested on the batch.

Why it matters in an investigation

  • Hashes and imphash let you search threat intelligence and group variants of the same tool; TLSH measures how close two files are.
  • Compile, debug and signing times date a tool — and disagreements between them reveal tampering.
  • Imports and strings show capabilities (network, injection, persistence) and indicators (URLs, IPs, paths, registry keys).
  • Version information, PDB paths and the Rich header point to the author's environment; a signature says who vouched for the file.

Limitations

  • Static only: UPX is unpacked in the browser, but other packers, protectors and encrypted code have to be unpacked elsewhere before their real imports and strings appear.
  • Certificate chains are not validated (no trust store, no revocation): the tool checks integrity, not trust.
  • Packer detection uses section names, entry-point stubs, protector SDK imports and import-table shapes, not a signature database such as Detect It Easy's. Only UPX is unpacked.
  • The emulator covers ordinary integer x86 / x64 code (no floating point or SIMD), so some decoders are missed; no ssdeep (no permissively licensed implementation).

How to get the files

  • Pivot from execution artefacts (Prefetch, Amcache, services, tasks) to the exact paths, then copy those files without running them.
  • On a live system, sweep user-writable folders with PowerShell or collect running binaries with Velociraptor's Windows.Triage.Targets (_Live).
  • Keep folder structure and hash everything before analysis.

FAQ

Is the file uploaded or executed?

Neither. The analyzer is Rust compiled to WebAssembly and runs in Web Workers in your browser. Nothing from the file runs on your machine: the code analysis interprets instructions in a WebAssembly emulator, and there is no upload endpoint. Lookup links send only the SHA-256, and only when you click them.

Can it tell me if a file is malware?

No tool can from static data alone. It shows facts (imports, signature, packer, timestamps) and plain-language indicators worth a look. Combine them with context, threat intelligence and, if needed, dynamic analysis in a sandbox.

Does it verify signatures like Windows does?

Partly. It recomputes the Authenticode hash and checks it against the signed digest, then verifies the signer's RSA signature with the embedded certificate. It does not check whether the chain ends at a trusted root or whether a certificate was revoked — that needs a trust store and online data.

Can it unpack UPX and extract hidden payloads?

Yes, statically. UPX-packed EXEs and DLLs (32- and 64-bit, every compression method, also with a tampered header that makes upx -d refuse them) are decompressed as data and rebuilt with their original imports, so the imphash matches the original build. Executables hidden inside a file, stored as-is, XOR-encoded or compressed with LZNT1, aPLib, zlib, gzip or LZMA, are extracted too. Each one is added as a child file and can be saved as a ZIP protected with the password infected.

Can I run YARA rules on the files?

Yes. Open YARA rules, type or drop .yar files, and run them: every loaded file is scanned, including files unpacked or extracted by the tool, and files you add later. The engine (boreal, YARA-compatible, pe with signatures, dotnet, hash, math and string modules) runs in your browser, so neither rules nor files are uploaded. Matches are listed per file and open in the hex view, and a rule can be started from bytes selected there.

How is the imphash computed?

Exactly like pefile: lower-case "dll.function" pairs (the .dll, .ocx or .sys extension dropped, ordinals of ws2_32, wsock32 and oleaut32 named from pefile's tables, others as ordN), joined with commas, then MD5. Delay-load imports are not included.

How is this different from pestudio, PE-bear or Detect It Easy?

It brings the views analysts use most from those tools into one page with no install, handles a batch of files at once (hashes, imphash families, time range, comparison) and never needs the sample on an analysis VM. Those tools go further in their specialities: debugging, full decompilation, large signature databases, editing.

Extract a Cobalt Strike beacon configuration statically and turn each field — C2, sleep, pipe names, spawn-to, watermark, public key — into a hunt.
Extract indicators of compromise from Windows executables, defang them, filter the noise and export them as CSV, a MISP event, a STIX 2.1 bundle or a YARA rule.
Why malware hides its strings, how stack strings, tight strings and decoded strings work, and how emulation recovers them without running the file.