Rainfuzz : reinforcement-learning driven heat-maps for boosting coverage-guided fuzzing

Fuzzing is a dynamic-analysis technique that consists in repeatedly executing the target program with many different inputs, with the goal of triggering abnormal behaviour, such as a crash. One of the most successful techniques consists in generating inputs with the purpose of increasing code-coverage, by using a mutational approach: this type of fuzzers maintains a population of inputs, they perform mutations on the inputs in the current population, and they add mutated inputs to the population if they discover new codecoverage in the target program. Researchers are continuously looking for techniques to increment the efficiency of fuzzers; one of this techniques consists in generating heat-maps for targeting specific bytes during the mutation of the input, as not all bytes might be useful for controlling the program’s work-flow. We propose the first approach in the literature that uses reinforcement-learning for building heat-maps, by formalizing the problem of choosing the position to be mutated within the input as a “contextual multi-armed bandit”. We model the policy by means of a neural-network, and we train it by using Proximal Policy Optimization techniques (PPO). We implement our approach in Rainfuzz and we show the effectiveness of its heat-maps by comparing Rainfuzz against an equivalent fuzzer that performs mutations at random positions; in a 24H experiment using libjpeg-turbo as PUT, Rainfuzz finds an edge-coverage of 1291, while the random version finds an edge coverage of 1133. We achieve the best performance by running AFL++ and Rainfuzz in parallel (in a “collaborative fuzzing” setting) with an edge-coverage of 1473. This configuration outperforms a setting where two AFL++ instances are run in parallel (here we observe an edge-coverage of 1414).

il “Fuzzing” è una tecnica di analisi dinamica che consiste nell’ eseguire ripetutamente il programma da testare con molti input diversi, con lo scopo di far emergere comportamenti anomali, come un “crash”. Una delle tecniche più affermate consiste nel generare i nuovi input allo scopo di aumentare la “code-coverage”, utilizzando un approccio mutazionale: i fuzzer di questo tipo mantengono una popolazione di input, ad ogni step applicano una mutazione ad uno di questi input, ed aggiungono l’ input mutato alla popolazione se raggiunge nuova “edge-coverage” nel programma sotto test. I ricercatori nel campo sono costantemente alla ricerca di nuove tecniche per incrementare l’ efficienza dei fuzzer. Una di queste tecniche consiste nel generare delle “heat-map” per focalizzare le mutazioni in specifiche zone dell’ input, in quanto non tutti i byte potrebbero essere utili a controllare il flusso di esecuzione del programma. Proponiamo il primo approccio in letteratura che usa reinforcement-learning per costruire delle “heat-map”, formalizzando il problema di scegliere una posizione per eseguire le mutazioni come un “contextual multi-armed bandit”. Modelliamo la policy con una neural-network, e la alleniamo usando tecniche di “Proximal Policy Optimization” (PPO). Implementiamo il nostro approccio in Rainfuzz; mostriamo la funzionalità delle sue heat-map confrontando Rainfuzz con un fuzzer equivalente ma che esegue le mutazioni in posizioni casuali; in un esperimento di 24 ore usando libjpeg-turbo come programma sotto test, Rainfuzz raggiunge una “edge-coverage” di 1291, mentre la versione casuale raggiunge una “edge-coverage” di 1133. Raggiungiamo la performance migliore eseguendo AFL++ e Rainfuzz in parallelo (in una configurazione di “fuzzing collaborativo”) con una “edge-coverage” di 1473. Questa coppia sorpassa una configurazione in cui due istanze di AFL++ vengono eseguite in parallelo (dove osserviamo una “edge-coverage” di 1414).