FFUF es un fuzzer web escrito en Go y desarrollado por joohoi que sustituye un marcador llamado FUZZ por palabras de un diccionario y prueba combinaciones de URL para descubrir rutas, archivos, parámetros o subdominios ocultos. Es extremadamente útil al inicio de una auditoría para reconocer la superficie de la aplicación.  

Recuerda que usar FFUF contra cualquier sitio requiere autorización expresa del propietario. Empléalo únicamente en entornos de práctica, CTFs o auditorías donde se permita su uso.  

Instalación de FFUF

Para instalar FFUF existen varias opciones. La forma más rápida es descargar el binario ya compilado desde el repositorio, descomprimirlo y ejecutarlo directamente. Si usas macOS puedes instalarlo con Homebrew con brew install ffuf. En caso de que tengas Go 1.16 o una versión superior, también puedes instalarlo o actualizarlo con go install github.com/ffuf/ffuf/v2@latest. Otra alternativa es compilarlo manualmente.

Enumeración de contenido con FFUF.me

FFUF.me es un sitio web creado por Adam Langley que funciona como un entorno de práctica para usar FFUF. Allí se pueden lanzar pruebas de web fuzzing contra un servidor preparado con diferentes lecciones y casos prácticos sin caer en actos ilegales. En definitiva, es un laboratorio online donde practicar descubrimiento de directorios, enumeración de parámetros, fuzzing en peticiones POST y otros usos de la herramienta.

Lo primero que vamos a hacer es descargar los diccionarios que nos ofrece FFUF.me. Para ello, copiaremos el siguiente snippet:

mkdir wordlists
cd wordlists
wget http://ffuf.me/wordlist/common.txt
wget http://ffuf.me/wordlist/parameters.txt
wget http://ffuf.me/wordlist/subdomains.txt

Lista los archivos en tu directorio. Tendrás que estar viendo tres archivos .txt. Una vez estés seguro de que tienes los ficheros, ejecutaremos el siguiente comando:

ffuf -w ~/wordlists/common.txt -u http://ffuf.me/cd/basic/FUZZ

Habremos encontrados dos ficheros: class y development.log. Si escribimos curl -i http://ffuf.me/cd/basic/development.log o class, leeremos el mensaje «You Found The File!». Ahora ejecutaremos la siguiente linea de código en la terminal:

ffuf -w ~/wordlists/common.txt -recursion -u http://ffuf.me/cd/recursion/FUZZ

Lo que hace la flag -recursion es que cada vez que detecta una entrada que parece ser un directorio válido, crea un nuevo task que explora dentro de ese directorio usando el mismo diccionario, y repite el proceso hasta que no queden nuevos directorios por explorar. Encontraremos la ruta /admin/users/96. Escribiremos curl -i ‘http://ffuf.me/cd/recursion/FUZZ/admin/users/96’ y el servidor nos devolverá el mensaje «You Found The File!».

ffuf -w ~/wordlists/common.txt -e .log -u http://ffuf.me/cd/ext/logs/FUZZ

El objetivo es encontrar algún .log accesible en /logs probando cada palabra del diccionario con la extensión .log (-e). Ahora ejecutaremos el siguiente comando:

ffuf -w ~/wordlists/common.txt -u http://ffuf.me/cd/no404/FUZZ

Te habrás dado cuenta de que ha devuelto todos los directorios, lo cual es casi improbable que ocurra en la vida real. Si te has dado cuenta, el servidor lo que hace es mostrar como válido los archivos que no encontrados, que extrañamente pesan lo mismo. Ahora ejecutaremos con la flag -fs 669 que filtra los resultados que pesan 669.

ffuf -w ~/wordlists/common.txt -u http://ffuf.me/cd/no404/FUZZ -fs 669

Al decirle FFUF que ignore todas las respuestas con ese tamaño, desaparecieron los falsos positivos y quedó solo el archivo real que sí estaba allí. Tras escribir curl -s http://ffuf.me/cd/no404/secret podemos leer el texto «Controller does not exist».

Si entramos a http://ffuf.me/cd/param veremos que nos pide un parámetro el cual desconocemos. Ejecutaremos este comando:

ffuf -w ~/wordlists/parameters.txt -u http://ffuf.me/cd/param/data?FUZZ=1

Lo que hace es que ffuf sustituya fuff por cada nombre de parámetro de la lista, encontrando que el parámetro es debug. Al ejecutar curl -i ‘http://ffuf.me/cd/param/data?debug=1’, el servidor nos responderá «Required Parameter Found».

FFUF.me también ofrecía un ejercicio para demostrar como al escanear con FFUF se puede chocar contra límites de tasa del servidor y recibir muchos 429. Lo hacía con el siguiente comando:

ffuf -w ~/wordlists/common.txt -u http://ffuf.test/cd/rate/FUZZ -mc 200,429

Esto se debe a que si se lanza el escaneo sin controlar la concurrencia se obtienen esos Too many requests porque, en este caso, el directorio aplica un límite de 50 peticiones por segundo. FFUF.me nos animaba a usar el siguiente comando:

ffuf -w ~/wordlists/common.txt -t 5 -p 0.1 -u http://ffuf.test/cd/rate/FUZZ -mc 200,429

No obstante, ffuf.test está caído, por lo que es imposible de completar el ejercicio.

El último ejercicio propuesto de enumeración de contenido nos enseña que a veces los diccionarios no son útiles. Pone como ejemplo un caso de vulnerabilidad por exposición de identificadores (IDOR), donde lo que se necesita es probar muchos números secuenciales como identificadores para ver si alguno da acceso no autorizado. Para ello propone el siguiente comando, que nos devuelve el ID 657 y que tras usar curl -i http://ffuf.me/cd/pipes/user\?id=657 nos responde «User ID Found».

seq 1 1000 | ffuf -w - -u http://ffuf.me/cd/pipes/user?id=FUZZ

Enumeración de subdominios con FFUF.me

FFUF se puede usar para descubrir subdominios mediante el uso de virtual hosts cambiando la cabecera Host. Prueba a ejecutar el siguiente comando:

ffuf -w ~/wordlists/subdomains.txt -H "Host: FUZZ.ffuf.me" -u http://ffuf.me

Verás en los resultados que todas las respuestas devuelven un tamaño de 1495 bytes. Ahora ejecuta el mismo escaneo pero usando la opción -fs para filtrar y excluir todas las respuestas de 1495 bytes que nos devolverá el subdominio redhat.

ffuf -w ~/wordlists/subdomains.txt -H "Host: FUZZ.ffuf.me" -u http://ffuf.me -fs 1495

Ahora utilizaremos curl -i -H «Host: redhat.ffuf.me» http://ffuf.me/ y el servidor nos mostrará «Subdomain Found».