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 :
- La liste
modules. - La liste sysfs
module_kset, où chaque kobject pointe vers son module. - Un carving de la zone des modules (à partir de
0xffffffffa0000000sur x86-64). Chaquestruct modulecontient son propre kobject sysfs, dont le champmkobj.modpointe vers le module lui-même. Une valeurvtrouvée à l'adressev + offsetof(module, mkobj.mod)signale un module env, 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 modules | sysfs | Carving | Verdict |
|---|---|---|---|
| oui | oui | oui | normal |
| non | oui | — | critique : retiré de lsmod |
| non | non | oui | critique : uniquement en mémoire des modules |
| oui | non | — | 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é aureceive_buf/receive_buf2de sa discipline de ligne. Le contrôle parcourttty_driverset, comme les pseudo-terminaux devpts (sessions SSH) ne figurent dans aucune table de pilote, aussi les tty que les processus tiennent ouverts, atteints viafile->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_netsur 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
- 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.
- Vérifiez les tâches et modules cachés. L'un ou l'autre suffit pour escalader.
- Passez en revue les résultats syscalls, IDT, tables d'opérations et hooks inline, ainsi que tout handler attribué à « no known code ».
- Parcourez les frameworks de hooks en écartant les agents connus d'après leur propriétaire.
- Pour chaque résultat, revenez aux processus, sockets et fichiers qu'il cachait.