Résumé exécutif :
La vulnérabilité Copy Fail permet une élévation de privilèges root sur de nombreux systèmes Linux.
Elle est simple à exploiter, invisible aux outils classiques et nécessite une correction immédiate.
Description technique :
Bug logique dans l’interface AF_ALG combinée à splice(). Manipulation du page cache permettant modification mémoire sans trace disque.
Impact :
Accès root local, compromission de serveurs, escape de conteneurs et propagation dans des environnements cloud.
Détection :
Analyse du kernel, présence AF_ALG, modules chargés et tests comportementaux.
Remédiation :
Mise à jour kernel, désactivation AF_ALG, hardening système et activation LSM.
Recommandations :
Mettre à jour immédiatement, auditer tous les systèmes, renforcer la sécurité et surveiller les accès.
Voici un outil de détection simple en C pour vérifier si ton système est potentiellement concerné.
Ce script ne réalise pas d’exploitation, il teste uniquement :
- la disponibilité de AF_ALG
- la possibilité d’utiliser splice() avec ce type de socket
👉 Ce sont les préconditions nécessaires à l’exploitation.
/*
* copyfail_check.c
*
* Détection des préconditions de la vulnérabilité "Copy Fail"
* (AF_ALG + splice)
*
* Compilation :
* gcc -O2 -Wall -o copyfail_check copyfail_check.c
*
* Usage :
* ./copyfail_check
*/
#define _GNU_SOURCE
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <errno.h>
#include <fcntl.h>
#include
#include
#include
int main(void)
int sockfd = -1, opfd = -1 ;
struct sockaddr_alg sa ;
int pipefd[2] ;
printf("[*] CopyFail detection tool\n") ;
/* 1. Création socket AF_ALG */
sockfd = socket(AF_ALG, SOCK_SEQPACKET, 0) ;
if (sockfd < 0)
perror("[-] AF_ALG non disponible") ;
printf("[!] Système probablement NON vulnérable (ou feature désactivée)\n") ;
return 0 ;
printf("[+] AF_ALG supporté\n") ;
memset(&sa, 0, sizeof(sa)) ;
sa.salg_family = AF_ALG ;
strcpy((char *)sa.salg_type, "aead") ;
strcpy((char *)sa.salg_name, "authencesn") ;
if (bind(sockfd, (struct sockaddr *)&sa, sizeof(sa)) != 0)
perror("[-] bind authencesn échoué") ;
printf("[!] Algo non disponible → vulnérabilité peu probable\n") ;
close(sockfd) ;
return 0 ;
printf("[+] authencesn disponible\n") ;
opfd = accept(sockfd, NULL, 0) ;
if (opfd < 0)
perror("[-] accept échoué") ;
close(sockfd) ;
return 1 ;
printf("[+] Socket opérationnel créé\n") ;
/* 2. Création pipe pour splice */
if (pipe(pipefd) != 0)
perror("[-] pipe") ;
close(opfd) ;
close(sockfd) ;
return 1 ;
printf("[+] Pipe créé\n") ;
/* 3. Écriture dans pipe */
const char *data = "TESTDATA" ;
if (write(pipefd[1], data, strlen(data)) < 0)
perror("[-] write pipe") ;
return 1 ;
printf("[+] Données injectées dans pipe\n") ;
/* 4. Test splice vers AF_ALG */
ssize_t spliced = splice(pipefd[0], NULL, opfd, NULL, strlen(data), 0) ;
if (spliced < 0)
perror("[-] splice échoué") ;
printf("[!] splice vers AF_ALG non fonctionnel\n") ;
printf("[+] Système probablement NON vulnérable\n") ;
else
printf("[+] splice fonctionne (%ld bytes)\n", spliced) ;
printf("[!!!] SYSTÈME POTENTIELLEMENT VULNÉRABLE à Copy Fail\n") ;
close(pipefd[0]) ;
close(pipefd[1]) ;
close(opfd) ;
close(sockfd) ;
return 0 ;
Compilation : gcc -O2 -Wall -o copyfail_check copyfail_check.c
Execution : ./copyfail_check
Analyse des résultats :
✅ Cas sécurisé
AF_ALG non disponible
OU
bind authencesn échoué
OU
splice échoue
👉 Le système n’est probablement pas exploitable.
⚠️ Cas vulnérable
[+] AF_ALG supporté
[+] authencesn disponible
[+] splice fonctionne
[!!!] SYSTÈME POTENTIELLEMENT VULNÉRABLE
👉 Toutes les conditions sont réunies pour l’exploit Copy Fail
Ce script vérifie uniquement :
- surface d’attaque exposée
- comportement attendu pour exploitation
❗ Il ne valide PAS :
- si le bug exact est présent dans ton kernel
- si un patch partiel est déjà appliqué
Cf les pièces jointes ci-dessous.