ffuf — Fuzz Faster U Fool — GhostAcademy SecLearn

📈

¿Qué es ffuf?

Fuzzing web de alto rendimiento: directorios, archivos, vhosts, parámetros y APIs

ffuf (Fuzz Faster U Fool) es una herramienta de fuzzing web de alto rendimiento escrita en Go por Joona Hoikkala. Es la herramienta de referencia moderna para descubrimiento de directorios, archivos, vhosts, parámetros y endpoints de API en aplicaciones web. Viene incluida en Kali Linux y está documentada en certificaciones como OSCP, eJPT, CEH y en las rutas de aprendizaje de HackTheBox y TryHackMe.

Su punto diferencial frente a herramientas clásicas como Dirb o Gobuster es su flexibilidad total: la palabra clave FUZZ puede colocarse en cualquier parte de la petición HTTP (URL, cabeceras, cuerpo POST, cookies) y soporta múltiples palabras clave simultáneas. Además, su motor concurrente en Go lo hace extremadamente rápido.

🛡 HERRAMIENTA DE RECONOCIMIENTO WEBffuf realiza peticiones HTTP estándar hacia el objetivo. En modo de descubrimiento de directorios, es funcionalmente equivalente a navegar manualmente miles de URLs. Es legal usarlo contra tus propias aplicaciones o en entornos con permiso explícito de auditoría. Es la herramienta que usan los equipos de seguridad para auditar su propia superficie de ataque web.

📂Directory FuzzingDescubrir directorios y rutas ocultas en el servidor web

📄File FuzzingBuscar archivos por nombre y extensión (.php, .bak, .txt...)

🌐VHost FuzzingDescubrir subdominios y virtual hosts en un servidor

📊Parameter FuzzingEncontrar parámetros GET/POST ocultos

🔌API FuzzingDescubrir endpoints de APIs REST no documentados

📈Multi-FUZZFuzzear múltiples posiciones con varios diccionarios a la vez

⚙

Instalación y Preparación

Instalar ffuf y preparar las wordlists necesarias

Instalar ffuf

# En Kali Linux (preinstalado en versiones recientes):
ffuf -V

# Instalar desde apt:
sudo apt update && sudo apt install ffuf -y

# Instalar la version mas reciente desde GitHub (recomendado):
# Go debe estar instalado: sudo apt install golang -y
go install github.com/ffuf/ffuf/v2@latest
# El binario queda en ~/go/bin/ffuf
# Anadir al PATH:
export PATH=$PATH:~/go/bin
echo 'export PATH=$PATH:~/go/bin' >> ~/.bashrc

# Descargar binario precompilado (mas rapido):
# https://github.com/ffuf/ffuf/releases
wget https://github.com/ffuf/ffuf/releases/latest/download/ffuf_2.1.0_linux_amd64.tar.gz
tar -xzf ffuf_2.1.0_linux_amd64.tar.gz
sudo mv ffuf /usr/local/bin/

# Verificar:
ffuf -V
# ffuf version: 2.1.0

📌 ENTORNO DE LABORATORIOPara practicar ffuf sin objetivos reales, usa: DVWA (Damn Vulnerable Web App), Juice Shop de OWASP, HackTheBox (Starting Point machines), TryHackMe (rooms de Content Discovery), o simplemente levanta un Apache local con sudo apt install apache2.

📚WORDLISTS: DONDE ESTAN EN KALI

Ubicacion y preparacion de wordlists

# SecLists: la coleccion mas completa (preinstalada en Kali)
ls /usr/share/seclists/

# Directorios y archivos web (los mas usados con ffuf):
ls /usr/share/seclists/Discovery/Web-Content/

# Los mas importantes:
# common.txt              : 4.600 palabras comunes
# directory-list-2.3-small.txt  : 87.000 palabras
# directory-list-2.3-medium.txt : 220.560 palabras
# raft-medium-directories.txt   : 30.000 directorios
# raft-large-files.txt          : 37.000 archivos
# big.txt                       : 20.000 palabras

# Instalar SecLists si no esta:
sudo apt install seclists -y

# O desde GitHub:
git clone https://github.com/danielmiessler/SecLists.git /usr/share/seclists

📄

Sintaxis y Flags Principales

La palabra clave FUZZ, los flags de control y el sistema de filtrado

La sintaxis de ffuf gira en torno a una idea central: la palabra clave FUZZ puede colocarse en cualquier parte de la petición HTTP. Donde aparezca FUZZ, ffuf sustituirá cada línea del diccionario y enviará la petición resultante.

Sintaxis general de ffuf

# Estructura basica:
ffuf -u URL_CON_FUZZ -w WORDLIST [opciones]

# La palabra clave FUZZ puede ir en cualquier parte:
ffuf -u http://objetivo.com/FUZZ -w wordlist.txt                 # En la URL
ffuf -u http://objetivo.com/FUZZ.php -w wordlist.txt             # Con extension
ffuf -u http://objetivo.com/?param=FUZZ -w wordlist.txt          # En parametro GET
ffuf -u http://objetivo.com/ -H 'Host: FUZZ.objetivo.com' -w wordlist.txt  # En cabecera
ffuf -u http://objetivo.com/login -d 'user=FUZZ&pass=test' -w wordlist.txt  # En POST body

-u URLURL objetivo con la palabra FUZZ donde se inyectara el payload

-w wordlistWordlist a usar. Formato: archivo.txt o archivo.txt:NOMBRE para multiples

-cColorear la salida por codigo de respuesta HTTP

-vVerbose: mostrar URL completa en los resultados

-t NNumero de hilos paralelos (default: 40)

-p delayPausa entre peticiones en segundos (ej: 0.1, 1, 1-2 para rango)

-H cabeceraAgregar o sobreescribir una cabecera HTTP

-d datosCuerpo de la peticion POST

-X metodoMetodo HTTP (GET, POST, PUT, DELETE...)

-b cookieCookie(s) para peticiones autenticadas

-rSeguir redirecciones HTTP (301, 302)

-sModo silencioso: solo mostrar resultados encontrados

-o archivoGuardar resultados en archivo

-of formatoFormato de salida: json, csv, ejson, html, md, all

-e extExtensiones a probar: .php,.html,.txt (con -u URL/FUZZ)

-maxtime NTiempo maximo de ejecucion en segundos

-recursionModo recursivo: fuzzear subdirectorios encontrados

-recursion-depth NProfundidad maxima del modo recursivo

📊FLAGS DE FILTRADO Y MATCHING (LOS MÁS IMPORTANTES)

Flag	Tipo	Descripción	Ejemplo
`-mc`	Match	Mostrar solo respuestas con estos códigos HTTP	`-mc 200,301,302`
`-fc`	Filter	Ocultar respuestas con estos códigos HTTP	`-fc 404,403`
`-ms`	Match	Mostrar solo respuestas de este tamaño exacto	`-ms 1234`
`-fs`	Filter	Ocultar respuestas de este tamaño (filtrar false positives)	`-fs 4242`
`-mw`	Match	Mostrar solo respuestas con este número de palabras	`-mw 100`
`-fw`	Filter	Ocultar respuestas con este número de palabras	`-fw 1`
`-mr`	Match	Mostrar solo respuestas que contengan este regex	`-mr "admin"`
`-fr`	Filter	Ocultar respuestas que contengan este regex	`-fr "not found"`
`-ml`	Match	Mostrar solo respuestas con este número de líneas	`-ml 10`
`-fl`	Filter	Ocultar respuestas con este número de líneas	`-fl 0`

📚

Wordlists: El Combustible de ffuf

Las wordlists más efectivas para cada tipo de fuzzing

La calidad de los resultados de ffuf depende directamente de la calidad de la wordlist usada. SecLists es la colección de referencia para pentesting web y cubre la mayoría de los casos de uso.

📚WORDLISTS RECOMENDADAS POR CASO DE USO

Caso de uso	Wordlist recomendada	Tamaño
Directorios comunes (rapido)	`/usr/share/seclists/Discovery/Web-Content/common.txt`	4.600
Directorios completo	`/usr/share/seclists/Discovery/Web-Content/directory-list-2.3-medium.txt`	220.560
Directorios raft (muy bueno)	`/usr/share/seclists/Discovery/Web-Content/raft-medium-directories.txt`	30.000
Archivos (con extensiones)	`/usr/share/seclists/Discovery/Web-Content/raft-medium-files.txt`	17.000
Archivos grandes	`/usr/share/seclists/Discovery/Web-Content/raft-large-files.txt`	37.000
Virtual hosts / subdominios	`/usr/share/seclists/Discovery/DNS/subdomains-top1million-5000.txt`	5.000
Subdominios completo	`/usr/share/seclists/Discovery/DNS/subdomains-top1million-20000.txt`	20.000
Parametros GET/POST	`/usr/share/seclists/Discovery/Web-Content/burp-parameter-names.txt`	2.500
Extensiones de archivos	`/usr/share/seclists/Fuzzing/extensions/CommonWebExtensions.fuzz.txt`	~30
APIs REST verbs	`/usr/share/seclists/Discovery/Web-Content/api/api-endpoints.txt`	~500

Crear wordlists personalizadas

# Crear wordlist de extensiones comunes para fuzzing de archivos:
cat > extensiones.txt << 'EOF'
php
html
htm
txt
bak
old
conf
config
log
xml
json
zip
gz
tar
EOF

# Combinar wordlists:
cat common.txt raft-medium-directories.txt | sort -u > combinada.txt

# Crear wordlist de nombres de archivos de backup tipicos:
cat > backups.txt << 'EOF'
backup
backup.zip
backup.tar.gz
www.zip
site.zip
dump.sql
database.sql
credentials.txt
config.php.bak
.env
.git
.htaccess
EOF

# Descargar wordlists especializadas:
# API fuzzing:
curl -o api-words.txt https://raw.githubusercontent.com/danielmiessler/SecLists/master/Discovery/Web-Content/api/api-endpoints.txt

🔍

Sistema de Filtrado: Eliminar Falsos Positivos

La habilidad clave: calibrar los filtros para obtener resultados limpios

El filtrado de respuestas es la habilidad más importante para usar ffuf eficientemente. Sin filtros correctos, los resultados estarán llenos de falsos positivos que harán imposible encontrar los hallazgos reales. La estrategia es: primero identificar cómo responde el servidor a paths inválidos, y luego filtrar exactamente ese patrón.

Identificar el patrón de respuesta para paths inválidosCALIBRACIÓN

Calibrar el filtro antes de empezar

# PASO 1: Ver como responde el servidor a un path que no existe:
curl -s -o /dev/null -w '%{http_code} %{size_download}\n' http://objetivo.com/RUTA_QUE_NO_EXISTE_123456
# Ej: 200 1234  <- responde 200 con tamano 1234 (custom 404 en HTML)
# Ej: 404  312  <- 404 estandar

# PASO 2: Si responde con 200 (custom 404), necesitas filtrar por tamano:
# Ejecutar ffuf sin filtros primero para ver el tamano de las respuestas falsas:
ffuf -u http://objetivo.com/FUZZ -w /usr/share/seclists/Discovery/Web-Content/common.txt -c | head -20

# Si ves que TODOS los resultados tienen el mismo tamano (ej: 1234):
# Ese es el tamano de la pagina 'no encontrado' personalizada
# Filtrar ese tamano:
ffuf -u http://objetivo.com/FUZZ -w wordlist.txt -c -fs 1234

Estrategias de filtrado por tipo de servidorESTRATEGIAS

Diferentes estrategias segun el comportamiento del servidor

# CASO 1: Servidor con 404 estandar
# Mostrar solo 200, 301, 302, 403:
ffuf -u http://objetivo.com/FUZZ -w wordlist.txt -mc 200,301,302,403

# CASO 2: Custom 404 (devuelve 200 para todo)
# Filtrar por tamano de la respuesta:
ffuf -u http://objetivo.com/FUZZ -w wordlist.txt -fs TAMANO_FALSO

# CASO 3: Redireccion para todo (301/302 siempre)
# Ver la URL de destino de la redireccion:
ffuf -u http://objetivo.com/FUZZ -w wordlist.txt -r -fc 301

# CASO 4: Respuesta variable (WAF, rate limiting)
# Filtrar por regex en el contenido:
ffuf -u http://objetivo.com/FUZZ -w wordlist.txt -fr 'Page Not Found|404|Not Found'

# CASO 5: Filtrar por numero de palabras (cuando el contenido varia pero no el tamano):
ffuf -u http://objetivo.com/FUZZ -w wordlist.txt -fw 32
# (si la pagina de error siempre tiene 32 palabras)

Usar el modo autocalibrationAUTOCALIBRATION

Autocalibration: ffuf detecta los filtros automaticamente

# ffuf puede detectar automaticamente el tamano/palabras/lineas de los falsos positivos
# usando el flag -ac (autocalibration)

# Modo automatico: ffuf envia algunas peticiones de calibracion y decide el filtro:
ffuf -u http://objetivo.com/FUZZ -w wordlist.txt -ac

# Autocalibration con estrategia:
ffuf -u http://objetivo.com/FUZZ -w wordlist.txt -ac -acc -c

# La autocalibration funciona enviando palabras aleatorias largas que con seguridad
# no existen, y midiendo el tamano/palabras/lineas de esas respuestas

💡 La estrategia más efectiva: usa siempre -ac primero. Si hay muchos falsos positivos, añade -fs TAMANO manualmente. Puedes combinar varios filtros: -fc 404 -fs 0 -fw 1

📂

Ejercicio 1 — Directory Fuzzing

Descubrir directorios y rutas ocultas en aplicaciones web

El uso más común de ffuf: descubrir directorios y rutas ocultas en una aplicación web. Muchos paneles de administración, páginas de backup y configuraciones sensibles están simplemente ocultos por su URL, no protegidos.

Directory fuzzing básicoBÁSICO

Descubrir directorios ocultos

# Fuzzing basico de directorios:
ffuf -u http://objetivo.com/FUZZ \
  -w /usr/share/seclists/Discovery/Web-Content/common.txt \
  -c

# Con autocalibration para evitar falsos positivos:
ffuf -u http://objetivo.com/FUZZ \
  -w /usr/share/seclists/Discovery/Web-Content/common.txt \
  -c -ac

# Mas completo (wordlist mediana + verbose):
ffuf -u http://objetivo.com/FUZZ \
  -w /usr/share/seclists/Discovery/Web-Content/directory-list-2.3-medium.txt \
  -c -v -ac

# Solo mostrar 200 y 403 (excluir 404 y redirecciones):
ffuf -u http://objetivo.com/FUZZ \
  -w /usr/share/seclists/Discovery/Web-Content/common.txt \
  -mc 200,403 -c

Interpretar la salidaSALIDA

[Status: 200][Size: 4512]http://objetivo.com/admin

[Status: 301][Size: 234]http://objetivo.com/images -> http://objetivo.com/images/

[Status: 403][Size: 278]http://objetivo.com/.htaccess

[Status: 404][Size: 152]http://objetivo.com/noexiste [FILTRADO]

💡 Un 403 Forbidden es un hallazgo valioso: significa que el directorio existe pero esta protegido. Un 401 significa que requiere autenticacion. Ambos deben investigarse en profundidad.

Modo recursivo: fuzzear subdirectorios encontradosRECURSIVO

Fuzzing recursivo con -recursion

# Fuzzing recursivo: cuando encuentra un directorio, lo fuzzea tambien
ffuf -u http://objetivo.com/FUZZ \
  -w /usr/share/seclists/Discovery/Web-Content/common.txt \
  -c -recursion -recursion-depth 2

# Con profundidad maxima de 3:
ffuf -u http://objetivo.com/FUZZ \
  -w /usr/share/seclists/Discovery/Web-Content/common.txt \
  -c -recursion -recursion-depth 3 -ac

# CUIDADO: recursion con wordlists grandes puede generar mucho trafico
# Usar una wordlist pequena para la recursion:
ffuf -u http://objetivo.com/FUZZ \
  -w /usr/share/seclists/Discovery/Web-Content/raft-small-directories.txt \
  -c -recursion -recursion-depth 2 -t 50

Guardar resultadosOUTPUT

Guardar resultados en diferentes formatos

# Guardar en JSON (el mas util para procesar despues):
ffuf -u http://objetivo.com/FUZZ \
  -w wordlist.txt \
  -c -o resultados.json -of json

# Guardar en todos los formatos a la vez:
ffuf -u http://objetivo.com/FUZZ \
  -w wordlist.txt \
  -c -o resultados -of all
# Genera: resultados.json, resultados.csv, resultados.html, resultados.md

# Ver resultados JSON con jq:
jq '.results[] | {url: .url, status: .status, length: .length}' resultados.json

❓ Ejercicio práctico

Levanta un servidor Apache local (sudo systemctl start apache2) y crea algunos directorios de prueba en /var/www/html/. Luego usa ffuf para descubrirlos. ¿Qué wordlist detecta más directorios?

💡 Pista: mkdir /var/www/html/admin /var/www/html/backup /var/www/html/secret --- ffuf -u http://localhost/FUZZ -w wordlist.txt

Ver solución

sudo mkdir /var/www/html/admin /var/www/html/backup /var/www/html/secret --- ffuf -u http://localhost/FUZZ -w /usr/share/seclists/Discovery/Web-Content/common.txt -c --- common.txt encontrara admin y backup (palabras comunes). secret puede requerir una wordlist mayor. Compara con raft-medium-directories.txt para ver diferencias.

📄

Ejercicio 2 — File Fuzzing y Extensiones

Descubrir archivos de configuración, backups y código fuente expuesto

Buscar archivos específicos es tan importante como buscar directorios. Archivos de configuración, backups, logs y páginas abandonadas pueden revelar credenciales, código fuente o información sensible.

Fuzzing de archivos con extensionesARCHIVOS

Buscar archivos con extensiones especificas

# Metodo 1: usar el flag -e para probar extensiones
# ffuf anade las extensiones a cada palabra del diccionario
ffuf -u http://objetivo.com/FUZZ \
  -w /usr/share/seclists/Discovery/Web-Content/common.txt \
  -e .php,.html,.txt,.bak,.old,.conf,.xml,.json \
  -c -ac

# Metodo 2: usar una wordlist de archivos directamente
ffuf -u http://objetivo.com/FUZZ \
  -w /usr/share/seclists/Discovery/Web-Content/raft-medium-files.txt \
  -c -ac

# Buscar archivos de backup tipicos:
ffuf -u http://objetivo.com/FUZZ \
  -w /usr/share/seclists/Discovery/Web-Content/raft-large-files.txt \
  -c -mc 200

Buscar archivos sensibles específicosARCHIVOS SENSIBLES

Wordlist personalizada de archivos de alto valor

# Crear wordlist de archivos sensibles:
cat > archivos_sensibles.txt << 'EOF'
.env
.htaccess
.htpasswd
web.config
config.php
config.php.bak
database.php
db.php
connection.php
setup.php
install.php
phpinfo.php
test.php
admin.php
backup.zip
backup.sql
dump.sql
site.zip
www.tar.gz
EOF

ffuf -u http://objetivo.com/FUZZ \
  -w archivos_sensibles.txt \
  -c -mc 200,403 -v

# Buscar archivos .git expuestos (muy frecuente):
ffuf -u http://objetivo.com/FUZZ \
  -w /usr/share/seclists/Discovery/Web-Content/common.txt \
  -c -mr '\.git|composer\.json|\.env' -ac

Fuzzing en subdirectorios ya descubiertosSUBDIRECTORIOS

Fuzzear dentro de un directorio conocido

# Una vez descubierto /admin/, fuzzear su contenido:
ffuf -u http://objetivo.com/admin/FUZZ \
  -w /usr/share/seclists/Discovery/Web-Content/common.txt \
  -e .php,.html,.txt \
  -c -ac

# Fuzzear archivos de configuracion en /config/:
ffuf -u http://objetivo.com/config/FUZZ \
  -w /usr/share/seclists/Discovery/Web-Content/raft-medium-files.txt \
  -c -mc 200

# Script para fuzzear recursivamente todos los directorios encontrados:
for dir in admin backup api config; do
  echo "[*] Fuzzeando /$dir/"
  ffuf -u http://objetivo.com/$dir/FUZZ \
    -w /usr/share/seclists/Discovery/Web-Content/common.txt \
    -c -ac -s 2>/dev/null
done

❓ Ejercicio práctico

Crea un archivo secreto.php y otro backup.sql en el directorio raíz de tu Apache local. Usa ffuf con el flag -e para descubrir ambos archivos. ¿Qué extensiones incluirías en el flag?

💡 Pista: ffuf -u http://localhost/FUZZ -w common.txt -e .php,.sql,.html,.txt,.bak

Ver solución

ffuf -u http://localhost/FUZZ -w /usr/share/seclists/Discovery/Web-Content/common.txt -e .php,.sql,.html,.txt,.bak -c -mc 200 --- Con la wordlist common.txt y las extensiones .php y .sql deberia encontrar tanto secreto.php como backup.sql si los nombres base estan en common.txt. Para nombres arbitrarios, usa raft-medium-files.txt.

🌐

Ejercicio 3 — Virtual Host Fuzzing

Descubrir subdominios y aplicaciones internas por cabecera Host HTTP

Virtual host fuzzing (o vhost fuzzing) consiste en descubrir subdominios y virtual hosts que están alojados en el mismo servidor IP pero responden a diferentes cabeceras Host. En ffuf se consigue colocando FUZZ en la cabecera Host en lugar de en la URL.

Muchas aplicaciones tienen entornos de desarrollo, APIs internas o paneles de administración accesibles solo por su vhost específico.

VHost fuzzing básico con cabecera HostVHOST

Descubrir virtual hosts en un servidor

# La clave: FUZZ va en la cabecera Host, no en la URL
# La IP/dominio en la URL es la misma para todas las peticiones
ffuf -u http://IP_SERVIDOR/ \
  -H 'Host: FUZZ.dominio.com' \
  -w /usr/share/seclists/Discovery/DNS/subdomains-top1million-5000.txt \
  -c

# El servidor respondera de forma distinta a hosts que existen vs. los que no
# Necesitamos filtrar la respuesta por defecto (host no encontrado)

# Primero: ver como responde el servidor a un host que no existe
curl -s -o /dev/null -w '%{http_code} %{size_download}\n' \
  -H 'Host: hostquenoeXISTE123.dominio.com' http://IP_SERVIDOR/
# Ej: 200 612 -> siempre devuelve 200 con 612 bytes -> filtrar ese tamano

# Con filtro de tamano:
ffuf -u http://IP_SERVIDOR/ \
  -H 'Host: FUZZ.dominio.com' \
  -w /usr/share/seclists/Discovery/DNS/subdomains-top1million-5000.txt \
  -c -fs 612

VHost fuzzing con HTTPSHTTPS

VHost fuzzing en servidores HTTPS

# Para HTTPS, ignorar el error de certificado con -k:
ffuf -u https://IP_SERVIDOR/ \
  -H 'Host: FUZZ.dominio.com' \
  -w /usr/share/seclists/Discovery/DNS/subdomains-top1million-5000.txt \
  -c -k -ac

# Cuando encuentres un vhost, aniadirlo al /etc/hosts para acceder:
echo 'IP_SERVIDOR  admin.dominio.com' | sudo tee -a /etc/hosts
curl http://admin.dominio.com/

Diferencia entre VHost fuzzing y DNS bruteforceDIFERENCIA

📊VHOST FUZZING vs DNS BRUTE FORCE

Técnica	Cómo funciona	Detecta	Requiere
VHost fuzzing (ffuf)	Cambia la cabecera Host HTTP, misma IP	Vhosts en el mismo servidor (sin DNS)	Acceso directo a la IP del servidor
DNS brute force (gobuster/subfinder)	Resuelve nombres DNS reales	Subdominios con registros DNS	Acceso a DNS del objetivo

VHost fuzzing puede descubrir aplicaciones internas que no tienen registro DNS público: panel de admin accesible solo por IP con cabecera Host específica, entornos de staging, APIs internas...

❓ Ejercicio práctico

Configura Apache con dos virtual hosts en tu máquina local: public.local y secret.local, apuntando a directorios diferentes. Usa ffuf para descubrir secret.local mediante VHost fuzzing.

💡 Pista: Crea los vhosts en /etc/apache2/sites-available/ --- ffuf -u http://127.0.0.1/ -H 'Host: FUZZ.local' -w wordlist.txt

Ver solución

Configurar Apache con dos vhosts en localhost --- ffuf -u http://127.0.0.1/ -H 'Host: FUZZ.local' -w /usr/share/seclists/Discovery/DNS/subdomains-top1million-5000.txt -c -fs TAMANO_RESPUESTA_DEFAULT --- El tamano de respuesta por defecto (cuando el vhost no existe) es el filtro clave. Si 'public' y 'secret' estan en la wordlist, ffuf los encontrara por tener un tamano distinto.

📊

Ejercicio 4 — Parameter Fuzzing (GET y POST)

Descubrir parámetros ocultos y detectar IDOR en APIs y formularios

Muchas vulnerabilidades web como IDOR, SSRF, o inyecciones dependen de parámetros ocultos no documentados. ffuf puede fuzzear parámetros tanto en peticiones GET como en el cuerpo de peticiones POST.

GET parameter fuzzingPARAMETROS GET

Descubrir parametros GET ocultos

# Fuzzear el nombre del parametro (la clave):
ffuf -u 'http://objetivo.com/page?FUZZ=test' \
  -w /usr/share/seclists/Discovery/Web-Content/burp-parameter-names.txt \
  -c -ac

# Fuzzear el valor de un parametro conocido (ej: id):
ffuf -u 'http://objetivo.com/user?id=FUZZ' \
  -w /usr/share/seclists/Fuzzing/Integers/Integers.fuzz.txt \
  -c -ac

# Fuzzear el valor con una lista de payloads especificos (IDOR):
ffuf -u 'http://objetivo.com/api/document?id=FUZZ' \
  -w numeros.txt \
  -c -mc 200 -ac

POST parameter fuzzingPARAMETROS POST

Descubrir parametros POST ocultos en formularios

# Fuzzear parametros en POST body:
ffuf -u 'http://objetivo.com/login' \
  -X POST \
  -d 'FUZZ=test' \
  -H 'Content-Type: application/x-www-form-urlencoded' \
  -w /usr/share/seclists/Discovery/Web-Content/burp-parameter-names.txt \
  -c -ac

# Fuzzear el valor de un parametro POST conocido (password spraying simple):
ffuf -u 'http://objetivo.com/login' \
  -X POST \
  -d 'username=admin&password=FUZZ' \
  -H 'Content-Type: application/x-www-form-urlencoded' \
  -w /usr/share/seclists/Passwords/Common-Credentials/best110.txt \
  -c -fc 401

# Fuzzear JSON (APIs):
ffuf -u 'http://objetivo.com/api/login' \
  -X POST \
  -d '{"username":"admin","password":"FUZZ"}' \
  -H 'Content-Type: application/json' \
  -w /usr/share/seclists/Passwords/Common-Credentials/best110.txt \
  -c -fc 401

Fuzzear valores numericos (IDOR)IDOR

Generar y fuzzear IDs numericos para detectar IDOR

# Generar lista de numeros del 1 al 1000:
seq 1 1000 > numeros.txt

# O usar Python:
python3 -c 'print("\n".join(map(str, range(1, 1001))))' > numeros.txt

# Fuzzear IDs para detectar IDOR (Insecure Direct Object Reference):
ffuf -u 'http://objetivo.com/api/user/FUZZ' \
  -w numeros.txt \
  -c -mc 200 \
  -H 'Cookie: session=abc123'

# Si encuentra IDs que devuelven 200 con diferente tamano -> posible IDOR
# Filtrar solo las respuestas con tamano significativo:
ffuf -u 'http://objetivo.com/api/user/FUZZ' \
  -w numeros.txt \
  -c -mc 200 -ms 150-500

❓ Ejercicio práctico

Instala DVWA en tu máquina local y usa ffuf para fuzzear el parámetro id en /vulnerabilities/sqli/?id=FUZZ. ¿Qué valores de ID producen respuestas de tamaño diferente?

💡 Pista: ffuf -u 'http://localhost/dvwa/vulnerabilities/sqli/?id=FUZZ' -w numeros.txt -b 'PHPSESSID=...' -c -ac

Ver solución

seq 1 100 > numeros.txt --- ffuf -u 'http://localhost/dvwa/vulnerabilities/sqli/?id=FUZZ&Submit=Submit' -w numeros.txt -b 'PHPSESSID=TU_SESION;security=low' -c -ac --- Los IDs que corresponden a usuarios en la base de datos devuelven una respuesta mas grande. Los inexistentes devuelven un tamano menor o distinto.

🔒

Ejercicio 5 — Fuzzing Autenticado

Fuzzear áreas protegidas con cookies de sesión, JWT y HTTP Auth

Muchas aplicaciones requieren autenticación para acceder a áreas de interés. ffuf puede enviar cookies de sesión, tokens JWT, cabeceras de autorización o credenciales HTTP Basic para fuzzear dentro de áreas protegidas.

Fuzzing con cookie de sesiónCOOKIE

Fuzzing autenticado con cookies

# Obtener la cookie de sesion haciendo login con curl:
curl -c cookies.txt -s -o /dev/null \
  -X POST http://objetivo.com/login \
  -d 'username=admin&password=Password123'

# Ver la cookie obtenida:
cat cookies.txt

# Usar la cookie en ffuf:
ffuf -u http://objetivo.com/admin/FUZZ \
  -w /usr/share/seclists/Discovery/Web-Content/common.txt \
  -b 'PHPSESSID=abc123def456' \
  -c -ac

# Multiples cookies:
ffuf -u http://objetivo.com/dashboard/FUZZ \
  -w wordlist.txt \
  -b 'session=abc; token=xyz; role=admin' \
  -c -mc 200

Fuzzing con cabecera Authorization (JWT / Bearer)JWT

Fuzzing con token JWT o Bearer

# Con token JWT en cabecera Authorization:
ffuf -u http://api.objetivo.com/FUZZ \
  -w /usr/share/seclists/Discovery/Web-Content/api/api-endpoints.txt \
  -H 'Authorization: Bearer eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9...' \
  -c -ac

# Con API Key:
ffuf -u http://api.objetivo.com/v1/FUZZ \
  -w wordlist.txt \
  -H 'X-API-Key: tu_api_key_aqui' \
  -c -mc 200

# HTTP Basic Auth:
ffuf -u http://objetivo.com/FUZZ \
  -w wordlist.txt \
  --request-proto http \
  -H 'Authorization: Basic YWRtaW46YWRtaW4=' \
  -c -ac
# 'YWRtaW46YWRtaW4=' = base64('admin:admin')

Usar archivo de peticion HTTP de Burp SuiteBURP REQUEST

Importar peticion HTTP de Burp directamente

# Guardar una peticion completa de Burp Suite en un archivo:
# (copiar desde Burp -> boton derecho -> 'Copy to file')

# Contenido de peticion.txt:
# GET /FUZZ HTTP/1.1
# Host: objetivo.com
# Cookie: session=abc123
# User-Agent: Mozilla/5.0
# Accept: */*

# Usar el archivo de peticion directamente:
ffuf -request peticion.txt \
  -w /usr/share/seclists/Discovery/Web-Content/common.txt \
  -c -ac

# Para HTTPS:
ffuf -request peticion.txt \
  -request-proto https \
  -w wordlist.txt \
  -c -ac

❓ Ejercicio práctico

Accede a DVWA o a tu aplicación de prueba, obtiene la cookie de sesión con curl, y luego usa ffuf para fuzzear el área autenticada. ¿Qué directorios o páginas están disponibles después del login?

💡 Pista: curl -c cookies.txt -X POST URL_LOGIN -d 'user=admin&pass=admin' --- ffuf -b 'COOKIE=VALOR' ...

Ver solución

curl -c /tmp/cookies.txt -s -X POST http://localhost/dvwa/login.php -d 'username=admin&password=password&Login=Login' --- SESION=$(grep PHPSESSID /tmp/cookies.txt | awk '{print $NF}') --- ffuf -u http://localhost/dvwa/FUZZ -w /usr/share/seclists/Discovery/Web-Content/common.txt -b "PHPSESSID=$SESION;security=low" -c -ac -mc 200

🔌

Ejercicio 6 — API Endpoint Fuzzing

Descubrir endpoints REST, versiones de API y métodos HTTP soportados

Las APIs REST modernas exponen múltiples endpoints que pueden no estar documentados. ffuf es la herramienta ideal para descubrir la superficie de ataque de una API: versiones, recursos y métodos HTTP soportados.

Descubrir endpoints de APIAPI ENDPOINTS

Fuzzing de endpoints REST

# Descubrir endpoints de API:
ffuf -u http://api.objetivo.com/api/v1/FUZZ \
  -w /usr/share/seclists/Discovery/Web-Content/api/api-endpoints.txt \
  -c -ac

# Probar diferentes versiones de la API:
ffuf -u http://api.objetivo.com/api/FUZZ/users \
  -w /usr/share/seclists/Discovery/Web-Content/api/api-seen-in-wild.txt \
  -c -mc 200,301,401

# Descubrir versiones:
ffuf -u http://api.objetivo.com/FUZZ \
  -w versiones.txt \
  -c -mc 200,301

# versiones.txt:
# v1, v2, v3, api, api/v1, api/v2, rest, graphql, swagger

Fuzzear métodos HTTP soportadosMETODOS HTTP

Descubrir metodos HTTP permitidos en un endpoint

# Crear lista de metodos HTTP:
cat > metodos.txt << 'EOF'
GET
POST
PUT
DELETE
PATCH
HEAD
OPTIONS
TRACE
CONNECT
EOF

# Fuzzear el metodo HTTP:
ffuf -u http://api.objetivo.com/api/v1/users \
  -X FUZZ \
  -w metodos.txt \
  -c -mc 200,201,204,405

# Metodo alternativo con curl para un endpoint especifico:
for method in GET POST PUT DELETE PATCH OPTIONS; do
  code=$(curl -s -o /dev/null -w '%{http_code}' -X $method http://api.objetivo.com/api/v1/users)
  echo "$method: $code"
done

API fuzzing completo con autenticación JWTAPI COMPLETA

Flujo completo de API fuzzing

# 1. Obtener el token JWT haciendo login en la API:
TOKEN=$(curl -s -X POST http://api.objetivo.com/auth/login \
  -H 'Content-Type: application/json' \
  -d '{"username":"admin","password":"password"}' | \
  python3 -c 'import json,sys; print(json.load(sys.stdin)["token"])')

echo "Token: $TOKEN"

# 2. Descubrir endpoints autenticados:
ffuf -u http://api.objetivo.com/api/v1/FUZZ \
  -H "Authorization: Bearer $TOKEN" \
  -H 'Content-Type: application/json' \
  -w /usr/share/seclists/Discovery/Web-Content/api/api-endpoints.txt \
  -c -ac -mc 200,201,401,403

# 3. Fuzzear un endpoint especifico probando recursos:
ffuf -u http://api.objetivo.com/api/v1/users/FUZZ \
  -H "Authorization: Bearer $TOKEN" \
  -w numeros.txt \
  -c -mc 200 -ac

❓ Ejercicio práctico

Instala una API de prueba local (Juice Shop de OWASP o json-server). Usa ffuf para descubrir todos los endpoints disponibles. ¿Qué wordlist especializada en APIs da mejores resultados?

💡 Pista: ffuf -u http://localhost:3000/FUZZ -w /usr/share/seclists/Discovery/Web-Content/api/ --- Compara con common.txt

Ver solución

docker run -d -p 3000:3000 bkimminich/juice-shop --- ffuf -u http://localhost:3000/FUZZ -w /usr/share/seclists/Discovery/Web-Content/api/api-endpoints.txt -c -ac --- Juice Shop tiene endpoints como /api/Users, /api/Products, /api/FeedBacks, /rest/user/login. La wordlist api-endpoints.txt especializada da mejores resultados que common.txt para APIs.

📈

Ejercicio 7 — Múltiples Palabras Clave

Fuzzear varias posiciones simultáneamente con diferentes diccionarios

Una de las características más potentes de ffuf es el soporte para múltiples palabras clave (FUZZ, W2, NOMBRE_PERSONALIZADO). Permite fuzzear varias posiciones simultáneamente con diferentes diccionarios, lo que es muy útil para combinaciones de usuario+contraseña, extensiones variables, o combinaciones de paths.

Múltiples palabras clave con -wMULTI-FUZZ

Usar multiples palabras clave FUZZ y W2

# Sintaxis: -w wordlist1:NOMBRE1 -w wordlist2:NOMBRE2
# Y usar NOMBRE1, NOMBRE2 en la URL

# Ejemplo: fuzzear directorio Y extension simultaniamente:
ffuf -u http://objetivo.com/W1/FUZZ.W2 \
  -w /usr/share/seclists/Discovery/Web-Content/raft-small-directories.txt:W1 \
  -w extensiones.txt:W2 \
  -c -ac
# Prueba todas las combinaciones de directorio+archivo+extension

# Ejemplo: fuzzear usuario y contrasena en login (credential stuffing):
ffuf -u http://objetivo.com/login \
  -X POST \
  -d 'username=FUZZ&password=W2' \
  -H 'Content-Type: application/x-www-form-urlencoded' \
  -w /usr/share/seclists/Usernames/top-usernames-shortlist.txt:FUZZ \
  -w /usr/share/seclists/Passwords/Common-Credentials/best110.txt:W2 \
  -c -fc 401 \
  -t 20 -p 0.1

Modo cluster bomb con pitchforkMODOS DE ATAQUE

📊MODOS DE COMBINACIÓN EN FFUF

Modo	Descripción	Uso
clusterbomb (default)	Todas las combinaciones posibles de todas las listas. Total = W1 x W2 x...	Credential stuffing, path + ext
pitchfork	Itera en paralelo: W1[0]+W2[0], W1[1]+W2[1]... Las listas deben tener el mismo tamaño	Usuario + contraseña del mismo archivo
sniper (solo FUZZ)	Una sola lista, una sola posición	Fuzzing estandar de una posicion

Modo pitchfork: usuario y contrasena del mismo par

# Archivo credenciales.txt (usuario:contrasena por linea):
# admin:admin123
# user:password123

# Separar en dos archivos:
cut -d':' -f1 credenciales.txt > usuarios.txt
cut -d':' -f2 credenciales.txt > passwords.txt

# Pitchfork: combina usuario[0] con password[0], etc.:
ffuf -u http://objetivo.com/login \
  -X POST \
  -d 'user=FUZZ&pass=W2' \
  -w usuarios.txt:FUZZ \
  -w passwords.txt:W2 \
  -mode pitchfork \
  -c -fc 401

Combinacion de rutas y extensionesCOMBINACION PATH+EXT

Fuzzear directorios y extensiones en paralelo

# Crear lista de extensiones:
printf 'php\nhtml\ntxt\nbak\nold' > ext.txt

# Fuzzear: raft-directories + extensiones comunes
ffuf -u http://objetivo.com/W1.W2 \
  -w /usr/share/seclists/Discovery/Web-Content/raft-small-directories.txt:W1 \
  -w ext.txt:W2 \
  -c -ac -mc 200

# ATENCION: combinaciones = |W1| x |W2|
# Con 30.000 palabras y 5 extensiones = 150.000 peticiones
# Usar con moderacion y -t limitado

❓ Ejercicio práctico

Usa ffuf con dos palabras clave para fuzzear simultáneamente el nombre del archivo (con una wordlist) y su extensión (con tu lista de extensiones) en el directorio raíz de tu Apache local. ¿Cuántas peticiones totales genera con 100 palabras x 5 extensiones?

💡 Pista: Total peticiones = |wordlist1| x |wordlist2| --- -w lista1:W1 -w lista2:W2 -u http://host/W1.W2

Ver solución

Con 100 palabras x 5 extensiones = 500 peticiones totales (modo clusterbomb). --- ffuf -u http://localhost/W1.W2 -w palabras.txt:W1 -w ext.txt:W2 -c -mc 200 --- El modo pitchfork solo generaria 100 peticiones (minimo de ambas listas), ideal cuando cada par usuario/contrasena va junto.

🛠

Ejercicio 8 — Configuración Avanzada y Evasion

Control de velocidad, WAF bypass, archivo de configuración y Burp Suite

Configuración avanzada para objetivos con WAF, rate limiting o cuando necesitas ser más sigiloso. También cómo configurar ffuf mediante archivo de configuración para reutilizar opciones.

Control de velocidad y evasion de WAFVELOCIDAD Y EVASION

Controlar la velocidad para evitar bloqueos

# Por defecto ffuf va muy rapido (40 hilos)
# Para objetivos con rate limiting o WAF, reducir velocidad:

# Reducir hilos:
ffuf -u http://objetivo.com/FUZZ -w wordlist.txt -t 10

# Anadir delay entre peticiones:
ffuf -u http://objetivo.com/FUZZ -w wordlist.txt -p 0.5
# p 0.5 = esperar 500ms entre peticiones

# Delay aleatorio entre 1 y 3 segundos:
ffuf -u http://objetivo.com/FUZZ -w wordlist.txt -p '1-3'

# Cambiar User-Agent para evadir filtros basicos:
ffuf -u http://objetivo.com/FUZZ \
  -w wordlist.txt \
  -H 'User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 Chrome/120.0.0.0'

# Enrutar por proxy (Burp Suite para analizar el trafico):
ffuf -u http://objetivo.com/FUZZ \
  -w wordlist.txt \
  -x http://127.0.0.1:8080

Archivo de configuración ffuf.tomlCONFIGURACIÓN

Crear y usar archivo de configuracion .ffufrc

# ffuf puede leer la configuracion desde:
# ~/.ffufrc  (configuracion global)
# .ffufrc   (configuracion local del directorio)

# Crear ~/.ffufrc con opciones por defecto:
cat > ~/.ffufrc << 'EOF'
[general]
# Usar 40 hilos por defecto
concurrency = 40
# Delay de 100ms entre peticiones
delay = 0.1
# Colorear output
color = true
# Modo silencioso por defecto
silent = false
# Seguir redirecciones
followredirects = false

[http]
# User-Agent personalizado
useragent = "Mozilla/5.0 (compatible; SecurityAudit/1.0)"

[filter]
# Filtrar siempre 404
status = "404"
EOF

# Con este archivo, no hay que repetir -c -p etc. en cada comando:
ffuf -u http://objetivo.com/FUZZ -w wordlist.txt

Usar ffuf con Burp SuiteBURP INTEGRATION

Combinar ffuf con Burp Suite para analisis profundo

# 1. Iniciar Burp Suite con proxy en 127.0.0.1:8080

# 2. Enrutar ffuf por Burp:
ffuf -u http://objetivo.com/FUZZ \
  -w wordlist.txt \
  -x http://127.0.0.1:8080 \
  -c

# 3. En Burp veras todas las peticiones de ffuf
# Puedes interceptar las interesantes y modificarlas manualmente

# Para HTTPS con Burp:
# Instalar certificado de Burp primero
ffuf -u https://objetivo.com/FUZZ \
  -w wordlist.txt \
  -x http://127.0.0.1:8080 \
  -k -c
# -k = ignorar errores de certificado TLS

❓ Ejercicio práctico

Configura tu archivo ~/.ffufrc con un User-Agent personalizado y un delay de 200ms. Verifica que ffuf lo usa sin pasarle esas opciones por línea de comandos.

💡 Pista: cat > ~/.ffufrc con las opciones --- ffuf -u http://localhost/FUZZ -w wordlist.txt -v (sin -p ni -H)

Ver solución

cat ~/.ffufrc: [http] useragent='Mozilla/5.0 Custom' --- [general] delay=0.2 --- ffuf -u http://localhost/FUZZ -w /usr/share/seclists/Discovery/Web-Content/common.txt -v --- En el header de ffuf al inicio veras que usa el User-Agent y delay configurados. Util para no repetir opciones comunes en cada comando.

💻

Ejercicio 9 — Integración en Pipelines

Combinar ffuf con otras herramientas y procesar resultados JSON

ffuf puede integrarse en pipelines de reconocimiento y pentesting automatizados. La salida en JSON facilita el procesado posterior con Python, jq o herramientas de seguimiento de vulnerabilidades.

💻PIPELINE DE RECONOCIMIENTO WEB COMPLETO

Pipeline: Nmap + ffuf + analisis de resultados

#!/bin/bash
# Pipeline completo de reconocimiento web
# Uso: ./web_recon.sh http://objetivo.com

URL=${1:-"http://localhost"}
DOMINIO=$(echo $URL | sed 's|https\?://||;s|/.*||')
OUT="recon_$(date +%Y%m%d_%H%M%S)"
mkdir -p "$OUT"

echo "[1] Descubrimiento de directorios (wordlist rapida)..."
ffuf -u "$URL/FUZZ" \
  -w /usr/share/seclists/Discovery/Web-Content/common.txt \
  -c -ac -s -of json \
  -o "$OUT/dirs_rapido.json" 2>/dev/null
echo "   Hallazgos: $(jq '.results | length' $OUT/dirs_rapido.json)"

echo "[2] Descubrimiento de archivos sensibles..."
ffuf -u "$URL/FUZZ" \
  -w /usr/share/seclists/Discovery/Web-Content/raft-medium-files.txt \
  -c -ac -s -mc 200 -of json \
  -o "$OUT/files.json" 2>/dev/null

echo "[3] Descubrimiento con extensiones comunes..."
ffuf -u "$URL/FUZZ" \
  -w /usr/share/seclists/Discovery/Web-Content/raft-small-directories.txt \
  -e .php,.html,.txt,.bak,.conf \
  -c -ac -s -of json \
  -o "$OUT/exts.json" 2>/dev/null

echo "[4] Generando informe..."
python3 << PYEOF
import json, os
for f in os.listdir('$OUT'):
    if f.endswith('.json'):
        with open(f'$OUT/{f}') as fp:
            data = json.load(fp)
        results = data.get('results', [])
        print(f'\n=== {f} ===')
        for r in results:
            print(f'  [{r["status"]}] {r["url"]} ({r["length"]} bytes)')
PYEOF

echo "\nResultados guardados en $OUT/"

Procesar resultados JSON de ffuf con jq y Python

# Extraer solo las URLs encontradas:
jq -r '.results[].url' resultados.json

# Extraer URLs con codigo 200:
jq -r '.results[] | select(.status==200) | .url' resultados.json

# Ver resumen por codigo de respuesta:
jq -r '.results | group_by(.status) | .[] | {status: .[0].status, count: length}' resultados.json

# Extraer URLs y guardar para siguiente paso (ej: nikto):
jq -r '.results[] | select(.status==200) | .url' resultados.json | \
  xargs -I{} nikto -h {}

# Script Python para informe HTML:
python3 << 'EOF'
import json
with open('resultados.json') as f:
    data = json.load(f)
results = sorted(data['results'], key=lambda x: x['status'])
for r in results:
    print(f"[{r['status']}] {r['url']} - {r['length']} bytes - {r['words']} words")
EOF

❓ Ejercicio práctico

Crea un script que ejecute ffuf contra un objetivo, guarde los resultados en JSON, y luego use jq para extraer solo las URLs con código 200 y las imprima.

💡 Pista: ffuf ... -o resultados.json -of json --- jq '.results[] | select(.status==200) | .url' resultados.json

Ver solución

ffuf -u http://localhost/FUZZ -w /usr/share/seclists/Discovery/Web-Content/common.txt -c -ac -o /tmp/res.json -of json -s 2>/dev/null --- jq -r '.results[] | select(.status==200) | .url' /tmp/res.json --- Para un script: #!/bin/bash --- URL=$1 --- ffuf -u $URL/FUZZ -w wordlist.txt -o /tmp/ffuf_$$.json -of json -s 2>/dev/null --- jq -r '.results[] | select(.status==200) | .url' /tmp/ffuf_$$.json

📚

Cheatsheet Completo de ffuf

Referencia rápida de todos los comandos

ffuf Cheatsheet completo

# ── DIRECTORY FUZZING ──────────────────────────────
ffuf -u http://URL/FUZZ -w wordlist.txt -c                    # Basico
ffuf -u http://URL/FUZZ -w wordlist.txt -c -ac                # Con autocalibration
ffuf -u http://URL/FUZZ -w wordlist.txt -c -mc 200,301,403    # Solo esos codigos
ffuf -u http://URL/FUZZ -w wordlist.txt -c -fs 1234           # Filtrar tamano
ffuf -u http://URL/FUZZ -w wordlist.txt -c -recursion -recursion-depth 2

# ── FILE FUZZING ────────────────────────────────────
ffuf -u http://URL/FUZZ -w wordlist.txt -e .php,.html,.txt -c # Con extensiones
ffuf -u http://URL/FUZZ -w raft-medium-files.txt -c -mc 200  # Archivos directos

# ── VHOST FUZZING ───────────────────────────────────
ffuf -u http://IP/ -H 'Host: FUZZ.dominio.com' -w subdomains.txt -c -fs TAMANO

# ── PARAMETER FUZZING ──────────────────────────────
ffuf -u 'http://URL/page?FUZZ=test' -w burp-params.txt -c -ac         # GET param
ffuf -u http://URL/ -X POST -d 'FUZZ=test' -w burp-params.txt -c -ac  # POST param
ffuf -u 'http://URL/user?id=FUZZ' -w numeros.txt -c -ac               # IDOR

# ── AUTENTICADO ─────────────────────────────────────
ffuf -u http://URL/FUZZ -w wordlist.txt -b 'session=abc123' -c        # Cookie
ffuf -u http://URL/FUZZ -w wordlist.txt -H 'Authorization: Bearer JWT' -c
ffuf -request peticion.txt -w wordlist.txt -c                          # Burp request

# ── MULTIPLES PALABRAS CLAVE ────────────────────────
ffuf -u http://URL/W1/FUZZ.W2 -w dirs.txt:W1 -w ext.txt:W2 -c
ffuf -u http://URL/ -X POST -d 'u=FUZZ&p=W2' -w users.txt:FUZZ -w pass.txt:W2 -c

# ── CONTROL DE VELOCIDAD ────────────────────────────
ffuf -u http://URL/FUZZ -w wordlist.txt -t 10 -p 0.5          # Lento
ffuf -u http://URL/FUZZ -w wordlist.txt -t 100                 # Rapido
ffuf -u http://URL/FUZZ -w wordlist.txt -p '1-3'              # Delay aleatorio

# ── SALIDA ──────────────────────────────────────────
ffuf -u http://URL/FUZZ -w wordlist.txt -o out.json -of json
ffuf -u http://URL/FUZZ -w wordlist.txt -o out -of all
ffuf -u http://URL/FUZZ -w wordlist.txt -s                     # Silent: solo resultados

# ── HTTPS Y PROXY ───────────────────────────────────
ffuf -u https://URL/FUZZ -w wordlist.txt -k                    # Ignorar TLS errors
ffuf -u http://URL/FUZZ -w wordlist.txt -x http://127.0.0.1:8080  # Via Burp

# ── WORDLISTS DE REFERENCIA ─────────────────────────
# Dirs rapido:  /usr/share/seclists/Discovery/Web-Content/common.txt
# Dirs completo: /usr/share/seclists/Discovery/Web-Content/directory-list-2.3-medium.txt
# Archivos:     /usr/share/seclists/Discovery/Web-Content/raft-medium-files.txt
# VHosts:       /usr/share/seclists/Discovery/DNS/subdomains-top1million-5000.txt
# Params:       /usr/share/seclists/Discovery/Web-Content/burp-parameter-names.txt

📈

ffuf vs Otras Herramientas de Fuzzing

Gobuster, Dirb, Dirsearch, Feroxbuster: cuándo usar cada uno

📈FFUF VS OTRAS HERRAMIENTAS DE FUZZING WEB

Herramienta	Lenguaje	Fuerte en	Débil en	Mejor uso
ffuf	Go	Velocidad, flexibilidad total (FUZZ en cualquier parte), multi-FUZZ, filtros potentes	Curva de aprendizaje del filtrado	Todos los casos: dirs, vhosts, params, APIs
Gobuster	Go	Simple, rapido, modo DNS, intuitivo	Menos flexible que ffuf, sin multi-FUZZ	Discovery rapido de dirs y DNS
Dirb	C	Clasico, estable, incluido en Kali	Lento (single thread), menos opciones	Auditorias basicas, legacy
Dirsearch	Python	Recursivo por defecto, soporte de extensiones bueno	Mas lento que ffuf	Directory fuzzing con recursion automatica
Feroxbuster	Rust	Muy rapido, recursion automatica excelente	Menos opciones de filtrado que ffuf	Fuzzing recursivo intensivo
Wfuzz	Python	Muy similar a ffuf, maduro	Mas lento que ffuf	Alternativa clasica a ffuf

✓ CONCLUSIÓNffuf es la herramienta de fuzzing web más versátil disponible. Su capacidad de colocar FUZZ en cualquier parte de la petición HTTP, sus potentes filtros, el soporte para múltiples palabras clave simultáneas y su velocidad (Go) la hacen insustituible en pentesting web moderno. Es la herramienta preferida para CTFs (HTB, THM) y auditorías de aplicaciones web.

🛡

Detección y Defensa contra Fuzzing Web

Cómo detectar fuzzing en los logs y mitigarlo con rate limiting y WAF

Desde la perspectiva defensiva, el fuzzing genera un patrón de tráfico muy característico y detectable. Saber cómo detectarlo y mitigarlo es tan importante como saber usarlo.

🛡CÓMO DETECTAR FUZZING EN LOS LOGS

Patrones de fuzzing en logs de Apache/Nginx

# En Apache access.log, el fuzzing genera:
# - Muchas peticiones consecutivas desde la misma IP en poco tiempo
# - Muchas peticiones con codigos 404 (paths que no existen)
# - User-Agent de ffuf: 'Fuzz Faster U Fool' o 'Go-http-client/1.1'

# Detectar fuzzing en Apache access.log:
grep 'ffuf\|Fuzz Faster\|Go-http-client' /var/log/apache2/access.log

# Contar peticiones 404 por IP (posible fuzzing):
grep '" 404 ' /var/log/apache2/access.log | \
  awk '{print $1}' | sort | uniq -c | sort -rn | head -20

# Ver la frecuencia de peticiones por IP (muchas peticiones/segundo):
awk '{print $1,$4}' /var/log/apache2/access.log | \
  sort | uniq -c | sort -rn | head -20

# En tiempo real:
tail -f /var/log/apache2/access.log | \
  grep --line-buffered '404' | \
  awk '{print $1}' | uniq -c

🛡MITIGACIONES CONTRA FUZZING WEB

Mitigación	Cómo	Qué bloquea
Rate limiting	Nginx limit_req_zone, Apache mod_ratelimit, WAF	Fuzzing rapido, reduce velocidad efectiva
Bloqueo por User-Agent	Bloquear "ffuf", "Nikto", "Gobuster", "Go-http-client"	Herramientas sin UA personalizado
IP blocking / geo-blocking	fail2ban, WAF, iptables tras N 404s	Fuzzing desde IP fija conocida
CAPTCHA en areas sensibles	Login, registro, formularios criticos	Fuzzing automatizado de credenciales
Respuestas uniformes para 404	Devolver siempre el mismo tamano para 404	Dificulta el autocalibration de ffuf
WAF (Web Application Firewall)	Cloudflare, ModSecurity, AWS WAF	Patrones de fuzzing conocidos