Détecter les rootkits noyau Windows en mémoire : SSDT, IRP, callbacks et pilotes cachés
8 min de lecture
Un rootkit noyau a le même problème que du code injecté en mode utilisateur, un étage plus bas. Son code doit s'exécuter, donc quelque chose doit pointer dessus : une entrée de la table des appels système, un vecteur d'interruption, la table de dispatch d'un pilote, un callback de notification, un timer, un thread. Et il doit se cacher, c'est-à-dire se retirer de listes que le noyau tient mais que rien d'autre ne vérifie.
La forensique mémoire attrape les deux moitiés : résoudre chaque pointeur de code contre les modules chargés, et comparer chaque liste qu'un rootkit modifie à un scan qui l'ignore. Cet article montre comment ramparser fait les deux sur une image Windows avec symboles noyau, en reprenant les noms de plugins Volatility de The Art of Memory Forensics.
Le test central : à qui appartient cette adresse ?
Presque tous les contrôles ci-dessous se ramènent à une opération.
Prendre un pointeur de code dans une structure noyau, trouver le
module de PsLoadedModuleList dont l'image le contient, et se
demander si ce module devrait le posséder. Deux issues sont
intéressantes :
- le pointeur tombe dans le mauvais module (un gestionnaire d'appel système dans un pilote tiers) ;
- le pointeur ne tombe dans aucun module : du code en mémoire pool que le loader n'a jamais enregistré. C'est le signe le plus fort.
SSDT : la table des appels système
nt!KiServiceTable associe chaque numéro d'appel système à son
gestionnaire. En x64, chaque entrée est un décalage signé sur
32 bits, et le gestionnaire vaut KiServiceTable + (entrée >> 4).
ssdt décode chaque entrée (dans la limite de KiServiceLimit) et
attribue chaque routine à son module. Un rootkit qui détourne
NtQueryDirectoryFile pour cacher des fichiers apparaît comme une
entrée hors de ntoskrnl.exe.
PatchGuard rend ce cas rare sur un Windows x64 moderne, et c'est précisément pour cela qu'un résultat pèse lourd.
Hooks inline sur les gestionnaires d'appels système
Un rootkit peut laisser la table intacte et patcher le code vers
lequel elle pointe. inline_hooks lit les premières instructions de
chaque gestionnaire de la SSDT et décode un transfert de contrôle en
entrée : jmp rel32, jmp [rip+x], mov rax, imm; jmp rax ou
push; ret. Les sauts qui restent dans ntoskrnl ou hal sont des
thunks ordinaires et sont écartés. Seuls les sauts hors du noyau sont
signalés, avec la cible et son module. Le périmètre se limite aux
gestionnaires d'appels système, pas à toutes les fonctions exportées
du noyau.
IDT : les gestionnaires d'interruption
idt parcourt chaque CPU : KiProcessorBlock donne chaque _KPRCB,
d'où l'on retrouve le _KPCR et son IdtBase, puis les 256 entrées
_KIDTENTRY64 sont décodées. Chaque gestionnaire doit résider dans
ntoskrnl ou hal. Un gestionnaire hors de ces modules intercepte
exceptions ou interruptions sur ce CPU. Chaque ligne porte le numéro
de CPU : un hook posé sur une partie seulement des processeurs reste
visible.
Tables IRP des pilotes
Chaque _DRIVER_OBJECT possède une table MajorFunction[] de
28 entrées : les gestionnaires de IRP_MJ_CREATE, READ, WRITE,
DEVICE_CONTROL, etc. Hooker la table d'un autre pilote (disque,
système de fichiers, pile réseau) permet à un rootkit de filtrer ce
que le reste du système voit.
driverirp prend chaque objet pilote trouvé par driverscan (un scan
pool, donc pilotes déliés compris), lit la table et marque une entrée
comme hookée quand le gestionnaire est hors de l'image du pilote. Cette
règle brute est bruyante : beaucoup de pilotes délèguent légitimement
des IRP au noyau (IopInvalidDeviceRequest) ou à des frameworks
Microsoft comme wdf01000.sys, ndis.sys ou classpnp.sys. La
checklist d'intégrité les filtre et classe le reste en suspect,
pas en critique. Une limite : l'offset de la table dans
_DRIVER_OBJECT est la valeur fixe de Windows 10/11 x64.
Callbacks noyau
Les pilotes s'abonnent aux événements de processus, de threads et de
chargement d'images via PsSetCreateProcessNotifyRoutine[Ex],
PsSetCreateThreadNotifyRoutine et PsSetLoadImageNotifyRoutine. Le
noyau les range dans des tableaux de 64 EX_CALLBACK_FAST_REF, où
l'adresse de la routine est le pointeur dont on efface les 4 bits de
poids faible. Les rootkits s'y inscrivent parce qu'ils doivent savoir
quand un processus démarre pour s'y injecter ou le cacher. Les EDR
aussi.
callbacks parcourt les quatre tableaux Psp*NotifyRoutine et les
deux listes de callbacks de bugcheck (KeBugCheckCallbackListHead,
KeBugCheckReasonCallbackListHead), et attribue chaque routine à un
module. Un callback hors de tout module chargé est critique dans
la checklist. Les callbacks registre (CmRegisterCallback) et objet
(ObRegisterCallbacks) ne sont pas encore parcourus.
Timers et DPC
Un timer noyau peut exécuter périodiquement une routine DPC sans aucun
thread : une façon discrète de garder un pied dans le système.
timer_table parcourt le _KPRCB.TimerTable de chaque CPU, collecte
chaque _KTIMER en file et décode son pointeur de DPC. Depuis
Windows 7 x64, ce pointeur est obfusqué avec KiWaitNever et
KiWaitAlways, et ramparser vérifie que la valeur décodée tombe sur un
vrai _KDPC avant de s'y fier. Chaque timer est livré avec sa routine,
son module et sa période. Une routine hors de tout module est
critique. Quand aucun timer ne se décode sur un build donné, le
contrôle le dit au lieu d'afficher « propre ».
Threads système orphelins
Chaque thread du processus System démarre sur une routine passée à
PsCreateSystemThread, dans ntoskrnl, hal ou un pilote. Un rootkit
qui copie son code en pool puis délie ou décharge son pilote laisse
des threads dont l'adresse de départ n'appartient à aucun module.
orphan_threads vérifie StartAddress et Win32StartAddress, et
relève les 16 premiers octets à l'adresse de départ : un prologue de
fonction signale du code vivant, des zéros une mémoire libérée. Les
threads terminés sont listés mais pas jugés, leur mémoire ayant pu
être réutilisée. Un pilote déchargé sans arrêter son thread produit la
même forme : lisez ces résultats à côté de la liste des pilotes
déchargés.
Minifiltres du système de fichiers
Les minifiltres voient chaque opération sur les fichiers : c'est
pourquoi antivirus et logiciels de sauvegarde en enregistrent, et les
rootkits qui cachent des fichiers aussi. Avec les symboles du PDB
propre à fltmgr.sys, minifilters parcourt FltGlobals.FrameList
jusqu'à chaque _FLT_FILTER enregistré et indique son nom, son
altitude, les opérations interceptées et tout callback situé hors du
pilote du filtre. Sans les symboles du Filter Manager, le contrôle
indique qu'ils sont indisponibles.
Pilotes cachés, déliés et déchargés
Cacher un pilote revient en général à délier son entrée de
PsLoadedModuleList, comme le DKOM le fait pour les processus. Les
allocations restent dans le pool, donc la vue croisée fonctionne de la
même manière :
modulesparcourtPsLoadedModuleList;modscanscanne le pool à la recherche deMmLd(_LDR_DATA_TABLE_ENTRY) ;driverscanscanne le pool à la recherche de_DRIVER_OBJECT;drivermodulesignale un objet pilote dontDriverStartn'appartient à aucun module listé.
Un module trouvé par modscan mais pas par modules est signalé comme
caché, sauf les copies de la pile de crash dump (dump_*.sys) et les
transports du débogueur, légitimement absents de la liste, ainsi que
les pilotes de la liste des déchargés, dont les entrées traînent en
pool libéré.
unloadedmodules lit l'anneau MmUnloadedDrivers (nom, plage, date de
déchargement). Il est affiché à titre d'information, pas comme un
constat : la plupart des entrées sont normales, mais c'est là qu'un
cycle charger-utiliser-décharger d'un pilote vulnérable laisse une
trace. devicetree parcourt les périphériques de chaque pilote et
leurs piles d'attachement, où un pilote filtre apparaît comme un
niveau supplémentaire au-dessus d'un périphérique de base. La
checklist signale aussi les pilotes chargés hors des dossiers Windows,
et monte d'un cran quand un tel pilote n'a pas de signature intégrée.
La checklist d'intégrité
ramparser rassemble ces contrôles en une seule liste, avec un statut et les preuves derrière chacun :
| Contrôle | Source | Statut en cas de résultat |
|---|---|---|
| Table des appels système intacte | ssdt | critique |
| Gestionnaires non patchés | inline_hooks | critique |
| Tables d'interruption intactes | idt | critique |
| Callbacks dans des pilotes chargés | callbacks | critique |
| Timers exécutant du code connu | timer_table | critique |
| Threads système dans des pilotes chargés | orphan_threads | critique |
| Minifiltres exécutant leur propre code | minifilters | critique |
| Gestionnaires IRP non détournés | driverirp | suspect |
| Aucun pilote caché | modules vs modscan | suspect |
| Aucun processus caché | psxview | critique |
| Chaque thread appartient à un processus listé | thrdscan | suspect |
| Pilotes récemment déchargés | unloadedmodules | info |
psxview a sa place ici parce que cacher un processus par DKOM est une
technique noyau : il compare la liste des processus actifs, la
PspCidTable et le scan pool, et signale un processus absent de la
liste active mais vu par une autre source. thrdscan applique la même
idée aux threads : des objets _ETHREAD trouvés dans le pool dont le
processus n'est pas dans la liste active. Les threads des processus
terminés subsistent et sont affichés pour contexte. Un thread encore
prêt ou en cours d'exécution est signalé à examiner plutôt qu'en
critique, car un processus qui se termine pendant une acquisition à
chaud laisse la même trace ; l'outil d'acquisition lui-même est
étiqueté comme tel.
Lire les résultats
Une checklist propre signifie que ces pointeurs et ces listes sont cohérents, pas que le noyau est sain. Une ligne critique est un point de départ : vérifiez si le même code apparaît ailleurs (un callback et un thread orphelin dans la même plage de pool forment une combinaison solide), puis cherchez comment il est arrivé là dans les services, l'anneau des pilotes déchargés et la timeline.