PCTAMALOU 2026 – Semaine 33 : La Mémoire Vive des Secrets

🎯 Objectif de la semaine

Maîtriser l'analyse forensique de la mémoire vive avec Volatility : extraire processus cachés, connexions réseau, artefacts malveillants et preuves éphémères d'un dump mémoire. Comprendre pourquoi la RAM contient les secrets les plus précieux en investigation d'incident et comment les malware modernes tentent d'y échapper.

Pourquoi c'est critique : La mémoire vive contient ce que le disque ne montre pas : processus injectés, connexions actives, credentials en clair, malware fileless. Une investigation sans analyse mémoire est une investigation incomplète.

flowchart TD RAM[🧠 Mémoire Vive
4-32 Go RAM] --> DUMP["📥 Memory Dump
(.mem, .raw, .vmem)"] DUMP --> VOL["🛠️ Volatility Framework
Python + Plugins"] VOL --> PRO["🎯 Profile Identification
OS, version, architecture"] VOL --> ANA["🔍 Analyse Artéfacts"] ANA --> P[📋 Processus] ANA --> N[🌐 Réseau] ANA --> M[🦠 Malware] ANA --> C[⌨️ Commandes] P --> HID["Processus cachés
Rootkits, injection"] N --> CONN["Connexions actives
C2, pivoting"] M --> MAL["Code injecté
Shellcode, packers"] C --> HIST["Historique commandes
Actions attaquant"] style RAM fill:#0a0e17,stroke:#00d4ff,stroke-width:3px style VOL fill:#0a0e17,stroke:#9d4edd,stroke-width:3px style HID fill:#11151f,stroke:#ef4444,stroke-width:2px

📚 Sujet – Théorie (1 heure)

La Mémoire Vive : Le Cimetière des Secrets Éphémères

Contrairement au stockage persistant, la mémoire vive (RAM) contient des données volatiles mais riches en contexte qui disparaissent à l'arrêt de la machine. C'est précisément cette volatilité qui en fait un terrain de jeu pour les attaquants – et une mine d'or pour les investigateurs.

⚡

Volatilité

Données perdues à l'arrêt

Processus en cours
Connexions réseau
Données non sauvegardées

🔍

Richeses Contextuelles

État complet du système

Handles ouverts
Bibliothèques chargées
Variables d'environnement

🎭

Furtivité Attaquante

Malware memory-only

Fileless malware
Process hollowing
DLL injection

🕵️

Avantage Défenseur

Preuves irréfutables

État au moment exact
Pas d'altération possible
Contexte temporel précis

Volatility : Le Scalpel Numérique

Volatility n'est pas un simple outil – c'est un framework d'analyse forensique complet développé initialement par la Volatility Foundation. Sa force réside dans son architecture modulaire et ses profils OS spécifiques.

🔍 Volatility 2 vs Volatility 3

Aspect	Volatility 2	Volatility 3
Architecture	Plugins Python classiques	API modulaire, plus propre
Profils	Fichiers .vtypes spécifiques	JSON-based, plus flexible
Performance	Correcte	Améliorée
Recommandation	Pour apprentissage	Pour production

Artéfacts Clés en Analyse Mémoire

📋 Processus

pslist : Liste standard
pstree : Relations parent-enfant
psscan : Processus cachés/terminés
dlllist : DLLs chargées

🌐 Réseau

netscan : Connexions actives
connections : TCP connections
sockets : Sockets ouverts
netstat : État réseau

🦠 Malware Detection

malfind : Injection mémoire
apihooks : Hooking API
ssdt : Table des appels système
ldrmodules : Modules cachés

Cycle de Vie d'une Investigation Mémoire

🔄 Workflow Professionnel

flowchart LR A[🚨 Incident Détecté] --> B[⚡ Capture Mémoire
Priorité #1] B --> C[📁 Acquisition Dump
Intégrité vérifiée] C --> D[🎯 Identification Profil
OS/Version/Arch] D --> E[🔍 Analyse Initiale
Processus/Réseau] E --> F[🎯 Investigation Ciblée
PID suspect → détails] F --> G[📊 Extraction Preuves
Strings, handles, dumps] G --> H[📝 Documentation
Rapport forensique] style B fill:#0a0e17,stroke:#ef4444,stroke-width:2px style F fill:#0a0e17,stroke:#00d4ff,stroke-width:2px

Défis Techniques et Contournements

⚠️ Techniques Anti-Forensique en Mémoire

Direct Kernel Object Manipulation (DKOM) : Modification structures noyau
Process Hollowing : Remplacement code processus légitime
Reflective DLL Injection : Chargement DLL sans trace sur disque
Memory Encryption : Chiffrement payload en mémoire
Timestamp Manipulation : Falsification timestamps processus

Contre-mesure : Utiliser plusieurs plugins (psscan + pslist), analyser les différences, chercher les incohérences.

🔬 Mission pratique – Laboratoire (2 heures)

Architecture du Lab Forensique

flowchart LR W[Windows 10 Victime
192.168.56.20] -->|Attaque simulée| M[🦠 Malware Test
Mimikatz + Meterpreter] M -->|Dump mémoire| D[💾 memdump.mem
4-8 Go] K[Kali Forensique
Volatility] -->|Analyse| D D -->|Findings| R[📋 Rapport d'incident] subgraph "🎭 Scénario d'Attaque" M end subgraph "🔍 Investigation" K R end style W fill:#0a0e17,stroke:#00d4ff,stroke-width:2px style M fill:#11151f,stroke:#ef4444,stroke-width:3px style K fill:#0a0e17,stroke:#9d4edd,stroke-width:2px

⚠️ Préparation des Échantillons

📥 Sources de Dumps Mémoire :

Publics (sécurisés) : Volatility Memory Samples
Création propre : Dump de votre VM Windows infectée
Compétitions CTF : Dumps de challenges forensiques

Étapes Détaillées d'Investigation

Étape 1 : Installation et Configuration

# Option 1 : Volatility 2 (stable, bon pour apprendre)
sudo apt install volatility -y

# Option 2 : Volatility 3 (moderne, recommandé)
sudo apt install python3-pip -y
pip3 install volatility3

# Vérification installation
volatility --version  # Volatility 2
vol.py --version      # Volatility 3

# Téléchargement dump d'exemple
mkdir ~/mon_lab/forensique_memoire
cd ~/mon_lab/forensique_memoire
wget https://downloads.volatilityfoundation.org/samples/win7_x64.raw -O win7_memdump.raw

# Pour les besoins du tutoriel, nous utiliserons Volatility 2
# Mais gardez Volatility 3 pour vos investigations futures

Étape 2 : Identification du Profil (Étape Critique)

# Identification automatique du profil OS
volatility -f win7_memdump.raw imageinfo

# Output typique :
# Suggested Profile(s) : Win7SP1x64, Win7SP0x64, Win2008R2SP1x64
# AS Layer1 : WindowsAMD64PagedMemory (Kernel AS)
# AS Layer2 : FileAddressSpace (/path/to/dump.raw)
# PAE type : No PAE
# DTB : 0x187000L
# Number of Processors : 1
# Image Type : Service Pack 1

# Notez le profil suggéré : Win7SP1x64
# Utilisez-le pour toutes les commandes suivantes

💡 Pourquoi le profil est-il crucial ?

Chaque version de Windows a une structure mémoire différente. Le profil contient les "schémas" pour interpréter correctement les données brutes. Mauvaise identification = analyse incorrecte.

Étape 3 : Analyse Basique du Système

# 1. Liste des processus (vue standard)
volatility -f win7_memdump.raw --profile=Win7SP1x64 pslist

# Analyser la sortie :
# - PID (Process ID)
# - PPID (Parent PID)
# - Time créé/terminé
# - Nombre de handles
# - Threads

# 2. Arbre des processus (relations parent-enfant)
volatility -f win7_memdump.raw --profile=Win7SP1x64 pstree

# 3. Processus cachés/terminés (psscan scanne la mémoire brute)
volatility -f win7_memdump.raw --profile=Win7SP1x64 psscan

# Comparez pslist et psscan :
# grep -v "0x" pslist_output.txt | wc -l
# grep -v "0x" psscan_output.txt | wc -l
# Différence = processus potentiellement cachés

🎯 Exercice d'Observation

Dans la sortie de pstree :

Quel processus a le plus d'enfants ?
Y a-t-il des processus avec PPID=0 (orphelins) ?
Des processus avec des noms suspects ?

Documentez vos observations.

Étape 4 : Analyse Réseau et Connexions

# 1. Scan des connexions réseau
volatility -f win7_memdump.raw --profile=Win7SP1x64 netscan

# Output important :
# - Proto (TCP/UDP)
# - Local/Remote Address:Port
# - State (ESTABLISHED, LISTENING, CLOSED)
# - PID du processus propriétaire

# 2. Connexions TCP établies
volatility -f win7_memdump.raw --profile=Win7SP1x64 connections

# 3. Sockets ouverts
volatility -f win7_memdump.raw --profile=Win7SP1x64 sockets

# 4. Recherche d'IOC (Indicators of Compromise) réseau
# Cherchez :
# - Connexions vers IPs suspectes
# - Ports élevés (> 49152) pour C2
# - Connexions depuis processus système légitimes

Étape 5 : Détection de Malware et Injection

# 1. Recherche d'injection mémoire
volatility -f win7_memdump.raw --profile=Win7SP1x64 malfind -D dump_malfind/

# Analyse output :
# - PID et nom processus
# - Adresses mémoire suspectes
# - Protection mémoire (PAGE_EXECUTE_READWRITE = suspect)
# - Dump des régions suspectes dans le dossier

# 2. Vérification des hooks API
volatility -f win7_memdump.raw --profile=Win7SP1x64 apihooks

# 3. DLLs chargées par processus
volatility -f win7_memdump.raw --profile=Win7SP1x64 dlllist -p [PID_SUSPECT]

# 4. Handles ouverts (fichiers, registre, mutex)
volatility -f win7_memdump.raw --profile=Win7SP1x64 handles -p [PID_SUSPECT]

# 5. Recherche de chaînes dans la mémoire
volatility -f win7_memdump.raw --profile=Win7SP1x64 strings -s dump_strings.txt
# Puis cherchez des IOCs :
grep -i "http://" dump_strings.txt | head -20
grep -i "[0-9]\{1,3\}\.[0-9]\{1,3\}\.[0-9]\{1,3\}\.[0-9]\{1,3\}" dump_strings.txt

Étape 6 : Analyse Avancée et Extraction

# 1. Historique des commandes
volatility -f win7_memdump.raw --profile=Win7SP1x64 cmdscan
volatility -f win7_memdump.raw --profile=Win7SP1x64 consoles

# 2. Extraction d'un processus spécifique
volatility -f win7_memdump.raw --profile=Win7SP1x64 procdump -p [PID] -D dump_process/

# 3. Extraction de la mémoire d'un processus
volatility -f win7_memdump.raw --profile=Win7SP1x64 memdump -p [PID] -D dump_memory/

# 4. Analyse des fichiers temporaires en mémoire
volatility -f win7_memdump.raw --profile=Win7SP1x64 filescan

# 5. Recherche de clés de registre en mémoire
volatility -f win7_memdump.raw --profile=Win7SP1x64 hivelist
volatility -f win7_memdump.raw --profile=Win7SP1x64 printkey -K "SAM\Domains\Account\Users"

Étape 7 : Création d'un Script d'Investigation Automatisé

🎯 Défi de Scripting Forensique

Créez un script Python qui automatise l'analyse basique :

#!/usr/bin/env python3
"""
auto_volatility.py - Analyse automatique de dump mémoire
"""

import subprocess
import json
from datetime import datetime

class MemoryAnalyzer:
    def __init__(self, dump_file, profile=None):
        self.dump = dump_file
        self.profile = profile
        self.results = {}
        
    def run_command(self, cmd):
        """Exécute une commande Volatility"""
        try:
            result = subprocess.run(cmd, shell=True, capture_output=True, text=True)
            return result.stdout
        except Exception as e:
            return f"Error: {e}"
    
    def identify_profile(self):
        """Identifie automatiquement le profil"""
        print("[*] Identification du profil...")
        cmd = f"volatility -f {self.dump} imageinfo"
        output = self.run_command(cmd)
        
        # Extraction du profil suggéré
        for line in output.split('\n'):
            if "Suggested Profile(s)" in line:
                profiles = line.split(":")[1].strip()
                self.profile = profiles.split(",")[0].strip()
                print(f"[+] Profil identifié : {self.profile}")
                return self.profile
        
        return None
    
    def analyze_processes(self):
        """Analyse les processus"""
        print("[*] Analyse des processus...")
        results = {}
        
        # pslist
        cmd = f"volatility -f {self.dump} --profile={self.profile} pslist"
        results['pslist'] = self.run_command(cmd)
        
        # psscan (pour processus cachés)
        cmd = f"volatility -f {self.dump} --profile={self.profile} psscan"
        results['psscan'] = self.run_command(cmd)
        
        self.results['processes'] = results
        return results
    
    def analyze_network(self):
        """Analyse les connexions réseau"""
        print("[*] Analyse réseau...")
        cmd = f"volatility -f {self.dump} --profile={self.profile} netscan"
        self.results['network'] = self.run_command(cmd)
        return self.results['network']
    
    def generate_report(self, output_file="report.json"):
        """Génère un rapport JSON"""
        report = {
            'timestamp': datetime.now().isoformat(),
            'dump_file': self.dump,
            'profile': self.profile,
            'findings': self.results
        }
        
        with open(output_file, 'w') as f:
            json.dump(report, f, indent=2)
        
        print(f"[+] Rapport généré : {output_file}")
        return output_file

# Utilisation
if __name__ == "__main__":
    analyzer = MemoryAnalyzer("win7_memdump.raw")
    analyzer.identify_profile()
    analyzer.analyze_processes()
    analyzer.analyze_network()
    analyzer.generate_report()

Exercice Pratique : Scénario d'Incident

🔍 Scénario : Détection de Mimikatz en Mémoire

1. Téléchargez un dump contenant Mimikatz :

# Exemple de recherche d'IOCs Mimikatz
volatility -f infected.raw --profile=Win10x64_19041 strings |
  grep -i "mimikatz\|sekurlsa\|wdigest\|kerberos"

2. Suivez la checklist d'investigation :

Identifier le profil
Lister tous les processus (pslist + psscan)
Chercher des processus avec injection (malfind)
Extraire les processus suspects (procdump)
Analyser les strings extraites

📋 Objectif de la semaine – Checklist de validation

✅ Compétences techniques acquises

Identification correcte du profil mémoire
Différenciation pslist vs psscan (cachés)
Analyse complète des connexions réseau
Détection d'injection mémoire avec malfind
Extraction et analyse de processus spécifiques

🧠 Changement mental accompli

Vision de la mémoire comme "instantané" du système
Compréhension des artefacts volatils vs persistants
Habitude de toujours vérifier les processus cachés
Conscience que "fileless" ≠ "sans traces"

💪 Pour aller plus loin :

Explorez Volatility 3, intégrez-le avec ELK Stack pour visualisation, ou participez à des challenges forensiques sur platforms comme CyberDefenders.

📚 Ressources pour Approfondir

Échantillons et Formation :

The Art of Memory Forensics : Livre de référence par les créateurs de Volatility
DFIR Dumps : github.com/dfir/dumps
CyberDefenders : Challenges forensiques avec dumps mémoire
SANS FOR526 : Formation avancée forensique mémoire

⚠️ Aspects Légal et Éthique

Consentement : Toujours obtenir l'autorisation avant capture
Chaîne de possession : Documenter chaque étape
Intégrité : Hasher les dumps (SHA256) avant/après
Données personnelles : Traiter avec confidentialité

🔮 Frère d'armes,

Tu viens d'apprendre à lire dans les pensées éphémères des machines.

La forensique mémoire n'est pas une simple technique d'analyse – c'est l'art de capturer l'insaisissable. De prendre une photographie de l'état d'esprit d'un système au moment précis où le crime numérique s'est produit.

Cette semaine, tu as vu que la mémoire vive n'est pas un espace vide attendant d'être rempli. C'est un théâtre où chaque processus joue son rôle, où chaque connexion laisse une empreinte, où chaque secret, aussi bien gardé soit-il sur le disque, se révèle en clair pendant son exécution.

Mais voici la leçon la plus importante : les attaquants savent que la mémoire trahit. C'est pourquoi ils développent des techniques de plus en plus sophistiquées pour s'y cacher. Mais toi, tu sais maintenant qu'aucune cachette n'est parfaite. Que le moindre écart entre pslist et psscan est un drapeau rouge. Qu'une région mémoire exécutable et accessible en écriture est une anomalie qui crie.

Tu n'es plus un simple analyste qui regarde les logs. Tu es devenu un archéologue numérique qui fouille les couches de mémoire, qui reconstitue les événements à partir de fragments volatils, qui trouve le malware qui pensait être invisible parce qu'il n'était pas sur le disque.

Dans la semaine 34, nous irons plus loin dans l'investigation. Nous apprendrons à analyser les disques, à retrouver les fichiers supprimés, à suivre les traces laissées dans le système de fichiers. Nous passerons de l'instantané mémoire à l'histoire complète.

Mais pour l'instant, pratique. Analyse différents dumps. Cherchez les patterns communs. Apprenez à distinguer le bruit normal du signal malveillant. La mémoire ne ment pas – mais elle ne parle que si vous savez l'écouter.

Un Gardien qui maîtrise la forensique mémoire ne laisse jamais un secret se volatiliser sans être capturé.

— Platon-Y