← Tous les articles

Détection de rootkits Linux en mémoire : vues croisées et contrôle des hooks

9 min de lecture

Un rootkit noyau Linux a deux missions : rester chargé sans apparaître dans les listes, et modifier ce que voit l'espace utilisateur. Les deux laissent des traces structurelles en mémoire. Le rootkit doit se délier de listes que le noyau référence encore ailleurs, et son code de filtrage doit être atteignable depuis un pointeur que le noyau suit. ramparser contrôle les deux, à partir du même instantané structuré que celui décrit dans forensique mémoire Linux.

Tous les contrôles de pointeurs appliquent une seule règle. Le code qu'appelle le noyau doit se trouver dans le texte du noyau (_stext à _etext, plus .init.text) ou dans la région principale d'un module présent dans la liste des modules. Un pointeur vers un module listé est attribué à ce module. Un pointeur qui ne mène ni à l'un ni à l'autre est signalé « no known code » : c'est le signal le plus fort de cet article.

Ces contrôles exigent l'ISF (fichier de symboles) du noyau. Chacun ne s'exécute que si les symboles dont il a besoin sont présents, et la vue d'intégrité indique quels contrôles ont réellement tourné.

Processus cachés

Attaquant : délier une task_struct de la liste des tâches pour que ps, top et /proc ne la parcourent jamais (DKOM).

Structure : chaque tâche possède toujours un struct pid enregistré dans l'allocateur de PID, init_pid_ns.idr (un xarray sur les noyaux récents, un radix tree sur les plus anciens). C'est la forme moderne de la vue croisée linux_pidhashtable du livre.

Contrôle : ramparser parcourt la table des PID, remonte de chaque pid.tasks[PIDTYPE_PID] à sa task_struct, et la compare à toutes les tâches atteintes depuis init_task.tasks, threads compris. Les tâches déjà marquées mortes sont ignorées, car une tâche qui se termine quitte la liste en premier.

Résultat : une ligne comme pid 4121 kworkerd (task 0xffff8881…), classée critique. Un processus présent dans la table des PID mais absent de la liste des tâches a été caché volontairement.

Faux positifs : une tâche créée ou détruite pendant l'acquisition peut n'apparaître que dans une seule vue. Vérifiez son état et si le même PID ressort dans des sockets ou des fichiers ouverts.

Identifiants partagés

Chaque processus reçoit sa propre struct cred au fork ; seuls les threads d'un même processus partagent la leur. Un rootkit qui veut rendre un shell root sans appeler setuid fait simplement pointer task_struct.cred du shell vers les identifiants d'init ou d'un autre processus root. C'est ce que cherche linux_check_creds, et ramparser fait de même : deux processus dont le pointeur cred est identique sont signalés, en critique quand l'identité partagée est root. Le constat nomme les deux processus, par exemple Shares its credentials with systemd (1), avec l'adresse de la structure cred. Sur un système sain, aucun couple de processus n'en partage une.

Modules cachés

Attaquant : list_del du module hors de modules (ce que lit lsmod), et souvent kobject_del hors de sysfs. Diamorphine et de nombreux autres kits LKM font les deux.

Contrôle : trois vues sont comparées, dans la lignée de linux_check_modules et linux_hidden_modules :

  1. La liste modules.
  2. La liste sysfs module_kset, où chaque kobject pointe vers son module.
  3. Un carving de la zone des modules (à partir de 0xffffffffa0000000 sur x86-64). Chaque struct module contient son propre kobject sysfs, dont le champ mkobj.mod pointe vers le module lui-même. Une valeur v trouvée à l'adresse v + offsetof(module, mkobj.mod) signale un module en v, et ce pointeur retour survit au retrait des deux listes. Un candidat n'est retenu que si son nom est imprimable et son état valide.
Liste modulessysfsCarvingVerdict
ouiouiouinormal
nonoui—critique : retiré de lsmod
nonnonouicritique : uniquement en mémoire des modules
ouinon—suspect : retiré de sysfs seulement

Résultat : diamorphine at 0xffffffffc0833080 — only in module memory (carved).

Faux positifs : un module en cours de chargement ou de déchargement. L'instantané enregistre l'état de chaque module listé (coming, going).

La vue noyau télécharge l'image chargée de tout module de la liste (linux_moddump) : code et données tels qu'ils sont en mémoire noyau, pas le fichier .ko, avec des zéros à la place des pages absentes de la RAM. Les modules trouvés uniquement par le carving ne sont pas proposés au téléchargement.

Intégrité de la table des appels système

Attaquant : remplacer des entrées de sys_call_table (kill, getdents64, openat…) pour que chaque programme reçoive des réponses filtrées.

Contrôle : linux_check_syscall. sys_call_table, ia32_sys_call_table et x32_sys_call_table sont lues en entier. Leur longueur se déduit de la distance jusqu'au symbole suivant, car l'ISF ne l'enregistre pas. Chaque entrée est attribuée à son propriétaire.

Résultat : sys_call_table[62] → 0xffffffffc0a1b2c0 (module diamorphine). L'index 62 correspond à kill sur x86-64, que Diamorphine utilise comme canal de commande. Toute entrée hors du noyau est critique, et le module propriétaire reçoit le marqueur « owns syscall table entries » dans la liste des modules.

Table des descripteurs d'interruption

linux_check_idt : les 256 portes de idt_table sont décodées (champs d'offset bas, moyen et haut, selon la structure de porte décrite dans l'ISF) et chaque handler est attribué. Les stubs d'exception précoces qui résident dans .init.text comptent comme noyau. Un vecteur hors noyau est critique. La technique est rare sur les noyaux récents, mais le contrôle ne coûte rien.

Tables d'opérations fichiers, /proc et réseau

Les rootkits modernes touchent rarement la table des syscalls. Ils remplacent plutôt un pointeur de fonction dans une structure d'opérations : iterate_shared d'un répertoire pour cacher des fichiers, show d'une seq_operations pour cacher des connexions. C'est le terrain de linux_check_fop et de linux_check_afinfo.

ramparser résout le type de chaque symbole dans l'ISF, énumère ses membres de type pointeur de fonction et vérifie chaque pointeur non nul. Tables couvertes :

  • /proc : proc_root_operations, proc_root_inode_operations, proc_dir_operations, proc_fd_operations, proc_tid_base_operations, proc_pid_link_inode_operations
  • Listes de connexions : tcp4_seq_ops, tcp6_seq_ops, udp_seq_ops, udp6_seq_ops, raw_seq_ops
  • Terminaux : tty_fops, ptmx_fops
  • Systèmes de fichiers : ext4_file_operations, ext4_dir_operations, ext4_file_inode_operations, ext4_dir_inode_operations, xfs_file_operations, xfs_dir_file_operations, btrfs_file_operations

Un résultat se lit tcp4_seq_ops.show → 0x… (no known code).

Hooks inline

Un rootkit peut aussi laisser toutes les tables intactes et remplacer par un saut les premiers octets de la fonction vers laquelle pointe une table. C'est le terrain de linux_check_inline_kernel. ramparser décode la première instruction de chaque handler de sys_call_table et d'ia32_sys_call_table, et de chaque fonction des tables d'opérations ci-dessus, après un éventuel endbr64, à la recherche des trampolines qu'écrivent les rootkits : jmp rel32, jmp [rip], push imm32/ret, et movabs suivi d'un jmp ou d'un push/ret sur le même registre. Un saut qui reste dans l'image de la fonction, comme un appel terminal, passe. Un saut qui en sort est signalé : suspect vers un module, critique vers « no known code ». Le call vers __fentry__ qu'installe ftrace est laissé au contrôle ftrace ci-dessous. L'ancien balayage à la demande check_inline_hooks reste disponible ; il n'est pas ancré sur les prologues, ses occurrences sont donc des pistes à désassembler.

Frameworks de hooks

Certaines interfaces du noyau permettent d'enregistrer un callback sans rien patcher. Les rootkits les utilisent pour la même raison que les outils légitimes : elles sont stables. Chaque callback enregistré est listé avec son propriétaire.

  • ftrace : ftrace_ops_list. Le hook via ftrace est la technique standard des rootkits LKM actuels. Le contrôle rapporte chaque callback et son propriétaire, pas la liste des fonctions qu'il filtre.
  • kprobes : les 64 compartiments de kprobe_table, avec le symbole (ou l'adresse) sondé et le handler pre/post.
  • Notifieurs clavier (linux_keyboard_notifiers) : keyboard_notifier_list, qui reçoit chaque frappe. Tout callback hors du noyau est critique : c'est le point d'accroche des keyloggers noyau.
  • Saisie terminal (linux_check_tty) : chaque terminal transmet ce qui est tapé au receive_buf / receive_buf2 de sa discipline de ligne. Le contrôle parcourt tty_drivers et, comme les pseudo-terminaux devpts (sessions SSH) ne figurent dans aucune table de pilote, aussi les tty que les processus tiennent ouverts, atteints via file->private_data. Un handler hors de tout code connu est critique : c'est un keylogger de terminal, mots de passe compris. Un handler dans un module est à examiner, car les disciplines PPP, SLIP et UART Bluetooth vivent dans des modules.
  • Netfilter (linux_netfilter) : entrées de hooks IPv4 et IPv6 d'init_net sur les cinq points d'accroche, emplacement habituel des backdoors à paquet magique. Les hooks appartenant à des modules sont normaux (iptables, conntrack), donc seul « no known code » est critique.
  • LSM : toutes les listes de security_hook_heads. Les modules de sécurité actifs sont nommés (apparmor, yama…), et tout hook hors du noyau est critique, puisque les LSM intégrés résident dans le texte du noyau.
  • eBPF : programmes de prog_idr, avec id, type et nom. Les types de traçage (kprobe, tracepoint, tracing, perf_event, raw_tracepoint, lsm) sont classés suspects : c'est là que s'attachent les rootkits eBPF comme TripleCross et ebpfkit. Les programmes cgroup et socket sont courants.

Pour ftrace et les kprobes, la gravité dépend du propriétaire : noyau, information ; module, suspect ; aucun code connu, critique. Falco, Tetragon, sysdig, livepatch et les agents EDR produisent tous des entrées ftrace, kprobe ou eBPF. Identifiez le propriétaire avant de conclure.

Taint du noyau

tainted_mask est décodé en indicateurs nommés : module propriétaire, module hors arbre, module non signé, chargement forcé, live patch, etc. Pour chaque module, les bits de taint et sig_ok produisent les marqueurs « out-of-tree » et « unsigned » dans la liste des modules. Un rootkit compilé pour l'occasion sur un noyau de distribution signé déclenche en général les deux. Les modules d'acquisition (lime, avml, pmem, fmem) sont étiquetés comme tels, pour que l'outil qui a capturé l'image ne soit pas pris pour un suspect.

Ce qui n'est pas contrôlé structurellement

La liste des fichiers ouverts par le noyau lui-même n'a pas encore d'équivalent structurel ici. Les hooks en espace utilisateur, GOT et inline (linux_apihooks), sont traités dans malwares userland Linux en mémoire.

Sans ISF, les plugins à la demande check_syscall, check_fop, check_afinfo, check_tty, check_lsm, netfilter, keyboard_notifiers, check_pidhash, bpf_progs et kernel_taint se contentent de chercher des chaînes de symboles. Ils montrent quels sous-systèmes apparaissent en mémoire, pas si un pointeur a été modifié.

Un ordre pratique

  1. Lisez d'abord les indicateurs de taint et la liste des modules. Un module hors arbre non signé sur un noyau de distribution est la piste.
  2. Vérifiez les tâches et modules cachés. L'un ou l'autre suffit pour escalader.
  3. Passez en revue les résultats syscalls, IDT, tables d'opérations et hooks inline, ainsi que tout handler attribué à « no known code ».
  4. Parcourez les frameworks de hooks en écartant les agents connus d'après leur propriétaire.
  5. Pour chaque résultat, revenez aux processus, sockets et fichiers qu'il cachait.

Pour aller plus loin