parsarium

Capítulo 01

Qué hace un parser

Entran bytes y sale estructura. Por qué ese paso importa para las pruebas y la seguridad, y cómo lo organiza Parsarium.

8 min de lectura5 preguntas3 ejercicios

Un parser toma bytes y los convierte en una estructura que un programa puede usar. Un decodificador PNG lee una firma y una secuencia de bloques, y devuelve un ancho, un alto y unos píxeles. Un parser HTTP lee una línea de petición y unas cabeceras, y devuelve un método, un destino y un mapa de campos. El resto del programa trabaja con esa estructura y confía en que sea correcta.

Eso convierte al parser en el primer código que ve la entrada externa. Los archivos llegan de usuarios, de adjuntos de correo, de subidas, de otros servicios. Digan lo que digan los bytes, el parser tiene que decidir qué significan antes de que se ejecute nada más.

Por qué merece la pena probar parsers

La mayoría de los formatos describen su propia estructura. Un bloque PNG empieza con su longitud, un archivo ZIP guarda los desplazamientos de sus entradas, una caja MP4 declara su tamaño, una cabecera PLY anuncia cuántos vértices vienen después. El parser lee esos números y actúa en consecuencia: reserva memoria, salta a un desplazamiento, repite un bucle un número de veces. Cuando los números están mal, un parser cuidadoso rechaza la entrada. Uno menos cuidadoso puede leer más allá del final de un búfer, reservar muchísima más memoria de la necesaria, entrar en una recursión sin límite o quedarse en un bucle durante mucho tiempo.

Un segundo tipo de problema aparece cuando dos parsers leen los mismos bytes de forma distinta. Un proxy y un servidor que no coinciden en dónde termina una petición HTTP pueden acabar viendo dos peticiones donde se pretendía enviar una. Una herramienta de compresión y un verificador de firmas que eligen entradas distintas del mismo ZIP pueden comprobar un archivo y extraer otro. Estos bugs no necesitan un crash. Necesitan dos programas que parecen correctos y toman decisiones distintas.

Ambos tipos de bugs se encuentran pasando muchas entradas por parsers reales y observando qué ocurre. Para eso está hecho Parsarium.

Aceptar y rechazar

Todo parser traza una línea entre las entradas que acepta y las que rechaza. Los parsers estrictos siguen la especificación de cerca. Los permisivos intentan recuperarse de pequeños errores, algo cómodo para los usuarios y a veces sorprendente para quien revisa la seguridad. Ninguna de las dos opciones es incorrecta por sí sola; lo que importa al probar es saber dónde traza su línea cada parser y si trata de forma segura todo lo que queda del lado aceptado.

Cómo organiza Parsarium los parsers

Parsarium se organiza primero por formato y después por lenguaje. Un formato en un lenguaje es una celda: PNG en C, ZIP en Go, HTTP/1.1 en PHP. Hay 14 formatos y ocho lenguajes, así que 112 celdas.

FormatoEstructura
PNGFirma y después bloques con longitud y tipo, con sumas de comprobación
ZIPEntradas locales, con un directorio central al final
MP4Cajas anidadas, cada una con un tamaño y un tipo
WAVBloques RIFF: una descripción del formato y después las muestras
PDFObjetos numerados y una tabla de referencias cruzadas
SVGUn árbol de elementos XML
HTTP/1.1Una línea inicial de texto, cabeceras y un cuerpo opcional
ASCII PLYUna cabecera de texto que declara elementos y después registros
ASCII PNMTokens separados por espacios: número mágico, tamaño, muestras
MP3 + ID3v2Un preámbulo de metadatos etiquetados antes de las tramas de audio

Elegí los formatos para cubrir distintos tipos de estructura: binarios y de texto, planos y anidados, secuenciales y basados en desplazamientos, archivos y mensajes de protocolo. Una herramienta que funciona bien con un tipo suele tener problemas con otro, así que una mezcla da una imagen más honesta.

Cada entrada de una celda es una ruta de paquete: una biblioteca de código abierto, o una API de la biblioteca estándar, junto con la función exacta que analiza la entrada. Cada una se ha comprobado con una entrada válida antes de añadirla. La mayoría tiene un harness Docker que puedes ejecutar.

Ideas clave

  • Un parser convierte bytes en estructura, y el resto del programa se fía de esa estructura.
  • Los formatos describen su propia estructura con longitudes, recuentos y desplazamientos. Los parsers actúan sobre esos números, y ahí empiezan muchos bugs.
  • Hay dos tipos de bugs de parser que merece la pena buscar: el manejo inseguro de una sola entrada, y dos parsers que no se ponen de acuerdo sobre la misma entrada.
  • Parsarium se organiza por formato y después por lenguaje. Un formato en un lenguaje es una celda; 14 formatos y ocho lenguajes dan 112 celdas.

Comprueba lo que sabes

Responde a las cinco para ver tu resultado

¿Por qué el parser suele ser lo primero que conviene probar en un programa que maneja archivos?

  1. Es el primer código que interpreta la entrada externa.
  2. Los parsers suelen estar escritos en C.
  3. Los parsers se ejecutan con más privilegios que el resto del programa.

Sean cuales sean los bytes, el parser decide qué significan antes de que se ejecute nada más. Eso vale para cualquier lenguaje, no solo para C.

Un archivo ZIP guarda al final un directorio central que apunta a cada entrada. ¿Qué tipo de estructura es esta?

  1. Una secuencia de bloques
  2. Desplazamientos y un directorio
  3. Un árbol de texto

El lector encuentra primero el directorio y después salta a las entradas que enumera, así que a los mismos bytes se puede llegar por más de un camino.

Un proxy y un servidor leen la misma petición HTTP. El proxy cree que termina después de las cabeceras; el servidor lee un cuerpo. Ninguno falla. ¿Es un problema?

  1. No. Sin fallo no hay bug.
  2. Sí. El desacuerdo puede permitir que una petición se esconda dentro de otra.
  3. Solo si los dos programas están escritos en el mismo lenguaje.

Los bugs diferenciales no necesitan un fallo. Dos programas que parecen correctos por separado toman decisiones distintas sobre los mismos bytes.

¿Qué es una celda en Parsarium?

  1. Una versión de un parser
  2. Un archivo de control
  3. Un formato en un lenguaje

PNG en C, ZIP en Go y HTTP/1.1 en PHP son celdas. Cada celda tiene su propia búsqueda, su propio ranking y sus propios paquetes verificados.

Un parser permisivo acepta un PNG con una suma de comprobación incorrecta. ¿Qué te dice eso?

  1. Que tiene un bug.
  2. Que traza la línea de aceptación en otro sitio. Si eso importa depende de cómo maneje lo que acepta.
  3. Que en realidad no es un parser de PNG.

La permisividad es una decisión de diseño. Para probar, lo que importa es dónde traza la línea cada parser y si maneja de forma segura todo lo que queda del lado aceptado.

Ejercicios

Ejercicio 1.1Calentamiento

Lista el catálogo, abre una celda e inspecciona un target.

$ parsarium list
$ parsarium catalog png c
$ parsarium show png c stb

La salida de catalog ordena los paquetes en C por estrellas de GitHub. Fíjate en la última columna, la familia subyacente. ¿Cuántos paquetes leen PNG a través de stb_image?

Pista

Busca el texto stb_image en la columna de familia. Las copias incluidas en otros proyectos también cuentan.

Solución

Tres: raylib y sdl3 incluyen stb_image, y stb es el propio stb_image. Tres paquetes en el ranking y un solo decodificador debajo. El capítulo 4 vuelve sobre esto.

Ejercicio 1.2Práctica

Compara cómo de cubierto está cada lenguaje para un formato.

$ parsarium list --format http11

¿Qué lenguajes tienen más targets ejecutables de HTTP/1.1 y cuáles menos? Comprueba tu respuesta con la fila de HTTP/1.1 del atlas.

Pista

El recuento de ejecutables es el número de targets con un harness Docker. Puede ser mayor que el de verificados porque las APIs de la biblioteca estándar se cuentan aparte.

Solución

Compara la columna RUNNABLE con las de verificados. Cuando un lenguaje tiene menos targets ejecutables que paquetes verificados, todavía se están construyendo harnesses. En HTTP/1.1 se nota sobre todo en C y C++: muchos de sus parsers HTTP están integrados en servidores más grandes y es más difícil alimentarlos desde un archivo.

Ejercicio 1.3Reto

Busca una vulnerabilidad publicada en un parser de uno de los 14 formatos. La búsqueda de NVD o los avisos de seguridad de un proyecto son buenos puntos de partida. Responde a tres preguntas: qué campo del formato controlaba el atacante, qué hacía el parser con él, y si era un bug de una sola entrada o un desacuerdo entre dos programas.

Pista

Busca el nombre de una biblioteca junto con palabras como overflow, out-of-bounds o path traversal. Los avisos que incluyen un archivo de prueba de concepto son los más fáciles de analizar.

Solución

Un ejemplo muy conocido es Zip Slip (2018). El atacante controla el nombre de una entrada en un archivo ZIP y escribe nombres como ../../etc/cron.d/job. Muchas rutinas de extracción unían ese nombre al directorio de destino sin comprobarlo, así que los archivos se escribían fuera de él. Es un bug de una sola entrada: un programa se fió de un campo que debería haber validado. Apunta tu propio ejemplo de la misma manera: campo, comportamiento, tipo.