Triage forensique Windows pour la réponse à incident

1Introduction

Le triage est la première phase technique de la réponse à incident : un examen rapide et structuré d’une machine Windows suspecte pour répondre à quatre questions. Est-elle compromise ? Comment l’attaquant est-il entré ? Qu’a-t-il fait et quand ? Quels autres systèmes et comptes sont concernés ? Un bon triage y répond en quelques heures, préserve les preuves nécessaires à un examen forensique complet et évite d’alerter un attaquant encore actif. Ce guide présente l’ordre de travail, les commandes et les outils pour bien le mener sur Windows 10, Windows 11 et Windows Server.

2Règles de base avant de toucher à l’hôte

• Collectez par ordre de volatilité (RFC 3227) : d’abord la mémoire et l’état du réseau, puis les processus et les sessions, puis les artefacts du disque et les journaux. Redémarrer, réinstaller ou lancer d’abord une analyse antivirus complète détruit les preuves les plus utiles.
• Ne vous connectez pas de façon interactive avec un compte d’administrateur de domaine. Les connexions interactives et RDP laissent des identifiants réutilisables dans la mémoire de LSASS sur une machine que l’attaquant contrôle peut-être. Utilisez la réponse à chaud de l’EDR, un compte de réponse dédié avec des droits d’administrateur local uniquement, ou des outils à distance fondés sur des connexions réseau.
• Exécutez les outils depuis un support de confiance en lecture seule ou un partage réseau, jamais à partir de binaires de l’hôte suspect, et écrivez sur un stockage externe ou un partage de collecte, jamais sur le disque système.
• Notez tout en UTC : chaque commande, qui l’a lancée, quand, et le SHA-256 de chaque fichier collecté. Ce journal devient votre chaîne de possession et l’ossature de la chronologie.
• Décidez tôt si vous enquêtez discrètement ou si vous contenez immédiatement. Des actions visibles, comme désactiver des comptes ou arrêter des processus, indiquent à l’attaquant que vous l’avez trouvé.
• Supposez que plusieurs hôtes sont concernés. Examinez la première machine en pensant aux indicateurs à rechercher sur le reste du parc.

3Préparer la trousse de triage

Assemblez et testez la trousse avant d’en avoir besoin. Gardez-la sur une clé USB protégée en écriture ou un partage à accès contrôlé, notez l’empreinte de chaque exécutable et actualisez-la chaque trimestre. La plupart des outils essentiels sont gratuits.

4Les quinze premières minutes

Commencez par établir le contexte. Vous devez savoir exactement sur quelle machine vous êtes, son fuseau horaire et le décalage de son horloge, qui est connecté et depuis combien de temps elle fonctionne. Une machine redémarrée il y a une heure a perdu ses preuves en mémoire, et une horloge décalée de cinq minutes déplace chaque événement corrélé avec d’autres systèmes.

$case = "E:\IR-2026-031\$env:COMPUTERNAME"
New-Item -ItemType Directory -Path $case -Force | Out-Null
Start-Transcript -Path "$case\transcript.txt"

(Get-Date).ToUniversalTime().ToString('o')
hostname; whoami /all
Get-TimeZone
w32tm /query /status
Get-CimInstance Win32_OperatingSystem |
  Select-Object Caption, Version, BuildNumber, InstallDate, LastBootUpTime
Get-CimInstance Win32_ComputerSystem | Select-Object Domain, Manufacturer, Model
Get-NetIPConfiguration | Format-List InterfaceAlias, IPv4Address, IPv4DefaultGateway, DNSServer
quser 2>$null

Décidez ensuite du confinement. Si la machine a un agent EDR, l’isolation réseau depuis la console est généralement la meilleure première action : elle coupe l’attaquant tout en gardant la machine en marche et accessible par l’EDR, ce qui préserve la mémoire et l’état en direct. Sans EDR, comparez le risque de dégâts en cours, comme un chiffrement ou une fuite de données, aux preuves et à la visibilité perdues en débranchant le réseau. N’éteignez jamais simplement la machine.

5Capturer d’abord la mémoire

La mémoire contient ce que le disque n’a pas : code injecté, logiciels malveillants sans fichier, charges déchiffrées, historique des shells actifs, connexions réseau déjà fermées et parfois des clés de chiffrement. Capturez-la avant tout autre changement. Comptez environ une minute pour 4 à 8 GB de RAM vers un disque USB 3 rapide.

# WinPmem (run from the kit drive, write to the evidence drive)
E:\tools\winpmem_mini_x64_rc2.exe E:\IR-2026-031\HOST01\HOST01.raw

Get-FileHash -Algorithm SHA256 E:\IR-2026-031\HOST01\HOST01.raw |
  Export-Csv E:\IR-2026-031\HOST01\hashes.csv -NoTypeInformation -Append

# Velociraptor alternative, run remotely from the server console:
#   artifact Windows.Memory.Acquisition

Le fichier d’échange et le fichier d’hibernation contiennent aussi des pages mémoire et méritent d’être collectés avec les artefacts du disque. Ils sont verrouillés lorsque Windows fonctionne : utilisez donc KAPE, Velociraptor ou FTK Imager, qui les lisent par accès direct au disque. Sur les machines virtuelles, un instantané avec mémoire ou une suspension produit un fichier mémoire directement lisible par Volatility.

vol -f HOST01.raw windows.info
vol -f HOST01.raw windows.pstree                 # parent and child relationships
vol -f HOST01.raw windows.psscan                 # finds unlinked and exited processes too
vol -f HOST01.raw windows.cmdline
vol -f HOST01.raw windows.netscan                # connections and listeners with PIDs
vol -f HOST01.raw windows.malfind                # executable private memory, injected code
vol -f HOST01.raw windows.svcscan
vol -f HOST01.raw windows.dlllist --pid 4416
vol -f HOST01.raw windows.handles --pid 4416
vol -f HOST01.raw -o out windows.dumpfiles --pid 4416

# MemProcFS: browse processes, handles and timelines as files under M:\
MemProcFS.exe -device HOST01.raw -forensic 1

Comparez pslist et psscan : un processus trouvé seulement par psscan a été retiré de la liste active, technique de rootkit, ou s’est déjà terminé. Dans les résultats de malfind, les zones de mémoire exécutable qui commencent par un en-tête MZ ou contiennent du shellcode dans des processus comme explorer.exe, svchost.exe ou rundll32.exe méritent un examen, même si les compilateurs JIT des navigateurs et de .NET produisent des faux positifs.

6Réponse à chaud : processus, réseau et sessions

Une fois la mémoire sécurisée, notez l’état en direct avec les commandes intégrées. Ces sorties sont rapides à lire pendant l’incident et faciles à comparer entre hôtes. Enregistrez chacune en CSV pour la trier et la filtrer ensuite dans Timeline Explorer ou un tableur.

Get-CimInstance Win32_Process |
  Select-Object ProcessId, ParentProcessId, Name, CommandLine, ExecutablePath,
    @{n='Created';e={$_.CreationDate.ToUniversalTime()}},
    @{n='Owner';e={(Invoke-CimMethod -InputObject $_ -MethodName GetOwner).User}} |
  Export-Csv "$case\processes.csv" -NoTypeInformation

Get-Process | Where-Object Path | Select-Object -ExpandProperty Path -Unique |
  ForEach-Object { Get-FileHash -Algorithm SHA256 $_ } |
  Export-Csv "$case\process-hashes.csv" -NoTypeInformation

tasklist /svc /fo csv > "$case\tasklist-svc.csv"

Get-NetTCPConnection |
  Select-Object LocalAddress, LocalPort, RemoteAddress, RemotePort, State, OwningProcess,
    @{n='Process';e={(Get-Process -Id $_.OwningProcess -ErrorAction SilentlyContinue).Name}},
    CreationTime |
  Export-Csv "$case\tcp.csv" -NoTypeInformation

Get-NetUDPEndpoint | Select-Object LocalAddress, LocalPort, OwningProcess |
  Export-Csv "$case\udp.csv" -NoTypeInformation

netstat -anob > "$case\netstat.txt"
Get-DnsClientCache | Export-Csv "$case\dns-cache.csv" -NoTypeInformation
Get-NetNeighbor | Export-Csv "$case\arp.csv" -NoTypeInformation
route print > "$case\routes.txt"
Get-SmbSession | Export-Csv "$case\smb-sessions.csv" -NoTypeInformation   # who is connected to us
Get-SmbMapping; net use                                                     # where we are connected
Get-SmbShare | Export-Csv "$case\shares.csv" -NoTypeInformation
netsh advfirewall show allprofiles > "$case\firewall.txt"

Le cache du client DNS est de courte durée et montre souvent des domaines de commande et contrôle qui n’ont plus de connexion ouverte. Les sessions SMB entrantes montrent quelles machines et quels comptes sont connectés à cet hôte en ce moment, preuve directe d’un déplacement latéral en cours.

quser; qwinsta
Get-CimInstance Win32_LogonSession |
  Select-Object LogonId, LogonType, AuthenticationPackage, StartTime
Get-LocalUser | Select-Object Name, Enabled, LastLogon, PasswordLastSet, Description
Get-LocalGroupMember Administrators
Get-LocalGroupMember 'Remote Desktop Users'
Get-ChildItem C:\Users -Directory | Select-Object Name, CreationTime, LastWriteTime
klist sessions

Recherchez un compte local récemment créé, un membre inattendu du groupe Administrators ou un dossier de profil créé pendant la fenêtre de l’incident. Un nouveau dossier de profil signifie que ce compte s’est connecté pour la première fois de façon interactive sur cette machine.

$b64 = 'SQBFAFgAIAAoAE4AZQB3AC0ATwBiAGoAZQBjAHQAIABOAGUAdAAuAFcAZQBiAEMAbABpAGUAbgB0ACkA'
[Text.Encoding]::Unicode.GetString([Convert]::FromBase64String($b64))

E:\tools\sigcheck64.exe -accepteula -nobanner -u -e -s -c -h C:\Users > "$case\unsigned-users.csv"
E:\tools\sigcheck64.exe -accepteula -nobanner -u -e -s -c -h C:\ProgramData > "$case\unsigned-programdata.csv"
# -u unsigned only, -e executables only, -s recurse, -c CSV, -h hashes
# Add -v to look hashes up on VirusTotal. It sends hashes only, never the files.

7Rechercher la persistance

Les attaquants qui veulent rester s’assurent que leur accès survit à un redémarrage et à un changement de mot de passe. Windows offre des centaines d’endroits pour cela, mais la plupart des intrusions en utilisent peu : clés Run, tâches planifiées, services, abonnements WMI, dossiers de démarrage et nouveaux comptes. Commencez par Autoruns, qui les contrôle presque tous à la fois, puis confirmez manuellement les entrées intéressantes.

E:\tools\autorunsc64.exe -accepteula -nobanner -a * -c -h -s -m '*' > "$case\autoruns.csv"
# -a *   every category       -c  CSV output        -h  file hashes
# -s     verify signatures    -m  hide Microsoft-signed entries
# '*'    include every user profile, not only the current one

Triez le CSV par signataire et regardez d’abord les entrées non signées, celles qui pointent vers des dossiers accessibles en écriture par les utilisateurs et celles dont la commande appelle un hôte de script ou un interpréteur. Masquer les entrées Microsoft réduit le bruit, mais les attaquants détournent souvent des binaires Microsoft signés : une entrée lançant rundll32.exe ou mshta.exe avec un argument inhabituel reste importante même si le binaire est signé.

$keys = @(
  'HKLM:\Software\Microsoft\Windows\CurrentVersion\Run',
  'HKLM:\Software\Microsoft\Windows\CurrentVersion\RunOnce',
  'HKLM:\Software\WOW6432Node\Microsoft\Windows\CurrentVersion\Run',
  'HKCU:\Software\Microsoft\Windows\CurrentVersion\Run',
  'HKCU:\Software\Microsoft\Windows\CurrentVersion\RunOnce',
  'HKLM:\Software\Microsoft\Windows NT\CurrentVersion\Winlogon',
  'HKLM:\System\CurrentControlSet\Control\Session Manager'
)
foreach ($k in $keys) { "== $k"; Get-ItemProperty -Path $k -ErrorAction SilentlyContinue }

# Debugger hijacks: a program that runs instead of, or when, the target starts
Get-ChildItem 'HKLM:\Software\Microsoft\Windows NT\CurrentVersion\Image File Execution Options' |
  Get-ItemProperty | Where-Object { $_.Debugger -or $_.GlobalFlag } |
  Select-Object PSChildName, Debugger, GlobalFlag

Dans la clé Winlogon, Userinit doit valoir C:\Windows\system32\userinit.exe suivi d’une virgule, et Shell doit valoir explorer.exe. Tout ajout s’exécute à chaque connexion. Dans Session Manager, vérifiez BootExecute, qui ne doit normalement contenir que autocheck autochk *. Les entrées Image File Execution Options avec une valeur Debugger sur des outils d’accessibilité comme sethc.exe ou utilman.exe sont une porte dérobée classique qui ouvre un shell SYSTEM depuis l’écran de connexion.

Get-ScheduledTask | Where-Object State -ne 'Disabled' |
  Select-Object TaskPath, TaskName, State, Author,
    @{n='Run';e={($_.Actions | ForEach-Object { "$($_.Execute) $($_.Arguments)" }) -join ' | '}},
    @{n='User';e={$_.Principal.UserId}} |
  Export-Csv "$case\tasks.csv" -NoTypeInformation

# Raw task XML, including tasks hidden by deleting their SD registry value
Get-ChildItem C:\Windows\System32\Tasks -Recurse -File |
  Sort-Object LastWriteTime -Descending | Select-Object -First 30 FullName, LastWriteTime

Get-CimInstance Win32_Service |
  Select-Object Name, DisplayName, State, StartMode, StartName, PathName |
  Export-Csv "$case\services.csv" -NoTypeInformation

# Services launching shells, scripts or binaries from writable folders
Get-CimInstance Win32_Service | Where-Object {
  $_.PathName -match 'cmd(\.exe)?\s*/c|powershell|mshta|rundll32|\\Users\\|\\ProgramData\\|\\Temp\\|\\AppData\\'
} | Select-Object Name, StartMode, PathName

Les noms de services générés par des outils comme PsExec, Impacket ou Cobalt Strike sont souvent des suites aléatoires de lettres ou de chiffres, et leur chemin binaire est fréquemment une ligne de commande plutôt qu’un exécutable. Recherchez aussi les chemins de service sans guillemets contenant des espaces, car un dossier accessible en écriture sur ce chemin est une voie d’élévation de privilèges également utilisée pour la persistance.

Get-CimInstance -Namespace root\subscription -ClassName __EventFilter |
  Select-Object Name, Query
Get-CimInstance -Namespace root\subscription -ClassName CommandLineEventConsumer |
  Select-Object Name, CommandLineTemplate, ExecutablePath
Get-CimInstance -Namespace root\subscription -ClassName ActiveScriptEventConsumer |
  Select-Object Name, ScriptingEngine, ScriptText
Get-CimInstance -Namespace root\subscription -ClassName __FilterToConsumerBinding

Get-BitsTransfer -AllUsers | Select-Object DisplayName, JobState, OwnerAccount, FileList

Get-ChildItem 'C:\ProgramData\Microsoft\Windows\Start Menu\Programs\StartUp',
  'C:\Users\*\AppData\Roaming\Microsoft\Windows\Start Menu\Programs\Startup' -Force -ErrorAction SilentlyContinue |
  Select-Object FullName, CreationTime, LastWriteTime

Un poste sain a généralement un ou deux filtres et consommateurs WMI intégrés, comme SCM Event Log Consumer. Tout CommandLineEventConsumer ou ActiveScriptEventConsumer que vous ne pouvez pas attribuer à un logiciel de gestion est très suspect, car la persistance WMI ne laisse aucun fichier dans un emplacement de démarrage et survit aux redémarrages.

Get-MpComputerStatus |
  Select-Object AMServiceEnabled, RealTimeProtectionEnabled, IsTamperProtected, AntivirusSignatureLastUpdated
Get-MpPreference | Select-Object ExclusionPath, ExclusionProcess, ExclusionExtension, ExclusionIpAddress
Get-MpThreatDetection | Sort-Object InitialDetectionTime -Descending | Select-Object -First 20
Get-WinEvent -FilterHashtable @{LogName='Microsoft-Windows-Windows Defender/Operational'; Id=1116,1117,5001,5007} -MaxEvents 50 |
  Select-Object TimeCreated, Id, Message

Les attaquants ajoutent des exclusions Defender pour leur dossier de préparation ou désactivent la protection en temps réel avant de déposer leurs outils. L’événement 5007 enregistre chaque changement de configuration, y compris le nouveau chemin exclu, et 5001 la désactivation de la protection en temps réel. Les exclusions de disques entiers, de dossiers de profil ou d’extensions courantes comme .ps1 sont des signaux d’alerte. Les versions actuelles de Defender masquent la liste aux non-administrateurs : collectez-la depuis une session élevée.

• Autres endroits à vérifier lorsque les emplacements courants sont propres : détournements d’objets COM sous HKCU\Software\Classes\CLSID, compléments et modèles Office (Normal.dotm), extensions de navigateur, DLL d’assistance netsh, moniteurs d’impression et packages d’authentification ou de notification LSA.
• Les comptes sont aussi de la persistance : un nouvel administrateur local, un compte désactivé réactivé ou un mot de passe de compte de service qui n’expire jamais permettent à l’attaquant de revenir après la suppression de ses logiciels malveillants.
• Les logiciels d’accès à distance comptent aussi comme persistance. Vérifiez les programmes et services installés pour trouver les outils de supervision à distance que votre équipe IT n’utilise pas.

8Les journaux d’événements importants

Les journaux d’événements Windows sont ce qui se rapproche le plus d’une boîte noire sur l’hôte. Exportez-les tôt : les attaquants les effacent, et la taille par défaut sur les postes les fait s’écraser en quelques jours. Copiez tout le dossier des journaux, ce qui préserve chaque canal, même ceux auxquels vous n’avez pas pensé.

New-Item -ItemType Directory "$case\evtx" -Force | Out-Null
foreach ($log in 'Security','System','Application',
  'Microsoft-Windows-PowerShell/Operational','Microsoft-Windows-Sysmon/Operational',
  'Microsoft-Windows-TaskScheduler/Operational','Microsoft-Windows-Windows Defender/Operational',
  'Microsoft-Windows-TerminalServices-LocalSessionManager/Operational',
  'Microsoft-Windows-TerminalServices-RemoteConnectionManager/Operational',
  'Microsoft-Windows-WMI-Activity/Operational','Microsoft-Windows-WinRM/Operational') {
  $name = ($log -replace '[/ ]', '_') + '.evtx'
  wevtutil epl $log "$case\evtx\$name" 2>$null
}

# Or simply copy every channel
robocopy C:\Windows\System32\winevt\Logs "$case\evtx-all" *.evtx /COPY:DAT /R:0 /W:0

Les propriétés des événements sont positionnelles et varient selon l’ID : analysez donc le XML par nom de champ plutôt que par indice. Ce modèle fonctionne pour tout événement et rend la sortie facile à filtrer.

Get-WinEvent -FilterHashtable @{LogName='Security'; Id=4624; StartTime=(Get-Date).AddDays(-7)} |
  ForEach-Object {
    $d = @{}
    ([xml]$_.ToXml()).Event.EventData.Data | ForEach-Object { $d[$_.Name] = $_.'#text' }
    [pscustomobject]@{
      TimeUtc = $_.TimeCreated.ToUniversalTime()
      User    = "$($d.TargetDomainName)\$($d.TargetUserName)"
      Type    = $d.LogonType
      Source  = $d.IpAddress
      Host    = $d.WorkstationName
      Auth    = $d.AuthenticationPackageName
      Process = $d.ProcessName
    }
  } | Where-Object { $_.Type -in '3','10' -and $_.Source -notin '-','127.0.0.1','::1' } |
  Export-Csv "$case\logons.csv" -NoTypeInformation

Get-WinEvent -FilterHashtable @{LogName='Security'; Id=1102} -ErrorAction SilentlyContinue
Get-WinEvent -FilterHashtable @{LogName='System'; Id=104,7045} -ErrorAction SilentlyContinue |
  Select-Object TimeCreated, Id, Message | Format-List
Get-WinEvent -FilterHashtable @{LogName='Security'; Id=4698} -ErrorAction SilentlyContinue |
  Select-Object TimeCreated, Message | Format-List

Get-WinEvent -FilterHashtable @{LogName='Microsoft-Windows-PowerShell/Operational'; Id=4104} -MaxEvents 500 |
  Where-Object Message -match 'DownloadString|IEX|Invoke-Expression|FromBase64String|Net.WebClient|-enc|Bypass|Mimikatz|Invoke-' |
  Select-Object TimeCreated, Message | Format-List

Lire les événements une requête à la fois ne fonctionne plus au-delà du premier hôte. Les outils de chasse fondés sur Sigma appliquent en quelques minutes des milliers de règles communautaires aux journaux exportés et produisent une chronologie des seuls événements intéressants. Exécutez-les sur les fichiers EVTX exportés, sur votre poste d’analyse, pas sur l’hôte suspect.

# Hayabusa: Sigma and built-in rules, timeline output
hayabusa.exe update-rules
hayabusa.exe csv-timeline -d E:\IR-2026-031\HOST01\evtx-all -o host01-hayabusa.csv -p verbose -U -w
hayabusa.exe logon-summary -d E:\IR-2026-031\HOST01\evtx-all

# Chainsaw: Sigma hunting plus fast keyword search
chainsaw hunt E:\IR-2026-031\HOST01\evtx-all -s sigma\ --mapping mappings\sigma-event-logs-all.yml -r rules\ --csv --output host01-chainsaw
chainsaw search mimikatz -i E:\IR-2026-031\HOST01\evtx-all

# EvtxECmd: every event normalized into one CSV for Timeline Explorer
EvtxECmd.exe -d E:\IR-2026-031\HOST01\evtx-all --csv E:\out --csvf host01-evtx.csv

Commencez par les résultats les plus graves de Hayabusa ou Chainsaw, notez les horodatages, puis lisez tout ce qui s’est passé dans la sortie d’EvtxECmd quelques minutes avant et après. Les détections indiquent où regarder ; les événements ordinaires autour indiquent ce qui s’est réellement passé.

9Preuves d’exécution

Lorsque les journaux manquent ou ont été effacés, Windows garde encore beaucoup de traces des programmes exécutés, de leur date et de leur emplacement. Chaque artefact a ses lacunes et ses particularités : les conclusions les plus solides viennent donc de deux ou trois artefacts concordants.

PECmd.exe -d C:\Windows\Prefetch --csv E:\out --csvf prefetch.csv
AmcacheParser.exe -f C:\Windows\AppCompat\Programs\Amcache.hve -i --csv E:\out
AppCompatCacheParser.exe --csv E:\out --csvf shimcache.csv
SrumECmd.exe -d E:\collect\C --csv E:\out
RECmd.exe -d E:\collect\C --bn BatchExamples\Kroll_Batch.reb --csv E:\out
LECmd.exe -d E:\collect\C\Users --csv E:\out
JLECmd.exe -d E:\collect\C\Users --csv E:\out

# PowerShell history for every user
Get-ChildItem C:\Users\*\AppData\Roaming\Microsoft\Windows\PowerShell\PSReadLine\ConsoleHost_history.txt -Force |
  ForEach-Object { "===== $($_.FullName)"; Get-Content $_.FullName }

L’empreinte SHA-1 d’Amcache est précieuse, car elle survit à la suppression du fichier. Un attaquant qui nettoie ses outils laisse souvent cette empreinte, que vous pouvez rechercher dans VirusTotal ou votre plateforme de renseignement sans avoir le binaire.

10Triage du système de fichiers

La Master File Table NTFS enregistre chaque fichier du volume avec quatre dates dans deux attributs distincts. Le journal USN enregistre chaque création, renommage, écriture et suppression des derniers jours ou semaines. Ensemble, ils montrent les dossiers de préparation, les dépôts d’outils, les logiciels malveillants renommés et les chiffrements massifs, même après la disparition des fichiers.

$since = (Get-Date).AddDays(-14)
Get-ChildItem C:\Users, C:\ProgramData, C:\Windows\Temp, C:\PerfLogs, 'C:\$Recycle.Bin' -Recurse -Force -File -ErrorAction SilentlyContinue -Include *.exe,*.dll,*.ps1,*.bat,*.cmd,*.vbs,*.js,*.hta,*.lnk,*.iso,*.zip,*.7z,*.rar |
  Where-Object { $_.CreationTime -gt $since -or $_.LastWriteTime -gt $since } |
  Select-Object FullName, Length, CreationTimeUtc, LastWriteTimeUtc |
  Sort-Object CreationTimeUtc | Export-Csv "$case\recent-files.csv" -NoTypeInformation

# Where did a file come from? Mark of the Web stores the download URL
Get-Content C:\Users\bob\Downloads\invoice.iso -Stream Zone.Identifier

MFTECmd.exe -f 'E:\collect\C\$MFT' --csv E:\out --csvf mft.csv
MFTECmd.exe -f 'E:\collect\C\$Extend\$J' --csv E:\out --csvf usn.csv
RBCmd.exe -d 'E:\collect\C\$Recycle.Bin' --csv E:\out       # deleted file names and times

• Timestomping : les attaquants modifient les dates des fichiers pour passer inaperçus. Les dates $STANDARD_INFORMATION sont faciles à changer, pas celles de $FILE_NAME. MFTECmd signale les enregistrements où la date de création dans $SI est antérieure à celle de $FN, ou dont les fractions de seconde sont toutes à zéro.
• Dossiers de préparation : une rafale d’archives (zip, 7z, rar) dans un même dossier peu avant un important trafic sortant dans SRUM est un schéma d’exfiltration courant.
• Clichés instantanés : exécutez vssadmin list shadows. Une disparition soudaine, avec des commandes vssadmin, wmic shadowcopy ou wbadmin dans les événements 4688 ou Sysmon, indique la préparation d’un rançongiciel.
• Dossiers courants des attaquants : C:\PerfLogs, C:\Users\Public, C:\ProgramData, C:\Windows\Temp et la racine de C:\, souvent avec des noms imitant des dossiers système.

yara64.exe -r -s -w E:\rules\index.yar C:\Users\Public C:\ProgramData C:\Windows\Temp > "$case\yara-files.txt"

# Scan a running process by PID
yara64.exe -s E:\rules\cobaltstrike.yar 4416

# Loki and THOR Lite bundle curated rules and IOC lists
loki.exe -p C:\ --noprocscan --csv

11Collecter une image de triage

Une image de triage est une copie ciblée des artefacts importants, généralement de 1 à 5 GB au lieu d’un disque entier. Elle prend des minutes plutôt que des heures, peut être récupérée par le réseau et suffit pour la plupart des questions d’enquête. Ne collectez aussi une image complète que si l’affaire peut aller en justice ou si l’image de triage laisse d’importantes questions ouvertes.

E:\KAPE\kape.exe --tsource C: --tdest E:\IR-2026-031\%m\tout --target KapeTriage --vhdx %m --zv false --msource E:\IR-2026-031\%m\tout --mdest E:\IR-2026-031\%m\mout --module !EZParser

# Add memory-related files and browser history when relevant
E:\KAPE\kape.exe --tsource C: --tdest E:\IR-2026-031\%m\extra --target FileSystem,WebBrowsers,PowerShellConsole --vhdx %m-extra

KapeTriage rassemble la MFT, le journal USN, les ruches du registre, les journaux d’événements, prefetch, Amcache, SRUM, les fichiers LNK, les jump lists et d’autres éléments, avec une lecture directe du disque pour copier les fichiers verrouillés. Le module EZParser exécute les analyseurs d’Eric Zimmerman sur la copie : les CSV sont donc prêts pour Timeline Explorer à la fin de la collecte. La variable %m correspond au nom de la machine, ce qui garde les collectes multi-hôtes bien rangées.

Au-delà de quelques machines, Velociraptor est le meilleur outil. Un seul serveur gère des milliers de postes, les collectes s’exécutent comme des chasses sur tout le parc, et un collecteur hors ligne peut être créé sous forme d’un seul exécutable pour les machines sans agent. Les versions récentes nomment l’artefact de type KAPE Windows.Triage.Targets ; les plus anciennes l’appellent Windows.KapeFiles.Targets.

Si vous n’avez aucun de ces outils, un court script PowerShell peut capturer l’essentiel de façon cohérente. Il ne remplace pas un vrai collecteur, mais vaut bien mieux que des commandes improvisées sous pression, et il calcule l’empreinte de sa propre sortie.

param([string]$Out = "E:\IR\$env:COMPUTERNAME-$((Get-Date).ToUniversalTime().ToString('yyyyMMddTHHmmssZ'))")
New-Item -ItemType Directory -Path $Out -Force | Out-Null
Start-Transcript "$Out\transcript.txt"

Get-CimInstance Win32_Process | Select-Object ProcessId,ParentProcessId,Name,CommandLine,ExecutablePath,CreationDate | Export-Csv "$Out\processes.csv" -NoTypeInformation
Get-NetTCPConnection | Select-Object LocalAddress,LocalPort,RemoteAddress,RemotePort,State,OwningProcess,CreationTime | Export-Csv "$Out\tcp.csv" -NoTypeInformation
Get-DnsClientCache | Export-Csv "$Out\dns.csv" -NoTypeInformation
Get-CimInstance Win32_Service | Select-Object Name,State,StartMode,StartName,PathName | Export-Csv "$Out\services.csv" -NoTypeInformation
Get-ScheduledTask | Select-Object TaskPath,TaskName,State,@{n='Run';e={($_.Actions.Execute + ' ' + $_.Actions.Arguments)}} | Export-Csv "$Out\tasks.csv" -NoTypeInformation
Get-LocalUser | Export-Csv "$Out\local-users.csv" -NoTypeInformation
Get-LocalGroupMember Administrators | Export-Csv "$Out\local-admins.csv" -NoTypeInformation
Get-CimInstance -Namespace root\subscription -ClassName __FilterToConsumerBinding | Out-File "$Out\wmi-bindings.txt"
Get-MpPreference | Select-Object Exclusion* | Out-File "$Out\defender-exclusions.txt"

New-Item -ItemType Directory "$Out\evtx" | Out-Null
robocopy C:\Windows\System32\winevt\Logs "$Out\evtx" *.evtx /R:0 /W:0 /NP | Out-Null
robocopy C:\Windows\Prefetch "$Out\prefetch" *.pf /R:0 /W:0 /NP | Out-Null
Get-ChildItem C:\Users\*\AppData\Roaming\Microsoft\Windows\PowerShell\PSReadLine\*.txt -Force -ErrorAction SilentlyContinue |
  ForEach-Object { Copy-Item $_.FullName "$Out\pshistory-$(($_.FullName -split '\\')[2]).txt" }

Stop-Transcript
Get-ChildItem $Out -Recurse -File | Get-FileHash -Algorithm SHA256 | Export-Csv "$Out\..\$(Split-Path $Out -Leaf)-sha256.csv" -NoTypeInformation

Les fichiers verrouillés comme les ruches du registre, la MFT et le fichier d’échange exigent un accès direct au disque, que ce script ne tente pas. En solution de repli pour les ruches, reg save HKLM\SYSTEM system.hiv fonctionne depuis une invite élevée pour SYSTEM, SOFTWARE, SAM et SECURITY, mais les ruches des utilisateurs connectés (NTUSER.DAT) exigent un outil de copie directe.

12Déplacement latéral et vol d’identifiants

Une fois le premier hôte connu, la question suivante est où l’attaquant est allé ensuite et quels identifiants il a pris. Considérez cet hôte à la fois comme une destination (qui est entré) et une source (vers où il s’est connecté).

• Accès à LSASS : événement Sysmon 10 avec TargetImage lsass.exe depuis un processus source inattendu, procdump ou rundll32 chargeant comsvcs.dll avec MiniDump, ou nouveaux fichiers .dmp dans les dossiers Temp. Supposez que chaque identifiant en cache sur l’hôte est volé.
• Pass-the-hash : 4624 type 3 avec authentification NTLM d’un poste vers de nombreux autres en peu de temps, ou type 9 avec le processus de connexion seclogo sur la source.
• Kerberoasting : sur les contrôleurs de domaine, une rafale d’événements 4769 pour des comptes de service avec chiffrement de ticket 0x17 (RC4), demandés par un seul utilisateur.
• DCSync : 4662 sur un contrôleur de domaine avec les GUID des droits de réplication (1131f6aa-9c07-11d1-f79f-00c04fc2dcd2 et 1131f6ad-9c07-11d1-f79f-00c04fc2dcd2) demandés par un compte qui n’est pas un contrôleur de domaine.
• Vol de NTDS : ntdsutil, vssadmin create shadow ou diskshadow sur un contrôleur de domaine, suivis de copies de ntds.dit et de la ruche SYSTEM.

13Triage propre aux rançongiciels

Dans un cas de rançongiciel, le chiffrement est la dernière étape d’une intrusion qui a généralement commencé des jours ou des semaines plus tôt. Le triage a deux missions à la fois : limiter les dégâts maintenant, et trouver le point d’entrée et les comptes utilisés pour que l’attaquant ne puisse pas recommencer après la restauration.

1. Photographiez la demande de rançon et notez l’extension des fichiers et le nom de la note. ID Ransomware et le projet No More Ransom identifient la famille et recensent les déchiffreurs gratuits.
2. Trouvez le début du chiffrement en triant la sortie de la MFT ou du journal USN sur la nouvelle extension. Le premier fichier chiffré et le processus qui l’a écrit mènent au binaire de chiffrement et au compte qui l’a lancé.
3. Recherchez les étapes de préparation dans les journaux 4688, Sysmon et PowerShell : vssadmin delete shadows, wmic shadowcopy delete, wbadmin delete catalog, bcdedit avec recoveryenabled no, et l’arrêt des services de sauvegarde et de bases de données.
4. Recherchez l’exfiltration avant le chiffrement. La plupart des groupes volent d’abord les données. Cherchez rclone, MEGAsync, WinSCP, restic ou des clients de synchronisation cloud, des fichiers rclone.conf dans AppData, de grosses archives dans des dossiers de préparation et le volume sortant dans SRUM.
5. Identifiez la méthode de déploiement : des tâches planifiées par stratégie de groupe, PsExec, WMI ou un outil de gestion à distance poussant le chiffreur sur le réseau indiquent tous un compte d’administrateur de domaine compromis.
6. Vérifiez que les sauvegardes sont intactes et hors ligne avant de vous y fier. Les attaquants visent d’abord les consoles de sauvegarde et suppriment les dépôts.

Import-Csv E:\out\mft.csv |
  Where-Object { $_.Extension -eq '.lockbit' } |
  Sort-Object { [datetime]$_.Created0x10 } |
  Select-Object -First 20 ParentPath, FileName, Created0x10, LastModified0x10

14Construire la chronologie

La chronologie est le principal produit du triage. Elle transforme des centaines d’observations en un récit : accès initial, exécution, persistance, élévation de privilèges, déplacement latéral, collecte, exfiltration et impact. Gardez-la en UTC, citez l’artefact de chaque entrée et séparez ce qui est confirmé de ce qui est déduit.

log2timeline.py --storage-file host01.plaso E:\IR-2026-031\HOST01\tout\HOST01.vhdx
psort.py -o dynamic -w host01-timeline.csv host01.plaso "date > '2026-10-20 00:00:00' AND date < '2026-10-28 00:00:00'"

Pour aller vite, chargez côte à côte dans Timeline Explorer les CSV d’EvtxECmd, MFTECmd, PECmd, AmcacheParser et Hayabusa, filtrez sur la fenêtre de l’incident et copiez les lignes utiles dans un tableau simple avec l’heure, l’hôte, le compte, l’activité, l’artefact source et le niveau de confiance. C’est ce tableau que vous remettrez à la direction, au service juridique, aux assureurs et aux autorités.

15Confinement, éradication et transmission

Contenez en une seule action coordonnée une fois l’étendue comprise. Un confinement partiel, comme changer un mot de passe alors que l’attaquant garde une porte dérobée ailleurs, lui apprend surtout à mieux se cacher.

1. Isolez chaque hôte confirmé via l’EDR ou le réseau, en le gardant allumé jusqu’à la fin de la collecte.
2. Bloquez les indicateurs au périmètre, au proxy, au DNS et dans l’EDR : domaines et adresses de commande et contrôle, empreintes de fichiers et certificats malveillants.
3. Désactivez les comptes compromis et réinitialisez leurs mots de passe deux fois. Si un administrateur ou un contrôleur de domaine a été compromis, prévoyez une réinitialisation de krbtgt (deux fois, avec réplication complète entre les deux) et réinitialisez tous les identifiants à privilèges et de service.
4. Supprimez la persistance trouvée sur chaque hôte, en recherchant les indicateurs sur tout le parc pour trouver les hôtes non examinés.
5. Reconstruisez les machines compromises à partir d’images saines plutôt que de les nettoyer. Le nettoyage manque ce que vous n’avez pas trouvé.
6. Corrigez ou fermez la voie d’accès initial : le VPN vulnérable, le RDP exposé, le compte victime de phishing sans MFA.
7. Surveillez de près pendant au moins 30 jours les mêmes indicateurs, comptes et techniques.

Transmettez un rapport court : résumé pour la direction, étendue (hôtes, comptes, données), chronologie, cause première, indicateurs de compromission, actions menées et recommandations. Conservez les preuves et leur liste d’empreintes selon votre politique ; les régulateurs, assureurs et forces de l’ordre peuvent les demander des mois plus tard.

16Liste de contrôle rapide

1. Ouvrez un journal de dossier en UTC ; notez qui, quoi et quand pour chaque action.
2. Notez l’identité de l’hôte, le fuseau horaire, le décalage d’horloge, la durée de fonctionnement et les utilisateurs connectés.
3. Décidez du confinement ; préférez l’isolation EDR à l’arrêt.
4. Capturez la mémoire et calculez son empreinte.
5. Notez les processus avec lignes de commande et parents, les connexions réseau, le cache DNS, les sessions SMB et les administrateurs locaux.
6. Lancez Autoruns et examinez les tâches planifiées, les services, les abonnements WMI, les clés Run et les exclusions Defender.
7. Exportez tous les journaux d’événements et exécutez Hayabusa ou Chainsaw dessus.
8. Collectez une image de triage avec KAPE ou Velociraptor et analysez-la avec les outils d’Eric Zimmerman.
9. Examinez les artefacts d’exécution : prefetch, Amcache, ShimCache, BAM, SRUM, historique PowerShell.
10. Examinez la MFT et le journal USN pour les dépôts d’outils, la préparation et les suppressions.
11. Tracez le déplacement latéral dans les deux sens et supposez que les identifiants en cache sont volés.
12. Construisez la chronologie, recherchez les indicateurs sur le parc, puis contenez en une seule action coordonnée.

17Conclusion

Un bon triage Windows suit un ordre fixe : noter le contexte, capturer les preuves volatiles, vérifier la persistance et les journaux d’événements, collecter une image de triage, puis contenir. Cet ordre garde les preuves exploitables et répond aux questions importantes : comment l’attaquant est entré, ce qu’il a touché et s’il est encore là. Entraînez-vous sur un hôte de test pour que la trousse et les étapes vous soient familières avant un vrai incident.