4 failles critiques dans le noyau Linux

Élévation de privilèges root sur toutes les distributions majeures en moins de trois semaines

Introduction

Entre le 29 avril et le 14 mai 2026, quatre vulnérabilités distinctes ont frappé le noyau Linux, toutes exploitables par un utilisateur local non privilégié pour obtenir root ou lire des fichiers sensibles appartenant à root. Le rythme est sans précédent : une divulgation publique tous les cinq jours en moyenne, chacune accompagnée d’un proof-of-concept fonctionnel.

Les composants touchés sont au cœur de l’infrastructure Linux : le sous-système crypto (AF_ALG / algif_aead), le chiffrement réseau IPsec (ESP / XFRM), le protocole RxRPC, et le mécanisme d’accès ptrace. La quasi-totalité des distributions Linux livrées depuis 2017 sont concernées.

Voici la liste des vulnérabilités publiées : 

• CVE-2026-31431 — Copy Fail : CVSS 7.8, CWE-669 (Incorrect Resource Transfer Between Spheres), élévation de privilèges locale vers root via corruption déterministe du page cache — exploit de 732 octets en Python. Ajouté au catalogue CISA KEV le 1er mai 2026. Exploitation in-the-wild confirmée.

  • Etat du PoC : public

• CVE-2026-43284 + CVE-2026-43500 — Dirty Frag : CVSS 8.8 / 7.8, CWE-123 (Write-what-where Condition), chaîne de deux LPE dans les modules esp4/esp6 et rxrpc — contourne la mitigation de Copy Fail. Exploitation limitée observée par Microsoft Defender.

  • Etat du PoC : public

• CVE-2026-46300 — Fragnesia : CVSS 7.8, même classe de vulnérabilité (page-cache write) dans XFRM ESP-in-TCP, variante introduite accidentellement par le correctif de Dirty Frag. 

  • Etat du PoC : public

• CVE-2026-46333 — ssh-keysign-pwn : CVSS 5.5, CWE-362 (Race Condition), divulgation d’informations : lecture des clés privées SSH et de /etc/shadow par un utilisateur non privilégié. Bug présent depuis ~2020.

  •             Etat du PoC : public

Des correctifs sont disponibles en upstream et chez la majorité des distributions pour les quatre CVE. Les kernels patchés intégrant les quatre correctifs ont commencé à être livrés à partir du 16 mai 2026.

Dans ce blog post rédigé par les équipes opérationnelles Safercy, vous trouverez les informations suivantes :

• Chronologie et contexte

• Impacts pour les organisations

• Explications concernant le page cache Linux, en cause sur 3 des 4 vulnérabilités publiées

• Détail sur chacune des vulnérabilités

• Détections

• Recommandations

• Conclusion

Chronologie et contexte

Copy Fail a été ajouté au CISA KEV, ce qui signifie que l’exploitation a été observée dans la nature. Microsoft Defender a documenté une activité de test préliminaire sur Dirty Frag. Aucune attribution à un groupe APT n’est publique à ce jour, mais la classe de vulnérabilité (LPE noyau fiable, sans race condition) est exactement le type de primitive que les opérateurs de ransomware et les acteurs d’espionnage utilisent après un accès initial.

La découverte assistée par IA (Xint Code pour Copy Fail, V12/Zellic pour Fragnesia) signale un changement structurel : le coût de découverte de bugs kernel-grade est en train de s’effondrer.

Périmètre et versions impactées

Kernels upstream patchés (15 mai 2026) : 7.0.8, 6.18.31, 6.12.89, 6.6.139, 6.1.173, 5.15.207, 5.10.256.

Impact pour les organisations

Les trois premières CVE (Copy Fail, Dirty Frag, Fragnesia) donnent root immédiat à tout utilisateur local. Cela signifie les impacts suivants : exécution de code arbitraire en tant que root, installation de backdoors persistantes, désactivation des agents de sécurité (EDR, auditd), accès à tous les secrets du système, et lateral movement vers d’autres hôtes. Dans un environnement Kubernetes ou conteneurisé, le page cache partagé transforme ces LPE en container escape.

ssh-keysign-pwn (CVE-2026-46333) est une divulgation d’informations, pas une LPE directe. Mais les informations divulguées (clés privées SSH, hashes de mots de passe) sont les prérequis directs d’une compromission complète : usurpation d’identité de serveurs SSH (man-in-the-middle), cracking offline de mots de passe, accès à d’autres systèmes.

Le périmètre d'impact potentiel est maximal. Le noyau Linux est le composant le plus partagé de tout l’écosystème. Un LPE kernel affecte simultanément chaque VM, conteneur, serveur bare-metal, CI/CD runner et poste de travail développeur utilisant un noyau non patché. Les environnements multi-tenant (hébergement mutualisé, Kubernetes managé, plateformes CI/CD) sont les plus exposés.

Contexte réglementaire. Sous NIS2, les entités essentielles et importantes doivent notifier les incidents significatifs sous 24h et appliquer les correctifs dans des délais raisonnables. Sous DORA, les établissements financiers doivent démontrer la résilience de leur infrastructure IT. Pour les OIV français, l’ANSSI attend une gestion de crise opérationnelle immédiate sur ce niveau de criticité.

Comment fonctionne le page cache Linux

Le page cache est le mécanisme central par lequel Linux met en cache le contenu des fichiers en mémoire vive. Quand un processus lit /usr/bin/su, le noyau charge les pages depuis le disque une seule fois, puis sert les lectures suivantes depuis la RAM. Ce cache est partagé entre tous les processus du système — y compris entre conteneurs sur un même hôte.

C’est précisément ce qui rend les trois premières vulnérabilités (Copy Fail, Dirty Frag, Fragnesia) aussi dévastatrices. Elles permettent toutes de modifier la copie en mémoire d’un fichier en lecture seule sans toucher au fichier sur disque. Conséquence directe : les vérifications d’intégrité basées sur le contenu disque (hashes, AIDE, rpm -V) ne détectent rien.

Dans un environnement conteneurisé, le page cache étant partagé au niveau de l’hôte, une corruption depuis un conteneur non privilégié affecte tous les conteneurs et l’hôte. C’est le scénario de container escape.

Pour ssh-keysign-pwn, le mécanisme est différent. Il s’agit d’une race condition dans le chemin de sortie d’un processus privilégié : le noyau libère la structure mémoire (mm) avant de fermer les file descriptors. Pendant cette fenêtre, pidfd_getfd() peut récupérer un FD ouvert par un binaire SUID sur un fichier root.

Détails techniques — CVE-2026-31431 (Copy Fail)

CWE-669 — Incorrect Resource Transfer Between Spheres

Composant : algif_aead (module noyau), accessible via les sockets AF_ALG.

Mécanisme d’exploitation :

• L’attaquant ouvre un socket AF_ALG et configure un algorithme AEAD (authencesn).

• Il utilise splice() pour injecter des pages du page cache d’un fichier cible (ex: /usr/bin/su) dans le socket crypto.

• Une optimisation de 2017 tente de réutiliser le buffer source comme buffer destination lors d’opérations AEAD in-place. Quand l’opération échoue, le code ne bascule pas correctement sur un chemin out-of-place.

• Le résultat est un « scratch write » de 4 octets contrôlés par l’attaquant, écrits directement dans la page du page cache.

• L’attaquant invoque ensuite su, qui exécute la version corrompue — et obtient root.

Conditions d’exploitation :

• Authentification : utilisateur local non privilégié. Aucun droit spécial requis.

• Complexité : triviale. L’exploit tient en 732 octets de Python, fonctionne sans modification sur toutes les distributions.

• Race condition : aucune. C’est un bug logique déterministe.

• Module algif_aead : doit être chargeable (il l’est par défaut partout, auto-chargé au bind AF_ALG).

# Vérifier si le module est chargeable (et donc exploitable)
cat /boot/config-$(uname -r) | grep CONFIG_CRYPTO_USER_API_AEAD
# Si =m ou =y → vulnérable (sauf si blacklisté)

# Vérifier si le module est actuellement chargé
lsmod | grep algif_aead

Détails techniques — CVE-2026-43284 et CVE-2026-43500 (Dirty Frag)

CWE-123 — Write-what-where Condition

Composant : esp4/esp6 (IPsec) et rxrpc (AFS).

Mécanisme d’exploitation :

Dirty Frag chaîne deux primitives d’écriture page-cache :

CVE-2026-43284 (ESP) : Quand le chemin de réception IPsec ESP (esp_input()) traite un socket buffer contenant des fragments paginés non exclusivement détenus par le noyau, le déchiffrement in-place s’exécute directement sur ces pages. L’attaquant conserve une référence aux pages, obtenant une primitive STORE de 4 octets dans le page cache. Nécessite CAP_NET_ADMIN, obtenu via unshare(CLONE_NEWUSER) (user namespace) — possible par défaut sur la majorité des distros.

CVE-2026-43500 (RxRPC) : Même classe de bug dans le chemin de déchiffrement rxrpc. Fournit une primitive STORE de 8 octets. Ne nécessite pas de namespace, mais dépend du module rxrpc.ko (chargé par défaut sur Ubuntu, pas sur RHEL).

L’exploit enchaîne les deux vulnérabilité : ESP pour les distributions où les user namespaces sont ouverts, RxRPC comme fallback quand les namespaces sont bloqués. Résultat : root sur toutes les distributions.

Conditions d’exploitation :

• Authentification : utilisateur local non privilégié.

• Complexité : triviale (exploit en C, compilation + exécution en une commande).

• La mitigation de Copy Fail (blacklist algif_aead) ne protège pas contre Dirty Frag.

# Vérifier l’exposition
lsmod | egrep '^(esp4|esp6|rxrpc)'
# Si l’un des trois est chargé → surface d’attaque exposée

# Vérifier si les user namespaces sont accessibles (pour CVE-2026-43284)
sysctl user.max_user_namespaces
# Si > 0 → l’exploit ESP fonctionne

Détails techniques — CVE-2026-46300 (Fragnesia)

CWE : même classe que CWE-123 (Write-what-where).

Composant : skb_try_coalesce() / XFRM ESP-in-TCP.

Mécanisme d’exploitation :

Fragnesia est une conséquence directe du correctif de Dirty Frag. Le fix de CVE-2026-43284 a corrigé le déchiffrement in-place dans esp4/esp6, mais a « activé accidentellement » un bug latent dans skb_try_coalesce() :

• Quand des fragments paginés sont transférés d’un socket buffer à un autre, skb_try_coalesce() ne propage pas le marqueur SKBFL_SHARED_FRAG.

• Le noyau perd la trace du fait qu’un fragment est adossé à des pages du page cache.

• Le chemin de réception XFRM ESP-in-TCP exécute un déchiffrement AES-GCM in-place directement sur ces pages.

• L’exploit cible /usr/bin/su : il écrit un stub ELF dans la copie cachée, puis invoque su pour exécuter le code de l’attaquant en root.

Conditions d’exploitation :

• Complexité : triviale.

• Fonctionne y compris sur les systèmes patchés pour Dirty Frag (c’est le correctif Dirty Frag qui l’active).

• La mitigation par blacklist des modules esp4/esp6/rxrpc fonctionne aussi pour Fragnesia.

# La même vérification de modules que Dirty Frag s’applique
lsmod | egrep '^(esp4|esp6|rxrpc)'

# Vérifier la version kernel
# Kernels upstream patchés : 7.0.8, 6.18.31, 6.12.89, 6.6.139, 6.1.173, 5.15.207, 5.10.256
uname -r

Détails techniques — CVE-2026-46333 (ssh-keysign-pwn)

CWE-362 — Concurrent Execution Using Shared Resource with Improper Synchronization

Composant : __ptrace_may_access() dans le noyau, via le syscall pidfd_getfd(2).

Mécanisme d’exploitation :

• Quand un processus SUID (ex: ssh-keysign, chage) se termine, do_exit() exécute exit_mm() (libération de la structure mémoire) avant exit_files() (fermeture des file descriptors).

• Pendant cette fenêtre, la structure mm du processus est NULL. Or __ptrace_may_access() saute sa vérification de « dumpable » quand mm == NULL.

• Un attaquant dont l’UID correspond au processus cible peut utiliser pidfd_getfd(2) dans cette fenêtre pour obtenir un duplicata des file descriptors encore ouverts.

• ssh-keysign ouvre les clés privées SSH de l’hôte en tant que root avant de dropper ses privilèges. chage ouvre /etc/shadow. Ces FD restent ouverts pendant la fenêtre de race.

• L’attaquant récupère ces FD et lit les fichiers root-owned.

Conditions d’exploitation :

• Authentification : utilisateur local non privilégié dont l’UID correspond au processus cible.

• Complexité : modérée (race condition, mais reproductible de manière fiable).

• Le syscall pidfd_getfd() doit être disponible (noyaux ≥ 5.6).

• Totalement indépendant des trois vulnérabilités précédentes.

# Vérifier si pidfd_getfd est disponible (noyau >= 5.6)
uname -r

# Vérifier si ssh-keysign est SUID
ls -la /usr/lib/openssh/ssh-keysign 2>/dev/null || \
ls -la /usr/libexec/openssh/ssh-keysign 2>/dev/null
# Si -rwsr-xr-x → cible disponible pour l’exploit

# Vérifier si chage est SGID
ls -la /usr/bin/chage

Détection et indicateurs de compromission (IoC)

Pour Copy Fail, Dirty Frag et Fragnesia (corruption du page cache) :

Ces vulnérabilités ne laissent pas de traces disque — la modification se fait uniquement en mémoire. La détection repose sur des signaux comportementaux faibles.

# Vérifier si les modules vulnérables sont chargés
lsmod | egrep '^(algif_aead|esp4|esp6|rxrpc)'

# Chercher des traces d’enregistrement AF_ALG suspect dans les logs kernel
journalctl -k | grep "Registered PF_ALG protocol family"
# Corréler temporellement avec des exécutions su/sudo inattendues

# Chercher des transitions root suspectes (via auditd)
ausearch -m EXECVE -c su --success yes 2>/dev/null | \
  grep -v "uid=0" | head -20
# Un su réussi depuis un UID non privilégié sans saisie de mot de passe est suspect

# Vérifier l’intégrité en mémoire vs disque de binaires setuid critiques
sha256sum /usr/bin/su           # hash depuis le disque
cat /usr/bin/su | sha256sum     # hash depuis le page cache
# Si les deux diffèrent → compromission probable

Pour ssh-keysign-pwn (CVE-2026-46333) :

# Chercher des artefacts de PoC dans les répertoires utilisateur
find /home /tmp /var/tmp -name "ssh-keysign-pwn" -o -name "sshkeysign_pwn" \
  -o -name "chage_pwn" 2>/dev/null

# Vérifier la valeur actuelle de ptrace_scope
sysctl kernel.yama.ptrace_scope
# 0 = pas de restriction → vulnérable
# 1 = restreint au parent → vulnérable (l’exploit fonctionne)
# 2 = admin only → mitigation partielle
# 3 = aucun ptrace → mitigation effective

Recommandations de sécurité

Priorité 1 — Patcher immédiatement.

Appliquer les mises à jour kernel sur toutes les machines Linux. Les quatre CVE sont corrigées dans les kernels upstream 7.0.8, 6.18.31, 6.12.89, 6.6.139, 6.1.173, 5.15.207, 5.10.256. Vérifier les versions spécifiques de votre distribution.

# Debian/Ubuntu
sudo apt update && sudo apt upgrade -y linux-image-generic && sudo reboot

# RHEL/AlmaLinux/Rocky
sudo dnf clean metadata && sudo dnf upgrade kernel && sudo reboot

# Vérifier après reboot
uname -r

Priorité 2 — Mitigations temporaires si le patch n’est pas immédiatement possible.

Pour Copy Fail :

# Blacklister le module algif_aead
echo "install algif_aead /bin/false" | sudo tee /etc/modprobe.d/copyfail.conf
sudo rmmod algif_aead 2>/dev/null

Pour Dirty Frag + Fragnesia (une seule mitigation couvre les deux) :

# Blacklister esp4, esp6, rxrpc
sudo tee /etc/modprobe.d/dirtyfrag.conf <<'EOF'
install esp4 /bin/false
install esp6 /bin/false
install rxrpc /bin/false
EOF

sudo rmmod esp4 esp6 rxrpc 2>/dev/null
# Attention : cette modification risque de bloquer IPsec et AFS si utilisés

Pour ssh-keysign-pwn :

# Restreindre ptrace (mitigation immédiate, réversible au reboot)
echo "kernel.yama.ptrace_scope = 3" | sudo tee /etc/sysctl.d/99-CVE-2026-46333.conf
sudo sysctl -w kernel.yama.ptrace_scope=3

# Note : ptrace_scope=3 bloque tous les ptrace pour les processus sans CAP_SYS_PTRACE
# Cela va bloquer les debuggers (gdb, strace) pour les utilisateurs non-root

Priorité 3 — Mesures de durcissement complémentaires.

# Limiter les user namespaces (réduit la surface d’attaque de Dirty Frag ESP)
echo "user.max_user_namespaces = 0" | sudo tee /etc/sysctl.d/no-userns.conf
sudo sysctl --system
# Attention : casse les conteneurs rootless (Podman, etc.)

# Après application des mitigations page-cache, purger le cache
# pour éliminer toute corruption résiduelle
sudo sh -c "echo 3 > /proc/sys/vm/drop_caches"



# Rotation des clés SSH (si ssh-keysign-pwn a pu être exploité)
sudo rm /etc/ssh/ssh_host_*_key*
sudo ssh-keygen -A
sudo systemctl restart sshd

Recommandations opérationnelles

Pour les équipes SOC / Blue Team :

• Monitorer les transitions de privilèges anormales : un processus non-root qui devient root sans passer par sudo/su légitime est le signal le plus fiable.

• Sur les environnements Kubernetes : auditer les nœuds non patchés en priorité. Tout nœud avec un kernel antérieur aux versions patchées du 15 mai est exposé aux quatre CVE.

• Traiter toute compromission de conteneur comme une compromission de l’hôte (le page cache est partagé).

• Mettre en place une alerte sur les créations de socket AF_ALG corrélées avec des exécutions de binaires setuid.

Pour les équipes pentest :

• Intégrer les quatre CVE dans les scénarios d’escalade de privilèges post-exploitation.

• Copy Fail est l’exploit le plus simple à déployer (codePython, aucune dépendance). Si le module algif_aead est chargeable, c’est root en 3 secondes.

• Si algif_aead est blacklisté mais les modules ESP sont présents, Dirty Frag prend le relais.

• ssh-keysign-pwn est utile en mode information disclosure même sans obtenir root — les clés SSH de l’hôte permettent du man-in-the-middle ou du lateral movement.

Playbook de réponse à incident si compromission avérée :

1. Isoler le système compromis du réseau immédiatement.

2. Purger le page cache pour éliminer les corruptions en mémoire (ne supprime pas les backdoors déjà installées).

3. Vérifier l’intégrité des binaires : comparer les packages installés avec les signatures du distributeur (rpm -Va sur RHEL, debsums sur Debian/Ubuntu).

4. Chercher des backdoors : vérifier crontab, systemd timers, authorized_keys, modules noyau chargés, binaires modifiés dans /usr/bin et /usr/sbin.

5. Rotation complète des secrets : clés SSH de l’hôte, mots de passe de tous les comptes locaux, tokens et credentials applicatifs.

6. Patcher et redémarrer avec un kernel corrigé.

7. Si l’environnement est Kubernetes : recycler le nœud entier (drain + replace), pas seulement les Pods.

Conclusion

Ces quatre CVE illustrent un pattern désormais structurel dans l’écosystème Linux : la classe de bugs « page-cache write » (inaugurée par Dirty COW en 2016, étendue par Dirty Pipe en 2022) n’est pas un accident isolé mais une surface d’attaque systémique. Chaque sous-système noyau qui manipule des pages partagées via splice() est un candidat potentiel. L’accélération de la découverte par des outils d’audit assistés par IA (Xint Code, Zellic V12) signifie que le rythme ne va pas ralentir.

La priorité est claire : patcher les quatre CVE, dans cet ordre — Copy Fail (exploitation confirmée), Dirty Frag (exploitation limitée observée), Fragnesia, ssh-keysign-pwn. Si vous n’avez pas encore commencé, chaque jour de retard augmente l’exposition.

Safercy accompagne ses clients dans l’évaluation de leur exposition à ces vulnérabilités via SaferScan, notre plateforme de scan de vulnérabilités, et nos missions de Pentest-as-a-Service qui intègrent systématiquement les dernières primitives d’escalade de privilèges kernel.

Safercy

SaferScan intègre déjà les checks pour CVE-2026-31431, CVE-2026-43284, CVE-2026-43500, CVE-2026-46300 et CVE-2026-46333.

Nos règles de détection couvrent la vérification des versions kernel, l’état de chargement des modules vulnérables, et la présence des mitigations recommandées.

Vous suspectez une compromission liée à ces vulnérabilités ? Contactez immédiatement l’équipe Safercy pour une analyse de compromission et un accompagnement dans la réponse à incident.

contact@safercy.com / ir@safercy.com |  safercy.com

Références

Copy Fail (CVE-2026-31431)

Xint Code — Write-up original : https://xint.io/blog/copy-fail-linux-distributions

CERT-EU Advisory 2026-005 : https://cert.europa.eu/publications/security-advisories/2026-005/

Ubuntu Blog — Fixes : https://ubuntu.com/blog/copy-fail-vulnerability-fixes-available

Microsoft Security Blog : https://www.microsoft.com/en-us/security/blog/2026/05/01/cve-2026-31431-copy-fail-vulnerability-enables-linux-root-privilege-escalation/

CISA KEV Alert : https://www.cisa.gov/news-events/alerts/2026/05/01/cisa-adds-one-known-exploited-vulnerability-catalog

NVD : https://nvd.nist.gov/vuln/detail/CVE-2026-31431

PoC GitHub (Theori) : https://github.com/theori-io/copy-fail-CVE-2026-31431

Dirty Frag (CVE-2026-43284, CVE-2026-43500)

Hyunwoo Kim — Write-up et PoC : https://github.com/V4bel/dirtyfrag

Red Hat RHSB-2026-003 : https://access.redhat.com/security/vulnerabilities/RHSB-2026-003

Ubuntu Blog — Fixes : https://ubuntu.com/blog/dirty-frag-linux-vulnerability-fixes-available

Microsoft Security Blog : https://www.microsoft.com/en-us/security/blog/2026/05/08/active-attack-dirty-frag-linux-vulnerability-expands-post-compromise-risk/

Wiz Blog : https://www.wiz.io/blog/dirty-frag-linux-kernel-local-privilege-escalation-via-esp-and-rxrpc

CCCS (Canada) AL26-011 : https://www.cyber.gc.ca/en/alerts-advisories/al26-011-vulnerabilities-affecting-linux-cve-2026-43284-cve-2026-43500

Fragnesia (CVE-2026-46300)

V12 Security — PoC : https://github.com/v12-security/pocs/tree/main/fragnesia

AlmaLinux Blog : https://almalinux.org/blog/2026-05-13-fragnesia-cve-2026-46300/

TuxCare / CloudLinux : https://tuxcare.com/blog/fragnesia-cve-2026-46300-is-a-new-linux-kernel-lpe/

Help Net Security : https://www.helpnetsecurity.com/2026/05/14/fragnesia-cve-2026-46300-linux-lpe-vulnerability/

ssh-keysign-pwn (CVE-2026-46333)

Qualys — Disclosure oss-security : https://www.openwall.com/lists/oss-security/2026/05/15/2

PoC GitHub (_SiCk) : https://github.com/0xdeadbeefnetwork/ssh-keysign-pwn

Upstream fix (Linus) : https://github.com/torvalds/linux/commit/31e62c2ebbfdc3fe3dbdf5e02c92a9dc67087a3a

AlmaLinux Blog : https://almalinux.org/blog/2026-05-15-ssh-keysign-pwn-cve-2026-46333/

Ubuntu Blog : https://ubuntu.com/blog/ssh-keysign-pwn-linux-vulnerability-fixes-available

CloudLinux : https://blog.cloudlinux.com/ptrace-exit-race-cve-2026-46333-mitigation-and-kernel-update

Debian Security Tracker : https://security-tracker.debian.org/tracker/CVE-2026-46333