KaPilot: LLM-Assisted Generation of Kani Specifications for Unsafe Rust Verification

Immagina di costruire una casa con un set di mattoni magici e autocorrettivi. Questi mattoni, chiamati "Rust", sono famosi perché hanno un ispettore di sicurezza integrato che si rifiuta di lasciarti costruire qualsiasi cosa instabile. Se provi a mettere una finestra dove dovrebbe esserci un muro, l'ispettore urla "No!" e ti ferma prima ancora di posare la prima pietra. Questo rende Rust incredibilmente sicuro per costruire software, prevenendo crash e falle di sicurezza prima che accadano. Tuttavia, a volte un maestro costruttore ha bisogno di fare qualcosa che l'ispettore non comprende — come usare uno strumento speciale e pericoloso per spostare una trave pesante velocemente. Nel mondo di Rust, questo è chiamato "codice unsafe". È come un passaggio segreto che ti permette di aggirare l'ispettore, ma comporta un prezzo pesante: se commetti un singolo errore, l'intera casa potrebbe crollare. Per mantenere la casa in piedi, devi scrivere un "regolamento" (chiamato specifica) molto rigoroso e matematico che provi esattamente come usare questi strumenti pericolosi. Ma scrivere questi regolamenti a mano è incredibilmente difficile, lento e incline all'errore umano.

È qui che inizia la storia di KaPilot. I ricercatori dietro questo progetto si sono posti una domanda semplice: possiamo insegnare a un cervello informatico super intelligente (un'IA) di scrivere questi regolamenti di sicurezza per noi? La sfida è che queste IA sono bravissime a scrivere codice, ma spesso copiano gli errori nel codice che vedono, invece di comprenderne l'intento. Potrebbero scrivere un regolamento che sembra perfetto ma che manca di un dettaglio minuscolo e mortale. Il documento presenta KaPilot, un team di agenti IA che lavorano insieme per risolvere questo enigma. Invece di chiedere semplicemente all'IA di "scrivere una regola", KaPilot agisce come un detective, uno scrittore e un rigoroso editor, tutto in uno. Legge le note del costruttore (documentazione), estrae le vere regole di sicurezza, scrive una bozza, la controlla per cercare falle e poi la sottopone a un test rigoroso per assicurarsi che funzioni davvero. Il risultato è un sistema in grado di generare automaticamente regole di sicurezza di alta qualità per il codice pericoloso, rendendo molto più facile costruire software sicuri senza la necessità di un team di esperti umani per scrivere ogni singola regola a mano.

Il Detective, Lo Scrittore e L'Editor

Pensa al processo di verifica del codice Rust unsafe come al tentativo di scrivere un manuale di istruzioni perfetto per un'auto da corsa ad alta velocità che non ha freni. Se il manuale è sbagliato, l'auto si schianta. Se il manuale è troppo vago, il pilota non sa come guidare. Se il manualo è troppo rigido, il pilota non può muoversi affatto.

KaPilot è un framework multi-agente, che è solo un modo elaborato per dire che è un team di personaggi IA specializzati che lavorano insieme. Ecco come interpretano i loro ruoli:

1. Il Detective (SafetyReq): Prima di scrivere qualsiasi cosa, il team deve sapere quali dovrebbero essere le regole. Di solito, queste regole sono nascoste nelle note disordinate e scritte dagli umani (documentazione) che accompagnano il codice. L'agente "SafetyReq" agisce come un detective. Legge queste note, ignora il superfluo ed estrae un elenco pulito e conciso di requisiti di sicurezza. È come trasformare un racconto confuso su "non toccare il pulsante rosso" in un elenco numerato chiaro: "1. Non premere il pulsante rosso. 2. Non stare entro 5 piedi dal pulsante rosso". Questo passaggio è cruciale perché impedisce all'IA di limitarsi a copiare gli errori del codice.
2. Lo Scrittore (SpecGenerate): Una volta che il detective ha l'elenco, entra in gioco l'agente "SpecGenerate". È lo scrittore che trasforma quell'elenco in un linguaggio formale e matematico che il computer può comprendere (specificamente, un linguaggio chiamato Kani). Non va a tentativi; usa l'elenco del detective come una guida rigorosa.
3. L'Editor (SpecPrecheck): Prima che la bozza dello scrittore vada al capo finale, l'agente "SpecPrecheck" la revisiona. È un editor severo che chiede: "Hai coperto ogni punto trovato dal detective? La tua frase è troppo debole? È troppo forte?". Se la bozza è trascurata, l'editor la rimanda allo scrittore con note specifiche su come correggerla. Questo avviene in un ciclo finché la bozza non è solida.
4. Il Pilota di Prove (SpecVerify): Infine, l'agente "SpecVerify" prende la bozza e la sottopone a un test nel mondo reale. Utilizza uno strumento chiamato Kani per simulare milioni di diversi scenari di guida per vedere se l'auto si schianta. Se l'auto si schianta (la verifica fallisce), il Pilota di Prove dice allo Scrittore esattamente perché è successo, e il ciclo ricomincia.

La Strategia "Mescola e Mischia"

Ecco dove il team diventa davvero astuto. A volte l'IA genera diverse versioni del regolamento. Una versione potrebbe avere una condizione di "inizio" (precondizione) perfetta ma una condizione di "fine" (postcondizione) debole. Un'altra potrebbe avere un inizio debole ma una fine perfetta. Se ne scegliessi solo una, potresti perdere la combinazione migliore.

KaPilot utilizza una strategia chiamata "shuffle-and-implication" (mescola e implicazione). Immagina di avere un mazzo di carte, dove ogni carta è una parte diversa del regolamento. Il team mescola queste carte, unendo la migliore "parte iniziale" di una versione con la migliore "parte finale" di un'altra. Testano poi queste nuove combinazioni per vedere se funzionano meglio delle bozze originali. È come prendere il miglior motore da un'auto e le migliori gomme da un'altra per costruire l'auto da corsa definitiva. Questo assicura che non si accontentino di un regolamento "abbastanza buono", ma trovino il migliore possibile.

Cosa Hanno Scoperto

I ricercatori hanno testato KaPilot su 124 diversi pezzi di codice Rust unsafe. Li hanno divisi in due gruppi:

• Il Gold Set (54 funzioni): Queste avevano regolamenti con "verità di base" (ground truth) scritti da esperti umani, quindi il team poteva controllare se il lavoro di KaPilot fosse corretto.
• L'Ultra Set (70 funzioni): Queste non avevano regolamenti umani, quindi il team ha solo controllato se KaPilot riuscisse a generare un qualsiasi regolamento funzionante.

I risultati sono stati impressionanti. Per il Gold Set, KaPilot è riuscito a generare un regolamento funzionante per l'88,9% delle funzioni. Ancora più importante, nel 57,4% dei casi, il regolamento scritto era altrettanto buono o addirittura migliore di quello scritto dagli esperti umani. Per l'Ultra Set, è riuscito a creare regolamenti funzionanti per il 71,4% delle funzioni.

Quando hanno confrontato KaPilot con un altro strumento di IA chiamato AutoSpec (che è stato adattato per lavorare con questo nuovo sistema), KaPilot ha vinto a mani basse. Ha prodotto il 14,8% di regolamenti in più che superavano i test e il 25,9% in più di regolamenti semanticamente equivalenti o migliori di quelli scritti dagli umani.

Perché Questo È Importante

L'articolo sostiene che semplicemente chiedere a un'IA di "scrivere una regola di sicurezza basata su questo codice" non funziona bene. L'IA tende a copiare i difetti del codice o a confondersi con la complessità. Scomponendo il compito in un team di specialisti — uno per leggere le note, uno per scrivere, uno per editare e uno per testare — KaPilot evita queste trappole.

I ricercatori hanno anche scoperto che la qualità delle note umane (documentazione) conta molto. Se le note sono vaghe, l'IA fatica. Ma quando le note sono chiare, KaPilot brilla. Hanno anche scoperto che la loro strategia di "mescolamento" è un ingrediente chiave; senza di essa, il sistema si sarebbe spesso accontentato di una soluzione mediocre invece di trovare la combinazione perfetta di regole.

In breve, KaPilot suggerisce che non dobbiamo scegliere tra l'esperienza umana e la velocità dell'IA. Usando l'IA come un team di assistenti specializzati che seguono un processo logico e rigoroso, possiamo automatizzare la creazione di regole di sicurezza per le parti più pericolose del nostro software, rendendo il mondo digitale un posto più sicuro in cui vivere. Il documento non sostiene di aver risolto ogni problema (alcuni cicli complessi richiedono ancora l'aiuto umano), ma dimostra che questo approccio multi-agente è un passo avanti enorme nel rendere la verifica del software automatica e affidabile.