← Tous les articles

Détecter l'injection de code dans la mémoire Windows : malfind, hollowing et hooks

8 min de lecture

Le code injecté a une faiblesse structurelle : il faut bien qu'il réside quelque part. Le loader ne l'a jamais mappé depuis un fichier, donc la comptabilité que le noyau tient pour le processus (arbre des VAD, listes du loader, points d'entrée des threads) contredit ce que le processus montre en mode utilisateur. Chaque technique ci-dessous exploite l'une de ces contradictions.

Cet article passe en revue les contrôles d'injection et d'altération de processus que ramparser applique à une image Windows avec symboles noyau, en reprenant les noms de plugins Volatility de The Art of Memory Forensics : ce que fait l'attaquant, quelle structure le trahit, à quoi ressemble un résultat, et d'où viennent les faux positifs.

malfind : la mémoire privée exécutable

Chaque plage réservée de l'espace d'adressage d'un processus est décrite par un nœud VAD (_MMVAD). Il enregistre la protection donnée à l'allocation et indique si un fichier (DLL, EXE, section mappée) sous-tend la plage. Le code légitime vient de mappings d'images. Le shellcode et les DLL chargées de façon réflexive viennent de VirtualAlloc : ils résident en mémoire privée.

Le malfind de ramparser parcourt l'arbre des VAD de chaque processus et retient une région quand :

  • elle est privée et sans fichier derrière, et
  • sa protection est exécutable et inscriptible (EXECUTE_READWRITE, EXECUTE_WRITECOPY), ou elle est exécutable seule mais l'une de ses pages est marquée « dirty » dans la table des pages, signe que du code y a été écrit après l'allocation ;
  • et au moins une page est non nulle. Les régions réservées ou entièrement paginées sont écartées.

Chaque résultat indique la plage, la protection et un drapeau mz levé quand la région commence par MZ. La liste des constats classe une région MZ en sévérité haute (« PE injection ») et une région sans MZ en moyenne (« suspicious RWX »). Un en-tête MZ en mémoire privée, c'est un PE mappé à la main ; sans en-tête, c'est en général du shellcode ou un PE dont l'en-tête a été effacé.

Faux positifs : .NET, les navigateurs et tout ce qui embarque un compilateur JIT allouent couramment de la mémoire privée RWX. Un résultat malfind dans chrome.exe ne dit pas grand-chose seul ; le même dans svchost.exe avec un en-tête MZ en dit beaucoup.

Processus évidés (hollowing)

Le process hollowing lance un exécutable légitime suspendu, démappe son image, écrit une charge utile à sa place puis relance le thread. Le processus garde son nom, son chemin et son parent. hollowprocesses vérifie trois choses que la substitution casse en général :

  1. PEB.ImageBaseAddress (modifiable depuis le mode utilisateur) diffère de _EPROCESS.SectionBaseAddress (enregistré par le noyau au mappage de l'image).
  2. Aucun VAD ne commence à la base de l'exécutable : l'image d'origine a été démappée.
  3. Le VAD à la base de l'exécutable n'a pas la protection EXECUTE_WRITECOPY d'un mappage d'image normal.

Chaque symptôme donne une ligne distincte (PEB-mismatch, exe-vad-missing, exe-protection) pour voir lesquels concordent.

Process ghosting

Le ghosting crée la section d'image à partir d'un fichier déjà marqué pour suppression : le fichier a disparu avant même que le processus démarre. processghosting signale les processus vivants dont _EPROCESS.ImageFilePointer est nul, ou pointe vers un _FILE_OBJECT dont DeletePending est positionné. System, Idle et les processus minimaux sans PEB (Registry, MemCompression) sont ignorés : ils n'ont jamais eu de fichier image. Une limite : le bit DeletePending est lu à un offset fixe de Windows 10 x64, pas depuis le PDB.

Des threads qui démarrent au mauvais endroit

L'injection a besoin d'un thread pour exécuter la charge (CreateRemoteThread, NtCreateThreadEx, file d'APC). suspicious_threads parcourt la liste des threads de chaque processus et situe chaque _ETHREAD.Win32StartAddress en mode utilisateur dans l'arbre des VAD. Un thread qui démarre dans un VAD sans fichier est signalé avec le motif « start in non-file-backed region ». Le nom du fichier mappé est résolu, si bien que les sections adossées au fichier d'échange comptent comme sans fichier. Les adresses hors de tout VAD sont ignorées (lectures corrompues). La vue des constats regroupe les résultats par processus en sévérité moyenne. La réserve JIT de malfind s'applique aussi.

ldrmodules : DLL déliées du PEB

Le loader suit chaque DLL dans trois listes de _PEB_LDR_DATA : InLoadOrder, InMemoryOrder et InInitializationOrder. Les outils qui passent par l'API Windows (Toolhelp, EnumProcessModules) lisent ces listes : un malware masque donc une DLL en la déliant. Le mappage, lui, reste dans l'arbre des VAD.

Pour chaque processus, ramparser fait l'union des trois listes et des VAD d'image qui commencent par un en-tête MZ, puis signale toute base absente d'au moins une source, avec les drapeaux in_load / in_mem / in_init / in_vad. Une DLL mappée dans les VAD mais absente des trois listes, c'est le cas d'école. Le panneau de détail du processus les liste sous « ldrmodules unlinked », et chacune constitue un constat de sévérité haute.

Quelques écarts bénins sont normaux : l'exécutable principal ne figure jamais dans la liste d'ordre d'initialisation.

impscan : ce que le code injecté appelle

Une charge mappée à la main n'a pas de table d'imports remplie par le loader : son propre stub a résolu les adresses d'API. impscan reconstruit ces imports pour chaque région signalée par malfind. Il indexe tous les exports des DLL mappées dans le processus (adresse vers dll!fonction), puis :

  • lit la région comme une table de pointeurs alignés (8 octets, et 4 octets pour WOW64) et garde chaque valeur qui est une adresse d'export ;
  • décode les call/jmp via [rip+disp32] (x64) ou [abs32] (WOW64) et suit l'emplacement référencé.

La vue des constats traduit ces imports en capacités. Par exemple, VirtualAllocEx + WriteProcessMemory + CreateRemoteThread devient « peut injecter dans d'autres processus » ; SetWindowsHookEx ou GetAsyncKeyState devient « peut enregistrer les frappes ». Un bloc RWX anonyme devient ainsi une affirmation sur ce qu'il fait.

Hooks et évasion d'EDR dans ntdll

PluginCe qu'il examineUn résultat signifie
apihooksL'IAT de chaque module, comparée à l'image de la DLL importéeUn import pointe hors de la DLL qu'il désigne (exports redirigés exclus)
iatpatchLa même chose, limitée aux imports de ntdll.dllUne entrée modifiée sur le chemin vers le noyau
unhooked_system_callsLes 0x20 premiers octets d'un ensemble fixe de stubs Nt* dans le ntdll de chaque processusLe stub de ce processus diffère de la majorité
direct_system_callsLes paires d'octets 0F 05 (syscall) dans les modules chargés autres que ntdll / win32uUn module qui fait ses propres appels système
etwpatchLe prologue de EtwEventWrite, EtwEventWriteEx, EtwEventWriteFull, EtwNotificationRegisterret, xor eax,eax; ret, mov eax,0; ret ou un jmp en entrée

unhooked_system_calls n'a besoin d'aucune image de référence. Quand un EDR hooke ntdll dans tous les processus, le stub hooké est majoritaire. Un processus qui a restauré les octets d'origine, ou posé son propre hook, est minoritaire, et ses octets divergents sont affichés pour examen.

Deux limites. direct_system_calls compte des paires d'octets brutes sur les 4 premiers Mo de chaque module de la liste du loader, données comprises : un faible total demande un désassemblage à l'adresse indiquée avant de signifier quoi que ce soit. etwpatch ne reconnaît que les signatures de patch connues ci-dessus ; un patch inédit avec une autre première instruction n'est pas signalé.

YARA dans la mémoire des processus

vadyarascan parcourt les régions VAD de chaque processus (jusqu'à 4 Mo par région) avec un petit catalogue intégré de chaînes caractéristiques (Cobalt Strike, Metasploit, Mimikatz, Quasar, AsyncRAT, Remcos, Conti, LockBit) et attribue chaque résultat au processus. C'est de la recherche de chaînes, pas du YARA complet, et une simple correspondance sur le nom d'une famille est classée faible car elle touche aussi du texte sans rapport.

Pour de vraies règles, la vue YARA exécute les vôtres (YARA-X, dans le navigateur) sur la mémoire physique et sur les régions VAD de chaque processus, avec une taille maximale par région et des résultats attribués au processus propriétaire. Par défaut, seules les régions sans fichier sont scannées, là où vit le code injecté ; les images et fichiers mappés peuvent être inclus.

Lire les résultats ensemble

Aucun contrôle ici n'est un verdict. Les cas solides sont ceux où des structures indépendantes concordent : une région MZ signalée par malfind, un thread qui y démarre, des imports reconstruits qui décrivent une injection et une détection YARA sur la même plage. Un processus, quatre structures, une seule histoire. Pour chaque PID suspect, pivotez vers sa ligne de commande, ses handles et ses connexions réseau avant de conclure.

Pour aller plus loin