Lab 11.2: Detection de Malwares par Analyse Memoire

Objectifs d'Apprentissage

A la fin de ce laboratoire, vous serez capable de:

• Identifier les techniques de malware en memoire
• Utiliser des outils de detection d'anomalies
• Comprendre l'injection de processus
• Analyser un dump memoire basique
• Reconnaitre les indicateurs de compromission memoire

Duree Estimee

55 minutes

Prerequis

• Lab 11.1 complete
• VM Windows 10/11 isolee
• Process Explorer, Process Monitor
• Droits administrateur

Contexte Professionnel

La detection de malwares en memoire est critique car:

• Les malwares "fileless" n'ecrivent pas sur le disque
• L'analyse memoire revele les comportements actifs
• C'est une competence essentielle en incident response

---

AVERTISSEMENT

Ce lab utilise des techniques a des fins educatives uniquement. Executez uniquement sur des VMs isolees et de test.

---

Partie 1: Techniques de Malware en Memoire

Etape 1.1: Vue d'ensemble

Technique	Description	Detection
Process Injection	Injecter du code dans un autre processus	Regions RWX anormales
DLL Injection	Charger une DLL malveillante	DLL non signee/inconnue
Process Hollowing	Remplacer le code d'un processus	Image ne correspond pas au disque
Reflective Loading	Charger DLL sans passer par l'API	DLL sans fichier correspondant
Fileless Malware	Code uniquement en memoire	Scripts encodes, PowerShell suspect

Etape 1.2: Indicateurs cles

Signaux d'alerte:

• Regions de memoire RWX (Read-Write-Execute)
• Processus systeme lances depuis mauvais emplacement
• DLLs non signees dans processus sensibles
• Threads sans module associe
• Connexions reseau anormales depuis processus legitimes

---

Partie 2: Detection avec Process Explorer

Etape 2.1: Configuration avancee

1. Lancez Process Explorer en admin
2. Options > Verify Image Signatures
3. View > Select Columns > Ajoutez "Verified Signer"

Etape 2.2: Identifier les processus non signes

Les processus en rose/violet ont une signature non verifiee.

Processus qui DOIVENT etre signes Microsoft:

• svchost.exe
• csrss.exe
• lsass.exe
• services.exe
• winlogon.exe
• explorer.exe

Question 1: Tous vos processus systeme sont-ils signes Microsoft?

Etape 2.3: Verifier les chemins

Processus legitimes et leurs chemins:
- svchost.exe    -> C:\Windows\System32\
- csrss.exe      -> C:\Windows\System32\
- lsass.exe      -> C:\Windows\System32\
- services.exe   -> C:\Windows\System32\
- explorer.exe   -> C:\Windows\

Script de verification:

# Verifier les chemins des processus critiques
$criticalProcesses = @{
    "svchost" = "C:\Windows\System32\svchost.exe"
    "csrss" = "C:\Windows\System32\csrss.exe"
    "lsass" = "C:\Windows\System32\lsass.exe"
    "services" = "C:\Windows\System32\services.exe"
    "winlogon" = "C:\Windows\System32\winlogon.exe"
}

Write-Host "=== VERIFICATION PROCESSUS CRITIQUES ===" -ForegroundColor Cyan

foreach ($proc in $criticalProcesses.Keys) {
    $running = Get-Process -Name $proc -ErrorAction SilentlyContinue
    
    foreach ($p in $running) {
        $expectedPath = $criticalProcesses[$proc]
        $actualPath = $p.Path
        
        if ($actualPath -ne $expectedPath) {
            Write-Host "[ALERTE] $proc" -ForegroundColor Red
            Write-Host "  Attendu: $expectedPath"
            Write-Host "  Trouve:  $actualPath"
        } else {
            Write-Host "[OK] $proc - $actualPath" -ForegroundColor Green
        }
    }
}

Question 2: Le script detecte-t-il des anomalies?

---

Partie 3: Detection de DLL Injection

Etape 3.1: Lister les DLLs d'un processus

Process Explorer:

1. Selectionnez un processus
2. View > Show Lower Pane
3. View > Lower Pane View > DLLs

PowerShell:

# Lister les DLLs d'un processus
$proc = Get-Process notepad
$proc.Modules | Select-Object ModuleName, FileName, Size

# Chercher des DLLs suspectes (non dans System32 ou Program Files)
$proc.Modules | Where-Object {
    $_.FileName -notlike "C:\Windows\*" -and
    $_.FileName -notlike "C:\Program Files*"
} | Select-Object ModuleName, FileName

Etape 3.2: DLLs suspectes a rechercher

Indicateur	Description
DLL dans Temp	Emplacement anormal
DLL dans AppData	Potentiellement malveillant
DLL non signee	Manque de verification
Nom aleatoire	Possible malware
Taille tres petite	Stub/loader

Etape 3.3: Script de detection DLL

# Detection de DLLs suspectes
Write-Host "=== ANALYSE DLLs SUSPECTES ===" -ForegroundColor Cyan

$suspiciousPaths = @(
    "*\Temp\*",
    "*\AppData\Local\Temp\*",
    "*\Downloads\*",
    "*\Desktop\*"
)

Get-Process | Where-Object { $_.Modules } | ForEach-Object {
    $procName = $_.Name
    $_.Modules | ForEach-Object {
        $dll = $_
        foreach ($path in $suspiciousPaths) {
            if ($dll.FileName -like $path) {
                Write-Host "[SUSPECT] $procName charge: $($dll.FileName)" -ForegroundColor Red
            }
        }
    }
}

Write-Host "`nAnalyse terminee." -ForegroundColor Green

Question 3: Des DLLs suspectes sont-elles chargees?

---

Partie 4: Detection de Process Hollowing

Etape 4.1: Concept

Process Hollowing:

1. Creer un processus legitime en mode suspendu
2. Vider ("hollow") sa memoire
3. Injecter du code malveillant
4. Reprendre l'execution

Resultat: Le processus semble legitime mais execute du code malveillant.

Etape 4.2: Indicateurs de detection

Indicateur	Description
Image ≠ Memoire	Le code en memoire differe du fichier
PEB modifie	Process Environment Block altere
Sections anormales	Taille/permissions inattendues

Etape 4.3: Verification basique

# Comparer la taille de l'image en memoire vs sur disque
# Necessite des outils avances pour une vraie detection

Get-Process | Where-Object { $_.Path } | ForEach-Object {
    $proc = $_
    try {
        $fileSize = (Get-Item $proc.Path -ErrorAction Stop).Length
        $memorySize = $proc.WorkingSet64
        
        # Ratio tres eleve peut indiquer une anomalie
        $ratio = [math]::Round($memorySize / $fileSize, 2)
        
        if ($ratio -gt 100) {
            Write-Host "[INFO] $($proc.Name) - Ratio mem/file: $ratio" -ForegroundColor Yellow
        }
    } catch {}
}

---

Partie 5: Analyse avec Process Monitor

Etape 5.1: Capturer l'activite

procmon64.exe /accepteula

Etape 5.2: Filtres utiles pour detection

Creer des filtres pour detecter les comportements suspects:

1. Filter > Filter...
2. Ajoutez:
   • Operation is WriteFile then Include
   • Path contains \Temp\ then Include
   • Process Name is powershell.exe then Include

Etape 5.3: Comportements a surveiller

Operation	Suspect si...
WriteFile	Dans Temp avec extension .exe/.dll
CreateFile	Creation dans dossiers systeme
RegSetValue	Modification de Run keys
CreateRemoteThread	Dans un autre processus
VirtualAllocEx	Allocation dans processus distant

---

Partie 6: Creer un Dump Memoire

Etape 6.1: Dump d'un processus (methode simple)

Task Manager:

1. Onglet Details
2. Clic droit sur le processus
3. "Creer un fichier de vidage"

PowerShell:

# Utiliser procdump (Sysinternals)
# procdump64.exe -ma <PID> dump.dmp

# Ou via comsvcs.dll (attention: detecte par les AV)
# Methode utilisee par les attaquants pour dumper lsass

Etape 6.2: Ou sont stockes les dumps?

# Emplacement par defaut
$env:LOCALAPPDATA + "\Temp"

# Lister les dumps existants
Get-ChildItem "$env:LOCALAPPDATA\Temp" -Filter "*.dmp" -ErrorAction SilentlyContinue

Etape 6.3: Analyser un dump (basique)

Pour une analyse approfondie, des outils comme Volatility sont necessaires.

Avec WinDbg (si installe):

windbg -z dump.dmp
!analyze -v
!process 0 0

---

Partie 7: Script de Detection Complet

# Script de detection d'anomalies memoire
# ========================================

param(
    [switch]$Verbose
)

Write-Host @"
=====================================
  DETECTION ANOMALIES MEMOIRE
=====================================
"@ -ForegroundColor Cyan

$alerts = @()

# 1. Verifier les chemins des processus critiques
Write-Host "`n[1/5] Verification processus critiques..." -ForegroundColor Yellow

$criticalPaths = @{
    "svchost" = "C:\Windows\System32\svchost.exe"
    "lsass" = "C:\Windows\System32\lsass.exe"
    "csrss" = "C:\Windows\System32\csrss.exe"
    "services" = "C:\Windows\System32\services.exe"
}

foreach ($name in $criticalPaths.Keys) {
    Get-Process -Name $name -ErrorAction SilentlyContinue | ForEach-Object {
        if ($_.Path -and $_.Path -ne $criticalPaths[$name]) {
            $alerts += "[CRITIQUE] $name depuis mauvais chemin: $($_.Path)"
        }
    }
}

# 2. Chercher les DLLs dans des emplacements suspects
Write-Host "[2/5] Analyse DLLs..." -ForegroundColor Yellow

$suspectDlls = @()
Get-Process | Where-Object { $_.Modules } | ForEach-Object {
    $_.Modules | Where-Object {
        $_.FileName -like "*\Temp\*" -or
        $_.FileName -like "*\Downloads\*"
    } | ForEach-Object {
        $alerts += "[SUSPECT] DLL suspecte: $($_.FileName)"
    }
}

# 3. Processus avec connexions reseau inhabituelles
Write-Host "[3/5] Analyse connexions..." -ForegroundColor Yellow

$networkProcs = Get-NetTCPConnection -State Established -ErrorAction SilentlyContinue | 
    Where-Object { $_.RemoteAddress -notmatch "^(127\.|::1|0\.0\.0\.0)" }

foreach ($conn in $networkProcs) {
    $proc = Get-Process -Id $conn.OwningProcess -ErrorAction SilentlyContinue
    if ($proc.Name -in @("notepad", "calc", "mspaint")) {
        $alerts += "[SUSPECT] $($proc.Name) a une connexion reseau: $($conn.RemoteAddress):$($conn.RemotePort)"
    }
}

# 4. PowerShell avec connexions
Write-Host "[4/5] Verification PowerShell..." -ForegroundColor Yellow

$psConnections = Get-NetTCPConnection -OwningProcess (Get-Process -Name powershell -ErrorAction SilentlyContinue).Id -ErrorAction SilentlyContinue |
    Where-Object { $_.State -eq "Established" }

if ($psConnections) {
    $alerts += "[INFO] PowerShell a des connexions reseau actives"
}

# 5. Processus avec memoire RWX (necessite outils avances)
Write-Host "[5/5] Verification terminee." -ForegroundColor Yellow

# Rapport
Write-Host "`n========== RAPPORT ==========" -ForegroundColor Cyan

if ($alerts.Count -eq 0) {
    Write-Host "[OK] Aucune anomalie majeure detectee" -ForegroundColor Green
} else {
    Write-Host "Alertes detectees: $($alerts.Count)" -ForegroundColor Red
    foreach ($alert in $alerts) {
        if ($alert -match "CRITIQUE") {
            Write-Host "  $alert" -ForegroundColor Red
        } elseif ($alert -match "SUSPECT") {
            Write-Host "  $alert" -ForegroundColor Yellow
        } else {
            Write-Host "  $alert" -ForegroundColor Gray
        }
    }
}

Write-Host "`n=============================" -ForegroundColor Cyan

Question 4: Executez le script. Quelles alertes obtient-il?

---

Livrables

1. Captures d'ecran:

   • Process Explorer avec signatures verifiees
   • DLLs d'un processus
   • Resultat du script de detection

2. Reponses aux 4 questions

3. Rapport (2 pages):

   • Techniques de malware en memoire
   • Methodes de detection utilisees
   • Resultats de l'analyse de votre VM
   • Recommandations

---

Criteres d'Evaluation

Critere	Points
Process Explorer	25%
Detection DLLs	25%
Script de detection	30%
Rapport et comprehension	20%

---

Ressources

• MITRE ATT&CK: Process Injection
• Volatility Framework
• Process Hollowing Explained

---

Lab developpe dans le cadre du cours Systemes d'Exploitation - MODULE 11