Utente con privilegi ridotti  ──►  AF_ALG + splice()  ──►  Scrittura di 4 byte nella cache di pagine  ──►  ROOT

AF_ALG (API crittografica userspace)
└── modulo algif_aead
    └── template authencesn  ◄── VULNERABILE
        └── ottimizzazione in-place (2017)
            └── req->src == req->dst  ◄── pagine da splice() concatenate in scatterlist dst scrivibile

Passo 1: Aprire un socket AF_ALG AEAD
        socket(AF_ALG, SOCK_SEQPACKET, 0)

Passo 2: Inviare pagine splice() che referenziano il file target
        (pagine cache di pagine di un binario con privilegi, es. /usr/bin/sudo)

Passo 3: Attivare la scrittura scratch su authencesn
        authencesn usa il buffer dst come area scratch →
        scrive 4 byte controllati OLTRE la regione di output legittima

Passo 4: La voce nella cache di pagine per il file target è ora corrotta
        (file su disco intatto — solo la copia in memoria è modificata)

Passo 5: Eseguire il binario modificato → ROOT

# Corretto nel commit: a664bf3d603d
git show a664bf3d603d

CVE-2026-31431-CopyFail/
│
├── 📄 README.md                          ← Sei qui
├── 📄 LICENSE                            ← Licenza per ricerca/educazione
├── 📄 DISCLAIMER.md                      ← Politica di uso legale ed etico
├── 📄 CHANGELOG.md                       ← Cronologia versioni
│
├── 📂 docs/
│   ├── vulnerability-analysis.md         ← Approfondimento: causa e meccanismi
│   ├── exploitation-walkthrough.md       ← Metodologia passo-passo
│   ├── affected-kernels.md               ← Matrice completa versioni kernel/distribuzioni
│   ├── detection.md                      ← Copertura Defender, Tenable, Wazuh
│   └── references.md                     ← Tutti i CVE, blog, advisory
│
├── 📂 exploit/
│   ├── README.md                         ← Utilizzo, prerequisiti, distribuzioni testate
│   ├── copyfail.py                       ← PoC di riferimento (educativo)
│   ├── trigger.c                         ← Trigger C per AF_ALG + splice()
│   └── variants/
│       ├── ubuntu.py                     ← Variante specifica per Ubuntu
│       ├── rhel.py                       ← Variante per RHEL/CentOS
│       └── amazon_linux.py              ← Variante per Amazon Linux
│
├── 📂 detection/
│   ├── yara/
│   │   └── copyfail.yar                  ← Regola YARA per artefatti exploit
│   ├── sigma/
│   │   └── copyfail_lpe.yml              ← Regola Sigma per SIEM/SOC
│   └── scripts/
│       ├── check_vulnerable.sh           ← Verifica rapida vulnerabilità kernel
│       └── detect_algif_aead.sh         ← Controlla se il modulo è caricato/attivo
│
├── 📂 mitigation/
│   ├── README.md                         ← Panoramica mitigazione
│   ├── disable_algif_aead.sh             ← Disabilita il modulo kernel affetto
│   ├── patch-notes.md                    ← Dettagli patch upstream
│   └── kubernetes-hardening.md          ← Hardening per K8s / container
│
├── 📂 lab/
│   ├── Vagrantfile                       ← Macchina virtuale vulnerabile riproducibile
│   ├── setup.sh                          ← Script di bootstrap del laboratorio
│   └── docker/
│       └── Dockerfile                    ← Container Ubuntu vulnerabile
│
├── 📂 reports/
│   ├── pentest-report-template.md        ← Template report pronto per il cliente
│   └── sample-finding.md                ← Esempio di segnalazione di vulnerabilità
│
└── 📂 assets/
    ├── demo.gif                          ← (Opzionale) demo terminale
    └── diagrams/
        └── page-cache-write.png         ← Diagramma del flusso di attacco

# Clona il repository
git clone https://github.com/0xFuffM3/CVE-2026-31431-CopyFail.git
cd CVE-2026-31431-CopyFail

# Avvia la VM vulnerabile del laboratorio
cd lab/
vagrant up

# Connettiti via SSH al laboratorio
vagrant ssh

# Verifica la versione del kernel (dovrebbe essere vulnerabile)
uname -r

cd lab/docker/

# Crea l'immagine del container vulnerabile
docker build -t copyfail-lab .

# Esegui con i privilegi necessari per interazione con il kernel
docker run --rm -it --privileged copyfail-lab /bin/bash

# Esegui lo script di controllo rapido
chmod +x detection/scripts/check_vulnerable.sh
./detection/scripts/check_vulnerable.sh

[!] Versione kernel: 5.15.0-91-generic
[!] Modulo algif_aead: CARICATO
[✗] Il sistema appare VULNERABILE a CVE-2026-31431 (Copy Fail)
[*] Azione consigliata: Applicare l'aggiornamento del kernel o disabilitare algif_aead

[✓] Versione kernel: 6.1.132
[✓] Il sistema appare PATCHATO contro CVE-2026-31431 (Copy Fail)

# Python 3.6+
python3 --version

# Moduli kernel richiesti presenti
lsmod | grep algif_aead

# Verifica che il binario target sia leggibile
ls -la /usr/bin/sudo

cd exploit/

# Controlla il livello di privilegio corrente
id
# uid=1000(utente) gid=1000(utente) gruppi=1000(utente)

# Esegui il PoC di Copy Fail
python3 copyfail.py

# Verifica la scalata di privilegi
id
# uid=0(root) gid=0(root) gruppi=0(root)

1. Enumera la versione del kernel
   └─► uname -r / cat /proc/version

2. Verifica se algif_aead è caricato
   └─► lsmod | grep algif_aead

3. Conferma il punto d'appoggio con privilegi ridotti
   └─► id / whoami

4. Esegui il PoC di Copy Fail
   └─► python3 exploit/copyfail.py

5. Verifica l'accesso root
   └─► id && cat /etc/shadow

6. Documenta le prove
   └─► Screenshot + registra versione kernel, distribuzione, hash exploit

7. Applica la mitigazione (dopo il test)
   └─► sudo bash mitigation/disable_algif_aead.sh

8. Includi nel report di pentest
   └─► Usa reports/pentest-report-template.md

// detection/yara/copyfail.yar
rule CopyFail_CVE_2026_31431 {
    meta:
        description = "Rileva artefatti dell'exploit Copy Fail (CVE-2026-31431)"
        author      = "0xFuffM3"
        date        = "2026-04-30"
        reference   = "https://copy.fail"
    strings:
        $py1 = "algif_aead" ascii
        $py2 = "AF_ALG" ascii
        $py3 = "splice" ascii
        $py4 = "page_cache" ascii
        $py5 = "authencesn" ascii
    condition:
        3 of them
}

yara detection/yara/copyfail.yar /tmp/ -r

# detection/sigma/copyfail_lpe.yml
title: Esecuzione exploit LPE Copy Fail (CVE-2026-31431)
status: stable
logsource:
    category: process_creation
    product: linux
detection:
    selection:
        CommandLine|contains:
            - 'AF_ALG'
            - 'algif_aead'
            - 'authencesn'
    condition: selection
falsepositives:
    - Test legittimo dell'API crittografica
level: high

chmod +x detection/scripts/detect_algif_aead.sh
./detection/scripts/detect_algif_aead.sh

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

# RHEL / CentOS
sudo yum update kernel

# Amazon Linux
sudo yum update kernel

# Dopo l'aggiornamento, riavviare
sudo reboot

# Esegui lo script di mitigazione
chmod +x mitigation/disable_algif_aead.sh
sudo bash mitigation/disable_algif_aead.sh

echo "install algif_aead /bin/false" > /etc/modprobe.d/disable-algif.conf
rmmod algif_aead 2>/dev/null || echo "[*] Modulo non attualmente caricato"
echo "[✓] algif_aead disabilitato. Riavviare per confermare la persistenza."

Segnalazione: Scalata di privilegi locale tramite Copy Fail (CVE-2026-31431)
Gravità:    ALTA (CVSS 7.8)
Host:       10.10.10.55 (ubuntu-prod-01)
Kernel:     5.15.0-91-generic

Prove:
  - Shell senza privilegi (uid=1000) scalata a root (uid=0)
  - Modulo kernel algif_aead confermato caricato
  - Nessun artefatto su disco — solo cache di pagine

Raccomandazione:
  1. Applicare immediatamente la patch del kernel del fornitore
  2. In via temporanea: disabilitare il modulo algif_aead
  3. Verificare nodi Kubernetes e runner CI/CD