Capítulo 07
Fuzzing a escala
De una campaña de AFL++ a cientos: semillas, presupuestos, ejecuciones en paralelo, repeticiones y cómo no perder el control de todo.
Una campaña de fuzzing es un comando. Cien campañas son un plan: cuánto dura cada una, cuántas se ejecutan a la vez, dónde van los resultados y cómo los vas a comparar después. Este capítulo cubre las dos cosas.
Una campaña
Todo target ejecutable tiene una imagen para AFL++. Una campaña tiene cuatro pasos:
$ parsarium afl build zip go stdlib_openreader $ parsarium afl prepare zip go stdlib_openreader runs/zip-go-afl $ parsarium afl run runs/zip-go-afl --seconds 3600 $ parsarium afl summary runs/zip-go-afl
afl buildconstruye la imagen instrumentada y comprueba que el control produce feedback.afl preparecopia las semillas, fija el ID de la imagen y escribeplan.jsoncon el comando exacto.afl runcomprueba el plan, la imagen y los hashes de las semillas, y después ejecuta AFL++ durante el tiempo indicado.--checksolo hace las comprobaciones.--resumecontinúa una ejecución existente.afl summaryenumera los archivos dequeue/,crashes/yhangs/con sus hashes, y lee elfuzzer_statsde AFL++.
Cada target tiene también el motor de fuzzing propio de su lenguaje (libFuzzer, el fuzzing nativo de Go, Jazzer, Jazzer.js, Atheris, PHP-Fuzzer) a través de parsarium.py build y parsarium.py native. Son útiles cuando quieres comparar con la herramienta que ya usan los desarrolladores de ese lenguaje.
Semillas
Por defecto, una campaña parte del control válido del target. Es una buena semilla mínima: llega al camino principal del parsing. Un corpus de semillas más rico suele ayudar, sobre todo en formatos con muchas partes opcionales. Puedes añadir archivos con --seed o directorios completos con --seed-dir:
$ parsarium fandango setup $ parsarium fandango generate png c stb runs/stb-generated --count 100 --seed 42 $ parsarium afl prepare png c stb runs/stb-afl --seed-dir runs/stb-generated/generated
Cuando compares herramientas, dales a todas las mismas semillas, para que la comparación trate de lo que hace cada herramienta una vez que arranca.
Presupuestos
Calcula el tiempo total antes de empezar. Cada instancia de AFL++ usa un núcleo de CPU. Con T targets, S segundos cada uno, R repeticiones y P campañas en paralelo, el tiempo real es aproximadamente T × S × R / P. Cien targets de una hora cada uno, repetidos cinco veces en dieciséis núcleos, son algo más de 31 horas. Deja uno o dos núcleos libres para Docker y el sistema, y revisa el espacio en disco: las colas y los logs crecen con cada campaña.
Los targets con puente hacen menos ejecuciones por segundo que los compilados. Si usas el mismo presupuesto de tiempo real para ambos, dilo en tu informe; si prefieres igualar el número de ejecuciones, el execs_done de AFL++ en fuzzer_stats te da la cifra.
Ejecutar muchas campañas
El banco genera un script que ejecuta una selección target a target. Para ejecutar varias a la vez, escribe la lista de targets en un archivo y usa xargs:
cat > targets.txt <<'EOF'
png c stb
png rust png
zip go stdlib_openreader
zip python stdlib_zipfile
EOF
run_one() {
set -- $1
dir="runs/batch/$1-$2-$3"
parsarium afl build "$1" "$2" "$3" &&
parsarium afl prepare "$1" "$2" "$3" "$dir" &&
parsarium afl run "$dir" --seconds 3600 &&
parsarium afl summary "$dir" > /dev/null
}
export -f run_one
xargs -P 4 -I{} bash -c 'run_one "{}"' < targets.txt
Usa parsarium projects --format zip para consultar los slugs. Cada campaña escribe su propio plan.json, campaign.json y afl-summary.json, así que un lote se puede recoger y comparar más tarde con un script corto.
Repeticiones
El fuzzing es aleatorio. Dos campañas con la misma semilla y el mismo presupuesto pueden terminar con una cobertura distinta y encontrar crashes distintos. Una sola ejecución por target dice poco de una herramienta. Ejecuta cada configuración varias veces, presenta la mediana y la dispersión, y usa un test estadístico cuando afirmes que una herramienta es mejor. Klees et al., "Evaluating Fuzz Testing" (CCS 2018) es la referencia estándar y merece la pena leerla antes de un experimento grande.
Ideas clave
- Una campaña son cuatro comandos: build, prepare, run y summary.
--checkverifica un plan y--resumecontinúa uno. - Da a todas las herramientas las mismas semillas, para que la comparación trate de lo que hace cada herramienta una vez arranca.
- El tiempo total es aproximadamente targets × segundos × repeticiones ÷ campañas en paralelo. Cada instancia de AFL++ usa un núcleo.
- El fuzzing es aleatorio. Repite cada configuración y presenta la dispersión, no una sola ejecución.
Comprueba lo que sabes
Responde a las cinco para ver tu resultado
50 targets, 2 horas cada uno, 5 repeticiones y 10 campañas en paralelo. ¿Cuánto dura más o menos el experimento?
- 10 horas
- 50 horas
- 500 horas
50 × 2 × 5 = 500 horas de campaña; divididas entre 10 en paralelo, unas 50 horas.
¿Qué hace afl run --check?
- Comprueba el plan, la imagen y los hashes de las semillas sin lanzar la campaña
- Lanza una campaña de un minuto
- Busca crashes en el target
Es un ensayo en seco: todo lo que una campaña verifica antes de empezar, y nada más.
Vas a comparar dos fuzzers. ¿Qué semillas deberías usar?
- Las que genere cada herramienta por su cuenta
- El control para una herramienta y un corpus grande para la otra
- El mismo conjunto de semillas para las dos
Con las mismas semillas aíslas el efecto de la herramienta. Con semillas distintas mezclas dos variables.
¿Por qué ejecutar cada configuración varias veces?
- Para aprovechar todo el hardware
- Porque dos ejecuciones con la misma configuración pueden terminar con cobertura y crashes distintos
- Porque AFL++ lo exige
La mutación aleatoria recorre caminos distintos cada vez. Una sola ejecución por configuración dice poco de la herramienta.
Una campaña se paró a mitad porque la máquina se reinició. ¿Cómo la continúas?
afl runcon--resumesobre el mismo directorio de ejecución- Preparas una ejecución nueva con la cola como semillas
- Empiezas de cero; AFL++ no puede continuar
--resume continúa el directorio afl-out/ existente, con su cola y sus estadísticas.
Ejercicios
Ejercicio 7.1Calentamiento
Usa el banco para crear una selección de cuatro targets de ZIP, uno por lenguaje, y descarga su manifiesto. Ejecútala con un presupuesto de cinco minutos por target:
$ parsarium run-selection sel-….json --mode afl --seconds 300
Recoge execs_per_sec, corpus_count y saved_crashes de cada afl-summary.json.
Pista
Selecciona ZIP, pon Targets por formato × lenguaje a 1 y elige cuatro lenguajes.
Solución
Las cifras de cada target están en instances[0].fuzzer_stats de su afl-summary.json. Los targets compilados suelen tener el execs_per_sec más alto. Guarda la tabla: el ejercicio 7.3 parte de ella.
Ejercicio 7.2Práctica
Mide el efecto de las semillas. Genera un corpus de PNG con Fandango y ejecuta stb_image dos veces durante diez minutos: una solo con el control y otra con las semillas generadas.
$ parsarium fandango setup $ parsarium fandango generate png c stb runs/stb-generated --count 100 --seed 42 $ parsarium afl prepare png c stb runs/stb-control-only $ parsarium afl prepare png c stb runs/stb-seeded --seed-dir runs/stb-generated/generated $ parsarium afl run runs/stb-control-only --seconds 600 $ parsarium afl run runs/stb-seeded --seconds 600
Compara corpus_count y edges_found. ¿Ayuda el conjunto de semillas más rico? ¿Basta una ejecución para afirmarlo?
Pista
fandango setup instala la versión fijada. Ejecuta antes afl build png c stb si todavía no has construido la imagen.
Solución
Un corpus de semillas variado suele empezar con más cobertura, porque ya contiene tipos de chunk que el control no tiene. Que termine más alto a los diez minutos es menos seguro. Una ejecución de cada no basta para afirmar una diferencia; ejecuta cada configuración al menos cinco veces y compara las medianas, como explica el capítulo 9.
Ejercicio 7.3Reto
Escribe un script que recorra un directorio de ejecuciones de AFL++ y escriba una fila de CSV por campaña: project, execs_done, execs_per_sec, corpus_count, saved_crashes, saved_hangs.
Pista
Cada directorio de ejecución tiene un afl-summary.json con project y una lista de instances, cada una con un diccionario fuzzer_stats.
Solución
python3 - runs/batch <<'EOF'
import csv, json, pathlib, sys
fields = ["execs_done", "execs_per_sec", "corpus_count", "saved_crashes", "saved_hangs"]
out = csv.writer(sys.stdout)
out.writerow(["project", "run", *fields])
for path in sorted(pathlib.Path(sys.argv[1]).rglob("afl-summary.json")):
summary = json.loads(path.read_text())
for instance in summary["instances"]:
stats = instance["fuzzer_stats"]
out.writerow([summary["project"], path.parent.name, *(stats.get(f, "") for f in fields)])
EOFEjecútalo una vez por lote y guarda el CSV junto al manifiesto de la selección.