Rilevamento COPY FAIL con Wazuh 4.14.4 - CVE-2026-31431

Detection engineering per l'LPE del kernel Copy Fail · Ubuntu / RHEL / SUSE / Amazon Linux 2023 / Kali

Cos'è Copy Fail?

CVE-2026-31431 è un bug logico nel template crittografico authencesn del kernel Linux. Consente a qualsiasi utente locale non privilegiato di eseguire una scrittura deterministica e controllata di 4 byte nella page cache di qualsiasi file leggibile sul sistema - senza richiedere race condition, offset del kernel o privilegi elevati.

Uno script Python 3.10+ di 732 byte che utilizza solo moduli della libreria standard (os, socket, zlib) sfrutta la vulnerabilità per ottenere root su tutte le principali distribuzioni Linux rilasciate dal 2017.

Il file su disco rimane invariato, rendendo il tradizionale monitoraggio dell'integrità dei file (FIM) completamente cieco.

Scoperto da Taeyang Lee (Theori / Xint) con l'assistenza dello strumento AI Xint Code.

Riferimenti Ufficiali

Perché il FIM Fallisce - Perché Esiste Questo Repo

La scrittura ha come bersaglio solo la page cache in memoria. Il kernel non marca mai la pagina come sporca, quindi il meccanismo di writeback non la persiste mai su disco. Il binario su disco rimane byte per byte identico all'originale.

Approccio FIM tradizionale:
  legge file da disco -> calcola hash -> confronta -> nessuna anomalia segnalata

Realtà di Copy Fail:
  file su disco = INVARIATO
  page cache   = CORROTTA
  risultato FIM = CIECO

L'unico rilevamento efficace è comportamentale, tramite il monitoraggio delle syscall. Questo repository fornisce regole Wazuh validate in produzione che rilevano la catena di exploit a livello di syscall del kernel.

Catena di Exploit

Passo 1: socket(38, 5, 0)       socket AF_ALG - nessun privilegio richiesto
Passo 2: bind()                  Bind a authencesn - attiva il codice vulnerabile
Passo 3: sendmsg()               Costruisce payload AAD - byte 4-7 = valore da scrivere
Passo 4: splice()          [!]   TRIGGER - le pagine della page cache entrano in SGL scrivibile
Passo 5: recv()                  authencesn scrive seqno_lo nella page cache
Passo 6: execve(/usr/bin/su)     Il binario setuid corrotto esegue shellcode come UID 0

splice() è il passaggio critico. Consegna le pagine della page cache nello scatterlist scrivibile del socket AF_ALG senza copiarle - un'ottimizzazione in-place del 2017 in algif_aead.c che rendeva riutilizzabili le pagine del buffer della pipe nel SGL di destinazione. Quando authencesn.decrypt() viene eseguito, scrive in quelle pagine, che risultano essere la page cache del file bersaglio.

Distribuzioni Interessate

Tutte le distribuzioni Linux che distribuiscono kernel successivi al commit 72548b093ee3 (2017) sono interessate.

Fuga dal container: Copy Fail è anche un vettore di fuga dal container. La page cache è condivisa tra tutti i processi sull'host, inclusi quelli oltre i confini dei container. La Parte 2 di Xint copre lo sfruttamento in Kubernetes.

Struttura del Repository

COPY-FAIL-Detection-with-Wazuh-4.14.4/
│
├── rules/
│   └── local_rules.xml              # 8 regole di rilevamento Wazuh (199600-199607)
│
├── auditd/
│   └── cve-2026-31431.rules         # regole sensore syscall auditd
│
├── sca/
│   └── cve_2026_31431.yml           # policy SCA - indipendente dalla versione del kernel
│
└── docs/
    ├── pentlab_uid.png               # Esecuzione PoC - root ottenuta su Kali
    ├── Rule-199604-TRIGs.png         # Regola 199604 - 80 hit su pentlab
    ├── Rule_199604_Wazuh_Server_only.png  # Regola 199604 - prima validazione
    ├── Splice_-_Non-root_process.png # Regole 199600/199601/199604 attivate
    ├── Modprobe_-_Possible_Algif_aed_load_attempt.png  # Regola 199603
    ├── Pentlab-PoC.png               # Regola 199603 sull'agente pentlab
    ├── exploit_chain_timeline.svg    # Catena di Exploit
    └── SCA_CVE-2026-31431.png        # Punteggio policy SCA 75%

Architettura di Rilevamento

Due livelli indipendenti — nessuno dei due dipende dalla versione del kernel.

Livello 1 - Rilevamento Comportamentale (auditd + Wazuh)

Il filtro uid!=0 copre utenti oltre gli account interattivi: account di servizio (www-data, postgres, jenkins), container e web shell senza sessione di login.

Regole sensore auditd (auditd/cve-2026-31431.rules):

-a always,exit -F arch=b64 -S socket -F a0=0x26 -F uid!=0 -k copy_fail_af_alg
-a always,exit -F arch=b32 -S socket -F a0=0x26 -F uid!=0 -k copy_fail_af_alg
-a always,exit -F arch=b64 -S splice -F uid!=0 -k copy_fail_splice
-w /usr/bin/su    -p x -k copy_fail_execve_su
-w /usr/bin/kmod  -p x -k copy_fail_modload

Livello 2 - Superficie di Vulnerabilità (Policy SCA)

Controlli di configurazione automatizzati ogni 12 ore tramite sca/cve_2026_31431.yml. Nessuna versione del kernel richiesta.

Architettura della Catena di Regole

Nota ingegneristica: Le regole 199600 e 199601 devono essere figlie della regola 92600 (processo Python, profondità 1), non della 80700. Il motore delle regole Wazuh segue un solo percorso di catena per evento. Posizionare le regole di rilevamento a profondità 2 sotto la 92600 garantisce che vincano la valutazione della catena rispetto alle regole sorelle (es. 92603-92606 in 0850-audit_rules.xml che corrispondono anch'esse a if_group=audit + exe=python).

Distribuzione

Passo 1 - Installare auditd

# Ubuntu / Debian / Kali
apt install auditd audispd-plugins -y
systemctl enable --now auditd
auditctl -s | grep enabled

# RHEL / Amazon Linux
yum install audit -y
systemctl enable --now auditd

# SUSE
zypper install audit -y
systemctl enable --now auditd

Passo 2 - Distribuire le regole sensore auditd

cp auditd/cve-2026-31431.rules /etc/audit/rules.d/
augenrules --load
auditctl -l | grep copy_fail

Output atteso:

-a always,exit -F arch=b64 -S socket -F a0=0x26 -F uid!=0 -F key=copy_fail_af_alg
-a always,exit -F arch=b32 -S socket -F a0=0x26 -F uid!=0 -F key=copy_fail_af_alg
-a always,exit -F arch=b64 -S splice -F uid!=0 -F key=copy_fail_splice
-w /usr/bin/su -p x -k copy_fail_execve_su
-w /usr/bin/kmod -p x -k copy_fail_modload

Passo 3 - Distribuire le regole di rilevamento Wazuh

Le regole sono fornite in rules/local_rules.xml. Puoi unire il contenuto nel tuo /var/ossec/etc/rules/local_rules.xml esistente o distribuirle come file autonomo:

# Opzione A - file autonomo
cp rules/local_rules.xml /var/ossec/etc/rules/cve-2026-31431_rules.xml

# Opzione B - aggiungi a local_rules.xml
cat rules/local_rules.xml >> /var/ossec/etc/rules/local_rules.xml

# Valida la sintassi - deve uscire con 0 e zero warning
/var/ossec/bin/wazuh-analysisd -t 2>&1 | tail -5

# Riavvia il manager
systemctl restart wazuh-manager

Passo 4 - Distribuire la policy SCA

cp sca/cve_2026_31431.yml /var/ossec/etc/shared/default/

Aggiungi a ossec.conf all'interno del blocco <sca>:

<policies>
  <policy>/var/ossec/etc/shared/default/cve_2026_31431.yml</policy>
</policies>

systemctl restart wazuh-manager

Passo 5 - Configurare localfile in ossec.conf

Assicurati che Wazuh acquisisca il log auditd:

<!-- Aggiungi all'interno di <ossec_config> -->
<localfile>
  <log_format>audit</log_format>
  <location>/var/log/audit/audit.log</location>
</localfile>

Validazione

Test rapido (nessun exploit - solo syscall)

# Crea un utente di test se necessario
useradd -m testuser 2>/dev/null || true

# Genera SEGNALE 1 - socket AF_ALG
su - testuser -c "python3 -c \"import socket; socket.socket(38, 5, 0); print('AF_ALG OK')\""

# Genera SEGNALE 3 - esecuzione /usr/bin/su
su - testuser -c "/usr/bin/su --help 2>/dev/null || true"

# Verifica che auditd abbia catturato gli eventi
ausearch -k copy_fail_af_alg -ts recent 2>/dev/null | grep "key=\|exe=\|uid=" | head -5

# Verifica che Wazuh abbia generato gli alert
grep -E "199600|199602" /var/ossec/logs/alerts/alerts.log | tail -10

Valida i risultati SCA

grep -E "31431|cve_2026" /var/ossec/logs/alerts/alerts.log | tail -10

Punteggio SCA atteso (sistema non mitigato): 75% (3 superati / 1 fallito - algif_aead non in blacklist)

Evidenze di Validazione in Produzione

Esecuzione PoC - Root ottenuta su Kali (pentlab)

testuser (uid=1001) ha eseguito il PoC di 732 byte e ha ottenuto una shell root:

Regola 199604 - CATENA DI EXPLOIT RILEVATA (pentlab, 80 hit)

Socket AF_ALG + splice() dallo stesso processo python - pid=46784 - INDAGINE IMMEDIATA RICHIESTA:

Regola 199604 - Prima validazione (server Wazuh, pid=53447)

Regole 199600 / 199601 / 199604 - splice() e AF_ALG attivate

Regola 199603 - esecuzione modprobe rilevata (93 hit)

Regola 199603 - agente pentlab (35 hit)

Policy SCA - Punteggio 75% (3 superati / 1 fallito)

Risultati Wazuh Dashboard Discover (agente=pentlab, Oggi):

wazuh-analysisd -t: uscita 0 - zero warning - tutte le 8 regole caricate.

Rimedio

Mitigazione immediata (prima della patch)

rmmod algif_aead 2>/dev/null || true
echo 'install algif_aead /bin/false' > /etc/modprobe.d/disable-algif-aead.conf

Questo non influisce su dm-crypt/LUKS, kTLS, IPsec, OpenSSL, GnuTLS o SSH.

Fix permanente

Applica il commit del kernel a664bf3d603d tramite l'aggiornamento del kernel della tua distribuzione. Annulla l'ottimizzazione in-place del 2017 in algif_aead.c, separando req->src (SGL TX, dove splice consegna le pagine) da req->dst (SGL RX, buffer utente). Tutte le principali distribuzioni stanno distribuendo il fix.

# Ubuntu / Debian
apt update && apt upgrade linux-generic

# RHEL / Amazon Linux
dnf update kernel

# SUSE
zypper update kernel-default

Cronologia della Divulgazione

Confronto con Vulnerabilità Simili

Riepilogo Policy SCA

Autore

Kislley Rodrigues (m0us3r) Ambasciatore Wazuh | Detection Engineering | Blue Team

Ringraziamenti

• Taeyang Lee (Theori / Xint) per la scoperta, il write-up e la divulgazione coordinata di CVE-2026-31431
• Team Wazuh per la piattaforma SIEM/XDR open source e il Programma Ambasciatori
• Xint Research per la profondità tecnica su https://xint.io/blog/copy-fail-linux-distributions

Regole di rilevamento, configurazione sensore auditd e policy SCA validate su Wazuh 4.14.4, Ubuntu 24.04.2 LTS (kernel 6.8.0-106-generic) e Kali GNU/Linux 2026.1 (kernel 6.18.12+kali-amd64).

Aggiornamento 2026-05-03

Wazuh

Questo progetto è stato sviluppato come parte del Programma Ambasciatori Wazuh.

Wazuh è una piattaforma di sicurezza open source e gratuita che fornisce protezione XDR e SIEM unificata. Scopri di più su wazuh.com.