Durcissement du noyau : sysctl, modules, lockdown

Le noyau est le composant le plus privilégié d'un hôte Linux : une seule faiblesse à ce niveau peut compromettre tous les autres contrôles. Le durcir consiste à réduire les informations qu'il divulgue aux utilisateurs non privilégiés, à diminuer la surface d'attaque des modules chargeables et à restreindre la modification du noyau en cours d'exécution. Ce guide couvre trois couches complémentaires : les paramètres sysctl dans /etc/sysctl.d/, le blacklisting de modules dans /etc/modprobe.d/ et le lockdown du noyau. Il complète le durcissement des services et le guide des référentiels de conformité.

Durcissement des paramètres sysctl

Déposez un fichier dédié dans /etc/sysctl.d/ plutôt que de modifier /etc/sysctl.conf : vos changements restent isolés et faciles à auditer. Les fichiers sont appliqués par ordre lexical ; un préfixe numérique rend la priorité prévisible.

cat > /etc/sysctl.d/60-kernel-hardening.conf <<'EOF'
# Masque les pointeurs noyau aux utilisateurs non privilégiés (limite les fuites KASLR)
kernel.kptr_restrict = 2
# Restreint l'accès au tampon circulaire du noyau / dmesg
kernel.dmesg_restrict = 1
# Limite ptrace aux processus parents uniquement (Yama)
kernel.yama.ptrace_scope = 1
# Randomisation complète de l'espace d'adressage (pile, tas, mmap, VDSO)
kernel.randomize_va_space = 2
# Désactive le chargement d'un nouveau noyau via kexec à l'exécution
kernel.kexec_load_disabled = 1
# Interdit le chargement d'eBPF non privilégié
kernel.unprivileged_bpf_disabled = 1
# Durcit le JIT BPF contre le spraying / les attaques type Spectre
net.core.bpf_jit_harden = 2
# Refuse l'accès non privilégié aux événements perf
kernel.perf_event_paranoid = 3
# Protège contre les attaques TOCTOU sur liens physiques/symboliques
fs.protected_hardlinks = 1
fs.protected_symlinks = 1
# N'effectue jamais de core dump pour les binaires setuid
fs.suid_dumpable = 0
EOF

Chaque clé a un rôle précis. kernel.kptr_restrict=2 masque les adresses noyau dans /proc pour tous, privant l'attaquant des fuites servant à contourner KASLR. kernel.dmesg_restrict=1 empêche les utilisateurs non root de lire les messages du noyau, qui contiennent souvent des adresses et des traces de pile. kernel.yama.ptrace_scope=1 bloque l'attachement d'un processus non enfant à un autre, technique courante de vol d'identifiants et d'injection. kernel.randomize_va_space=2 active l'ASLR le plus fort. kernel.kexec_load_disabled=1 empêche un attaquant disposant de root de démarrer une image noyau non signée pour contourner le lockdown ou Secure Boot. Les clés BPF et perf coupent des primitives puissantes que du code non privilégié pourrait détourner, et les clés fs.protected_* et fs.suid_dumpable ferment les courses classiques sur le système de fichiers et les fuites de core dump abordées dans permissions du système de fichiers.

Appliquez et vérifiez :

sysctl --system
sysctl kernel.kptr_restrict kernel.yama.ptrace_scope fs.suid_dumpable

Blacklisting des modules noyau inutilisés

Chaque module chargeable est une surface d'attaque potentielle. Désactivez les systèmes de fichiers rares, les protocoles réseau peu utilisés et les interfaces de stockage dont vous ne vous servez pas. Utilisez install <mod> /bin/true pour neutraliser les chargements explicites et blacklist pour empêcher l'autoload sur détection matérielle.

cat > /etc/modprobe.d/blacklist-hardening.conf <<'EOF'
# Systèmes de fichiers peu courants
install cramfs /bin/true
install freevxfs /bin/true
install jffs2 /bin/true
# Protocoles réseau rares / risqués
install dccp /bin/true
install sctp /bin/true
install rds /bin/true
install tipc /bin/true
# Interfaces matérielles de niche
install firewire-core /bin/true
blacklist firewire-ohci
# Stockage de masse USB (uniquement si la politique sur les supports l'exige)
install usb-storage /bin/true
EOF

Inspectez ce qui est actuellement chargé et retirez un module s'il n'est pas utilisé :

lsmod
modprobe -r dccp 2>/dev/null

Réservez le blacklisting d'usb-storage aux postes où les supports amovibles sont interdits ; sur un poste de travail, cela peut casser un usage légitime. Combinez cette approche avec les contrôles décrits dans le durcissement du pare-feu pour les protocoles que vous ne pouvez pas supprimer totalement.

Lockdown du noyau et Secure Boot

Le lockdown du noyau restreint même l'utilisateur root dans la modification du noyau en cours d'exécution. Il a deux niveaux : integrity, qui bloque les opérations susceptibles d'altérer le noyau (kexec, écriture dans /dev/mem, chargement de modules non signés), et confidentiality, qui bloque en plus les chemins permettant de lire la mémoire du noyau. Sur la plupart des distributions, activer Secure Boot bascule automatiquement le lockdown en mode integrity, les deux reposant sur une chaîne de démarrage vérifiée. On peut aussi le forcer via le paramètre de démarrage :

# À ajouter à la ligne de commande du noyau (GRUB), par exemple :
#   lockdown=integrity   ou   lockdown=confidentiality
cat /sys/kernel/security/lockdown

Le mode actif apparaît entre crochets, par exemple [none] integrity confidentiality. Notez que le lockdown ne peut pas être assoupli à l'exécution une fois positionné ; on le modifie au démarrage.

Un noyau durci ou aligné sur KSPP (Kernel Self Protection Project) intègre nombre de ces protections par défaut à la compilation, raison pour laquelle certains sysctls peuvent déjà afficher leur valeur durcie ou ne pas exister du tout sur votre noyau. Considérez les listes ci-dessus comme une base et validez-les selon votre distribution et votre version de noyau.

Vérification

# valeurs sysctl
sysctl kernel.kptr_restrict kernel.dmesg_restrict kernel.yama.ptrace_scope
sysctl kernel.randomize_va_space kernel.kexec_load_disabled
sysctl kernel.unprivileged_bpf_disabled net.core.bpf_jit_harden
sysctl kernel.perf_event_paranoid fs.protected_hardlinks fs.protected_symlinks fs.suid_dumpable

# blacklist de module effectif (aucune sortie = bloqué)
modprobe -n -v dccp

# état du lockdown
cat /sys/kernel/security/lockdown