parsarium

Capítulo 06

Testing diferencial

Envía los mismos bytes a muchos parsers y compara lo que dicen. Donde no coinciden es donde hay que mirar.

6 min de lectura5 preguntas3 ejercicios

Cuando muchos programas implementan el mismo formato, pueden comprobarse entre sí. Envía una entrada a todos y compara las respuestas. Si la mayoría de los parsers dicen que la imagen mide 2 por 1 y uno dice 3 por 1, al menos uno de ellos merece una mirada más atenta. No necesitas saber de antemano la respuesta correcta; el desacuerdo es la señal.

Por qué importan los desacuerdos

Algunos desacuerdos son inofensivos: un parser es tolerante con un campo que falta y otro es estricto. Otros son problemas de seguridad. Si un proxy y un servidor parsean la misma petición HTTP de forma distinta, un atacante puede esconder una segunda petición dentro de la primera. Si un verificador de firmas y un instalador leen entradas distintas del mismo ZIP, el archivo comprobado y el instalado no son el mismo. Si un PDF muestra contenido distinto en visores distintos, quien lo revisa y quien lo lee ven documentos diferentes. En todos estos casos, cada programa puede parecer correcto por separado.

El testing diferencial también encuentra bugs normales. Un parser que acepta un archivo que todas las demás implementaciones rechazan suele estar saltándose alguna comprobación.

Pasar un archivo por todos los parsers

Parsarium tiene un comando para esto. Ejecuta todos los harnesses verificados de un formato, opcionalmente limitados a un lenguaje, y guarda un registro por target más un summary.json.

$ parsarium run-format png --list
$ parsarium run-format png --file my.png --results runs/png-my-file --workers 4

summary.json enumera cada target con su estado y el directorio de su registro. Los recuentos por estado dan una primera visión: cuántos terminaron, cuántos salieron con error y cuántos agotaron el tiempo.

Comparar las respuestas

El estado por sí solo no te dice si un parser aceptó la entrada, así que el siguiente paso es comparar las salidas. Los harnesses imprimen los campos que observaron, y los nombres de los campos varían un poco entre targets, así que elige los campos que importan para tu pregunta y normalízalos. Para imágenes, el ancho y el alto son un buen punto de partida. Basta con un script corto:

python3 - runs/png-my-file <<'EOF'
import json, sys, pathlib, collections
root = pathlib.Path(sys.argv[1])
summary = json.loads((root / "summary.json").read_text())
groups = collections.defaultdict(list)
for row in summary["results"]:
    receipts = list((root / row["receipt_dir"]).glob("*.json"))
    tail = json.loads(receipts[0].read_text()).get("stdout_tail", "") if receipts else ""
    groups[(row["status"], tail.strip()[-80:])].append(row["project"])
for (status, tail), projects in sorted(groups.items(), key=lambda g: -len(g[1])):
    print(f"{len(projects):4}  {status:15}  {tail}")
    for p in projects[:5]:
        print("        ", p)
EOF

El grupo más grande suele ser el consenso. Los grupos pequeños son los interesantes.

Otra vez las familias

Cuando cuentes coincidencias, recuerda que los wrappers comparten motor. Ocho paquetes de PHP que coinciden entre sí pueden ser un solo decodificador que coincide consigo mismo. Agrupa los resultados por familia de parsers antes de decidir lo raro que es un desacuerdo.

Ideas clave

  • Enviar una misma entrada a muchas implementaciones no exige conocer de antemano la respuesta correcta: el desacuerdo es la señal.
  • Algunos desacuerdos son simple tolerancia. Otros son problemas de seguridad cuando dos parsers están en el mismo camino.
  • run-format ejecuta todos los harnesses de un formato y guarda un registro por target, además de un resumen.
  • Los recuentos de estados son una primera vista; la comparación de verdad se hace sobre los campos de salida normalizados.
  • Agrupa por familia de parsers antes de decidir lo raro que es un desacuerdo.

Comprueba lo que sabes

Responde a las cinco para ver tu resultado

¿Necesitas conocer la salida correcta antes de lanzar una prueba diferencial?

  1. No. El desacuerdo entre implementaciones es la señal.
  2. Sí; si no, los resultados no se pueden interpretar.
  3. Solo en los formatos binarios.

Esa es la gran ventaja de las pruebas diferenciales. Miras las respuestas minoritarias y luego decides quién tiene razón.

¿Qué provoca el HTTP request smuggling?

  1. Un servidor que falla con cabeceras largas
  2. Un front end y un back end que no se ponen de acuerdo sobre dónde termina una petición
  3. Las peticiones que usan HTTP/2

Si un programa usa Content-Length y el otro Transfer-Encoding, los bytes que uno ve como cuerpo el otro los ve como el comienzo de una petición nueva.

run-format devuelve ok para todos los targets. ¿Están de acuerdo todos los parsers?

  1. Sí, todos aceptaron el archivo.
  2. Sí, si están escritos en el mismo lenguaje.
  3. No necesariamente. ok significa que cada harness terminó; todavía tienes que comparar sus salidas.

Un rechazo limpio y un análisis correcto dan los dos ok. El acuerdo está en los campos de salida.

Nueve de diez paquetes de PHP dan la misma respuesta. ¿Es un consenso sólido?

  1. Sí, son nueve votos independientes.
  2. Puede que no. Si comparten motor, es una sola respuesta repetida.
  3. No, PHP siempre es tolerante.

Los wrappers heredan el comportamiento de su motor. Agrupa los resultados por familia para contar opiniones independientes.

¿Por qué normalizar los nombres de los campos antes de comparar salidas?

  1. Los harnesses llaman de forma distinta al mismo campo, así que una comparación ingenua muestra desacuerdos falsos.
  2. Para que los registros ocupen menos
  3. Porque JSON distingue mayúsculas y minúsculas

Un harness de PNG imprime rgba0 y otro first. Elige los campos que necesita tu pregunta y asígnales nombres comunes.

Ejercicios

Ejercicio 6.1Calentamiento

Toma wide-new-crc.png del ejercicio 2.2: un PNG que dice medir 3 píxeles de ancho pero solo trae datos para 2. Envíalo a todos los parsers de PNG.

$ parsarium run-format png --file wide-new-crc.png --results runs/png-wide --workers 4

Agrupa los resultados con el script de este capítulo. ¿Cuántos parsers rechazan el archivo? ¿Alguno informa de un ancho de 3? ¿Las respuestas se separan por lenguajes o por familias de parsers?

Pista

Empieza por status_counts en summary.json y después ejecuta el script de agrupación.

Solución

El reparto exacto depende de los parsers, y precisamente por eso hay que ejecutarlo. Busca tres grupos: los parsers que rechazan el archivo porque los datos de la imagen son demasiado cortos, los que lo aceptan e informan de un ancho de 3 (rellenando o ignorando los píxeles que faltan), y los que terminan con un error o agotan el tiempo. Este último grupo merece una mirada más atenta. Luego revisa la columna de familia: si un grupo está formado por wrappers de un mismo motor, es un solo comportamiento, no muchos.

Ejercicio 6.2Práctica

Las entradas de un ZIP se pueden comprimir con métodos distintos. controls/zip/hello-zstd.zip usa Zstandard, un método más reciente que no todos los lectores soportan. Envíalo a todos los parsers de ZIP.

$ parsarium run-format zip --file "$PARSARIUM/controls/zip/hello-zstd.zip" --results runs/zip-zstd --workers 4

¿Qué parsers pueden leer la entrada? ¿Cómo fallan los demás: con un error claro, con un resultado incorrecto o con un crash?

Pista

Solo un target de ZIP del catálogo usa este archivo como control. Eso ya te dice algo sobre cuántos lectores se espera que lo soporten.

Solución

Lo normal es que la mayoría de los lectores no soporten Zstandard; el target zipfile-zstd del propio catálogo existe precisamente porque el zipfile de la biblioteca estándar de Python necesita una extensión para leerlo. Lo interesante es cómo falla cada lector. Un error claro del tipo «método de compresión no soportado» es un buen comportamiento. Devolver basura o un archivo vacío sin ningún error es el tipo de desacuerdo que puede importar en la práctica, por ejemplo cuando una herramienta comprueba un archivo comprimido y otra lo extrae.

Ejercicio 6.3Reto

Escribe una petición HTTP con una cabecera Content-Length y otra Transfer-Encoding: chunked, y envíala a todos los parsers de HTTP/1.1.

printf 'POST / HTTP/1.1\r\nHost: example.test\r\nContent-Length: 4\r\nTransfer-Encoding: chunked\r\n\r\n0\r\n\r\n' > cl-te.http
$ parsarium run-format http11 --file cl-te.http --results runs/http-cl-te --workers 4

¿Qué cabecera sigue cada parser y cuáles rechazan la petición?

Pista

Lee primero la sección 6.1 del RFC 9112 para saber qué permite la especificación.

Solución

El RFC 9112 permite a un servidor rechazar una petición así o procesarla usando solo Transfer-Encoding. Las dos opciones son válidas. El caso peligroso es un parser que usa Content-Length en su lugar, porque si está delante o detrás de un parser que sigue Transfer-Encoding, los dos no coinciden en dónde termina la petición. Agrupa tus resultados en esos tres comportamientos. Ten en cuenta que algunos targets analizan respuestas en lugar de peticiones; déjalos fuera de esta comparación.