dvyukov/centipedeMotor de fuzzing distribuido guiado por cobertura, compatible con objetivos de libFuzzer; escala a miles de trabajos concurrentes, emplea sanitizadores y destilación de corpus para descubrir errores.
¿Por qué no? Actualmente intentamos fuzzear objetivos muy grandes y muy lentos para los que libFuzzer, AFL y similares no escalan necesariamente bien. Para uno de nuestros ejemplos motivadores, ver SiliFuzz. Mientras trabajamos en Centipede, planeamos experimentar con nuevos enfoques de fuzzing diferencial a gran escala que los motores de fuzzing existentes no intentan hacer.
Características notables:
Soporte listo para usar para objetivos de fuzzing basados en libFuzzer. Para
usar tu LLVMFuzzerTestOneInput() favorito solo necesitas compilar tu objetivo
con las opciones de compilador y enlazador de Centipede.
Trabajo en curso. Probamos centipede en un equipo pequeño con un par de objetivos. A menos que formes parte del proyecto Centipede, o quieras ayudarnos, probablemente aún no quieras seguir leyendo.
Escalabilidad. La intención es poder ejecutar cualquier número de trabajos de forma concurrente, con muy poca sobrecarga de comunicación. Actualmente probamos con 100 trabajos locales y con 10 000 trabajos en un clúster.
Fuera de proceso. El objetivo se ejecuta en un proceso separado. Cualquier fallo en él no afectará al fuzzer. Centipede también se puede usar en el mismo proceso, pero este modo no es el objetivo principal. Si tu objetivo es pequeño y rápido, probablemente sigas queriendo libFuzzer.
La integración con los sanitizadores se logra mediante compilaciones separadas. Si durante el fuzzing quieres encontrar errores con ASAN, MSAN o TSAN, tendrás que proporcionar binarios separados para cada sanitizador, además de un binario principal para el propio Centipede. El binario principal no debe usar ninguno de los sanitizadores.
Ninguna parte de la interfaz interna es estable. Cualquier cosa puede cambiar en esta etapa.
Un programa que produce un flujo infinito de entradas para un objetivo y orquesta la ejecución.
Un binario, una biblioteca, una API, o más bien cualquier cosa que pueda consumir bytes como entrada y producir algún tipo de datos de cobertura como salida. Un objetivo de libFuzzer puede ser un objetivo de Centipede. Lee más aquí .
Una secuencia de bytes que se puede proporcionar a un objetivo. La entrada puede ser un conjunto arbitrario de bytes, o algún dato estructurado, p. ej. un proto serializado.
Un número que representa algún comportamiento único del objetivo. Por ejemplo, una característica 1234567 puede representar el hecho de que el bloque básico número 987 del objetivo se ha ejecutado 7 veces. Al ejecutar una entrada con el objetivo, el fuzzer recopila las características que se observaron durante la ejecución.
Un conjunto de características asociado a una entrada específica.
Información sobre el comportamiento del objetivo cuando ejecuta una entrada dada. La cobertura se representa normalmente como el conjunto de características que la entrada ha activado en el objetivo.
Una función que toma bytes como entrada y produce una pequeña mutación aleatoria de la entrada. Ver también: fuzzing sensible a la estructura .
Una función que sabe cómo introducir una entrada en un objetivo y obtener cobertura a cambio (es decir, ejecutar).
Un motor de fuzzing personalizable que permite al usuario sustituir el mutador y el ejecutor.
Una biblioteca que implementa la interfaz de ejecutor que espera el fuzzer Centipede. El runner sabe cómo ejecutar un objetivo instrumentado con sancov, recopilar la cobertura resultante y pasársela a Centipede. Los posibles objetivos de fuzzing de Centipede se pueden enlazar con esta biblioteca para que Centipede pueda ejecutarlos.
Un conjunto de entradas.
Un proceso de selección de un subconjunto de un corpus más grande, de modo que el subconjunto tenga las mismas características de cobertura que el corpus original.
Un archivo que representa un subconjunto del corpus y otro archivo que representa los conjuntos de características para ese mismo subconjunto del corpus.
Fusionar el shard B en el shard A significa: para cada entrada del shard B que tenga características que falten en el shard A, añadir esa entrada a A.
Un único proceso del fuzzer. Un trabajo escribe solo en un shard, pero puede leer varios shards.
Un directorio local o remoto que contiene datos producidos o consumidos por un fuzzer.
git clone https://github.com/google/centipede.git
cd centipede
CENTIPEDE_SRC=`pwd`
BIN_DIR=$CENTIPEDE_SRC/bazel-bin
bazel build -c opt :all
Lo que necesitarás para los siguientes pasos:
$BIN_DIR/centipede - el binario del motor (el fuzzer).$BIN_DIR/libcentipede_runner.pic.a - la biblioteca con la que necesitas enlazar tu objetivo de fuzzing (el runner).$CENTIPEDE_SRC/clang-flags.txt - las banderas de compilación de clang recomendadas para el objetivo.Puedes dejar estos archivos donde están o copiarlos a otro lugar.
Proporcionamos dos ejemplos de compilación del objetivo: un objetivo diminuto de un solo archivo y libpng. Una vez que hayas compilado tu objetivo, continúa con el paso de ejecución del objetivo de fuzzing.
Este ejemplo usa uno de los objetivos de fuzzing de ejemplo sencillos, también conocidos como puzzles, incluidos en el repositorio de Centipede.
NOTA: Los comandos siguientes usan las banderas de $CENTIPEDE_SRC/clang-flags.txt. Puedes elegir usar otro conjunto de banderas de instrumentación: clang-flags.txt solo proporciona una opción predeterminada simple.
FUZZ_TARGET=byte_cmp_4 # or any other source under $CENTIPEDE_SRC/puzzles
clang++ @$CENTIPEDE_SRC/clang-flags.txt -c $CENTIPEDE_SRC/puzzles/$FUZZ_TARGET.cc -o $BIN_DIR/$FUZZ_TARGET.o
Este paso enlaza el objetivo de fuzzing recién compilado con libcentipede_runner.pic.a y otras bibliotecas necesarias.
clang++ $BIN_DIR/$FUZZ_TARGET.o $BIN_DIR/libcentipede_runner.pic.a \
-ldl -lrt -lpthread -o $BIN_DIR/$FUZZ_TARGET
Salta al paso de ejecución.
LIBPNG_BRANCH=v1.6.37 # You can experiment with other branches if you'd like
git clone --branch $LIBPNG_BRANCH --single-branch https://github.com/glennrp/libpng.git
cd libpng
CC=clang CFLAGS=@$CENTIPEDE_SRC/clang-flags.txt ./configure --disable-shared
make -j
FUZZ_TARGET=libpng_read_fuzzer
clang++ -include cstdlib \
./contrib/oss-fuzz/$FUZZ_TARGET.cc \
./.libs/libpng16.a \
$BIN_DIR/libcentipede_runner.pic.a \
-ldl -lrt -lpthread -lz \
-o $BIN_DIR/$FUZZ_TARGET