strongcourage/uafuzzFuzzer dirigido a nivel de binario especializado en detectar vulnerabilidades de Use-After-Free mediante métricas de entrada sensibles al orden y análisis estático, lo que permite la reproducción de errores, las pruebas de parches y la verificación de informes.
Directed Greybox Fuzzing (DGF) como AFLGo tiene como objetivo realizar pruebas de estrés en ubicaciones objetivo potencialmente vulnerables preseleccionadas, con aplicaciones a diferentes contextos de seguridad: (1) reproducción de errores, (2) pruebas de parches o (3) verificación de informes de análisis estático. Recientemente hay más trabajos de investigación que mejoraron la efectividad y eficiencia del fuzzing dirigido (ver awesome-directed-fuzzing).
Proponemos UAFuzz, que es un fuzzer dirigido dedicado a errores Use-After-Free (UAF) a nivel binario al ajustar cuidadosamente los componentes clave del fuzzing dirigido para satisfacer las características específicas de esta clase de error. Los errores UAF aparecen cuando un elemento del heap se utiliza después de haber sido liberado. Detectar errores UAF es difícil: (1) complejidad porque una entrada de Prueba de Concepto (PoC) necesita desencadenar una secuencia de tres eventos – asignación, liberación y uso – en la misma ubicación de memoria, abarcando múltiples funciones del programa probado y (2) silencio sin fallo de segmentación.
En general, UAFuzz tiene el mismo flujo de trabajo que los fuzzers dirigidos con nuestras modificaciones resaltadas en naranja a lo largo de todo el proceso de fuzzing, como se muestra en la siguiente figura. Como nos centramos en aplicaciones de (1) reproducción de errores y (2) pruebas de parches, es más probable que tengamos rastros de pila (mayormente) completos de todos los eventos UAF relacionados con la memoria. A diferencia de los enfoques dirigidos generales existentes donde los objetivos podrían seleccionarse de forma independiente, tenemos en cuenta la relación entre los objetivos (por ejemplo, el orden que es esencial para los UAF) para mejorar la direccionalidad. Primero, el precálculo estático de UAFuzz es rápido a nivel binario. Segundo, introducimos nuevas métricas de entrada conscientes del orden para guiar al fuzzer hacia los objetivos en tiempo de ejecución. Finalmente, triamos solo las entradas potenciales que cubren todos los objetivos en el rastro esperado y prefiltramos las entradas libres que tienen menos probabilidades de desencadenar el error.
Más detalles en nuestro artículo en RAID'20 y nuestra charla en Black Hat USA'20. Gracias también a Sébastien Bardin, Matthieu Lemerre, Prof. Roland Groz y especialmente a Richard Bonichon (@rbonichon) por su ayuda en Ocaml.
Nuestro entorno de prueba es Ubuntu 16.04 de 64 bits.
# Instalar Ocaml y paquetes prerequisites para BINSEC vía OPAM
sudo apt update
sudo apt update
sudo apt install ocaml ocaml-native-compilers camlp4-extra opam emacs llvm-6.0-dev pkg-config protobuf-compiler libgmp-dev libzmq3-dev cmake valgrind
opam init
opam switch 4.05.0
opam depext conf-m4.1
opam install merlin ocp-indent caml-mode tuareg menhir ocamlgraph ocamlfind piqi zmq.5.0.0 zarith llvm.6.0.0
eval `opam config env`
# Instalar paquetes de Python (Python 2 para scripts de IDA)
sudo python -m pip install networkx pydot
sudo apt install graphviz
# Instalar Graph Easy
wget https://cpan.metacpan.org/authors/id/S/SH/SHLOMIF/Graph-Easy-0.76.tar.gz
tar xzf Graph-Easy-0.76.tar.gz
cd Graph-Easy-0.76
perl Makefile.PL; make test; sudo make install
export GRAPH_EASY_PATH=/usr/local/bin/graph-easy
# Obtener código fuente
git clone https://github.com/strongcourage/uafuzz.git
# Variables de entorno
export IDA_PATH = /path/to/ida-6.9/idaq
export GRAPH_EASY_PATH=/path/to/graph-easy
cd uafuzz; export UAFUZZ_PATH=`pwd`
# Compilar código fuente
./scripts/build.sh uafuzz
# Ayuda para la interfaz IDA/UAFuzz
./binsec/src/binsec -ida-help
./binsec/src/binsec -uafuzz-help
Nuestro fuzzer está construido sobre AFL v2.52b en modo QEMU para fuzzing y BINSEC para análisis estático ligero (ver uafuzz/README.md). Actualmente usamos IDA Pro v6.9 para extraer gráficos de flujo de control (CFGs) y el grafo de llamadas del binario probado (ver ida/README.md).
uafuzz
├── binsec/src
│ └── ida: un plugin para importar y procesar los CFGs y el grafo de llamadas de IDA
│ └── uafuzz: código de fuzzing
│ │ └── afl-2.52b: fuzzing central construido sobre AFL-QEMU
│ │ └── uafuzz_*.ml(i): un plugin para calcular información estática y comunicarse con AFL-QEMU
└── scripts: algunos scripts para construir y triar errores
Primero consideramos un error UAF simple. Tanto AFL-QEMU como incluso el fuzzer dirigido AFLGo con objetivos a nivel de código fuente no pueden detectar este error en 6 horas, mientras que UAFuzz puede detectarlo en minutos con la ayuda de un informe UAF de Valgrind.
# Ejecutar AFL-QEMU
$UAFUZZ_PATH/tests/example.sh aflqemu 360
# Ejecutar AFLGo dados los objetivos a nivel de código fuente
$UAFUZZ_PATH/tests/example.sh aflgo 360
# Ejecutar UAFuzz
$UAFUZZ_PATH/tests/example.sh uafuzz 360 $UAFUZZ_PATH/tests/example/example.valgrind
Para programas del mundo real, usamos el UAF Fuzzing Benchmark para nuestras evaluaciones.
# Obtener el benchmark
git clone https://github.com/strongcourage/uafbench.git
cd uafbench; export UAFBENCH_PATH=`pwd`
Mostramos en detalle cómo ejecutar UAFuzz para la aplicación de reproducción de errores de CVE-2018-20623 de readelf (Binutils). Los rastros de pila de este error UAF obtenidos por Valgrind son los siguientes:
// rastro de pila para el Uso incorrecto
==5358== Invalid read of size 1
==5358== at 0x40A9393: vfprintf (vfprintf.c:1632)
==5358== by 0x40A9680: buffered_vfprintf (vfprintf.c:2320)
==5358== by 0x40A72E0: vfprintf (vfprintf.c:1293)
[6] ==5358== by 0x80AB881: error (elfcomm.c:43)
[5] ==5358== by 0x8086217: process_archive (readelf.c:19409)
[1] ==5358== by 0x80868EA: process_file (readelf.c:19588)
[0] ==5358== by 0x8086B01: main (readelf.c:19664)
// rastro de pila para la Liberación
==5358== Address 0x4221dc0 is 0 bytes inside a block of size 80 free'd
==5358== at 0x402D358: free (in /usr/lib/valgrind/vgpreload_memcheck-x86-linux.so)
[4] ==5358== by 0x8086647: process_archive (readelf.c:19524)
[1] ==5358== by 0x80868EA: process_file (readelf.c:19588)
[0] ==5358== by 0x8086B01: main (readelf.c:19664)
// rastro de pila para la Asignación
==5358== Block was alloc'd at
==5358== at 0x402C17C: malloc (in /usr/lib/valgrind/vgpreload_memcheck-x86-linux.so)
[3] ==5358== by 0x80AD97E: make_qualified_name (elfcomm.c:906)
[2] ==5358== by 0x8086350: process_archive (readelf.c:19435)
[1] ==5358== by 0x80868EA: process_file (readelf.c:19588)
[0] ==5358== by 0x8086B01: main (readelf.c:19664)
El script de preprocesamiento toma el binario probado en x86 y los rastros de pila de Valgrind como entradas, luego genera el rastro del error UAF que es una secuencia de ubicaciones objetivo en el formato (basic_block_address,function_name) como el siguiente:
[0] (0x8086ae1,main) -> [1] (0x80868de,process_file) -> [2] (0x808632c,process_archive) ->
[3, alloc] (0x80ad974,make_qualified_name) -> [4, free] (0x808663a,process_archive) ->
[5] (0x808620b,process_archive) -> [6, use] (0x80ab86a,error)
Proporcionamos una plantilla de script de fuzzing con varios parámetros de entrada, por ejemplo, el fuzzer que queremos ejecutar, el tiempo de espera en minutos y los objetivos predefinidos (por ejemplo, extraídos del informe de error). Para el ejemplo anterior, usamos el script CVE-2018-20623.sh y ejecutamos UAFuzz como:
# Ejecutar UAFuzz con tiempo de espera de 60 minutos
$UAFBENCH_PATH/CVE-2018-20623.sh uafuzz 60 $UAFBENCH_PATH/valgrind/CVE-2018-20623.valgrind
Después del tiempo de espera de fuzzing, UAFuzz puede identificar qué entradas cubren en secuencia todas las ubicaciones objetivo del rastro de error UAF esperado (por ejemplo, nombre de entrada que termina con ',all'). Por lo tanto, UAFuzz solo tria esos tipos de entradas que probablemente desencadenen el error deseado utilizando herramientas de perfilado existentes como Valgrind o AddressSanitizer.
Usamos CVE-2018-6952 de GNU Patch para ilustrar la importancia de producir diferentes entradas únicas que desencadenen errores para favorecer el proceso de reparación. Había un doble free en GNU Patch que fue corregido por los desarrolladores (commit 9c98635). Sin embargo, al usar los rastros de pila de CVE-2018-6952, UAFuzz descubrió una corrección de error incompleta CVE-2019-20633 de la última versión 2.7.6 (commit 76e7758), con una ligera diferencia en el rastro del error. En general, el proceso es similar a la aplicación de reproducción de errores, excepto que podría requerirse algo de trabajo manual para identificar el rastro objetivo del error UAF. Usamos entradas PoC de errores existentes y archivos válidos de fuzzing-corpus como semillas de alta calidad.
# Fuzzear la versión parcheada de CVE-2018-6952
$UAFBENCH_PATH/CVE-2019-20633.sh uafuzz 360 $UAFBENCH_PATH/valgrind/CVE-2018-6952.valgrind
Un posible enfoque híbrido es combinar UAFuzz con GUEB, que es el único analizador estático a nivel binario escrito en Ocaml para UAF. Sin embargo, GUEB produce muchos falsos positivos y actualmente no puede funcionar correctamente con binarios complejos. Por lo tanto, actualmente mejoramos e integramos GUEB en BINSEC y luego usamos los objetivos extraídos de los informes de GUEB para guiar a UAFuzz. ¡Manténganse al tanto!