Analyse forensique de la mémoire vive avec Volatility

Ce guide montre comment utiliser Volatility pour analyser un dump de mémoire Windows : repérer les processus malveillants, extraire des DLL injectées, consulter l’historique de commandes et inspecter les connexions réseau. Il inclut une méthodologie d’investigation, une checklist pour rôles, des conseils de durcissement et une mini-arbre de décision pour prioriser les actions.

Introduction

L’analyse de la mémoire vive (RAM) est une étape cruciale de l’analyse de logiciels malveillants : elle permet d’identifier les processus en cours, les activités réseau, les handles ouverts et les modules injectés. Volatility est un framework open source, écrit en Python, dédié à l’analyse de la mémoire volatile. Il supporte les dumps 32/64 bits et les systèmes Windows, Linux, macOS et Android. Volatility peut traiter les dumps bruts, les crash dumps Windows, les hibernations, les images VMware/VirtualBox, les fichiers EWF et d’autres formats.

Ce tutoriel illustre une investigation forensique sur un dump mémoire Windows, en se concentrant sur les plugins malfind (extraction de code injecté), cmdscan (historique des commandes) et netscan (connections réseau). Les extractions sont ensuite comparées à des services en ligne (VirusTotal, Payload Security) et scannées localement avec Windows Defender et MalwareBytes pour vérification.

Important

• L’image mémoire a été vérifiée par hachage MD5 avant analyse (voir section Vérification d’intégrité). Toujours vérifier l’intégrité d’une copie avant toute modification.
• Toutes les commandes Volatility présentées utilisent l’exécutable standalone Windows fourni par l’auteur de la capture.

Formats de mémoire supportés

Les formats pris en charge par la version utilisée de Volatility incluent :

• Raw/Padded Physical Memory
• Firewire (IEEE 1394)
• Expert Witness (EWF)
• Crash dumps Windows 32/64 bits
• Hibernation Windows 32/64 bits
• MachO 32/64 bits
• VirtualBox Core Dumps
• VMware Saved State (.vmss) et Snapshot (.vmsn)
• HPAK Format (FastDump)
• Dumps mémoire QEMU

Installation

Volatility est disponible sous Windows, Linux et macOS. Des exécutables standalone existent pour Windows et macOS. Sous Ubuntu (exemple donné pour 16.04 LTS), Volatility peut être installé via apt :

apt-get install volatility

Méthodologie rapide recommandée

1. Vérifier l’intégrité de l’image (hachage) et travailler sur des copies.
2. Identifier le profil mémoire adapté (imageinfo).
3. Lister les processus (pslist, pstree) et repérer les noms/processus anormaux.
4. Utiliser malfind pour extraire modules/code injecté des PID suspects.
5. Scanner les extractions avec plusieurs moteurs (local + en ligne).
6. Rechercher l’historique de commandes (cmdscan) pour le contexte d’attaque.
7. Inspecter les connexions réseau (netscan).
8. Documenter, isoler les preuves et émettre recommandations de remédiation.

Analyse de la mémoire

L’exemple utilise un exécutable Volatility standalone sur Windows pour analyser un dump brut nommé memdump3.raw. L’objectif est d’identifier des processus malveillants et d’extraire les DLL/segments injectés pour analyse.

Vérification d’intégrité

Avant l’analyse, le hash MD5 du dump a été calculé pour garantir l’intégrité de l’image :

MD5:               ee043142485a83f4d49a3a7899408500

Conserver ce hachage dans le rapport et recalculer après toute copie/transfert.

Analyse avec Volatility

Identifier le profil adapté

La première commande utilisée est imageinfo pour suggérer les profils compatibles :

"E:\volatility_2.4.win.standalone\volatility-2.4.standalone.exe" imageinfo -f memdump3.raw

L’outil suggère deux profils : Win7SP0x86 et Win7SP1x86. Choisir le profil le plus approprié puis continuer l’analyse.

Lister les processus

Pour obtenir la liste des processus présents dans le dump :

"E:\volatility_2.4.win.standalone\volatility-2.4.standalone.exe" --profile=Win7SP0x86 pslist -f memdump3.raw

L’analyse du listing révèle plusieurs processus inhabituels : 0KqEC12.exe, rdpclip.exe (selon contexte), et plusieurs instances de iexplore.exe. Ces éléments justifient une inspection approfondie.

Arbre des processus

Pour connaître les relations parent/enfant et repérer un processus injecté par un parent légitime :

 "E:\volatility_2.4.win.standalone\volatility-2.4.standalone.exe" --profile=Win7SP0x86 pstree -f memdump3.raw

L’arbre met en évidence des PID spécifiques qui seront examinés avec malfind.

Extraction de code injecté avec malfind

Le plugin malfind repère des régions mémoire marquées comme potentiellement injectées et permet d’extraire leur contenu pour analyse statique dynamique ultérieure.

Processus inspectés (exemples extraits du dump) :

• PID 1120 (svchost.exe)
• PID 1788 (rdpclip.exe)
• PID 2104 (explorer.exe)
• PID 2240 (0KqEC12.exe)
• PID 2840 (iexplore.exe)
• PID 2364 (iexplore.exe)
• PID 3728 (iexplore.exe)

Commande générale pour extraire les régions suspectes d’un PID :

E:\>"E:\volatility_2.4.win.standalone\volatility-2.4.standalone.exe" --profile=Win7SP0x86 malfind -D E:\output/pid-1120 -p 1120 -f memdump3.raw

Pour PID 1120 (svchost.exe) et PID 1788 (rdpclip.exe), malfind n’a rien extrait :

E:\>"E:\volatility_2.4.win.standalone\volatility-2.4.standalone.exe" --profile=Win7SP0x86 malfind -D E:\output/pid-1788 -p 1788 -f memdump3.raw

Pour PID 2104 (explorer.exe), malfind a extrait des modules suspects :

 E:\>"E:\volatility_2.4.win.standalone\volatility-2.4.standalone.exe" --profile=Win7SP0x86 malfind -D E:\output/pid-2104 -p 2104 -f memdump3.raw

Pour PID 2240 (0KqEC12.exe), l’extraction a également produit des fichiers :

E:\>"E:\volatility_2.4.win.standalone\volatility-2.4.standalone.exe" --profile=Win7SP0x86 malfind -D E:\output/pid-2240 -p 2240 -f memdump3.raw

Pour plusieurs instances de iexplore.exe (PID 2840, 2364, 3728), malfind a également extrait des segments suspects :

 E:\>"E:\volatility_2.4.win.standalone\volatility-2.4.standalone.exe" --profile=Win7SP0x86 malfind -D E:\output/pid-2840 -p 2840 -f memdump3.raw

 E:\>"E:\volatility_2.4.win.standalone\volatility-2.4.standalone.exe" --profile=Win7SP0x86 malfind -D E:\output/pid-2364 -p 2364 -f memdump3.raw

 E:\>"E:\volatility_2.4.win.standalone\volatility-2.4.standalone.exe" --profile=Win7SP0x86 malfind -D E:\output/pid-3728 -p 3728 -f memdump3.raw

Note

• Conserver les extractions (DLL, PE, segments) dans un dépôt de preuves séparé et immuable.
• Documenter le PID, l’offset mémoire et le nom de fichier d’extraction.

Résultats de scan des extractions

Les fichiers extraits ont été scannés localement avec Windows Defender et MalwareBytes.

Windows Defender

Windows Defender a identifié des artefacts comme : Trojan:Win32/EyeStye.N et Trojan:Win32/EyeStye.plugin.

Détails (synthèse publique)

• Famille signalée : enregistre les frappes, surveille l’activité Internet, vol de credentials, exfiltration vers serveur distant.
• Comportement : injection de code dans des processus comme cmd.exe et explorer.exe, possible installation de rootkits, téléchargement de charges additionnelles.

L’observation d’injection dans explorer.exe concorde avec les résultats malfind.

MalwareBytes

MalwareBytes a classé les extractions comme Trojan.Grabber, confirmant une fonctionnalité de collecte d’informations et d’envoi à un tiers.

Historique des commandes (cmdscan)

Le plugin cmdscan permet d’extraire l’historique des commandes PowerShell/Invite de commandes présentes en mémoire :

 E:\>"E:\volatility_2.4.win.standalone\volatility-2.4.standalone.exe" --profile=Win7SP0x86 cmdscan -f memdump3.raw

L’historique montre l’exécution de programmes nommés “iexplorer.exe” et “ieplore.exe” (typos courantes utilisées par des malwares pour masquer la ressemblance avec iexplore.exe). Un artefact nommé _lt112.spn apparaît également et, après recherche en ligne, est lié à échantillons malveillants.

Exemples de références publiques trouvées :

• Exemple sur Malwr : https://malwr.com/analysis/ODMwYzM1NGViZDkwNDc4YTllYWU4ZTVlMTE1YzJmNGQ/

• Exemple sur Hybrid-Analysis : https://www.hybrid-analysis.com/sample/1416ff3fca01d4d4854799f2d3880fb6e100de3f7fa1c54465d4d6b9cf9b5d96?environmentId=100

Connexions réseau (netscan)

Le plugin netscan permet d’énumérer sockets et connexions observées en mémoire. Dans cet exemple, plusieurs connexions sortantes proviennent d’instances de iexplore.exe, certaines vers le port TCP 80 (HTTP) :

 E:\>"E:\volatility_2.4.win.standalone\volatility-2.4.standalone.exe" --profile=Win7SP0x86 netscan -f memdump3.raw

Observations

• Plusieurs processus nommés iexplore prennent part à des connexions sortantes.
• Port observé : 80/TCP (HTTP) — utile pour rechercher URL/hôtes contactés dans les extractions ou les logs réseau.

Interprétation et conclusions

L’ensemble des éléments (processus masqués/typos, injections détectées par malfind, détections anti-malware, commandes présentes dans cmdscan, connexions réseau actives) montre que le poste analysé est compromis. Le modus operandi correspond à un cheval de Troie de type « grabber »/exfiltration (ex. familles EyeStye/EyeSpy) qui s’injecte dans explorer.exe et lance des processus clients ressemblant aux navigateurs pour communiquer.

Recommandations immédiates

1. Isoler la machine compromise du réseau.
2. Préserver et cloner les preuves (image disque + mémoire) sur moyenne immuable.
3. Extraire tous les artefacts malfind et les URL/hôtes contactés pour une analyse réseau et indicateurs de compromission (IoC).
4. Effectuer une réinstallation complète (clean build) si l’analyse confirme une compromission persistante incluant rootkit ou injection profonde.
5. Changer les mots de passe des comptes potentiellement exposés depuis une machine sûre.

Checklist par rôle

Analyste forensique

• Vérifier l’intégrité du dump (hachage MD5) et sauvegarder l’original.
• Identifier le profil mémoire (imageinfo).
• Lister/processus suspects (pslist, pstree).
• Extraire régions suspectes (malfind) et stocker les artefacts.
• Rechercher historique commandes (cmdscan) et événements pertinents.
• Documenter toutes les commandes et outputs.

Analyste malware

• Scanner les extraits avec moteurs multiples (local et en ligne).
• Effectuer une analyse statique des modules PE extraits (.dll/.exe).
• Si possible, exécuter dans bac à sable contrôlé pour comportement réseau.

Equipe réponse incident

• Isoler l’hôte et collecter logs réseau.
• Rechercher IoC dans l’infrastructure (SIEM, proxys, EDR).
• Planifier remédiation et communication selon politique.

Mini-méthodologie pour reproduire l’analyse

1. Préparer un environnement d’analyse isolé et non connecté au réseau public.
2. Copier l’image mémoire sur un stockage de travail read-only.
3. Lancer imageinfo pour choisir le profil.
4. Lancer pslist/pstree puis malfind sur PID suspects.
5. Scanner les fichiers extraits, comparer signatures et rechercher hôtes.
6. Consolider les IoC (hashes, noms de fichiers, IP/URL) dans un rapport.

Arbre de décision (priorisation) — Merkmale

flowchart TD
  A[Détection initiale de code injecté] --> B{La machine est en production ?}
  B -- Oui --> C[Isoler la machine, capturer volatiles, prévenir responsables]
  B -- Non --> D[Cloner image, continuer analyse hors réseau]
  C --> E{Injection confirmée par malfind ?}
  D --> E
  E -- Oui --> F[Extraire artefacts et scanner, collecter IoC]
  E -- Non --> G[Surveiller et collecter données supplémentaires]
  F --> H{IoC détectés dans infra ?}
  H -- Oui --> I[Déclencher réponse étendue, nettoyage, patching]
  H -- Non --> J[Reporter et continuer monitoring]

Fiche récapitulative (chiffres clefs)

• Hash MD5 de l’image : ee043142485a83f4d49a3a7899408500
• PID examinés : 1120, 1788, 2104, 2240, 2364, 2840, 3728
• Port réseau notable : 80/TCP
• Plugins Volatility clés : imageinfo, pslist, pstree, malfind, cmdscan, netscan

Durcissement et mesures préventives

• Tenir les systèmes et antivirus à jour ; activer la protection comportementale si disponible.
• Restreindre l’exécution de binaires depuis dossiers temporaires et profils utilisateurs non-suje ts.
• Surveiller les processus système critiques (explorer, svchost) pour comportements anormaux.
• Déployer EDR avec capacité de détection d’injection et d’anomalies réseau.
• Appliquer principe de moindre privilège et segmentation réseau pour limiter l’exfiltration.

Vie privée et conformité

• Toute collecte d’images mémoire et d’artefacts doit respecter la législation applicable et la politique interne (notamment GDPR si données personnelles sont présentes). Minimiser l’exposition des données personnelles et documenter la justification légale pour l’analyse et la conservation des preuves.

Glossaire (une ligne chacun)

• Dump mémoire : copie brute du contenu RAM à un instant T.
• Profil Volatility : ensemble d’informations (OS/architecture) permettant d’interpréter la mémoire.
• malfind : plugin Volatility qui repère et extrait régions mémoire potentiellement injectées.
• cmdscan : plugin Volatility qui récupère l’historique de la ligne de commande présent en mémoire.
• netscan : plugin Volatility qui énumère sockets et connexions observables en mémoire.

Quand l’approche peut échouer

• Volatility dépend d’un profil adapté : un mauvais profil peut masquer objets ou corrompre l’analyse.
• Techniques modernes de furtivité (obfuscation mémoire, chiffrement en mémoire, rootkits bas niveau) peuvent empêcher la détection par malfind.
• Si l’image mémoire a été altérée après acquisition, les preuves peuvent être compromises.

Résumé final

L’analyse détaillée du dump memdump3.raw avec Volatility montre une compromission active — injection dans explorer.exe et instances de iexplore.exe, extraction de modules malveillants confirmées par Windows Defender et MalwareBytes, et connexions réseau sortantes sur HTTP. Actions recommandées : isolation, préservation des preuves, nettoyage/formatage et renforcement des contrôles défensifs.

Important

Ne pas redémarrer la machine compromise sans capture complète des volatiles; un redémarrage peut détruire des preuves en mémoire.

Références

1. http://www.volatilityfoundation.org/24
2. https://www.microsoft.com/security/portal/threat/encyclopedia/entry.aspx?Name=Trojan:Win32/EyeStye.N