Skip to content

MZ.exe · .dll · .sys

PE Parser

En-têtes, sections, imports, ressources, Rich header, Authenticode, métadonnées .NET, chaînes et empreintes des exécutables Windows, avec des indicateurs expliqués simplement. Analyse statique dans votre navigateur en WebAssembly : le fichier n'est jamais envoyé ni exécuté.

FIG. 0en attente d’un spécimen

Déposez ici des fichiers .exe, .dll ou .sys

Un fichier ou tout un lot : dossiers et collectes ZIP (Velociraptor, dossier zippé) sont acceptés tels quels. Les fichiers sont reconnus à leur en-tête MZ, donc les charges renommées sont trouvées aussi. Rien n'est exécuté : les octets sont seulement lus.

Cinq fichiers PE inoffensifs issus d'une intrusion fictive : quatre fabriqués à la main dont le code se limite à un `ret`, et wupd.exe, un vrai build packé avec UPX d'un programme qui affiche seulement un message. Astuce : comparez les deux versions de m64.exe, ouvrez la DLL signée, puis ouvrez wupd.exe pour le voir décompressé.

100 % local et statique : les fichiers sont analysés par WebAssembly dans votre navigateur, jamais envoyés, jamais exécutés.

Comment récupérer les fichiers

Guide de collecte complet

Sortez les binaires suspects de la machine sans les exécuter, en gardant leur dossier pour que chacun reste attribué, puis déposez ici les fichiers, le dossier ou un ZIP. Rien à installer.

  1. Copiez les binaires (sans jamais les lancer)
  2. Déposez les fichiers, le dossier ou le ZIP ici
  3. Analysé dans votre navigateur, jamais envoyé

Vous avez déjà le fichier ? Glissez-le directement sur cette page : il est lu, pas exécuté.

Pour balayer une machine allumée, collez ceci dans Windows PowerShell lancé en administrateur. Le script copie les exécutables (.exe, .dll, .sys, .scr, .cpl, .ocx) écrits ces 14 derniers jours sous ProgramData, Users et Windows\Temp, en conservant leurs chemins. Adaptez les dossiers et le nombre de jours à votre cas.

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
  }

Résultat : C:\triage\pe\ProgramData\…, C:\triage\pe\Users\<utilisateur>\… Déposez le dossier C:\triage\pe ici (glissez-le ou utilisez Choisir un dossier).

Analyse sur une autre machine ? Regroupez tout dans un ZIP avec le tar.exe intégré à Windows 10 1803 et suivants. L'antivirus peut mettre des fichiers en quarantaine pendant la copie : ajoutez une exclusion pour C:\triage ou collectez depuis une image.

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

Pièges

  • L'antivirus peut supprimer ou mettre en quarantaine des échantillons pendant la collecte. Excluez le dossier de destination ou travaillez sur une image.
  • Les ZIP protégés par mot de passe (les archives « infected » habituelles) ne s'ouvrent pas dans le navigateur : extrayez-les d'abord, puis déposez le dossier.
  • Les fichiers de plus de 512 Mo sont ignorés : le navigateur lit chaque fichier entier en mémoire.

Qu'est-ce qu'un fichier PE ?

PE (Portable Executable) est le format des programmes Windows : .exe, .dll, pilotes .sys, .scr, .cpl, .ocx et binaires EFI. Il commence par un en-tête MS-DOS (« MZ »), puis une signature PE, un en-tête de fichier COFF, un en-tête optionnel avec 16 répertoires de données et une table des sections qui décrit le placement en mémoire.

L'analyse statique lit cette structure sans rien exécuter : ce que le fichier importe, quand et avec quoi il a été compilé, s'il est signé, ce qu'il transporte dans ses ressources et son overlay. C'est la première étape, sans risque, du tri de malwares.

Ce que lit cet outil

  • En-têtes : DOS, COFF et en-tête optionnel (PE32 et PE32+), répertoires de données, table des sections avec tailles brutes et virtuelles, attributs et entropie par section, checksum recalculé.
  • Imports (ordinaux de ws2_32, wsock32 et oleaut32 nommés), imports différés et liés, exports et redirections, imphash.
  • Ressources : informations de version, manifeste, icônes, tables de chaînes, boîtes de dialogue, fichiers intégrés ; détection d'overlay.
  • Rich header traduit en versions de Visual Studio, répertoire de débogage (chemin PDB, GUID, âge), callbacks TLS, configuration de chargement (CFG, SafeSEH), relocations.
  • Authenticode : signataire, certificats, horodatage, empreinte du fichier face au condensé signé et vérification de la signature RSA. .NET : en-tête CLR, flux de métadonnées, assembly, références, P/Invoke, types.
  • Chaînes (ASCII et UTF-16LE) catégorisées, MD5 / SHA-1 / SHA-256 / TLSH, heuristiques de packers et compilateurs, et un tableau de lot pour repérer les familles.
  • Décompression : les fichiers packés avec UPX sont reconstruits avec leurs imports d’origine, et les exécutables cachés dans un fichier (stockés tels quels, encodés en XOR ou compressés en LZNT1, aPLib, zlib, gzip ou LZMA) sont extraits et analysés comme fichiers enfants.
  • YARA : exécutez vos propres règles (ou le jeu d’exemple) sur chaque fichier, fichiers enfants décompressés compris, avec les modules pe, dotnet, hash, math et string ; les correspondances s’ouvrent dans la vue hexa.
  • MITRE ATT&CK : capacités reconnues à partir des imports, des chaînes et des résultats de décompression, regroupées par tactique avec leurs éléments, exportables en calque ATT&CK Navigator.
  • Désassemblage : code x86 / x64 depuis le point d’entrée, les callbacks TLS, les exports ou toute adresse, avec les fonctions importées nommées et des branchements à suivre.
  • Métadonnées de compilation : infos de build et noms de fonctions Go, crates et chemins source Rust, modules Nim, fiches Delphi, contenu PyInstaller, méthodes .NET.
  • Configurations malveillantes décodées statiquement : balises Cobalt Strike, stagers shellcode Metasploit / Cobalt Strike, AsyncRAT, DcRat, VenomRAT, QuasarRAT, njRAT et Remcos (serveurs C2, clés, délais, chemins d’installation).
  • Analyse du code : fonctions découvertes dans le code x86 / x64, capacités reconnues d’après ce que chaque fonction appelle et calcule (anti-débogage, injection, constantes cryptographiques, hachage d’API…) rattachées à ATT&CK et MBC, et chaînes récupérées par émulation qu’une extraction classique ne voit pas (pile, boucle serrée, chaînes décodées).
  • .NET : désassemblage IL de chaque méthode avec les noms résolus, et détection des obfuscateurs et protections (ConfuserEx, SmartAssembly, Dotfuscator, Agile.NET, Costura…).
  • IOC : indicateurs réseau, artefacts système et empreintes, neutralisés, exportés en CSV, événement MISP ou STIX 2.1 ; une règle YARA peut être ébauchée depuis un fichier et testée sur le lot.

Pourquoi c'est utile en investigation

  • Empreintes et imphash permettent d'interroger le renseignement sur la menace et de regrouper les variantes d'un même outil ; TLSH mesure la proximité de deux fichiers.
  • Les dates de compilation, de débogage et de signature datent un outil, et leurs désaccords trahissent des retouches.
  • Imports et chaînes montrent les capacités (réseau, injection, persistance) et les indicateurs (URL, IP, chemins, clés de registre).
  • Informations de version, chemins PDB et Rich header renseignent sur l'environnement de l'auteur ; une signature dit qui s'est porté garant du fichier.

Limites

  • Uniquement statique : UPX est décompressé dans le navigateur, mais les autres packers, les protecteurs et le code chiffré doivent être décompressés ailleurs avant que leurs vrais imports et chaînes n’apparaissent.
  • Les chaînes de certificats ne sont pas validées (pas de magasin de confiance ni de révocation) : l'outil vérifie l'intégrité, pas la confiance.
  • La détection de packers repose sur les noms de sections, les stubs de point d’entrée, les imports de SDK de protection et la forme de la table d’imports, pas sur une base de signatures comme celle de Detect It Easy. Seul UPX est décompressé.
  • L’émulateur couvre le code x86 / x64 entier ordinaire (ni flottants ni SIMD), certains décodeurs échappent donc ; pas de ssdeep (aucune implémentation sous licence permissive).

Comment récupérer les fichiers

  • Partez des artefacts d'exécution (Prefetch, Amcache, services, tâches) pour obtenir les chemins exacts, puis copiez ces fichiers sans les lancer.
  • Sur une machine allumée, balayez les dossiers inscriptibles avec PowerShell ou collectez les binaires en cours avec Windows.Triage.Targets (_Live) de Velociraptor.
  • Conservez l'arborescence et calculez les empreintes avant toute analyse.

FAQ

Le fichier est-il envoyé ou exécuté ?

Ni l'un ni l'autre. L'analyseur est écrit en Rust, compilé en WebAssembly et tourne dans des Web Workers de votre navigateur. Rien du fichier ne s'exécute sur votre machine : l'analyse du code interprète les instructions dans un émulateur WebAssembly, et il n'y a aucun point d'envoi. Les liens de recherche n'envoient que le SHA-256, et seulement si vous cliquez.

Peut-il dire si un fichier est un malware ?

Aucun outil ne le peut à partir des seules données statiques. Il montre des faits (imports, signature, packer, dates) et des indicateurs expliqués qui méritent un coup d'œil. Croisez-les avec le contexte, le renseignement et, si besoin, une analyse dynamique en bac à sable.

Vérifie-t-il les signatures comme Windows ?

En partie. Il recalcule l'empreinte Authenticode et la compare au condensé signé, puis vérifie la signature RSA du signataire avec le certificat intégré. Il ne vérifie pas que la chaîne aboutit à une racine de confiance ni qu'un certificat a été révoqué : cela exige un magasin de confiance et des données en ligne.

Peut-il décompresser UPX et extraire des charges cachées ?

Oui, statiquement. Les EXE et DLL packés avec UPX (32 et 64 bits, toutes les méthodes de compression, y compris avec un en-tête altéré qui fait échouer upx -d) sont décompressés comme des données et reconstruits avec leurs imports d’origine, si bien que l’imphash correspond au build d’origine. Les exécutables cachés dans un fichier, stockés tels quels, encodés en XOR ou compressés en LZNT1, aPLib, zlib, gzip ou LZMA, sont aussi extraits. Chacun est ajouté comme fichier enfant et peut être enregistré dans un ZIP protégé par le mot de passe infected.

Puis-je exécuter des règles YARA sur les fichiers ?

Oui. Ouvrez Règles YARA, tapez ou déposez des fichiers .yar et lancez-les : chaque fichier chargé est analysé, y compris les fichiers décompressés ou extraits par l’outil et les fichiers ajoutés ensuite. Le moteur (boreal, compatible YARA, modules pe avec signatures, dotnet, hash, math et string) tourne dans votre navigateur : ni les règles ni les fichiers ne sont envoyés. Les correspondances sont listées par fichier et s’ouvrent dans la vue hexa, où une règle peut être amorcée à partir d’octets sélectionnés.

Comment l'imphash est-il calculé ?

Exactement comme pefile : paires « dll.fonction » en minuscules (extension .dll, .ocx ou .sys retirée, ordinaux de ws2_32, wsock32 et oleaut32 nommés avec les tables de pefile, les autres en ordN), jointes par des virgules, puis MD5. Les imports différés ne sont pas inclus.

Quelle différence avec pestudio, PE-bear ou Detect It Easy ?

Il réunit sur une seule page, sans installation, les vues les plus utilisées de ces outils, traite un lot de fichiers d'un coup (empreintes, familles d'imphash, plage horaire, comparaison) et n'oblige jamais à copier l'échantillon sur une VM d'analyse. Ces outils vont plus loin dans leurs spécialités : débogage, décompilation complète, grandes bases de signatures, édition.

Extraire statiquement la configuration d’une balise Cobalt Strike et transformer chaque champ — C2, sleep, pipes, spawn-to, watermark, clé publique — en piste.
Extraire les indicateurs de compromission d’exécutables Windows, les neutraliser, filtrer le bruit et les exporter en CSV, événement MISP, bundle STIX 2.1 ou règle YARA.
Pourquoi les malwares cachent leurs chaînes, comment fonctionnent stack strings, tight strings et chaînes décodées, et comment l’émulation les récupère sans exécution.