ffuf - Fuzz Faster U Fool

Un fuzzer web rápido escrito en Go.

• Instalación
• Ejemplo de uso
  • Descubrimiento de contenido
  • Descubrimiento de vhost
  • Fuzzing de parámetros
  • Fuzzing de datos POST
  • Uso de mutador externo
  • Archivos de configuración
• Ayuda
  • Modo interactivo

Instalación

• Descarga un binario precompilado desde la página de lanzamientos, descomprime y ejecuta.

  o

• Si estás en Windows con Scoop, ffuf se puede instalar con: scoop install ffuf

  o

• Si estás en Windows con Winget, ffuf se puede instalar con: winget install ffuf.ffuf

  o

• Si estás en macOS con homebrew, ffuf se puede instalar con: brew install ffuf

  o

• Si tienes un compilador Go reciente instalado: go install github.com/ffuf/ffuf/v2@latest (el mismo comando sirve para actualizar)

  o

• git clone https://github.com/ffuf/ffuf ; cd ffuf ; go get ; go build

1. Ffuf depende de Go 1.20 o superior.
2. Una compilación de Go desde un checkout muestra git-<date>-<commit> en lugar de la etiqueta. Una compilación local no es un lanzamiento oficial incluso si estás en una etiqueta, y la información de compilación embebida de Go nos da el commit pero no el nombre de la etiqueta — por lo que mostramos el commit exacto con el que se compiló. Los binarios versionados autoritativos son los de la página de lanzamientos.

Ejemplo de uso

Los ejemplos de uso a continuación muestran solo las tareas más simples que puedes realizar usando ffuf.

Documentación más detallada que cubre muchas características con muchos ejemplos está disponible en la wiki de ffuf en https://github.com/ffuf/ffuf/wiki

Para documentación más extensa, con ejemplos de uso reales y consejos, asegúrate de revisar la guía increíble: "Todo lo que necesitas saber sobre FFUF" de Michael Skelton (@codingo).

También puedes practicar tus escaneos de ffuf contra un host en vivo con diferentes lecciones y casos de uso, ya sea localmente usando el contenedor Docker https://github.com/adamtlangley/ffufme o contra la versión alojada en vivo en http://ffuf.me creada por Adam Langley @adamtlangley.

Descubrimiento típico de directorios

Usando la palabra clave FUZZ al final de la URL (-u):

ffuf -w /path/to/wordlist -u https://target/FUZZ

Descubrimiento de host virtual (sin registros DNS)

Suponiendo que el tamaño de respuesta del virtualhost predeterminado es 4242 bytes, podemos filtrar todas las respuestas de ese tamaño (-fs 4242) mientras fuzzeamos el encabezado Host:

ffuf -w /path/to/vhost/wordlist -u https://target -H "Host: FUZZ" -fs 4242

Fuzzing de parámetros GET

El fuzzing de nombres de parámetros GET es muy similar al descubrimiento de directorios, y funciona definiendo la palabra clave FUZZ como parte de la URL. Esto también asume un tamaño de respuesta de 4242 bytes para nombres de parámetros GET inválidos.

ffuf -w /path/to/paramnames.txt -u https://target/script.php?FUZZ=test_value -fs 4242

Si se conoce el nombre del parámetro, los valores pueden fuzzearse de la misma manera. Este ejemplo asume un valor de parámetro incorrecto que devuelve el código de respuesta HTTP 401.

ffuf -w /path/to/values.txt -u https://target/script.php?valid_name=FUZZ -fc 401

Fuzzing de datos POST

Esta es una operación muy sencilla, nuevamente usando la palabra clave FUZZ. Este ejemplo fuzzea solo una parte de la solicitud POST. De nuevo estamos filtrando las respuestas 401.

ffuf -w /path/to/postdata.txt -X POST -d "username=admin\&password=FUZZ" -u https://target/login.php -fc 401

Tiempo máximo de ejecución

Si no quieres que ffuf se ejecute indefinidamente, puedes usar -maxtime. Esto detiene todo el proceso después de un tiempo dado (en segundos).

ffuf -w /path/to/wordlist -u https://target/FUZZ -maxtime 60

Cuando trabajas con recursión, puedes controlar el maxtime por trabajo usando -maxtime-job. Esto detendrá el trabajo actual después de un tiempo dado (en segundos) y continuará con el siguiente. Se crean nuevos trabajos cuando la funcionalidad de recursión detecta un subdirectorio.

ffuf -w /path/to/wordlist -u https://target/FUZZ -maxtime-job 60 -recursion -recursion-depth 2

También es posible combinar ambas banderas limitando el tiempo máximo de ejecución por trabajo así como el tiempo total de ejecución. Si no usas recursión, ambas banderas se comportan igual.

Uso de mutador externo para generar casos de prueba

Para este ejemplo, fuzzearemos datos JSON que se envían mediante POST. Radamsa se utiliza como mutador.

Cuando se usa --input-cmd, ffuf mostrará las coincidencias según su posición. Este mismo valor de posición estará disponible para el llamado como una variable de entorno $FFUF_NUM. Usaremos este valor de posición como semilla para el mutador. Los archivos example1.txt y example2.txt contienen cargas útiles JSON válidas. Estamos comparando todas las respuestas, pero filtrando el código de respuesta 400 - Bad request:

ffuf --input-cmd 'radamsa --seed $FFUF_NUM example1.txt example2.txt' -H "Content-Type: application/json" -X POST -u https://ffuf.io.fi/FUZZ -mc all -fc 400

Por supuesto, no es muy eficiente llamar al mutador para cada carga útil, por lo que también podemos pregenerar las cargas útiles, aún usando Radamsa como ejemplo:

# Generate 1000 example payloads
radamsa -n 1000 -o %n.txt example1.txt example2.txt

# This results into files 1.txt ... 1000.txt
# Now we can just read the payload data in a loop from file for ffuf

ffuf --input-cmd 'cat $FFUF_NUM.txt' -H "Content-Type: application/json" -X POST -u https://ffuf.io.fi/ -mc all -fc 400

Archivos de configuración

Al ejecutar ffuf, primero verifica si existe un archivo de configuración predeterminado. La ruta predeterminada para un archivo ffufrc es $XDG_CONFIG_HOME/ffuf/ffufrc. Puedes configurar una o varias opciones en este archivo, y se aplicarán en cada trabajo posterior de ffuf. Un ejemplo de archivo ffufrc se puede encontrar aquí.

Una descripción más detallada sobre las ubicaciones de los archivos de configuración se puede encontrar en la wiki: https://github.com/ffuf/ffuf/wiki/Configuration