parsarium

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.

6 min de lectura5 preguntas3 ejercicios

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 build construye la imagen instrumentada y comprueba que el control produce feedback.
  • afl prepare copia las semillas, fija el ID de la imagen y escribe plan.json con el comando exacto.
  • afl run comprueba el plan, la imagen y los hashes de las semillas, y después ejecuta AFL++ durante el tiempo indicado. --check solo hace las comprobaciones. --resume continúa una ejecución existente.
  • afl summary enumera los archivos de queue/, crashes/ y hangs/ con sus hashes, y lee el fuzzer_stats de 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. --check verifica un plan y --resume continú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?

  1. 10 horas
  2. 50 horas
  3. 500 horas

50 × 2 × 5 = 500 horas de campaña; divididas entre 10 en paralelo, unas 50 horas.

¿Qué hace afl run --check?

  1. Comprueba el plan, la imagen y los hashes de las semillas sin lanzar la campaña
  2. Lanza una campaña de un minuto
  3. 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?

  1. Las que genere cada herramienta por su cuenta
  2. El control para una herramienta y un corpus grande para la otra
  3. 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?

  1. Para aprovechar todo el hardware
  2. Porque dos ejecuciones con la misma configuración pueden terminar con cobertura y crashes distintos
  3. 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?

  1. afl run con --resume sobre el mismo directorio de ejecución
  2. Preparas una ejecución nueva con la cola como semillas
  3. 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)])
EOF

Ejecútalo una vez por lote y guarda el CSV junto al manifiesto de la selección.