Linux : introduction aux LKMs

Le kernel Linux est monolithique: tout le code tourne dans le même espace d’adressage, en mode privilégié. Mais il accepte du code supplémentaire à chaud: les LKMs (Loadable Kernel Modules). Un LKM est un fichier .ko compilé pour le kernel en cours, qui s’insère dans l’espace kernel et ajoute des fonctionnalités: drivers de périphériques, filesystems, network protocols, syscalls custom.

Le plus petit LKM

// hello.c
#include <linux/module.h>
#include <linux/kernel.h>

static int __init hello_init(void) {
    printk(KERN_INFO "Hello from kernel space\n");
    return 0;
}

static void __exit hello_exit(void) {
    printk(KERN_INFO "Goodbye from kernel space\n");
}

module_init(hello_init);
module_exit(hello_exit);
MODULE_LICENSE("GPL");

Le Makefile:

obj-m += hello.o
all:
	make -C /lib/modules/$(shell uname -r)/build M=$(PWD) modules

make
insmod hello.ko       # charge le module
dmesg | tail -1       # "Hello from kernel space"
rmmod hello           # décharge le module
dmesg | tail -1       # "Goodbye from kernel space"

printk est le printf du kernel: il écrit dans le ring buffer de dmesg, pas sur stdout. Le kernel n’a pas de stdout, pas de libc, pas de malloc standard (il a kmalloc), pas de floating point (par défaut) et pas de protection mémoire entre les modules: un LKM buggé crashe le kernel entier.

Ce que ça implique pour la sécurité

Un LKM tourne en ring 0: il voit toute la mémoire, tous les process, tous les fichiers. Un LKM malveillant (rootkit) peut cacher des process, intercepter des syscalls, dissimuler des fichiers et le kernel ne peut pas le détecter parce que le kernel EST le LKM. Les rootkits LKM (adore, suckit, enyelkm) sont les plus puissants et les plus difficiles à détecter.

La contre-mesure: désactiver le chargement de modules après le boot (sysctl kernel.modules_disabled=1), signer les modules autorisés (CONFIG_MODULE_SIG) et surveiller /proc/modules pour les modules inattendus.

[edit: 2026] Les LKMs sont toujours le mécanisme d’extension du kernel Linux et les rootkits LKM sont toujours la classe de rootkits la plus dangereuse. Les kernels modernes signent les modules (CONFIG_MODULE_SIG_FORCE refuse les modules non signés) et eBPF a pris une partie du rôle des LKMs custom (du code kernel sans compiler de module, mais sandboxé). Le modules_disabled=1 reste la mesure la plus efficace contre les rootkits LKM, au prix de ne plus pouvoir ajouter de driver après le boot.