Vulnérabilités

Copy Fail : anatomie de la faille Linux la plus critique de ces dernières années

7 minutes de lecture

Avant-propos

Le 29 avril 2026, des chercheurs ont rendu publique une vulnérabilité d’élévation locale des privilèges (LPE), référencée sous l’identifiant CVE-2026-31431, dont l’exploitation se révèle extrêmement fiable. Cette vulnérabilité est communément appelée Copy Fail. Découverte en une heure environ à l’aide d’un processus assisté par l’IA, cette faille logique permet à un cyberattaquant local non privilégié d’obtenir systématiquement un accès root sur la quasi-totalité des grandes distributions Linux publiées depuis 2017.

Contrairement à de nombreuses vulnérabilités du noyau, cette faille logique est déterministe : elle ne dépend ni de conditions de concurrence, ni de décalages propres à certaines versions. Un simple script Python de 732 octets peut l’exploiter avec succès, sans modification, sur différentes distributions Linux.

La vulnérabilité trouve son origine dans le sous-système cryptographique du noyau Linux, et plus précisément dans le module algif_aead de l’interface AF_ALG, une API de chiffrement en espace utilisateur. Elle ne résulte pas d’une simple erreur de codage, mais de la combinaison de trois mises à jour indépendantes :

L’ajout de l’algorithme authencesn en 2011
La prise en charge d’AEAD par l’interface AF_ALG en 2015
Une optimisation en place critique introduite en 2017

Lors d’opérations cryptographiques, un bug dans cette optimisation en place amène l’algorithme à utiliser incorrectement le tampon de destination. Il écrit alors quatre octets contrôlés au-delà de la région légitime, directement dans le cache de pages du système. Les versions affectées incluent les noyaux Linux compris entre les versions 4.14 et 6.19.12.

Cette vulnérabilité affecte des millions de systèmes exécutant des distributions courantes comme Ubuntu, Amazon Linux, Red Hat Enterprise Linux, Debian, SUSE et AlmaLinux. Un cyberattaquant disposant d’un accès local standard peut l’exploiter pour modifier de manière malveillante le cache en mémoire de fichiers exécutables privilégiés, comme su ou sudo, sans déclencher les contrôles d’intégrité, puisque les fichiers physiques présents sur le disque restent inchangés. Le noyau et son cache de pages étant partagés à l’échelle de tout un nœud, cette faille permet aux cyberattaquants de :

S’échapper facilement de conteneurs Kubernetes
Prendre le contrôle d’hôtes multi-tenant
Compromettre des pipelines CI/CD

Nous recommandons vivement aux organisations d’appliquer immédiatement les correctifs nécessaires en déployant les mises à jour du noyau publiées par leurs fournisseurs.

Grâce aux solutions suivantes, les clients de Palo Alto Networks bénéficient de protections et de mesures d’atténuation contre la CVE-2026-31431 :

Next-Generation Firewall avec Advanced Threat Prevention
Cortex Cloud
Cortex XDR et XSIAM

La Linux Foundation a publié un avis contenant des informations détaillées sur les mesures d’atténuation de la CVE-2026-31431. Palo Alto Networks recommande vivement d’appliquer immédiatement les mises à jour du noyau publiées par les fournisseurs. Si cette option n’est pas envisageable, nous recommandons de suivre les recommandations temporaires visant à désactiver le module vulnérable jusqu’à ce que les correctifs puissent être appliqués.

L’équipe de réponse à incident d’Unit 42 peut également intervenir en cas de compromission ou réaliser une évaluation proactive afin de réduire votre niveau de risque.

Les vulnérabilités dont il est question

CVE-2026-31431

Détails de la CVE-2026-31431

La vulnérabilité référencée sous l’identifiant CVE-2026-31431, connue sous le nom de Copy Fail, est une faille logique déterministe située dans le sous-système cryptographique du noyau Linux – plus précisément dans le module algif_aead de l’interface AF_ALG.

Cause racine

La faille provient d’une optimisation en place défectueuse introduite dans le noyau Linux en 2017, avec le commit 72548b093ee3, pour le chiffrement AEAD. Cette optimisation a plus précisément conduit req->src et req->dst à pointer vers une scatterlist combinée. Les pages du cache de pages issues de l’appel splice() ont ainsi été chaînées de manière incorrecte directement dans la scatterlist de destination accessible en écriture.

Lors des opérations cryptographiques, l’algorithme authencesn utilise incorrectement le tampon de destination de l’appelant comme tampon de travail. Il écrit ainsi quatre octets contrôlés au-delà de la région de sortie légitime, en franchissant une limite de scatterlist chaînée, sans les restaurer ensuite. Le correctif, introduit avec le commit a664bf3d603d, résout le problème en rétablissant un traitement hors place, avec des scatterlists source et destination séparées. Les pages du cache de pages restent ainsi strictement cantonnées à la source en lecture seule.

Mécanisme d’action

Un cyberattaquant non privilégié peut exploiter cette erreur de gestion mémoire en détournant l’interaction entre l’interface de socket AF_ALG et l’appel système splice(). Lorsque splice() transmet des pages du cache de pages au sous-système cryptographique, la vulnérabilité permet au cyberattaquant d’orienter cette écriture de quatre octets directement dans le cache de pages de fichiers du noyau.

L’algorithme authencesn est utilisé pour la prise en charge des numéros de séquence étendus (ESN) dans IPsec. Il utilise le tampon de destination comme tampon de travail afin de réorganiser ces numéros de séquence. Le cyberattaquant contrôle la valeur exacte de l’écriture de quatre octets en fournissant seqno_lo, c’est-à-dire la moitié basse du numéro de séquence, dans les octets 4 à 7 des données authentifiées associées (AAD) lors de l’appel sendmsg().

Exploitation via le cache de pages

Le cache de pages est la copie temporaire en mémoire d’un fichier, que le noyau lit lorsqu’il charge un binaire en vue de son exécution. Un cyberattaquant peut exploiter l’écriture de quatre octets pour cibler le cache de pages de tout binaire setuid-root lisible, comme /usr/bin/su, sudo ou passwd.

Le cyberattaquant contrôle précisément l’emplacement de l’écriture en manipulant le décalage splice, la longueur splice et le paramètre assoclen, ou longueur associée. Il peut ainsi cibler spécifiquement la section .text d’un binaire setuid, comme /usr/bin/su, afin d’y injecter son shellcode.

Escalade de privilèges – La modification de la copie en cache du binaire altère son contexte d’exécution. Lorsque le binaire est exécuté, il accorde au cyberattaquant des privilèges de superutilisateur (UID 0), ce qui revient à rompre les limites de confiance du noyau.
Furtivité – Cette corruption s’effectuant entièrement dans la RAM du système, le fichier physique présent sur le disque reste totalement inchangé. Cela permet de contourner les chemins traditionnels du système de fichiers virtuel (VFS) et les outils de surveillance de l’intégrité des fichiers. Une fois la page évincée de la mémoire, ou après le redémarrage du système, le cache est rechargé proprement depuis le disque, sans laisser de trace de la compromission.

Caractéristiques de l’exploit

Ce qui rend Copy Fail exceptionnellement sévère par rapport à d’anciennes vulnérabilités LPE Linux comme Dirty Cow ou Dirty Pipe, c’est à la fois sa fiabilité et sa simplicité :

Aucune condition de concurrence ou décalage – Il s’agit d’une faille logique linéaire, qui ne dépend pas de la capacité à exploiter une fenêtre de condition de concurrence, ni à deviner des décalages mémoire propres à une version donnée du noyau.
Fiabilité de 100 % – L’exploit est déterministe et aboutit dès la première tentative.
Forte portabilité – L’exploit peut être exécuté au moyen d’un script Python autonome de 732 octets, reposant uniquement sur des bibliothèques standard (os, socket, zlib). Il ne nécessite donc ni compilation, ni dépendances externes. Le même script fonctionne sans modification sur la quasi-totalité des grandes distributions Linux publiées depuis 2017.

Recommandations temporaires pour la CVE-2026-31431

La vulnérabilité a été corrigée dans les branches stables upstream du noyau Linux par l’annulation de l’optimisation défectueuse introduite en 2017, avec le commit a664bf3d603d.

Si l’application immédiate des correctifs n’est pas possible, les administrateurs doivent mettre en œuvre une mesure d’atténuation temporaire en désactivant le module algif_aead affecté. Pour ce faire, ils peuvent exécuter les commandes suivantes en tant que root afin d’empêcher le chargement du module et de le retirer du noyau :

echo "install algif_aead /bin/false" > /etc/modprobe.d/disable-algif.conf
rmmod algif_aead

La Linux Foundation a publié un avis contenant des informations détaillées sur les mesures d’atténuation de la CVE-2026-31431.

Requêtes de l’équipe threat hunting managé d’Unit 42

L’équipe de threat hunting d’Unit 42 continue de surveiller activement toute tentative d’exploitation de cette CVE chez nos clients, à l’aide de Cortex XDR et des requêtes XQL ci-dessous. Les clients Cortex XDR peuvent également utiliser ces requêtes pour rechercher d’éventuels indicateurs d’exploitation.

// Title: CopyFail Detection via Non-root Launching su via Uncommon Parent Process
// Description: Query looks for non-root users launching the switch user (su) process via a parent process other than the normally expected processes such as shells, sudo, or su itself. May identify false positives, yet works well for identification of potential CopyFail exploitation.
// MITRE ATT&CK TTP ID: T1068

dataset = xdr_data
| fields _time, agent_hostname, agent_os_type, event_type, event_sub_type, actor_effective_username, actor_effective_user_sid, actor_process_image_path, actor_process_image_name, actor_process_command_line, actor_process_image_sha256, action_process_image_name, action_process_image_command_line, action_process_user_sid
| filter
    event_type = ENUM.PROCESS and event_sub_type = ENUM.PROCESS_START
    and agent_os_type = ENUM.AGENT_OS_LINUX
    and actor_effective_user_sid != "0"
    and (
        (action_process_image_name = "su" and action_process_image_command_line in ("su", "/usr/bin/su"))
        or (action_process_image_name in ("bash", "sh") and action_process_image_command_line ~= "-c(?:\s--)?\ssu$")
    )
   and actor_process_image_name not in ("bash", "sh", "zsh", "ksh", "sudo", "su")
| comp earliest(_time) as first_seen, latest(_time) as last_seen, count() as execution_count, values(actor_effective_username) as actor_usernames,  values(actor_process_image_path) as actor_image_paths, values(actor_process_command_line) as actor_cmd_lines, values(action_process_image_command_line) as action_cmd_lines, values(action_process_user_sid) as action_UIDs by agent_hostname, actor_process_image_name, actor_process_image_sha256

// Title: CopyFail Detection via Non-root Launching su via Uncommon Parent Process

// Description: Query looks for non-root users launching the switch user (su) process via a parent process other than the normally expected processes such as shells, sudo, or su itself. May identify false positives, yet works well for identification of potential CopyFail exploitation.

// MITRE ATT&CK TTP ID: T1068

dataset = xdr_data

| fields _time, agent_hostname, agent_os_type, event_type, event_sub_type, actor_effective_username, actor_effective_user_sid, actor_process_image_path, actor_process_image_name, actor_process_command_line, actor_process_image_sha256, action_process_image_name, action_process_image_command_line, action_process_user_sid

| filter

event_type = ENUM.PROCESS and event_sub_type = ENUM.PROCESS_START

and agent_os_type = ENUM.AGENT_OS_LINUX

and actor_effective_user_sid != "0"

and (

(action_process_image_name = "su" and action_process_image_command_line in ("su", "/usr/bin/su"))

or (action_process_image_name in ("bash", "sh") and action_process_image_command_line ~= "-c(?:\s--)?\ssu$")

)

and actor_process_image_name not in ("bash", "sh", "zsh", "ksh", "sudo", "su")

| comp earliest(_time) as first_seen, latest(_time) as last_seen, count() as execution_count, values(actor_effective_username) as actor_usernames, values(actor_process_image_path) as actor_image_paths, values(actor_process_command_line) as actor_cmd_lines, values(action_process_image_command_line) as action_cmd_lines, values(action_process_user_sid) as action_UIDs by agent_hostname, actor_process_image_name, actor_process_image_sha256

// Title: CopyFail Proof of Concept Code Execution
// Description: Query looks for potential CopyFail proof of concept (POC) code execution via identifying potentially correlated curl and su process executions. May identify false positives, yet works well for identification of CopyFail POC provided by Xint.Code.
// MITRE ATT&CK TTP ID: T1068

config case_sensitive = false
| dataset = xdr_data
| filter agent_os_type = ENUM.AGENT_OS_LINUX
| filter event_type = ENUM.PROCESS and event_sub_type = ENUM.PROCESS_START
| filter action_process_image_name in ("curl", "su")
| bin _time span = 2m
| filter action_process_image_command_line contains "copy.fail/exp" or (action_process_image_command_line = "su" or action_process_image_command_line ="/usr/bin/su")
| fields _time, agent_id, event_id, agent_hostname, action_process_image_command_line, action_process_image_name, actor_process_instance_id
| comp count() as event_count, values(agent_id) as agent_id, values(event_id) as event_id, values(action_process_image_name) as processes, values(action_process_image_command_line) as commands by agent_hostname, _time, actor_process_instance_id
| filter processes contains "su" and processes contains "curl"

// Title: CopyFail Proof of Concept Code Execution

// Description: Query looks for potential CopyFail proof of concept (POC) code execution via identifying potentially correlated curl and su process executions. May identify false positives, yet works well for identification of CopyFail POC provided by Xint.Code.

// MITRE ATT&CK TTP ID: T1068

config case_sensitive = false

| dataset = xdr_data

| filter agent_os_type = ENUM.AGENT_OS_LINUX

| filter event_type = ENUM.PROCESS and event_sub_type = ENUM.PROCESS_START

| filter action_process_image_name in ("curl", "su")

| bin _time span = 2m

| filter action_process_image_command_line contains "copy.fail/exp" or (action_process_image_command_line = "su" or action_process_image_command_line ="/usr/bin/su")

| fields _time, agent_id, event_id, agent_hostname, action_process_image_command_line, action_process_image_name, actor_process_instance_id

| comp count() as event_count, values(agent_id) as agent_id, values(event_id) as event_id, values(action_process_image_name) as processes, values(action_process_image_command_line) as commands by agent_hostname, _time, actor_process_instance_id

| filter processes contains "su" and processes contains "curl"

Conclusion

Compte tenu du volume d’informations publiquement disponibles, de la simplicité d’utilisation de l’exploit Copy Fail et de son efficacité, Palo Alto Networks recommande vivement d’appliquer immédiatement les mises à jour du noyau publiées par les fournisseurs. Si cette option n’est pas envisageable, nous recommandons de suivre les recommandations temporaires visant à désactiver le module vulnérable jusqu’à ce que les correctifs puissent être appliqués.

Cette mesure est d’autant plus importante qu’un script de preuve de concept (PoC) hautement fiable est déjà accessible publiquement et que des activités préliminaires de test ont été observées.

Les clients Palo Alto Networks bénéficient d’une protection renforcée grâce à nos solutions, comme détaillé ci-dessous.

Protections des produits Palo Alto Networks contre la CVE-2026-31431

Les clients Palo Alto Networks peuvent s’appuyer sur un large éventail de protections intégrées aux produits et de mises à jour pour identifier et contrer cette menace.

Vous pensez que votre entreprise a été compromise ? Vous devez faire face à une urgence ? Contactez l’équipe Unit 42 de réponse à incident ou composez l’un des numéros suivants :

Amérique du Nord : Gratuit : +1 (866) 486-4842 (866.4.UNIT42)
Royaume-Uni : +44 20 3743 3660
Europe et Moyen-Orient : +31.20.299.3130
Asie : +65.6983.8730
Japon : +81 50 1790 0200
Australie : +61.2.4062.7950
Inde : 000 800 050 45107
Corée du Sud : +82.080.467.8774

Next-Generation Firewall avec Advanced Threat Prevention

Next-Generation Firewall associés à l’abonnement de sécurité Advanced Threat Prevention permettent de bloquer la transmission de scripts d’exploitation sur le réseau grâce à la signature Threat Prevention suivante : 97176 - Linux Kernel Privilege Escalation Vulnerability.

Cortex XDR et XSIAM

L’agent Cortex XDR pour Linux, à partir de la mise à jour de contenu 2240-35441, intègre des capacités de détection et de prévention pour les échantillons connus associés à la vulnérabilité Copy Fail.

Cortex XDR et XSIAM contribuent à protéger contre les activités de pré-exploitation et de post-exploitation grâce à une approche de protection multicouche, qui inclut Advanced WildFire, Endpoint Protection Modules (EPM), Behavioral Threat Protection et le module Local Analysis.

Cortex Cloud

La protection des terminaux Cortex Cloud peut aider les organisations à se protéger contre les menaces décrites dans le présent article. Cortex Cloud 2.1 peut détecter et prévenir les opérations malveillantes grâce à des analyses comportementales et optimisées par l’IA, afin d’identifier les cas où des cyberattaquants ciblent des terminaux Linux, y compris des conteneurs et des machines virtuelles. La solution peut également détecter les cas d’utilisation abusive des politiques IAM de plateformes cloud associées à ces terminaux ciblés, et alerter les équipes lorsque des assets sont vulnérables à ces menaces.

Mis à jour le 6 mai 2026 à 15h15 PT afin d’étendre la couverture relative à Cortex XDR et XSIAM, et d’ajouter les Next-Generation Firewalls avec Advanced Threat Prevention.

Mis à jour le 7 mai 2026 à 14h00 PT afin de modifier la version de contenu Cortex XDR.

Étiquettes

Threat Research Center SuivantL’IA peut-elle s’attaquer au cloud ? Enseignements tirés de la construction d’un système multi-agents offensif autonome dans le cloud

Copy Fail : anatomie de la faille Linux la plus critique de ces dernières années

Avant-propos