Cómo instalar y usar Radamsa para realizar pruebas fuzzing de programas y servicios de red en Ubuntu 18.04

El autor seleccionó a Electronic Frontier Foundation Inc para recibir una donación como parte del programa Write for DOnations.

Introducción

Las amenazas a la seguridad son cada vez más sofisticadas, por lo que los desarrolladores y administradores de sistemas deben adoptar un enfoque proactivo para defender y probar la seguridad de sus aplicaciones.

Un método común para probar la seguridad de las aplicaciones cliente o los servicios de red es el fuzzing, que implica enviar repetidamente datos no válidos o mal formados a la aplicación y analizar su respuesta. Esto es útil para ayudar a probar qué tan resistente y robusta es la aplicación a la entrada inesperada, que puede incluir datos corruptos o ataques reales.

Radamsa es una herramienta de fuzzing de código abierto que puede generar casos de prueba basados ​​en datos de entrada especificados por el usuario. Radamsa es totalmente programable y hasta ahora ha logrado encontrar vulnerabilidades en aplicaciones del mundo real, como Gzip.

En este tutorial, instalará y utilizará Radamsa para realizar pruebas fuzzing de aplicaciones basadas en red y de línea de comandos utilizando sus propios casos de prueba.

Advertencia: Radamsa es una herramienta de pruebas de penetración que puede permitirle identificar vulnerabilidades o debilidades en ciertos sistemas o aplicaciones. No debe utilizar las vulnerabilidades encontradas en Radamsa para ninguna forma de comportamiento imprudente, daño o explotación maliciosa. Las vulnerabilidades deben informarse de manera ética al responsable del mantenimiento de la aplicación afectada y no deben divulgarse públicamente sin permiso explícito.

Prerrequisitos

Antes de comenzar esta guía necesitarás lo siguiente:

• Un servidor Ubuntu 18.04 configurado siguiendo la configuración inicial del servidor con Ubuntu 18.04, incluido un usuario sudo no root y un firewall habilitado para bloquear puertos no esenciales.
• Una aplicación de línea de comandos o basada en red que desee probar, por ejemplo, Gzip, Tcpdump, Bind, Apache, jq o cualquier otra aplicación de su elección. Como ejemplo para los fines de este tutorial, utilizaremos jq.

Advertencia: Radamsa puede provocar que las aplicaciones o los sistemas se ejecuten de forma inestable o se bloqueen, por lo que solo debe ejecutar Radamsa en un entorno en el que esté preparado para esto, como un servidor dedicado. Asegúrese también de tener permiso explícito por escrito del propietario de un sistema antes de realizar pruebas de fuzzing en él.

Una vez que tenga esto listo, inicie sesión en su servidor como usuario no root para comenzar.

Paso 1: Instalación de Radamsa

En primer lugar, deberá descargar y compilar Radamsa para comenzar a usarlo en su sistema. El código fuente de Radamsa está disponible en el repositorio oficial de GitLab.

Comience actualizando el índice de paquetes locales para reflejar cualquier cambio nuevo en sentido ascendente:

sudo apt update

Luego, instale los paquetes gcc, git, makey wgetnecesarios para compilar el código fuente en un binario ejecutable:

sudo apt install gcc git make wget

Después de confirmar la instalación, aptse descargarán e instalarán los paquetes especificados y todas sus dependencias necesarias.

A continuación, descargará una copia del código fuente de Radamsa clonándolo desde el repositorio alojado en GitLab:

git clone https://gitlab.com/akihe/radamsa.git

Esto creará un directorio llamado radamsa, que contiene el código fuente de la aplicación. Vaya al directorio para comenzar a compilar el código:

cd radamsa

A continuación, puede iniciar el proceso de compilación utilizando make:

make

Finalmente, puedes instalar el binario compilado de Radamsa en tu $PATH:

sudo make install

Una vez completado esto, puedes verificar la versión instalada para asegurarte de que todo funciona:

radamsa --version

El resultado será similar al siguiente:

OutputRadamsa 0.6

Si ve un radamsa: command not founderror, verifique que se hayan instalado todas las dependencias necesarias y que no haya habido errores durante la compilación.

Ahora que ha instalado Radamsa, puede comenzar a generar algunos casos de prueba de muestra para comprender cómo funciona Radamsa y para qué se puede utilizar.

Paso 2: Generación de casos de prueba de fuzzing

Ahora que se ha instalado Radamsa, puedes usarlo para generar algunos casos de prueba de fuzzing.

Un caso de prueba es un fragmento de datos que se utilizará como entrada para el programa que estás probando. Por ejemplo, si estás probando un programa de archivo como Gzip, un caso de prueba puede ser un archivo comprimido que estás intentando descomprimir.

Nota: Radamsa manipulará los datos de entrada de diversas formas inesperadas, como por ejemplo, repetición extrema, inversión de bits, inyección de caracteres de control, etc. Esto puede provocar que la sesión de su terminal se interrumpa o se vuelva inestable, por lo que debe tenerlo en cuenta antes de continuar.

En primer lugar, pasa un fragmento de texto sencillo a Radamsa para ver qué sucede:

echo "Hello, world!" | radamsa

Esto manipulará (o analizará) los datos ingresados ​​y generará un caso de prueba, por ejemplo:

OutputHello,, world!

En este caso, Radamsa agregó una coma adicional entre Helloy world. Puede que no parezca un cambio significativo, pero en algunas aplicaciones puede provocar que los datos se interpreten incorrectamente.

Intentémoslo nuevamente ejecutando el mismo comando. Verá un resultado diferente:

OutputHello, '''''''wor'd!

'Esta vez, se insertaron varias comillas simples ( ) en la cadena, incluida una que sobrescribió el lin world. Es más probable que este caso de prueba en particular genere problemas para una aplicación, ya que las comillas simples o dobles se utilizan a menudo para separar diferentes fragmentos de datos en una lista.

Vamos a intentarlo una vez más:

OutputHello, $+$PATHu0000`xcalc`world!

En este caso, Radamsa insertó una cadena de inyección de shell, que será útil para probar vulnerabilidades de inyección de comandos en la aplicación que está probando.

Ha utilizado Radamsa para realizar pruebas de fuzzing en una cadena de entrada y generar una serie de casos de prueba. A continuación, utilizará Radamsa para realizar pruebas de fuzzing en una aplicación de línea de comandos.

Paso 3: Fuzzing de una aplicación de línea de comandos

En este paso, utilizará Radamsa para fuzzear una aplicación de línea de comandos e informar sobre cualquier falla que ocurra.

La técnica exacta para realizar pruebas de fuzzing en cada programa varía enormemente, y los distintos métodos serán más efectivos para distintos programas. Sin embargo, en este tutorial utilizaremos el ejemplo de jq, que es un programa de línea de comandos para procesar datos JSON.

Puede utilizar cualquier otro programa similar siempre que siga el principio general de tomar algún tipo de datos estructurados o no estructurados, hacer algo con ellos y luego generar un resultado. Por ejemplo, este ejemplo también funcionaría con Gzip, Grep, bc, tr, etc.

Si aún no lo tienes jqinstalado, puedes instalarlo usando apt:

sudo apt install jq

jqAhora se instalará.

Para comenzar a realizar fuzzing, crea un archivo JSON de muestra que usarás como entrada para Radamsa:

nano test.json

Luego, agregue los siguientes datos JSON de muestra al archivo:

prueba.json

{  "test": "test",  "array": [    "item1: foo",    "item2: bar"  ]}

Puede analizar este archivo utilizando jqsi desea comprobar que la sintaxis JSON es válida:

jq . test.json

Si el JSON es válido, jqse generará el archivo. De lo contrario, se mostrará un error que puede utilizar para corregir la sintaxis cuando sea necesario.

A continuación, analice el archivo JSON de prueba con Radamsa y luego páselo a jq. Esto hará jqque se lea el caso de prueba analizado o manipulado, en lugar de los datos JSON válidos originales:

radamsa test.json | jq

Si Radamsa modifica los datos JSON de manera tal que sigan siendo sintácticamente válidos, jqgenerará los datos pero con los cambios que Radamsa les haya realizado.

De manera alternativa, si Radamsa hace que los datos JSON dejen de ser válidos, jqmostrará un error relevante. Por ejemplo:

Outputparse error: Expected separator between values at line 5, column 16

El resultado alternativo sería que jqno se puedan manejar correctamente los datos fuzzeados, lo que provocaría un bloqueo o un mal funcionamiento. Esto es lo que realmente se busca con el fuzzing, ya que puede ser indicativo de una vulnerabilidad de seguridad, como un desbordamiento de búfer o una inyección de comandos.

Para probar vulnerabilidades como esta de manera más eficiente, se puede usar un script Bash para automatizar el proceso de fuzzing, incluyendo la generación de casos de prueba, su paso al programa de destino y la captura de cualquier resultado relevante.

Crea un archivo llamado jq-fuzz.sh:

nano jq-fuzz.sh

El contenido exacto del script variará dependiendo del tipo de programa que estés analizando y de los datos de entrada, pero en el caso de jqy otros programas similares, el siguiente script es suficiente.

Copia el script en tu jq-fuzz.sharchivo:

jq-fuzz.sh

#!/bin/bashwhile true; do  radamsa test.json  input.txt  jq . input.txt  /dev/null 21  if [ $? -gt 127 ]; then    cp input.txt crash-`date +s%.%N`.txt    echo "Crash found!"  fidone

Este script contiene un whilepara hacer que el contenido se repita en bucle. Cada vez que el script se repite en bucle, Radamsa generará un caso de prueba basado en test.jsony lo guardará en input.txt.

input.txtLuego, se ejecutará el caso de prueba jqy todas las salidas estándar y de error se redirigirán a /dev/nullpara evitar llenar la pantalla del terminal.

jqPor último, se comprueba el valor de salida de . Si el valor de salida es mayor que 127, esto indica una terminación fatal (un bloqueo), entonces los datos de entrada se guardan para su revisión en una fecha posterior en un archivo llamado crash-seguido de la fecha actual en segundos y nanosegundos Unix.

Marque el script como ejecutable y configúrelo para que comience a ejecutarse automáticamente la prueba fuzz jq:

chmod +x jq-fuzz.sh
./jq-fuzz.sh

Puede ejecutar el comando CTRL+Cen cualquier momento para finalizar el script. Luego puede verificar si se han encontrado fallas utilizando lspara mostrar una lista de directorios que contiene todos los archivos de fallas que se han creado.

Es posible que desee mejorar sus datos de entrada JSON, ya que es probable que el uso de un archivo de entrada más complejo mejore la calidad de sus resultados de fuzzing. Evite usar un archivo grande o uno que contenga muchos datos repetidos: un archivo de entrada ideal es uno que sea pequeño en tamaño, pero que aún contenga tantos elementos "complejos" como sea posible. Por ejemplo, un buen archivo de entrada contendrá muestras de datos almacenados en todos los formatos, incluidas cadenas, números enteros, booleanos, listas y objetos, así como datos anidados cuando sea posible.

Ha utilizado Radamsa para realizar pruebas de fuzzing en una aplicación de línea de comandos. A continuación, utilizará Radamsa para realizar pruebas de fuzzing en solicitudes a servicios de red.

Paso 4: Solicitudes de fuzzing a servicios de red

Radamsa también se puede utilizar para fuzzear servicios de red, ya sea actuando como cliente o servidor de red. En este paso, utilizará Radamsa para fuzzear un servicio de red, con Radamsa actuando como cliente.

El objetivo de fuzzing de servicios de red es probar la resistencia de un servicio de red en particular a los clientes que le envían datos maliciosos o maliciosos. Muchos servicios de red, como servidores web o servidores DNS, suelen estar expuestos a Internet, lo que significa que son un objetivo común para los atacantes. Un servicio de red que no sea lo suficientemente resistente a la recepción de datos maliciosos puede bloquearse o, peor aún, fallar en un estado abierto, lo que permite a los atacantes leer datos confidenciales, como claves de cifrado o datos de usuario.

La técnica específica para fuzzear servicios de red varía enormemente dependiendo del servicio de red en cuestión, sin embargo, en este ejemplo usaremos Radamsa para fuzzear un servidor web básico que sirve contenido HTML estático.

En primer lugar, debe configurar el servidor web que utilizará para realizar pruebas. Puede hacerlo mediante el servidor de desarrollo integrado que viene con el php-clipaquete. También necesitará configurarlo curlpara probar su servidor web.

Si no los tienes php-cliy/o no curllos tienes instalados, puedes instalarlos usando apt:

sudo apt install php-cli curl

A continuación, crea un directorio para almacenar los archivos de tu servidor web y muévete a él:

mkdir ~/www
cd ~/www

Luego, crea un archivo HTML que contenga algún texto de muestra:

nano index.html

Añade lo siguiente al archivo:

índice.html

h1Hello, world!/h1

Ahora puede ejecutar su servidor web PHP. Deberá poder ver el registro del servidor web mientras sigue usando otra sesión de terminal, por lo que debe abrir otra sesión de terminal y conectarse por SSH a su servidor para esto:

cd ~/www
php -S localhost:8080

Esto producirá un resultado similar a lo siguiente:

OutputPHP 7.2.24-0ubuntu0.18.04.1 Development Server started at Wed Jan  1 16:06:41 2020Listening on http://localhost:8080Document root is /home/user/wwwPress Ctrl-C to quit.

Ahora puede volver a su sesión de terminal original y probar que el servidor web está funcionando usando curl:

curl localhost:8080

Esto generará el index.htmlarchivo de muestra que creó anteriormente:

Outputh1Hello, world!/h1

Su servidor web solo necesita ser accesible localmente, por lo que no debe abrir ningún puerto en su firewall para él.

Ahora que ha configurado su servidor web de prueba, puede comenzar a realizar pruebas fuzz utilizando Radamsa.

Primero, deberá crear una solicitud HTTP de muestra para usarla como datos de entrada para Radamsa. Cree un nuevo archivo para almacenarla en:

nano http-request.txt

Luego, copie la siguiente solicitud HTTP de muestra en el archivo:

Solicitud http.txt

GET / HTTP/1.1Host: localhost:8080User-Agent: testAccept: */*

A continuación, puede utilizar Radamsa para enviar esta solicitud HTTP a su servidor web local. Para ello, deberá utilizar Radamsa como cliente TCP, lo que puede hacerse especificando una dirección IP y un puerto al que conectarse:

radamsa -o 127.0.0.1:8080 http-request.txt

Nota: Tenga en cuenta que el uso de Radamsa como cliente TCP puede provocar que se transmitan datos maliciosos o maliciosos a través de la red. Esto puede causar problemas, por lo que debe tener mucho cuidado de acceder únicamente a las redes que está autorizado a probar o, preferiblemente, utilice la 127.0.0.1dirección localhost ( ).

Por último, si observa los registros generados por su servidor web local, verá que recibió las solicitudes, pero probablemente no las procesó porque no eran válidas o estaban mal formadas.

Los registros generados serán visibles en la segunda ventana de terminal:

Output[Wed Jan  1 16:26:49 2020] 127.0.0.1:49334 Invalid request (Unexpected EOF)[Wed Jan  1 16:28:04 2020] 127.0.0.1:49336 Invalid request (Malformed HTTP request)[Wed Jan  1 16:28:05 2020] 127.0.0.1:49338 Invalid request (Malformed HTTP request)[Wed Jan  1 16:28:07 2020] 127.0.0.1:49340 Invalid request (Unexpected EOF)[Wed Jan  1 16:28:08 2020] 127.0.0.1:49342 Invalid request (Malformed HTTP request)

Para obtener resultados óptimos y garantizar que se registren los fallos, es posible que desee escribir un script de automatización similar al utilizado en el Paso 3. También debe considerar utilizar un archivo de entrada más complejo, que puede contener elementos adicionales, como encabezados HTTP adicionales.

Ha realizado un fuzzing en un servicio de red utilizando Radamsa como cliente TCP. A continuación, realizará un fuzzing en un cliente de red con Radamsa como servidor.

Paso 5: Análisis de errores de las aplicaciones cliente de la red

En este paso, utilizará Radamsa para realizar pruebas de fuzzing en una aplicación cliente de red. Esto se logra interceptando las respuestas de un servicio de red y realizándolas antes de que el cliente las reciba.

El objetivo de este tipo de fuzzing es probar la resistencia de las aplicaciones cliente de red a la recepción de datos maliciosos o maliciosos de los servicios de red. Por ejemplo, probar un navegador web (cliente) que recibe HTML malformado de un servidor web (servicio de red) o probar un cliente DNS que recibe respuestas DNS malformadas de un servidor DNS.

Al igual que fue el caso con el fuzzing de aplicaciones de línea de comandos o servicios de red, la técnica exacta para fuzzing de cada aplicación cliente de red varía considerablemente; sin embargo, en este ejemplo utilizará whois, que es una aplicación de envío/recepción simple basada en TCP.

La whoisaplicación se utiliza para realizar solicitudes a servidores WHOIS y recibir registros WHOIS como respuestas. WHOIS opera a través del puerto TCP 43en texto sin formato, lo que la convierte en una buena candidata para pruebas de fuzzing basadas en red.

Si aún no lo tienes whoisdisponible, puedes instalarlo usando apt:

sudo apt install whois

Primero, deberá obtener una whoisrespuesta de muestra para usarla como datos de entrada. Puede hacerlo realizando una whoissolicitud y guardando el resultado en un archivo. Puede utilizar cualquier dominio que desee aquí, ya que está probando el whoisprograma localmente con datos de muestra:

whois example.com  whois.txt

A continuación, deberá configurar Radamsa como un servidor que proporcione versiones con errores de esta whoisrespuesta. Deberá poder seguir usando su terminal una vez que Radamsa se esté ejecutando en modo servidor, por lo que se recomienda abrir otra sesión de terminal y una conexión SSH a su servidor para esto:

radamsa -o :4343 whois.txt -n inf

Radamsa ahora se ejecutará en modo de servidor TCP y proporcionará una versión difusa whois.txtcada vez que se realice una conexión al servidor, sin importar qué datos de solicitud se reciban.

Ahora puede proceder a probar la whoisaplicación cliente. Deberá realizar una whoissolicitud normal para cualquier dominio que elija (no tiene que ser el mismo para el que se encuentran los datos de muestra), pero whoisapuntando a su servidor local de Radamsa:

whois -h localhost:4343 example.com

La respuesta serán los datos de muestra, pero con errores de fuzzing de Radamsa. Puede seguir realizando solicitudes al servidor local mientras Radamsa esté en ejecución y proporcionará una respuesta con errores de fuzzing diferente cada vez.

Al igual que con las pruebas fuzzing de servicios de red, para mejorar la eficiencia de estas pruebas fuzzing de clientes de red y garantizar que se capturen todas las fallas, es posible que desee escribir un script de automatización similar al utilizado en el Paso 3.

En este paso final, utilizó Radamsa para realizar pruebas fuzz de una aplicación cliente de red.

Conclusión

En este artículo, configuraste Radamsa y lo usaste para realizar pruebas de fuzzing en una aplicación de línea de comandos, un servicio de red y un cliente de red. Ahora tienes los conocimientos básicos necesarios para realizar pruebas de fuzzing en tus propias aplicaciones, con la esperanza de que el resultado sea una mejora en su solidez y resistencia a los ataques.

Si desea explorar Radamsa más a fondo, puede revisar el READMEarchivo Radamsa en detalle, ya que contiene más información técnica y ejemplos de cómo se puede utilizar la herramienta:

• Archivo README de Radamsa

También puede que desees consultar otras herramientas de fuzzing como American Fuzzy Lop (AFL), que es una herramienta de fuzzing avanzada diseñada para probar aplicaciones binarias a una velocidad y precisión extremadamente altas:

• Lop peludo americano