Analisi Approfondita della Catena di Exploit: CVE-2021-3156 (Baron Samedit)

Autore: IJ Baig
Data: 7 luglio 2026

1. ID CVE, Versioni Interessate e Conferma della Build

• ID CVE: CVE-2021-3156
• Tipo di Vulnerabilità: Buffer Overflow basato su Heap
• Intervallo di Versioni Interessate: Versioni legacy di Sudo da 1.8.2 a 1.8.31p2, e versioni stabili da 1.9.0 a 1.9.5p1.
• Versione Target Compilata: Sudo 1.9.5p1

1.1 Configurazione dell'Ambiente

Per analizzare in sicurezza questa vulnerabilità, la versione vulnerabile di Sudo è stata compilata in un ambiente isolato e non di produzione.

1.2 Compilazione dal Codice Sorgente

Il codice sorgente di Sudo 1.9.5p1 è stato scaricato e compilato localmente utilizzando le utility standard make. È stata prestata attenzione a eseguire questa operazione da una directory locale in modo da non sovrascrivere il binario sudo nativo e patchato del sistema host.

Conferma della Build: Dopo la compilazione, il binario personalizzato è stato eseguito per verificare che fosse stata compilata la versione vulnerabile corretta.

2. Analisi della Causa Principale

2.1 Posizione del Codice Vulnerabile

• File: plugins/sudoers/sudoers.c
• Funzione: set_cmnd() (circa linea 864 nella versione 1.9.5p1)

2.2 Spiegazione della Vulnerabilità

Immagina di avere un assistente il cui compito è rimuovere i caratteri di escape (backslash) da una lista di parole prima di inserirle in una nuova scatola di memoria allocata (un buffer heap). L'assistente presume ciecamente che ogni backslash sia sempre seguito da un carattere valido, quindi ogni volta che vede un backslash, lo salta e copia il carattere successivo.

Tuttavia, esiste un difetto nel modo in cui il programma gestisce gli argomenti quando si esegue sudoedit -s. Permette a un utente di introdurre una parola che termina esattamente con un singolo backslash (\), che è immediatamente seguito dal marcatore invisibile di fine parola (un terminatore nullo, \0).

Quando il codice dell'assistente raggiunge questo backslash finale, lo salta e guarda il carattere successivo—il terminatore nullo. Invece di fermarsi, la logica dell'istruzione if costringe l'assistente a saltare anche il terminatore nullo. Il ciclo continua, copiando nella scatola di memoria qualsiasi dato arbitrario fuori dai limiti che viene dopo. Questa copia continua oltre la lunghezza prevista della parola causa un overflow del buffer designato, portando a un grave buffer overflow basato su heap.

Frammento di Codice Vulnerabile:

/* Unescape characters, skipping over backslashes */
for (to = user_args, av = NewArgv + 1; (from = *av); av++) {
    while (*from) {
        // VULNERABILITY: If from[0] is '\' and from[1] is '\0', 
        // the loop evaluates to true, increments 'from', skipping the null terminator.
        if (from[0] == '\\' && !isspace((unsigned char)from[1]))
            from++;
        *to++ = *from++; 
    }
    *to++ = ' ';
}
*--to = '\0';

2.3 Spiegazione della Patch e della Correzione Ufficiale

Gli sviluppatori di Sudo hanno corretto questo errore logico nella versione 1.9.5p2 aggiungendo un rigoroso controllo dei limiti. Il codice ora verifica esplicitamente che il carattere successivo al backslash non sia il terminatore nullo prima di tentare di rimuovere l'escape.

Differenza della Patch:

- if (from[0] == '\\' && !isspace((unsigned char)from[1]))
+ if (from[0] == '\\' && from[1] != '\0' && !isspace((unsigned char)from[1]))

Perché questo corregge la causa principale: L'aggiunta di from[1] != '\0' arresta immediatamente la lettura fuori dai limiti. Ora, se il codice incontra un backslash finale alla fine della stringa (il che significa che from[1] è il terminatore nullo), l'istruzione if restituisce falso. Il puntatore non viene incrementato prematuramente, il terminatore nullo viene elaborato correttamente come fine della stringa e il ciclo termina in modo sicuro senza causare overflow dell'heap.

3. Riproduzione dell'Exploit

3.1 Prova di Concetto Pubblica (PoC)

Per questa riproduzione, è stato utilizzato il noto exploit Python sviluppato dal ricercatore di sicurezza Worawit (in particolare la variante exploit_nss.py).

3.2 Analisi dell'Esecuzione del PoC

Prima di eseguire il PoC, è fondamentale comprenderne il meccanismo. Lo script non si limita a far crashare il programma; orchestra una manipolazione estremamente precisa della memoria per ottenere l'esecuzione di codice.

Ecco l'analisi passo-passo delle operazioni del PoC:

1. Generazione del Payload: Lo script compila dinamicamente un payload C malevolo in un file oggetto condiviso (.so). Questo payload è progettato per eseguire /bin/sh come root.
2. Feng Shui dell'Heap: Lo script imposta variabili d'ambiente specifiche (come LC_ALL, LANG e TZ). Poiché Sudo carica le variabili d'ambiente nell'heap all'avvio, lo script calcola le dimensioni esatte necessarie per organizzare l'heap in un layout prevedibile.
3. L'Overflow: Lo script esegue sudoedit -s e passa un argomento da riga di comando che termina con un singolo backslash. Questo attiva la vulnerabilità off-by-one discussa nella Sezione 2, causando una scrittura fuori dai limiti.
4. Targeting della Struct NSS: La scrittura fuori dai limiti sovrascrive con precisione una specifica struttura glibc nella memoria heap adiacente: la struct service_user. Questa struct è utilizzata dal Name Service Switch (NSS) per cercare informazioni di sistema.
5. Esecuzione del Codice: La struct service_user viene corrotta in modo da puntare alla libreria .so malevola compilata nel Passaggio 1. Quando Sudo tenta di cercare i privilegi dell'utente, carica ed esegue ciecamente la libreria dell'attaccante, concedendo una shell di root.

3.3 Attivazione della Vulnerabilità (Sudo 1.9.5p1)

Innanzitutto, è stato condotto un test di crash di base per dimostrare l'esistenza della vulnerabilità senza armarla.

Successivamente, lo script completo exploit_nss.py di Worawit è stato eseguito contro il binario vulnerabile.

3.4 Verifica della Patch (Sudo 1.9.5p2)

Per verificare la correzione ufficiale, lo stesso trigger PoC è stato eseguito contro il binario Sudo patchato.

sudoedit -s '\' 2>&1 | grep -q "sudoedit:" && echo "Vulnerable" || echo "Not vulnerable"

4. Riepilogo Non Tecnico

Sudo, un programma amministrativo standard utilizzato sui nostri server, contiene un difetto critico nel modo in cui elabora gli input di testo contenenti backslash. Inviando con cura un comando malformato, un attaccante con accesso utente base può ingannare il sistema facendogli scrivere dati al di fuori della sua area di memoria designata. Questo errore gli permette di bypassare completamente i controlli di sicurezza e ottenere il pieno controllo amministrativo non autorizzato sulla macchina senza mai aver bisogno di una password.

5. Sfide Affrontate e Lezioni Apprese

Sfide: Una delle sfide principali è stata la fragilità della manipolazione dell'heap. I payload di exploit che targetizzano versioni specifiche del sistema operativo spesso falliscono su altre perché la libreria C standard sottostante (glibc) gestisce i blocchi di memoria in modo diverso. Armare con successo questa vulnerabilità ha richiesto una comprensione esatta dell'allineamento della memoria e dei layout delle variabili d'ambiente (Heap Feng Shui) specifici per l'ambiente target.

Lezioni Apprese: Da una prospettiva difensiva e di operazioni di sicurezza, questa analisi approfondita ha rafforzato diversi concetti critici:

• Il Valore degli Ambienti di Laboratorio Controllati: Passare da ambienti guidati basati sul web (come TryHackMe) alla costruzione e allo sfruttamento di un binario vulnerabile dal sorgente localmente fornisce una comprensione molto più profonda di come i meccanismi sottostanti del sistema operativo determinano la fattibilità dell'exploit.
• L'Ingegneria del Rilevamento è Fondamentale: Affidarsi esclusivamente al patching dei binari SUID è insufficiente perché il ciclo di patch richiede tempo. Esplorare questo exploit ha evidenziato la necessità di robuste regole di rilevamento SIEM. Monitorare la telemetria di esecuzione dei processi per comandi sudoedit -s sospetti che terminano con caratteri di escape potrebbe permettere a un team SOC di rilevare tentativi di exploit prima che una patch sia completamente distribuita nell'infrastruttura.
• Confini dei Privilegi: L'esercizio ha sottolineato l'enorme rischio associato ai binari SUID. Poiché Sudo viene eseguito con privilegi di root fin dalla sua prima istruzione, qualsiasi errore di logica di parsing all'avvio garantisce il compromesso totale del sistema.

6. Bonus: Vulnerabilità Parallele in Sudo

CVE Parallelo: CVE-2019-14287 (Bypass di Sicurezza di Sudo) Un'altra vulnerabilità prominente nello stesso codebase di Sudo condivide un pattern di causa principale simile: parsing e validazione impropri dell'input utente. In CVE-2019-14287, un difetto logico nel modo in cui Sudo analizzava l'ID utente (UID) ha permesso a un attaccante di eseguire comandi come root specificando l'ID utente -1 o 4294967295.

Il Parallelo: Mentre Baron Samedit (CVE-2021-3156) è un difetto di corruzione della memoria e CVE-2019-14287 è un bypass di autorizzazione, la causa principale in entrambi i casi è un fallimento nella logica iniziale di parsing degli argomenti. Entrambe le vulnerabilità derivano dal fatto che Sudo si fida e gestisce in modo errato argomenti della riga di comando borderline (backslash finali vs. avvolgimenti inaspettati di interi) prima di eseguire le sue funzioni privilegiate principali.

Dichiarazione di Sicurezza ed Etica: Tutto lo sfruttamento e i test dimostrati in questo rapporto sono stati condotti interamente all'interno di una macchina virtuale locale isolata e autorizzata. Nessun sistema di produzione o rete non autorizzata è stato preso di mira o ha interagito durante questo esercizio.