Fuzzilli

Un fuzzzer guidato dalla copertura per interpreti di linguaggi dinamici basato su un linguaggio intermedio personalizzato ("FuzzIL") che può essere mutato e tradotto in JavaScript.

Utilizzo

I passi fondamentali per utilizzare questo fuzzzer sono:

1. Scaricare il codice sorgente di uno dei motori JavaScript supportati. Consulta la directory Targets/ per l'elenco dei motori JavaScript supportati.
2. Applicare le patch corrispondenti dalla directory del target. Vedi anche il README.md in quella directory.
3. Compilare il motore con strumentazione di copertura (richiede clang >= 4.0) come descritto nel README.
4. Compilare il fuzzzer: swift build [-c release].
5. Eseguire il fuzzzer: swift run [-c release] FuzzilliCli --profile=<profilo> [altre opzioni CLI] /percorso/del/jsshell. Vedi anche swift run FuzzilliCli --help.

La compilazione e l'esecuzione di Fuzzilli e dei motori JavaScript supportati all'interno di Docker e su Google Compute Engine è anche supportata.

Hacking

Dai un'occhiata a main.swift per vedere un esempio di utilizzo della libreria Fuzzilli e sperimentare con le varie opzioni di configurazione. Successivamente, guarda Fuzzer.swift per la logica di fuzzing di alto livello. Da lì, approfondisci qualsiasi parte che sembri interessante.

Patch, aggiunte e altri contributi a questo progetto sono benvenuti! Tuttavia, dai un'occhiata rapidamente alle note per i contributori. Fuzzilli segue approssimativamente la guida di stile del codice di Google per Swift.

Sarebbe molto apprezzato se potessi inviare una breve nota (possibilmente includendo un numero CVE) a [email protected] o aprire una pull request per qualsiasi vulnerabilità trovata con l'aiuto di questo progetto, in modo che possa essere inclusa nella sezione vetrina dei bug. Per il resto, puoi ovviamente rivendicare qualsiasi bounty per bug, crediti CVE, ecc. per le vulnerabilità :)

Concetto

Quando si fuzzza per bug del core dell'interprete, ad esempio nei compilatori JIT, la correttezza semantica dei programmi generati diventa un problema. Questo è in contrasto con la maggior parte degli altri scenari, ad esempio il fuzzing delle API runtime, in cui la correttezza semantica può essere facilmente aggirata racchiudendo il codice generato in costrutti try-catch. Esistono diverse possibilità per ottenere un tasso accettabile di campioni semanticamente corretti, una delle quali è un approccio mutazionale in cui tutti i campioni nel corpus sono anche semanticamente validi. In tal caso, ogni mutazione ha solo una piccola probabilità di trasformare un campione valido in uno non valido.

Per implementare un fuzzzer JavaScript basato su mutazioni, è necessario definire mutazioni per il codice JavaScript. Invece di mutare l'AST o altri elementi sintattici di un programma, viene definito un linguaggio intermedio personalizzato (IL) sul quale le mutazioni al flusso di controllo e di dati di un programma possono essere eseguite più direttamente. Questo IL viene poi tradotto in JavaScript per l'esecuzione. Il linguaggio intermedio ha approssimativamente il seguente aspetto:

v0 <− LoadInteger '0'
v1 <− LoadInteger '10'
v2 <− LoadInteger '1'
v3 <− LoadInteger '0'
BeginFor v0, '<', v1, '+', v2 −> v4
   v6 <− BinaryOperation v3, '+', v4
   Reassign v3, v6
EndFor
v7 <− LoadString 'Result: '
v8 <− BinaryOperation v7, '+', v3
v9 <− LoadGlobal 'console'
v10 <− CallMethod v9, 'log', [v8]

Che può, ad esempio, essere tradotto banalmente nel seguente codice JavaScript:

const v0 = 0;
const v1 = 10;
const v2 = 1;
let v3 = 0;
for (let v4 = v0; v4 < v1; v4 = v4 + v2) {
    const v6 = v3 + v4;
    v3 = v6;
}
const v7 = "Result: ";
const v8 = v7 + v3;
const v9 = console;
const v10 = v9.log(v8);

Oppure al seguente codice JavaScript inlineando le espressioni intermedie:

let v3 = 0;
for (let v4 = 0; v4 < 10; v4++) {
    v3 = v3 + v4;
}
console.log("Result: " + v3);

FuzzIL ha una serie di proprietà:

• Un programma FuzzIL è semplicemente una lista di istruzioni.
• Un'istruzione FuzzIL è un'operazione insieme a variabili di input e output e potenzialmente uno o più parametri (racchiusi tra virgolette singole nella notazione sopra).
• Gli input per le istruzioni sono sempre variabili, non ci sono valori immediati.
• Ogni output di un'istruzione è una nuova variabile, e le variabili esistenti possono essere riassegnate solo tramite operazioni dedicate come l'istruzione Reassign.
• Ogni variabile è definita prima di essere utilizzata.

Su questi programmi possono essere eseguite diverse mutazioni:

• InputMutator: sostituisce le variabili di input delle istruzioni con altre diverse per mutare il flusso di dati del programma.
• CodeGenMutator: genera codice e lo inserisce da qualche parte nel programma mutato. Il codice viene generato eseguendo un generatore di codice o copiando alcune istruzioni da un altro programma nel corpus (splicing).
• CombineMutator: inserisce un programma dal corpus in una posizione casuale nel programma mutato.
• OperationMutator: muta i parametri delle operazioni, ad esempio sostituendo una costante intera con una diversa.
• e altri...

Una discussione molto più approfondita su come funziona Fuzzilli può essere trovata qui.

Implementazione

Il fuzzzer è implementato in Swift, con alcune parti (ad esempio misurazioni della copertura, interazioni socket, ecc.) implementate in C.

Architettura

Un'istanza del fuzzzer (implementata in Fuzzer.swift) è composta dai seguenti componenti centrali: