Riepilogo Tecnico: KCOV-DATAFLOW

1. Problema

I fuzzer per il kernel guidati dalla copertura, come syzkaller, si affidano esclusivamente alla copertura degli archi (trace-pc) come segnale di feedback. Questo approccio soffre di un "gap semantico" fondamentale: identifica quali blocchi di codice di base sono stati eseguiti, ma non con quali valori. Di conseguenza, due invocazioni di una funzione (ad esempio copy_from_user() o vfs_open()) con diversi valori di argomento attraversano archi di controllo-flusso identici, pur possedendo implicazioni di sicurezza drasticamente diverse.

Questa limitazione porta alla saturazione della copertura in sottosistemi stateful (ad esempio ksmbd, io_uring, binder) dove il comportamento critico per la sicurezza dipende dai valori degli argomenti a runtime piuttosto che dalla topologia del controllo-flusso. Le alternative esistenti non riescono ad affrontare il problema su larga scala:

• Tracciamento dinamico (ftrace/kprobes): Impone un elevato overhead per funzione, inadatto al fuzzing continuo.
• Annotazione manuale (IJON): Infattibile per i oltre 30 milioni di righe di codice del kernel Linux.
• Copertura sensibile al contesto (Angora, CollAFL): Esplode in complessità con il dispatch polimorfico.
• DataFlowSanitizer: Incurre in un overhead di 10–100×, rendendolo inutilizzabile per il fuzzing del kernel.
• Analisi post-mortem (drgn/vmcore): Non riesce a catturare gli argomenti delle funzioni Rust sotto l'ottimizzazione -O2 a causa dell'elisione delle variabili DWARF.

2. Metodologia: KCOV-DATAFLOW

Il documento presenta KCOV-DATAFLOW, un framework di strumentazione basato su LLVM che estende il Linux KCOV per catturare tuple di data-flow (argomenti delle funzioni e valori di ritorno) ai confini delle funzioni. Il sistema opera senza annotazione a livello di sorgente ed è progettato per un'operazione continua a basso overhead.

Architettura

Il sistema consiste di tre livelli:

1. Strumentazione a tempo di compilazione (LLVM Pass):

   • Estende l'attuale framework SanitizerCoverage.
   • All'ingresso e al ritorno della funzione, il pass emette callback che catturano tuple strutturate: <PC, arg_idx, arg_size, ptr, offsets[]>.
   • Decomposizione delle Strutture: Decompone automaticamente i tipi compositi (struct/union) percorrendo i metadati DICompositeType da DWARF. Genera un array di costanti a tempo di compilazione di offset e dimensioni dei campi, consentendo al runtime di estrarre specifici valori dei campi senza modifica del codice sorgente.
   • Supporto Rust: Fornisce due percorsi:
     • Post-compilazione: Converte l'IR di Rust in formato testuale (.ll), applica il pass e ricompila.
     • Nativo: Costruisce rustc contro un LLVM 23 personalizzato contenente il pass, permettendo la strumentazione diretta tramite RUSTFLAGS.

2. Trasporto Runtime del Kernel:

   • Implementa un buffer circolare lock-free, per task memorizzato in task_struct.
   • Sicurezza: Utilizza READ_ONCE/WRITE_ONCE per scritture atomiche. Include una guardia in_task() per rifiutare chiamate da contesti interrupt, softirq o NMI, prevenendo problemi di rientranza.
   • Sicurezza della Memoria: Utilizza copy_from_kernel_nofault() per dereferenziare in modo sicuro i puntatori, gestendo con grazia i valori di memoria KASAN-poisoned, pagine non mappate e valori ERR_PTR senza causare crash.
   • Interfaccia: Espone un'interfaccia debugfs dedicata (/sys/kernel/debug/kcov_dataflow) indipendente dal KCOV esistente, garantendo l'assenza di interferenze con l'operazione standard di syzkaller.

3. Consumatore User-Space:

   • I fuzzer o gli analisti mappano il buffer tramite mmap() per una lettura zero-copy.
   • I record includono gli argomenti di ingresso e i valori di ritorno, consentendo la verifica offline di pre/post-condizioni.

3. Contributi Chiave

• Estensione LLVM SanitizerCoverage: Un pass del compilatore che cattura argomenti di funzione e valori di ritorno con espansione automatica dei campi delle strutture tramite metadati DICompositeType, richiedendo zero annotazioni nel codice sorgente.
• Trasporto Lock-Free Per-Task: Un meccanismo residente nel kernel che opera in sicurezza nel contesto di processo con esplicito rifiuto degli interrupt, evitando interferenze con l'infrastruttura KCOV o syzkaller esistente.
• Strumentazione Rust: I primi metodi runtime per la cattura degli argomenti delle funzioni Rust sotto ottimizzazione -O2, affrontando il fallimento dell'analisi drgn e vmcore sul codice Rust ottimizzato.
• Validazione Empirica: Dimostrato su cinque classi di vulnerabilità (OOB, UAF, Double-Free, catene profonde e moduli Rust) mostrando che il contesto di data-flow ai confini fornisce informazioni non disponibili attraverso alcuna combinazione di strumenti esistenti (copertura + sanitizer + debugger post-mortem).

4. Risultati e Valutazione

Il sistema è stato valutato su Linux-next 7.1.0-rc6 con KASAN e Rust abilitati, eseguito in un ambiente QEMU/KVM.

• Correttezza: Lo strumento ha catturato correttamente i valori pre-corruzione (ENTRY) e post-corruzione (RET) per tutti i casi di test, corrispondendo alla verità di base di printk. Ha catturato con successo le violazioni dei contratti FFI di Rust e le espansioni dei campi delle strutture.
• Guadagno di Informazione: A differenza di KASAN (che riporta l'indirizzo della violazione ma non l'argomento specifico) o drgn (che fallisce su Rust ottimizzato), KCOV-DATAFLOW identifica l'argomento esatto e il campo responsabile della corruzione, anche nei moduli Rust.
• Overhead di Performance:
  • Costo per chiamata: ~27 ns per singola callback.
  • Overhead di Registrazione: +8.3% di latenza quando la registrazione è attiva.
  • Strumentazione Globale (Senza Registrazione): Quando tutti gli oggetti del kernel sono strumentati ma la registrazione è disabilitata, la latenza delle syscall aumenta del +133% e il tempo di boot del +71%. La sezione .data aumenta del 44% a causa degli array di offset per funzione.
  • Confronto: L'overhead rientra nell'intervallo di un singolo sanitizer (ad esempio KASAN) ed è significativamente inferiore a KMSAN. Gli autori notano che la strumentazione globale è adatta per sessioni mirate, mentre la strumentazione per modulo è raccomandata per il fuzzing continuo.

5. Significato e Rivendicazioni

Il documento afferma che KCOV-DATAFLOW colma il gap semantico tra il fuzzing guidato dalla copertura e l'analisi del data-flow per i sistemi operativi. La sua importanza risiede in:

1. Rottura della Saturazione della Copertura: Fornendo un feedback consapevole dei valori, permette ai fuzzer di distinguere tra percorsi di esecuzione che differiscono solo nei valori degli argomenti, abilitando la guida delle mutazioni verso transizioni di stato dipendenti dai valori che la copertura degli archi perde.
2. Analisi Deterministica della Root-Cause: Fornisce agli analisti di sicurezza record deterministici degli argomenti per il triage senza l'overhead di printk o kprobes, e crucialmente, funziona sui moduli kernel Rust dove altri strumenti falliscono.
3. Verifica dei Contratti a Runtime: Abilita una nuova forma di "auditing originato dal runtime", dove i record catturati vengono utilizzati per verificare i contratti di pre/post-condizione (ad esempio, la coerenza dei campi delle strutture) rispetto alle specifiche formali. Ciò consente il rilevamento di bug "silenziosi" (errori logici senza crash) che l'analisi statica e i sanitizer perdono.
4. Riproducibilità: Il sistema genera artefatti deterministici (tuple PC, arg, ret) che consentono a chiunque di riprodurre e verificare indipendentemente i risultati di sicurezza, spostando il flusso di lavoro dalla revisione speculativa del codice sorgente all'analisi basata su evidenze.

Gli autori sottolineano che, sebbene lo strumento fornisca prove di potenziali violazioni (ad esempio, valori fuori limite o violazioni di contratto), la determinazione finale se un comportamento costituisca un bug richiede il giudizio umano e la conferma dei manutentori, come dimostrato dal loro ritiro delle etichette di gravità iniziali su specifici risultati di Binder dopo la revisione dei manutentori.