← Tous les articles

Malware Linux en espace utilisateur : injection, hooks GOT et bash en mémoire

8 min de lecture

La plupart des intrusions Linux ne touchent jamais au noyau. Un cryptomineur déposé dans /tmp, une bibliothèque préchargée dans sshd pour voler des mots de passe, un reverse shell qui vit dans un processus bash : tout se passe en espace utilisateur, et tout laisse en RAM des structures que la forensique disque ne voit plus dès que l'attaquant a effacé ses fichiers.

Cet article passe en revue les contrôles par processus que ramparser applique à une image Linux, avec les noms de techniques de The Art of Memory Forensics (chapitres 21, 25 et 26) et les plugins Volatility linux_* correspondants. Tout ce qui suit repose sur le parcours structuré des tâches, qui exige l'ISF du noyau : task_struct, mm_struct, VMA, descripteurs de fichiers et sockets sont lus avec des offsets exacts issus des symboles.

Des bibliothèques chargées au mauvais endroit

Ce que fait l'attaquant. L'injection de bibliothèque partagée (ptrace puis dlopen, ou LD_PRELOAD) place du code malveillant dans un processus légitime. La bibliothèque doit bien venir de quelque part d'inscriptible, et elle est souvent supprimée juste après le chargement.

Ce qui la trahit. Chaque mapping adossé à un fichier dans la liste des VMA du processus porte son chemin. ramparser collecte chaque .so mappé et signale une bibliothèque dont le chemin se trouve dans un espace temporaire accessible à tous (/tmp, /var/tmp, /dev/shm, /run/user/<uid>), dans un dossier caché, qui se termine par (deleted), ou qui est un objet memfd: n'existant qu'en mémoire.

Une variable LD_PRELOAD= dans l'environnement d'un processus est signalée à part. Deux contrôles à l'échelle du système visent les rootkits par préchargement (Azazel, Jynx, libprocesshider) :

  • /etc/ld.so.preload présent et non vide dans le page cache. Un système standard n'a pas ce fichier ; le constat indique sa taille et sa date de modification.
  • La même bibliothèque, hors des arborescences système, mappée dans au moins trois processus et 20 % de l'ensemble des processus utilisateur. /usr/local compte comme hors système : aucun paquet ne s'y installe, et c'est un point de dépôt apprécié.

Faux positifs. Les postes de développement chargent des bibliothèques depuis des dossiers de build ; les applications autonomes sous /opt ou /snap sont traitées comme système et ne déclenchent rien.

Process hollowing : le programme n'est pas mappé

Tout processus mappe l'exécutable à partir duquel il a été lancé. Si mm_struct.exe_file désigne /usr/sbin/apache2 mais qu'aucune VMA n'est adossée à ce fichier, l'image d'origine a été démappée puis remplacée. ramparser le signale quand le processus a des mappings de fichiers mais qu'aucun ne correspond à son propre exécutable. Un binaire (deleted) toujours mappé n'est pas considéré comme du hollowing : il est signalé comme s'exécutant depuis un fichier supprimé, ce qui constitue un constat distinct.

Mémoire exécutable anonyme (linux_malfind)

Du code injecté ou décompressé à l'exécution réside en mémoire sans fichier derrière lui. ramparser marque chaque VMA exécutable, sans fichier associé et qui n'est pas le vDSO. Ces régions apparaissent dans la carte mémoire du processus avec l'anomalie exec-private et alourdissent son score de suspicion.

Seul, ce signal est faible : JVM, Node.js et navigateurs créent de telles régions en permanence. Sa valeur vient de sa combinaison avec les deux contrôles suivants.

Des threads qui exécutent de la mémoire anonyme (linux_info_regs)

Quand un thread entre dans le noyau, ses registres utilisateur sont sauvegardés dans une trame pt_regs au sommet de sa pile noyau. ramparser localise cette trame pour chaque thread utilisateur (en essayant les piles de 16 Kio et de 8 Kio, et en gardant le candidat dont les sélecteurs de segment sauvegardés sont en mode utilisateur), puis relève le pointeur d'instruction, le pointeur de pile, l'appel système en cours (via orig_ax, nommé grâce à sys_call_table) et le mode compat 32 bits éventuel.

La règle est simple : si le pointeur d'instruction sauvegardé d'un thread tombe dans une région exécutable anonyme, ce code tournait au moment de la capture. Un constat ressemble à tid 801 at 0x7f00000008db (running). Les mineurs qui compilent en JIT leur boucle de hachage le déclenchent aussi, ce qui reste utile à savoir.

Écrasement de la GOT/PLT (linux_plthook)

Un programme lié dynamiquement appelle les fonctions de bibliothèque à travers sa Global Offset Table. Écraser une entrée redirige chaque appel à readdir, write ou accept sans modifier une seule page de code.

Pour chaque objet ELF x86-64 mappé dans un processus, ramparser lit l'en-tête ELF, suit PT_DYNAMIC jusqu'aux relocations DT_JMPREL, lit chaque entrée R_X86_64_JUMP_SLOT et résout le nom du symbole depuis .dynsym. La cible de chaque entrée est ensuite classée :

RaisonSignification
anonymouspointe vers de la mémoire exécutable sans fichier : code injecté
non-executablepointe vers le tas, la pile ou un mapping sans droit d'exécution
unmappedne pointe vers aucun mapping
foreign libraryl'import d'un objet système aboutit dans une bibliothèque hors des dossiers système : interposition par préchargement

Les entrées non encore résolues (liaison paresseuse) pointent vers la PLT de l'objet lui-même et passent. Celles liées au vDSO (gettimeofday, clock_gettime) passent aussi. Les pages non résidentes sont ignorées au lieu d'être lues comme des zéros : une GOT paginée ne devient jamais un faux hook vers l'adresse 0. Un hook vers de la mémoire anonyme est classé critique, par exemple auth_password in sshd → [anon] (anonymous).

Hooks inline dans le code des bibliothèques (linux_apihooks)

Le hook peut aussi être écrit dans la fonction elle-même : les premiers octets de readdir dans la libc sont remplacés par un saut, et chaque appelant atterrit dans le code de l'attaquant, quoi que dise sa GOT. Pour chaque objet ELF mappé, ramparser décode la première instruction de chaque fonction exportée (STT_FUNC dans .dynsym) avec le même décodeur de trampolines que le contrôle noyau : jmp rel32, jmp [rip], push/ret et movabs + jmp/push-ret, après un éventuel endbr64. La destination est classée selon les quatre raisons ci-dessus. Seules les pages résidentes sont lues ; une page patchée est une copie privée, donc résidente sauf si elle a été swappée.

Bibliothèques inconnues du chargeur (linux_ldrmodules)

Le chargeur dynamique inscrit chaque bibliothèque qu'il charge, dlopen compris, dans sa liste link_map, accessible depuis l'entrée DT_DEBUG de l'exécutable. ramparser parcourt cette liste et la rapproche des objets ELF mappés par adresse de chargement, car les noms de la link_map sont souvent des liens symboliques. Une bibliothèque dont le code est mappé mais absente de la liste a été mappée à la main, ou retirée de la liste pour se cacher. Les binaires statiques n'ont pas de liste, et le contrôle est sauté quand elle n'est pas résidente.

Sockets raw et packet (linux_list_raw)

Sniffers, backdoors à port-knocking et canaux cachés ont besoin de voir le trafic sous TCP et UDP. ramparser signale tout processus qui détient un socket AF_PACKET ou un socket inet/inet6 de type raw. Les démons qui le font légitimement (clients DHCP, systemd-networkd, NetworkManager, ping, lldpd, chronyd, etc.) sont en liste blanche, et les sockets netlink sont ignorés.

Données en attente sur les sockets (linux_pkt_queues)

Pour chaque socket, ramparser parcourt les anneaux sk_receive_queue et sk_write_queue de sk_buff et relève le nombre de paquets et d'octets en attente, ainsi que les premiers octets du premier tampon. Dans la vue réseau, une ligne TCP ou UDP affiche alors par exemple 412 B unread, avec un aperçu au survol. Des octets non lus sur un socket de C2 peuvent être la prochaine commande ; des octets non envoyés peuvent être des données exfiltrées qui n'ont jamais atteint le réseau.

bash : table de hachage et historique (linux_bash_hash, linux_bash)

Pour chaque processus dont l'exécutable est bash, ramparser cherche deux structures dans les mappings [heap].

La table de hachage des commandes. bash retient le fichier vers lequel chaque commande tapée a été résolue (hash -l). ramparser cherche une HASH_TABLE de 64 compartiments dont le nombre d'entrées correspond à ses chaînes, puis lit chaque commande, son chemin résolu et son nombre d'utilisations. Une commande résolue dans /tmp, /dev/shm, un dossier caché ou un fichier supprimé signale le shell, même si l'historique a été effacé : nc → /tmp/.x/nc (3×).

La liste d'historique. bash horodate chaque entrée avec une chaîne #<epoch>. ramparser retrouve ces chaînes sur le tas, puis les structures HIST_ENTRY qui les référencent, et lit la ligne de commande voisine. Les lignes chargées depuis ~/.bash_history au démarrage partagent toutes l'heure de chargement ; quand au moins cinq entrées d'un même shell portent le même horodatage, elles sont marquées comme chargées depuis le fichier et privées d'heure d'exécution, pour ne pas polluer la chronologie. Les commandes récupérées alimentent la même liste que les enregistrements d'audit, où les téléchargements vers /tmp et motifs similaires sont étiquetés.

Lire le résultat

Ces règles produisent une seule liste de suspects classés, pas une pile de tableaux. Chaque raison a un poids et sa preuve. D'autres règles contribuent au même score : un shell dont l'entrée/sortie standard est un socket, un shell lancé par un serveur web, un processus utilisateur nommé comme un thread noyau, un répertoire de travail dans un dossier caché. Un processus qui charge une bibliothèque depuis /dev/shm, dont un thread exécute du code anonyme et dont la GOT est détournée raconte une histoire cohérente. Une région JIT dans un processus Java, non.

Pour aller plus loin