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 :
PEB.ImageBaseAddress(modifiable depuis le mode utilisateur) diffère de_EPROCESS.SectionBaseAddress(enregistré par le noyau au mappage de l'image).- Aucun VAD ne commence à la base de l'exécutable : l'image d'origine a été démappée.
- Le VAD à la base de l'exécutable n'a pas la protection
EXECUTE_WRITECOPYd'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/jmpvia[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
| Plugin | Ce qu'il examine | Un résultat signifie |
|---|---|---|
apihooks | L'IAT de chaque module, comparée à l'image de la DLL importée | Un import pointe hors de la DLL qu'il désigne (exports redirigés exclus) |
iatpatch | La même chose, limitée aux imports de ntdll.dll | Une entrée modifiée sur le chemin vers le noyau |
unhooked_system_calls | Les 0x20 premiers octets d'un ensemble fixe de stubs Nt* dans le ntdll de chaque processus | Le stub de ce processus diffère de la majorité |
direct_system_calls | Les paires d'octets 0F 05 (syscall) dans les modules chargés autres que ntdll / win32u | Un module qui fait ses propres appels système |
etwpatch | Le prologue de EtwEventWrite, EtwEventWriteEx, EtwEventWriteFull, EtwNotificationRegister | ret, 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.