← Tous les articles

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 :

  • modules parcourt PsLoadedModuleList ;
  • modscan scanne le pool à la recherche de MmLd (_LDR_DATA_TABLE_ENTRY) ;
  • driverscan scanne le pool à la recherche de _DRIVER_OBJECT ;
  • drivermodule signale un objet pilote dont DriverStart n'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ôleSourceStatut en cas de résultat
Table des appels système intactessdtcritique
Gestionnaires non patchésinline_hookscritique
Tables d'interruption intactesidtcritique
Callbacks dans des pilotes chargéscallbackscritique
Timers exécutant du code connutimer_tablecritique
Threads système dans des pilotes chargésorphan_threadscritique
Minifiltres exécutant leur propre codeminifilterscritique
Gestionnaires IRP non détournésdriverirpsuspect
Aucun pilote cachémodules vs modscansuspect
Aucun processus cachépsxviewcritique
Chaque thread appartient à un processus listéthrdscansuspect
Pilotes récemment déchargésunloadedmodulesinfo

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.

Pour aller plus loin