Forensique Mémoire : Guide Pratique Volatility 3 en 2026

La mémoire vive (RAM) est le témoin le plus fidèle de l'activité d'un système au moment de sa capture. Processus en cours d'exécution, connexions réseau actives, clés de chiffrement, mots de passe en clair, code injecté par des malwares -- tout transite ou réside en mémoire. Pour l'analyste forensique, un dump mémoire est une photographie instantanée d'un système vivant, capturant des artefacts souvent invisibles sur le disque dur. Ce guide approfondi examine en detail les aspects fondamentaux et avances de Forensique Mémoire, en proposant une analyse structuree et documentee des enjeux actuels. Les professionnels y trouveront des recommandations concretes, des methodologies eprouvees et des retours d'experience terrain directement applicables en environnement de production. L'analyse integre les dernieres evolutions technologiques, les tendances emergentes du secteur et les meilleures pratiques recommandees par les experts du domaine.

Volatility 3 est le successeur du légendaire Volatility Framework, entièrement réécrit en Python 3 avec une architecture modulaire basée sur les Symbol Tables au format ISF (Intermediate Symbol Format). Cette réécriture apporte une meilleure performance, une extensibilité accrue et un support natif des systèmes modernes (Windows 10/11, Server 2022, Linux 6.x, macOS Ventura+).

Ce guide couvre l'intégralité du workflow forensique mémoire : de l'acquisition du dump à l'extraction d'artefacts, en passant par la détection de malware et la corrélation avec d'autres sources d'investigation. Il s'adresse aux analystes DFIR, aux équipes SOC et aux professionnels de la sécurité souhaitant maitriser cet outil essentiel dans leur arsenal d'investigation. Les techniques présentées sont complémentaires aux analyses de rootkits kernel-mode et à la compréhension des frameworks C2.

En cas d'incident, seriez-vous capable de retracer le parcours exact de l'attaquant ?

Acquisition de Dumps Mémoire

L'acquisition est la phase la plus critique : un dump mal réalisé peut corrompre les preuves ou altérer l'état du système. Le principe fondamental est de minimiser l'empreinte sur le système cible (outil léger, pas d'installation, écriture sur support externe).

Windows : WinPmem et DumpIt

WinPmem (Velocidex) est l'outil recommandé pour Windows. Il utilise un driver kernel pour accéder directement à la mémoire physique, supportant les modes raw et AFF4 :

# Acquisition avec WinPmem (format raw)
winpmem_mini_x64.exe memdump.raw

# Acquisition avec WinPmem (format AFF4 compressé)
winpmem_mini_x64.exe --format aff4 --output memdump.aff4

# DumpIt (Comae) - exécution simple (double-clic ou CLI)
DumpIt.exe /OUTPUT memdump.raw /QUIET

# Vérification d'intégrité
certutil -hashfile memdump.raw SHA256 > memdump.raw.sha256

# Taille typique : 8 GB RAM = 8 GB dump (format raw)
# Temps d'acquisition : 2-5 minutes selon la taille RAM

Linux : LiME (Linux Memory Extractor)

# Compilation du module LiME (sur une machine de même kernel)
git clone https://github.com/504ensicsLabs/LiME.git
cd LiME/src
make

# Chargement du module et acquisition
sudo insmod lime-$(uname -r).ko "path=/mnt/usb/memdump.lime format=lime"

# Format lime (recommandé) vs raw vs padded
# lime : inclut les métadonnées d'adressage
# raw  : dump brut contigu
# padded : raw avec espaces pour les trous de mémoire

# Acquisition à distance via netcat (réseau isolé !)
# Sur l'analyste :
nc -l -p 4444 > memdump.lime
# Sur la cible :
sudo insmod lime.ko "path=tcp:ANALYST_IP:4444 format=lime"

Machines Virtuelles : Snapshots

Pour les VM, les snapshots offrent une acquisition non-intrusive. Les fichiers de mémoire sont directement exploitables par Volatility :

Hyperviseur	Fichier mémoire	Emplacement
VMware	.vmem	Dossier de la VM (snapshot ou suspend)
Hyper-V	.vsv / .bin	Conversion nécessaire (vm2dmp)
VirtualBox	.sav (ELF core)	Snapshots directory
QEMU/KVM	virsh dump	Commande manuelle
Proxmox	qm monitor dump-guest-memory	Commande qm monitor

Installation et Configuration de Volatility 3

Volatility 2 vs Volatility 3 : Différences majeures

Aspect	Volatility 2	Volatility 3
Langage	Python 2 (deprecated)	Python 3.7+
Profils	Profiles pré-construits (.zip)	Symbol Tables ISF (JSON)
Performance	Lent sur gros dumps	Parallélisme, caching, plus rapide
Plugins	~200 plugins communautaires	Plugins réécrits + nouveaux (auto-download symbols)
Syntaxe	vol.py --profile=X plugin	vol -f dump windows.plugin
OS Support	Windows XP-10, Linux 2.6-5.x	Windows 7-11, Server 2022, Linux 6.x, macOS

Installation

# Installation depuis PyPI
pip3 install volatility3

# Installation depuis les sources (dernière version)
git clone https://github.com/volatilityfoundation/volatility3.git
cd volatility3
pip3 install -e .

# Téléchargement des Symbol Tables Windows (automatique ou manuel)
# Volatility 3 télécharge automatiquement les ISF depuis le Symbol Server Microsoft
# Pour un usage offline, pré-télécharger :
python3 vol.py -f memdump.raw windows.info
# => télécharge automatiquement le bon ISF dans volatility3/symbols/

# Structure des symbols
# volatility3/symbols/
#   windows/
#     ntkrnlmp.pdb/GUID/ntkrnlmp.pdb.json.xz
#   linux/
#     banner-to-ISF mapping
#   mac/
#     version-to-ISF mapping

# Vérifier l'installation
vol --help
vol --info

Symbol Tables ISF

Le changement le plus significatif de Volatility 3 est l'abandon des profiles au profit des Intermediate Symbol Format (ISF). Les ISF sont des fichiers JSON compressés décrivant les structures de données du noyau pour une version exacte du système d'exploitation. Pour Windows, Volatility 3 utilise les PDB (Program Database) de Microsoft pour générer automatiquement les ISF nécessaires. Pour Linux, vous devez générer le ISF à partir des sources du noyau :

# Génération ISF Linux (sur la machine cible ou avec les mêmes headers)
cd volatility3/tools/linux
sudo python3 dwarf2json --elf /usr/lib/debug/boot/vmlinux-$(uname -r) \
    --system-map /boot/System.map-$(uname -r) > linux-$(uname -r).json

# Placer le ISF dans le bon répertoire
cp linux-$(uname -r).json volatility3/symbols/linux/

Analyse des Processus

L'analyse des processus est le point de départ de toute investigation mémoire. Elle permet d'identifier les programmes actifs, de repérer des anomalies (processus cachés, injections, noms suspects) et de reconstruire l'activité du système au moment de la capture.

Plugins d'analyse des processus

# pslist -- Liste les processus via la liste doublement chaînée EPROCESS
# Avantage : rapide. Limitation : un rootkit peut délier un processus
vol -f memdump.raw windows.pslist

# psscan -- Scanne toute la mémoire à la recherche de structures EPROCESS
# Avantage : détecte les processus cachés (unlinked). Plus lent
vol -f memdump.raw windows.psscan

# pstree -- Affiche l'arborescence parent/enfant
# Essentiel pour repérer des anomalies (svchost lancé par cmd.exe = suspect)
vol -f memdump.raw windows.pstree

# cmdline -- Affiche les arguments de ligne de commande de chaque processus
vol -f memdump.raw windows.cmdline

# dlllist -- Liste les DLLs chargées par chaque processus
vol -f memdump.raw windows.dlllist --pid 1234

# handles -- Affiche les handles ouverts (fichiers, registre, mutex, threads)
vol -f memdump.raw windows.handles --pid 1234

# envars -- Variables d'environnement de chaque processus
vol -f memdump.raw windows.envars --pid 1234

Détection de Process Hollowing

Le process hollowing est une technique d'évasion EDR/XDR où un attaquant crée un processus légitime (ex: svchost.exe), suspend son thread principal, remplace son image mémoire par du code malveillant, puis reprend l'exécution. La détection repose sur la comparaison entre l'image sur disque et l'image en mémoire :

# Indicateurs de process hollowing :
# 1. Le chemin affiché par cmdline ne correspond pas au PEB ImagePathName
# 2. Le parent du processus est inhabituel
# 3. Les sections mémoire RWX contiennent du code PE

# Vérifier avec malfind (détecte les régions mémoire suspectes)
vol -f memdump.raw windows.malfind --pid 1234

# Comparer les processus légitimes Windows avec leurs parents attendus :
# svchost.exe -> parent = services.exe
# lsass.exe -> parent = wininit.exe
# csrss.exe -> parent = smss.exe (session 0) ou csrss.exe
# explorer.exe -> parent = userinit.exe

Vos preuves numériques seraient-elles recevables devant un tribunal ?

Analyse Réseau

Netscan : Connexions et Sockets

# netscan -- Liste toutes les connexions TCP/UDP et les sockets d'écoute
vol -f memdump.raw windows.netscan

# Résultat typique :
# Offset     Proto  LocalAddr         LocalPort  ForeignAddr       ForeignPort State    PID   Owner
# 0x...      TCPv4  10.0.0.5          49152      185.220.101.45    443         ESTABLISHED 2048 chrome.exe
# 0x...      TCPv4  10.0.0.5          55321      91.234.56.78      4444        ESTABLISHED 3456 svchost.exe  <-- SUSPECT

# Points d'attention pour l'analyste :
# - Connexions vers des IP inhabituelles (C2)
# - Ports non-standard (4444, 8888, 1337)
# - Processus système avec connexions sortantes suspectes
# - Connexions ESTABLISHED depuis des processus qui ne devraient pas communiquer

La corrélation entre les connexions réseau et les processus est fondamentale pour identifier les communications Command & Control (C2). Un svchost.exe établissant une connexion vers un VPS étranger sur le port 443 est un indicateur fort de compromission. Croisez les IP avec des bases de Threat Intelligence (VirusTotal, AbuseIPDB, OTX) pour confirmer.

Détection de Malware

Malfind : Détection d'injection de code

malfind est le plugin le plus important pour la détection de malware. Il analyse les Virtual Address Descriptors (VAD) de chaque processus et signale les régions mémoire avec des permissions suspectes (PAGE_EXECUTE_READWRITE) contenant du code exécutable non adossé à un fichier sur disque :

# malfind -- Détecte les injections de code
vol -f memdump.raw windows.malfind

# vadinfo -- Informations détaillées sur les VAD d'un processus
vol -f memdump.raw windows.vadinfo --pid 1234

# ssdt -- System Service Descriptor Table (détection hooks kernel)
vol -f memdump.raw windows.ssdt

# callbacks -- Liste les callbacks kernel enregistrés
# Les rootkits enregistrent des callbacks pour intercepter des événements
vol -f memdump.raw windows.callbacks

# driverscan -- Scanne les structures de drivers en mémoire
vol -f memdump.raw windows.driverscan

# driverirp -- Affiche les IRP handlers des drivers (détection rootkits)
vol -f memdump.raw windows.driverirp

Analyse approfondie des résultats malfind

Quand malfind signale une région suspecte, l'analyste doit évaluer si c'est un vrai positif ou un faux positif. Les faux positifs sont fréquents avec certaines applications légitimes (JIT compilers, .NET CLR, navigateurs). Les indicateurs d'injection malveillante incluent :

• En-tête MZ/PE dans une région PRIVATE (pas adossée à un fichier)
• Shellcode patterns : NOP sleds, 0xFC 0x48 0x83 (x64 shellcode standard), appels système direct
• Strings suspectes : URLs de C2, noms de fonctions API (VirtualAlloc, CreateRemoteThread)
• Absence de fichier associé dans le VAD (Private vs Image)
• Taille disproportionnée d'une région RWX par rapport aux besoins du processus

Extraction d'Artefacts

Fichiers et Registry

# filescan -- Scanne les structures FILE_OBJECT en mémoire
vol -f memdump.raw windows.filescan

# dumpfiles -- Extrait des fichiers depuis la mémoire
vol -f memdump.raw windows.dumpfiles --pid 1234
vol -f memdump.raw windows.dumpfiles --virtaddr 0xFA8001234560

# registry.hivelist -- Liste les ruches de registre en mémoire
vol -f memdump.raw windows.registry.hivelist

# registry.printkey -- Affiche les clés de registre
vol -f memdump.raw windows.registry.printkey --key "Software\Microsoft\Windows\CurrentVersion\Run"

# hashdump -- Extrait les hashs NTLM depuis la SAM
vol -f memdump.raw windows.hashdump

# lsadump -- Extrait les secrets LSA
vol -f memdump.raw windows.lsadump

# cachedump -- Extrait les credentials cached domain
vol -f memdump.raw windows.cachedump

Extraction de credentials avec Mimikatz

L'un des artefacts les plus critiques en forensique mémoire est l'extraction des credentials en clair stockés dans le processus lsass.exe. Le plugin windows.hashdump extrait les hashs NTLM, mais pour obtenir les mots de passe en clair (WDigest, Kerberos tickets, DPAPI keys), il faut extraire le processus lsass et l'analyser avec Mimikatz ou pypykatz. C'est directement lié aux techniques d'infostealers utilisées par les attaquants :

# Méthode 1 : Extraire le minidump de lsass depuis le dump mémoire
# Identifier le PID de lsass.exe
vol -f memdump.raw windows.pslist | grep lsass
# => lsass.exe  PID: 756

# Dumper la mémoire du processus lsass
vol -f memdump.raw windows.memmap --pid 756 --dump

# Méthode 2 : pypykatz (Python, analyse offline)
pip3 install pypykatz
pypykatz volatility3 -f memdump.raw

# Résultat : credentials en clair si WDigest activé (défaut sur < Win10)
# username: admin  domain: CORP  NTLM: 31d6...  password: P@ssw0rd123

Plugins Linux

Volatility 3 supporte l'analyse de dumps Linux avec un ensemble de plugins dédiés. Les concepts sont similaires à Windows mais les structures de données kernel diffèrent :

# Analyse de base Linux
vol -f linux_memdump.lime linux.pslist
vol -f linux_memdump.lime linux.pstree
vol -f linux_memdump.lime linux.lsmod        # Modules kernel chargés
vol -f linux_memdump.lime linux.bash          # Historique bash en mémoire
vol -f linux_memdump.lime linux.check_syscall # Détection hooks syscall
vol -f linux_memdump.lime linux.check_idt     # Vérification IDT
vol -f linux_memdump.lime linux.tty_check     # TTY sessions actives
vol -f linux_memdump.lime linux.elfs          # Binaires ELF en mémoire
vol -f linux_memdump.lime linux.sockstat      # Sockets réseau

# Détection de rootkits Linux
vol -f linux_memdump.lime linux.check_modules  # Modules cachés
vol -f linux_memdump.lime linux.hidden_modules # Modules unlinkés

Méthodologie d'Investigation

Une investigation mémoire efficace suit une méthodologie structurée. Voici le workflow recommandé, applicable à la majorité des incidents (compromission, ransomware, exfiltration) :

Phase 1 : Triage rapide (15-30 minutes)

# 1. Identifier le système
vol -f memdump.raw windows.info

# 2. Lister les processus (vue d'ensemble)
vol -f memdump.raw windows.pstree

# 3. Scanner les connexions réseau
vol -f memdump.raw windows.netscan

# 4. Rechercher les injections évidentes
vol -f memdump.raw windows.malfind

# 5. Vérifier les services et autoruns
vol -f memdump.raw windows.svcscan
vol -f memdump.raw windows.registry.printkey --key "Software\Microsoft\Windows\CurrentVersion\Run"

Phase 2 : Analyse approfondie (1-4 heures)

• Focus sur les processus suspects identifiés en Phase 1 : cmdline, DLLs, handles, envars
• Extraction des artefacts : dumper les binaires suspects, extraire les fichiers des régions malfind
• Analyse des credentials : hashdump, lsadump pour évaluer le périmètre de compromission
• Extraction des clés de registre : persistence mechanisms, configuration malware
• Corrélation réseau : mapper chaque connexion suspecte à un processus et un comportement

Phase 3 : Intégration YARA

YARA est un outil de pattern matching essentiel pour scanner la mémoire à la recherche de signatures de malware connus ou de patterns personnalisés. Volatility 3 intègre nativement le scanning YARA :

# Scan YARA sur l'ensemble du dump
vol -f memdump.raw windows.vadyarascan --yara-rules "rule cobalt_strike { strings: $a = {FC 48 83 E4 F0 E8} condition: $a }"

# Scan avec un fichier de règles YARA
vol -f memdump.raw windows.vadyarascan --yara-file /path/to/rules/apt_rules.yar

# Scan ciblé sur un processus spécifique
vol -f memdump.raw windows.vadyarascan --pid 1234 --yara-file malware_rules.yar

# Exemples de règles YARA utiles en forensique mémoire :
# - Détection Cobalt Strike Beacon
# - Détection Mimikatz en mémoire
# - Détection Meterpreter
# - Détection de shellcode commun (x64 reverse shell)
# - Signatures d'infostealers connus

# Exemple de règle YARA pour Cobalt Strike Beacon
rule CobaltStrike_Beacon_Memory {
    meta:
        description = "Détecte Cobalt Strike Beacon en mémoire"
        author = "DFIR Analyst"
        severity = "critical"
    strings:
        $config = { 00 01 00 01 00 02 ?? ?? 00 02 00 01 00 02 ?? ?? }
        $sleep_mask = { 4C 8B 53 08 45 8B 0A 45 8B 5A 04 }
        $pipe_name = "/pipe/msagent_" ascii wide
        $beacon_dll = "beacon.dll" ascii wide
    condition:
        any of them
}

Cas pratique : Investigation d'un ransomware

Voici un workflow complet d'investigation mémoire suite à une attaque ransomware, de l'acquisition au rapport :

# ETAPE 1 : Identifier le malware
vol -f ransom_dump.raw windows.pstree
# => Processus suspect : update_service.exe (PID 4892) lancé par cmd.exe

# ETAPE 2 : Analyser le processus suspect
vol -f ransom_dump.raw windows.cmdline --pid 4892
# => update_service.exe -encrypt -path C:\ -ext .locked

vol -f ransom_dump.raw windows.dlllist --pid 4892
# => DLLs inhabituelles, bcrypt.dll (chiffrement)

vol -f ransom_dump.raw windows.handles --pid 4892 --type File
# => Handles ouverts sur des fichiers .docx, .xlsx (en cours de chiffrement)

# ETAPE 3 : Réseau - identifier le C2
vol -f ransom_dump.raw windows.netscan | grep 4892
# => TCP 10.0.0.15:49321 -> 185.141.62.123:443 ESTABLISHED

# ETAPE 4 : Extraire le binaire
vol -f ransom_dump.raw windows.dumpfiles --pid 4892
# => SHA256: a1b2c3d4... => VirusTotal: 58/70 détections (Ransom.Win64.LockBit)

# ETAPE 5 : Chercher la persistence
vol -f ransom_dump.raw windows.registry.printkey --key "Software\Microsoft\Windows\CurrentVersion\Run"
# => "WindowsUpdate" : "C:\ProgramData\update_service.exe"

# ETAPE 6 : Credentials compromis
vol -f ransom_dump.raw windows.hashdump
# => Évaluer le périmètre de compromission des comptes

# ETAPE 7 : Timeline
vol -f ransom_dump.raw windows.mftscan.MFTScan
# => Corréler timestamps de création des fichiers .locked

Pour approfondir ce sujet, consultez notre outil open-source memory-forensics-toolkit qui facilite l'analyse forensique de la mémoire vive.

Questions frequentes

Pour approfondir, consultez les ressources de CERT-FR et de NIST Cybersecurity.

Conclusion

La forensique mémoire avec Volatility 3 est une compétence essentielle pour tout professionnel DFIR. La mémoire vive contient des artefacts que le disque ne peut pas fournir : processus en cours, connexions actives, code injecté, credentials en clair, clés de chiffrement éphémères. Maitriser Volatility 3, c'est gagner en profondeur d'analyse et en rapidité de réponse lors d'incidents critiques.

Les points clés à retenir :

• L'acquisition est critique : un dump mal réalisé compromet l'intégralité de l'analyse. Utilisez des outils éprouvés (WinPmem, LiME) et respectez la chaîne de preuve
• Volatility 3 > Volatility 2 : la migration vers v3 est indispensable pour les systèmes modernes (Windows 11, Server 2022, Linux 6.x)
• malfind est votre meilleur allié pour détecter les injections de code et les process hollowing
• La corrélation est la clé : croisez processus + réseau + registre + fichiers pour reconstruire la kill chain complète
• YARA amplifie vos capacités : maintenez une bibliothèque de règles à jour pour détecter les menaces connues et leurs variantes
• Pratiquez régulièrement : utilisez des challenges CTF forensiques (MemLabs, CyberDefenders) pour affiner vos réflexes

Pour compléter votre boite à outils forensique, explorez les analyses de techniques d'évasion EDR/XDR, la compréhension des exploits kernel Windows et le reverse engineering de rootkits. La forensique mémoire ne s'exerce pas en isolation -- elle s'intègre dans un processus complet d'investigation numérique et de réponse aux incidents.

Partager cet article

Partager sur X Partager sur LinkedIn Copier le Lien

Ressources et Références Officielles

Documentation Volatility, outils et formations DFIR

Volatility 3 - GitHub

github.com/volatilityfoundation

Volatility 3 Documentation

volatility3.readthedocs.io

CyberDefenders - DFIR Challenges

cyberdefenders.org