PolyTracker

PolyTracker es una herramienta creada originalmente para la Automated Lexical Annotation and Navigation of Parsers, un backronym ideado únicamente para el propósito de referirse a ella como The ALAN Parsers Project. Sin embargo, ha evolucionado hasta convertirse en una herramienta de propósito general para realizar de forma eficiente análisis de flujo de datos y de flujo de control de programas. PolyTracker es un pass de LLVM que instrumenta programas para rastrear qué bytes de un archivo de entrada son operados por qué funciones. Genera una base de datos que contiene la información de flujo de datos, así como una traza de ejecución. PolyTracker también proporciona una biblioteca de Python para interactuar con su salida y analizarla, además de un REPL de Python interactivo.

PolyTracker se puede utilizar junto con PolyFile para determinar automáticamente el propósito semántico de las funciones de un parser. También tiene una característica experimental capaz de generar una gramática libre de contexto que representa el lenguaje aceptado por un parser.

A diferencia de las alternativas de instrumentación dinámica como Taintgrind, PolyTracker impone una sobrecarga de rendimiento insignificante para casi todas las entradas, y es capaz de rastrear cada byte de la entrada a la vez. PolyTracker comenzó como un fork del DataFlowSanitizer de LLVM y toma mucha inspiración del Angora Fuzzer. Sin embargo, a diferencia del sistema Angora, PolyTracker es capaz de rastrear toda la proveniencia de un taint. En febrero de 2021, el DataFlowSanitizer de LLVM añadió una nueva característica para rastrear la proveniencia del taint llamada origin tracking. Sin embargo, solo es capaz de rastrear un máximo de 16 taints a la vez, mientras que PolyTracker puede rastrear hasta 2³¹-1.

Este README sirve como guía de uso general para instalar PolyTracker y compilar/instrumentar binarios. Para interactuar programáticamente con o extender PolyTracker a través de su API de Python, así como para interactuar con trazas de ejecución producidas por código instrumentado, consulta la documentación de Python.

Inicio rápido

PolyTracker se controla mediante un script de Python llamado polytracker. Puedes instalarlo ejecutando

pip3 install polytracker

PolyTracker requiere un entorno de sistema muy específico para ejecutarse, por lo que casi todos los usuarios probablemente lo ejecutarán en un entorno contenedorizado. Por suerte, polytracker lo hace fácil. Todo lo que necesitas es tener docker instalado, y luego ejecutar:

polytracker docker pull

y

polytracker docker run

El último comando montará el directorio de trabajo actual en el contenedor Docker de PolyTracker y te permitirá compilar y ejecutar programas instrumentados.

El script de control polytracker —que puedes ejecutar desde tu sistema anfitrión o desde dentro del contenedor Docker— tiene una variedad de comandos, tanto para instrumentar programas como para analizar los artefactos resultantes. Por ejemplo, puedes explorar los flujos de datos en la ejecución, reconstruir el grafo de flujo de control del programa instrumentado e incluso extraer una gramática libre de contexto que coincida con las entradas aceptadas por el programa. Puedes explorar estos comandos ejecutando

polytracker --help

El script polytracker también es un REPL, si se ejecuta sin argumentos de línea de comandos:

$ polytracker
PolyTracker (4.0.0)
https://github.com/trailofbits/polytracker
Type "help" or "commands"
>>> commands

Instrumentación de un programa simple en C/C++

PolyTracker también incluye un comando build. Este comando permite al usuario ejecutar cualquier comando de compilación en un entorno instrumentado por Blight. Esto producirá un archivo blight_journal.jsonl que registra todos los comandos ejecutados durante la compilación. Si tienes un objetivo C/C++, puedes instrumentarlo invocando polytracker build y pasando tu comando de compilación:

polytracker build gcc -g -o my_binary my_source.c

Para instrumentar un objetivo de compilación, usa el comando instrument-targets. Por defecto, el comando usará un blight_journal.jsonl en tu directorio de trabajo actual para construir una versión instrumentada de tu objetivo de compilación. El objetivo de compilación instrumentado se construirá usando las mismas banderas que el objetivo de compilación original.

polytracker instrument-targets my_binary

build también admite programas más complejos que usan un sistema de compilación como autotools o CMake:

polytracker build cmake .. -DCMAKE_BUILD_TYPE=Release
polytracker build ninja
# or
polytracker build ./configure
polytracker build make

Luego ejecuta instrument-targets en cualquiera de los objetivos de la compilación:

polytracker instrument-targets a.bin b.so

Entonces a.instrumented.bin y b.instrumented.so serán las versiones instrumentadas. Consulta los Dockerfiles en el directorio examples para ver ejemplos de cómo se pueden instrumentar programas del mundo real.

Ejecución y Análisis de un Programa Instrumentado

El software instrumentado escribirá su salida en la ruta especificada en POLYDB, o en polytracker.tdag si se omite. Este es un archivo binario que se puede operar ejecutando:

from polytracker import PolyTrackerTrace, taint_dag

trace = PolyTrackerTrace.load("polytracker.tdag")
tdfile = trace.tdfile

first_node = list(tdfile.nodes)[0]
print(f"First node affects control flow: {first_node.affects_control_flow}")

# Operate on all Range nodes
for index, node in enumerate(tdfile.nodes):
  if isinstance(node, taint_dag.TDRangeNode):
    print(f"Node {index}: first {node.first}, last {node.last}")

# Access taint forest
tdforest = trace.taint_forest
n1 = tdforest.get_node(1)
print(
  f"Forest node {n1.label}. Parent labels: {n1.parent_labels}, "
  f"source: {n1.source.path if n1.source is not None else None}, "
  f"affects control flow: {n1.affected_control_flow}"
)

También puedes ejecutar un binario instrumentado directamente desde el REPL:

$ polytracker
PolyTracker (4.0.0)
https://github.com/trailofbits/polytracker
Type "help" or "commands"
>>> trace = run_trace("path_to_binary", "path_to_input_file")

Esto ejecutará automáticamente el binario instrumentado en un contenedor Docker, si es necesario.

⚠️ Si ejecutas PolyTracker dentro de Docker o una VM: PolyTracker puede ser muy lento si se ejecuta en un entorno virtualizado y el archivo de entrada o, especialmente, la base de datos de salida están ubicados en un directorio mapeado o montado desde el sistema operativo anfitrión. Esto es particularmente cierto cuando se ejecuta PolyTracker en Docker desde un anfitrión macOS. La solución es escribir la base de datos en una ruta dentro del contenedor/VM y luego copiarla al sistema anfitrión al final.