Bypass

# Ffuf CheatSheet

14 min read
Herramientas CheatSheet BugBounty fuzzing
Table of Contents

Guía Completa de Comandos de ffuf: Potencia tu Fuzzing Web

Durante las pruebas basadas en aplicativos web, la enumeración y el fuzzing es una de las técnicas esenciales para descubrir puntos débiles en aplicaciones. Una de las herramientas más potentes y versátiles para realizar este tipo de tareas es ffuf (Fuzz Faster U Fool). Esta guía completa te ayudara a tener una visión más detallada de los comandos de ffuf, acompañados de explicaciones contextuales para que puedas aprovechar al máximo sus capacidades.

¿Qué es ffuf?

ffuf es una herramienta escrita en Go para realizar fuzzing web de manera rápida y flexible. Permite realizar pruebas exhaustivas de enumeración de directorios, archivos, subdominios, vhosts, parámetros HTTP y mucho más. Su capacidad para manejar múltiples wordlists y su rendimiento optimizado lo convierten en una de las herramientas preferidas en el mundo de las pruebas de seguridad.

Uso Básico

Fuzz de Archivos/Rutas

El fuzzing de archivos o rutas es una de las funcionalidades más comunes de ffuf. Permite descubrir directorios o archivos ocultos en un servidor web al reemplazar la palabra clave FUZZ con cada entrada de una wordlist.

Comando:

bash
ffuf -w /path/to/wordlist.txt -u https://host.name/FUZZ

Descripción:

  • -w wordlist.txt: Especifica la wordlist a utilizar.
  • -u https://host.name/FUZZ: Define la URL objetivo donde FUZZ será reemplazado por cada palabra de la wordlist.

Fuzz de Extensiones de Archivos

Este comando es útil cuando necesitamos descubrir archivos con diferentes extensiones, como .php, .html, .js, etc.

Comando:

bash
ffuf -w /path/to/wordlist.txt -u https://host.name/indexFUZZ

Descripción:

  • Reemplaza FUZZ con las extensiones proporcionadas en la wordlist para buscar archivos como index.php, index.html,etc.

Nombres de Archivos

Permite realizar fuzzing en nombres de archivos específicos con una extensión determinada, útil para encontrar scripts vulnerables o páginas administrativas.

Comando:

bash
ffuf -w /path/to/wordlist.txt -u https://host.name/blog/FUZZ.php

Descripción:

  • Busca archivos PHP en el directorio /blog/ cuyos nombres están en la wordlist.

Usar la Salida de un Comando como Wordlist

Aprovechar la salida de comandos del sistema como una fuente dinámica de entradas para el fuzzing.

Comando:

bash
ffuf -c -w <(seq 1 1000) -u https://host.name/api/users/FUZZ

Descripción:

  • -c: Ejecuta el comando en un shell comó bandera para habilitar la salida colorizada.
  • -w <(seq 1 1000): Utiliza la salida del comando seq 1 1000 como wordlist, generando números del 1 al 1000.
  • -u https://host.name/api/users/FUZZ: Busca endpoints de usuarios con IDs numéricos.

Fuzzing Recursivo

Permite realizar fuzzing de forma recursiva aplicando múltiples niveles de profundidad, descubriendo rutas ocultas en estructuras de directorios complejas.

Comando:

bash
ffuf -recursion -recursion-depth 3 -w /path/to/wordlist.txt -u https://host.name/FUZZ

Descripción:

  • -recursion: Habilita el modo de fuzzing recursivo.
  • -recursion-depth 3: Define la profundidad máxima de recursión.
  • Descubre rutas ocultas hasta tres niveles de profundidad.

Establecer Cookies

Podemos enviar cookies personalizadas con cada solicitud, lo que puede ser útil para acceder a áreas protegidas o mantener sesiones.

Comando:

bash
ffuf -b "NAME1=VALUE1; NAME2=VALUE2" -w /path/to/wordlist.txt -u https://host.name/FUZZ

Descripción:

  • -b "NAME1=VALUE1; NAME2=VALUE2": Define las cookies a enviar con cada solicitud.

Wordlists Múltiples

Modo Clusterbomb

El modo clusterbomb intenta todas las combinaciones posibles de valores desde múltiples wordlists. Es ideal para escenarios donde se necesitas combinar diferentes parámetros, como usuarios y contraseñas.

Probar Diferentes Usuarios y Contraseñas

Este comando es útil para realizar ataques de fuerza bruta en formularios de inicio de sesión, combinando usuarios y contraseñas de dos wordlists diferentes.

Comando:

bash
ffuf -w /path/to/users.txt:USER -w /path/to/passwords.txt:PASS -u https://host.name/login?username=USER&password=PASS -mode clusterbomb

Descripción:

  • -w users.txt:USER: Define la wordlist de usuarios para el marcador USER.
  • -w passwords.txt:PASS: Define la wordlist de contraseñas para el marcador PASS.
  • --mode clusterbomb: Activa el modo clusterbomb para combinar usuarios y contraseñas.

Fuzzing de Múltiples Partes de una Solicitud JSON

Permite fuzzear múltiples campos dentro de una estructura JSON, ideal para realizar pruebas en APIs que aceptan datos complejos.

Comando:

bash
ffuf -w /path/to/usernames.txt:U -w /path/to/passwords.txt:P -X POST -d '{"username":"U","password":"P"}' -H 'Content-Type: application/json' -u https://host.name/api/login

Descripción:

  • -w usernames.txt:U: Wordlist para nombres de usuario.
  • -w passwords.txt:P: Wordlist para contraseñas.
  • -X POST: Define el método HTTP como POST.
  • -d '{"username":"U","password":"P"}': Define el cuerpo de la solicitud JSON, reemplazando U y P.
  • -H 'Content-Type: application/json': Establece el encabezado Content-Type.

Fuzzear Directorios y Nombres de Archivos Simultáneamente

Podemos combinar la enumeración de directorios y archivos para descubrir rutas completas y archivos específicos en una estructura de directorios.

Comando:

bash
ffuf -w /path/to/dirs.txt:DIR -w /path/to/files.txt:FILE -u https://host.name/DIR/FILE

Descripción:

  • -w dirs.txt:DIR: Wordlist para directorios.
  • -w files.txt:FILE: Wordlist para archivos.
  • Reemplaza DIR y FILE simultáneamente para construir rutas completas.

Modo Pitchfork

El modo pitchfork envía combinaciones sincronizadas de valores de diferentes wordlists, tomando una entrada de cada wordlist en cada iteración.

Probar Combinaciones Sincronizadas de Usuarios y Contraseñas

Comando:

bash
ffuf -w /path/to/users.txt:USER -w /path/to/passwords.txt:PASS -u https://host.name/login?username=USER&password=PASS --mode pitchfork

Descripción:

  • Similar al modo clusterbomb, pero en lugar de todas las combinaciones posibles, toma una entrada de cada wordlist en paralelo.

Subdominios y VHosts

Subdominios

El fuzzing de subdominios, ffuf también nos ayuda a descubrir subdominios ocultos que podrían estar expuestos y vulnerables.

Comando:

bash
ffuf -w /path/to/wordlist.txt -u https://FUZZ.host.name/

Descripción:

  • Reemplaza FUZZ con cada entrada de la wordlist para descubrir subdominios como admin.host.name, dev.host.name, etc.

VHosts

Fuzzear VHosts (Virtual Hosts) nos permite identificar configuraciones de servidores que pueden servir contenido diferente o estar expuestos a diferentes vulnerabilidades.

Comando:

bash
ffuf -w /path/to/wordlist.txt -u http://host.name/ -H 'Host: FUZZ.host.name'

Descripción:

  • -H 'Host: FUZZ.host.name': Define el encabezado Host con cada entrada de la wordlist para descubrir VHosts como api.host.name, mail.host.name, etc.

Parámetros HTTP

Nombres de Parámetros - GET

Fuzzear nombres de parámetros en solicitudes GET puede revelar parámetros ocultos o sensibles.

Comando:

bash
ffuf -w /path/to/wordlist.txt -u http://host.name/index.php?FUZZ=key

Descripción:

  • Reemplaza FUZZ con nombres de parámetros como user, id, token, etc., para descubrir cómo el servidor maneja estos parámetros.

Nombres de Parámetros - POST

Similar al fuzzing de parámetros GET, pero en solicitudes POST, donde los parámetros se envían en el cuerpo de la solicitud.

Comando:

bash
ffuf -w /path/to/wordlist.txt -u https://host.name/index.php -X POST -d 'FUZZ=key' -H 'Content-Type: application/x-www-form-urlencoded'

Descripción:

  • Reemplaza FUZZ con nombres de parámetros en el cuerpo de la solicitud POST para poder identificar cómo el servidor procesa diferentes parámetros.

Valores de Parámetros - POST

Fuzzear valores específicos de parámetros puede ayudar a descubrir vulnerabilidades como inyecciones SQL, XSS, entre otras.

Comando:

bash
ffuf -w /path/to/ids.txt -u https://host.name/index.php -X POST -d 'id=FUZZ' -H 'Content-Type: application/x-www-form-urlencoded'

Descripción:

  • Reemplaza FUZZ con diferentes IDs para probar cómo el servidor maneja distintos valores.

Fuzzing de Datos JSON en Solicitudes POST

Permite fuzzear valores dentro de estructuras JSON, ideal para pruebas de APIs que utilizan JSON para la comunicación.

Comando:

bash
ffuf -X POST -H "Content-Type: application/json" -d '{"username": "admin", "password": "FUZZ"}' -w /path/to/wordlist.txt -u http://host.name/api/login

Descripción:

  • Reemplaza FUZZ con diferentes contraseñas para probar la autenticación de la API.

Encabezados (Headers)

Cambiar User-Agent

Podemos establecer un User-Agent personalizado en las solicitudes, útil para simular diferentes navegadores o dispositivos.

Comando:

bash
ffuf -w /path/to/wordlist.txt -u https://host.name/FUZZ -H "User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:88.0) Gecko/20100101 Firefox/88.0"

Descripción:

  • Reemplaza FUZZ y establece un User-Agent específico para cada solicitud.

Establecer el Encabezado Content-Type

Define el tipo de contenido que se está enviando, esencial para solicitudes POST o PUT que envían datos estructurados.

Comando:

bash
ffuf -w /path/to/wordlist.txt -u https://host.name/FUZZ -H "Content-Type: application/json" -X POST

Descripción:

  • Establece el encabezado Content-Type a application/json para enviar datos en formato JSON.

Establecer el Encabezado Authorization

Incluye un token de autorización en las solicitudes, necesario para acceder a recursos protegidos.

Comando:

bash
ffuf -w /path/to/wordlist.txt -u https://host.name/FUZZ -H "Authorization: Bearer mytoken"

Descripción:

  • Reemplaza FUZZ y establece el encabezado Authorization con un token Bearer.

Valor de Token Bearer

Fuzzear tokens Bearer para probar la validez y seguridad de los mecanismos de autenticación.

Comando:

bash
ffuf -w /path/to/tokens.txt -H "Authorization: Bearer FUZZ" -u https://host.name/api/resource

Descripción:

  • Reemplaza FUZZ con diferentes tokens para evaluar la autenticidad y permisos.

Valor de un Encabezado Personalizado

Permite fuzzear valores de encabezados HTTP personalizados, útil para descubrir configuraciones específicas del servidor.

Comando:

bash
ffuf -w /path/to/wordlist.txt -u http://host.name -H "X-Forwarded-For: FUZZ"

Descripción:

  • Reemplaza FUZZ con diferentes direcciones IP para probar la manipulación de encabezados proxy.

Límites de Tasa (Rate Limits)

Controlar la tasa de solicitudes que enviamos durante el fuzzing, es crucial para evitar ser bloqueado por el servidor objetivo y para manejar eficientemente los recursos.

Limitar la Tasa a 50 Solicitudes por Segundo

Controlar la velocidad de las solicitudes para evitar sobrecargar el servidor o activar mecanismos de bloqueo.

Comando:

bash
ffuf -rate 50 -w /path/to/wordlist.txt -u https://host.name/FUZZ

Descripción:

  • -rate 50: Limita la tasa de solicitudes a 50 por segundo.

Establecer Número de Hilos

Definir la cantidad de hilos concurrentes para las solicitudes, afectando el rendimiento y la velocidad del fuzzing.

Comando:

bash
ffuf -t 5 -w /path/to/wordlist.txt -u https://host.name/FUZZ

Descripción:

  • -t 5: Utiliza 5 hilos concurrentes para enviar las solicitudes.

Delays (Retrasos)

Introduce retrasos entre las solicitudes para manejar mejor el flujo de tráfico y reducir la carga en el servidor.

Comando:

bash
ffuf -w /path/to/wordlist.txt -u https://host.name/FUZZ -t 2 -p 1

Descripción:

  • -t 2: Usa 2 hilos concurrentes.
  • -p 1: Introduce un retraso de 1 segundo entre las solicitudes.

Filtros (Filters)

Los filtros nos permiten excluir respuestas no deseadas basándose en diferentes criterios, optimizando los resultados del fuzzing.

Filtrar Códigos HTTP 301 y 302

Excluye respuestas que redirigen, enfocándose en respuestas finales.

Comando:

bash
ffuf -fc 301,302 -w /path/to/wordlist.txt -u https://host.name/FUZZ

Descripción:

  • -fc 301,302: Filtra y excluye respuestas con códigos de estado 301 y 302.

Filtrar por Tamaño de Respuesta

Excluye respuestas que no coinciden con un tamaño específico, lo que nos puede ayudar a identificar contenido único.

Comando:

bash
ffuf -fs 2003 -w /path/to/wordlist.txt -u https://host.name/FUZZ

Descripción:

  • -fs 2003: Filtra respuestas que tienen exactamente 2003 bytes.

Filtrar por Número de Líneas

Excluye respuestas basadas en el número de líneas, útil para filtrar contenido genérico.

Comando:

bash
ffuf -fl 5 -w /path/to/wordlist.txt -u https://host.name/FUZZ

Descripción:

  • -fl 5: Filtra respuestas que tienen exactamente 5 líneas.

Filtrar por Conteo de Palabras

Excluye respuestas que no tengan un número específico de palabras, nos ayuda a identificar respuestas únicas o sensibles.

Comando:

bash
ffuf -fw 10 -w /path/to/wordlist.txt -u https://host.name/FUZZ

Descripción:

  • -fw 10: Filtra respuestas que tienen exactamente 10 palabras.

Calibrar Opciones de Filtrado Automáticamente

Permite a ffuf ajustar automáticamente las opciones de filtrado basándose en las respuestas recibidas, optimizando el proceso de fuzzing.

Comando:

bash
ffuf -ac -w /path/to/wordlist.txt -u https://host.name/FUZZ

Descripción:

  • -ac: Habilita la calibración automática de filtros para mejorar la precisión de los resultados.

Matchers

Los matchers son unas reglas o parámetros que definen cómo ffuf interpreta y filtra las respuestas basándose en diferentes criterios.

Coincidir Código de Estado

Filtra resultados que coincidan con un código de estado HTTP específico, facilitando la identificación de respuestas exitosas.

Comando:

bash
ffuf -u https://host.name/FUZZ -w /path/to/wordlist.txt -mc 200

Descripción:

  • -mc 200: Muestra solo las respuestas con código de estado 200.

Coincidir Tamaño de Respuesta

Filtra resultados basados en el tamaño exacto de la respuesta, útil para identificar respuestas únicas.

Comando:

bash
ffuf -u https://host.name/FUZZ -w /path/to/wordlist.txt -ms 1000

Descripción:

  • -ms 1000: Muestra solo las respuestas que tienen exactamente 1000 bytes.

Coincidencia de un Rango de Tamaños de Respuesta

Filtra respuestas dentro de un rango específico de tamaños, ofreciendo mayor flexibilidad.

Comando:

bash
ffuf -u https://host.name/FUZZ -w /path/to/wordlist.txt -ms 900-1100

Descripción:

  • -ms 900-1100: Muestra solo las respuestas que tienen entre 900 y 1100 bytes.

Coincidencia por Conteo de Palabras

Filtra resultados basados en el conteo de palabras en la respuesta, ayudando a identificar contenido relevante.

Comando:

bash
ffuf -u https://host.name/FUZZ -w /path/to/wordlist.txt -mw 50

Descripción:

  • -mw 50: Muestra solo las respuestas que tienen exactamente 50 palabras.

Coincidencia por Número de Líneas de Respuesta

Filtra resultados basados en el número de líneas de la respuesta, útil para identificar respuestas únicas o relevantes.

Comando:

bash
ffuf -u https://host.name/FUZZ -w /path/to/wordlist.txt -ml 10

Descripción:

  • -ml 10: Muestra solo las respuestas que tienen exactamente 10 líneas.

Regex Matching

Permite filtrar respuestas que coincidan con una expresión regular específica, ofreciendonos una forma poderosa para identificar patrones en las respuestas.

Comando:

bash
ffuf -w /path/to/wordlist.txt -u https://host.name/FUZZ -mr "success|welcome"

Descripción:

  • -mr "success|welcome": Muestra solo las respuestas que contienen las palabras “success” o “welcome”.

Opciones de Salida (Output Options)

Guardar y exportar los resultados del fuzzing es esencial para análisis posteriores y documentación.

Guardar Resultados en JSON

Exportar los resultados en formato JSON, facilitando su integración con otras herramientas para su análisis.

Comando:

bash
ffuf -w /path/to/wordlist.txt -u https://host.name/FUZZ -o results.json -of json

Descripción:

  • -o results.json: Define el archivo de salida.
  • -of json: Especifica el formato de salida como JSON.

Guardar Resultados en CSV

Exportar los resultados en formato CSV, ideal para análisis en hojas de cálculo o bases de datos.

Comando:

bash
ffuf -w /path/to/wordlist.txt -u https://host.name/FUZZ -o results.csv -of csv

Descripción:

  • -o results.csv: Define el archivo de salida.
  • -of csv: Especifica el formato de salida como CSV.

Guardar Salida en Todos los Formatos Soportados

Permite guardar los resultados en todos los formatos disponibles simultáneamente, facilitando múltiples tipos de análisis.0

Comando:

bash
ffuf -w /path/to/wordlist.txt -u https://host.name/FUZZ -o results -of all

Descripción:

  • -o results: Define el prefijo del archivo de salida.
  • -of all: Guarda los resultados en todos los formatos soportados.

Proxy

El uso de proxies es fundamental que nos permite monitorear y manipular el tráfico HTTP durante las pruebas de fuzzing.

Proxy HTTP

Redirige las solicitudes a través de un proxy HTTP, útil para inspeccionar el tráfico con herramientas como Burp Suite, Caido y OWASP ZAP.

Comando:

bash
ffuf -x http://127.0.0.1:8080 -w /path/to/wordlist.txt -u https://host.name/FUZZ

Descripción:

  • -x http://127.0.0.1:8080: Define la URL del proxy HTTP.

Proxy SOCKS

Utilizar un proxy SOCKS para una mayor flexibilidad y compatibilidad con diferentes tipos de tráfico.

Comando:

bash
ffuf -x socks5://127.0.0.1:1080 -w /path/to/wordlist.txt -u https://host.name/FUZZ

Descripción:

  • -x socks5://127.0.0.1:1080: Define la URL del proxy SOCKS.

Proxy de Reproducción (Replay Proxy)

Reproducir las solicitudes a través de un proxy, permitiendo la inspección y modificación de las mismas en tiempo real.

Comando:

bash
ffuf -replay-proxy http://127.0.0.1:8080 -w /path/to/wordlist.txt -u https://host.name/FUZZ

Descripción:

  • -replay-proxy http://127.0.0.1:8080: Define la URL del proxy de reproducción.

Límites de Tiempo (Time Limits)

Controlar el tiempo de ejecución de tus pruebas es esencial para gestionar recursos y evitar bloqueos prolongados.

Establecer un Límite de Tiempo Máximo

Define el tiempo máximo permitido para la ejecución completa del escaneo, evitando que ffuf se ejecute indefinidamente.

Comando:

bash
ffuf -w /path/to/wordlist.txt -u https://host.name/FUZZ -maxtime 60

Descripción:

  • -maxtime 60: Establece un límite de tiempo de 60 segundos para toda la ejecución.

Límite de Tiempo por Trabajo

Definir un límite de tiempo específico para cada trabajo individual, asegurando que ninguna solicitud individual consuma demasiado tiempo.

Comando:

bash
ffuf -w /path/to/wordlist.txt -u https://host.name/FUZZ -maxtime-job 60

Descripción:

  • -maxtime-job 60: Establece un límite de tiempo de 60 segundos para cada solicitud individual.

Otras Opciones Útiles

Podemos usar Ffuf en otro tipo de usos que combinan múltiples opciones para maximizar la eficacia de nuestras pruebas de de fuzzing.

Fuzzing con Métodos HTTP Personalizados

Además de los métodos HTTP estándar como GET y POST, ffuf permite utilizar métodos personalizados para interactuar con aplicaciones que dependen de otros métodos HTTP, como PUT, DELETE o PATCH.

Comando:

bash
ffuf -w /path/to/wordlist.txt -u https://host.name/resource/FUZZ -X PUT -d '{"data":"test"}' -H "Content-Type: application/json" -mc 201 -o put_fuzz.json -of json

Descripción:

  • -X PUT: Establece el método HTTP a PUT.
  • -d '{"data":"test"}': Define el cuerpo de la solicitud con datos JSON.
  • -H "Content-Type: application/json": Establece el encabezado Content-Type.
  • -mc 201: Filtra respuestas con el código de estado 201 (Created).
  • -o put_fuzz.json -of json: Guarda los resultados en formato JSON.

Uso Práctico

Este comando es útil para probar endpoints que aceptan métodos HTTP menos comunes, como la creación de recursos a través de solicitudes PUT.

Autenticación de Proxy

Al trabajar a través de un proxy que requiere autenticación, es esencial proporcionar las credenciales correctas para que ffuf pueda realizar las solicitudes adecuadamente.

Comando:

bash
ffuf -x http://username:password@127.0.0.1:8080 -w /path/to/wordlist.txt -u https://host.name/FUZZ -o proxy_auth_fuzz.json -of json

Descripción:

  • -x http://username:password@127.0.0.1:8080: Define el proxy HTTP con credenciales.
  • -w wordlist.txt -u https://host.name/FUZZ: Configura la wordlist y la URL objetivo.
  • -o proxy_auth_fuzz.json -of json: Guarda los resultados en formato JSON.

Uso Práctico

Ideal para entornos corporativos donde el tráfico debe pasar a través de proxies autenticados, permitiendo realizar fuzzing sin interrupciones.

Fuzzing Adaptativo con Límites de Tasa Dinámicos

Implementa un fuzzing adaptativo que ajusta dinámicamente los límites de tasa basándose en la respuesta del servidor, evitando sobrecargas y posibles bloqueos.

Comando:

bash
ffuf -w /path/to/wordlist.txt -u https://host.name/FUZZ -rate 100 -rate-step -50 -rate-min 10 -ac -o adaptive_fuzz.json -of json

Descripción:

  • -rate 100: Comienza con 100 solicitudes por segundo.
  • -rate-min 10: No reduce la tasa por debajo de 10 solicitudes por segundo.
  • -ac: Habilita la calibración automática.
  • -o adaptive_fuzz.json -of json: Guarda los resultados en formato JSON.

Uso Práctico

Ideal para entornos donde la estabilidad del servidor es crítica y deseas minimizar la posibilidad de ser bloqueado mientras realizas pruebas intensivas.

Recursión Condicional Basada en Matchers

Realiza fuzzing recursivo únicamente cuando se cumplen ciertas condiciones definidas por los matchers, optimizando el proceso y enfocándose en áreas relevantes.

Comando:

bash
ffuf -w /path/to/wordlist.txt -u https://host.name/FUZZ -recursion -recursion-depth 2 -mc 200,403 -ms 1500 -o conditional_recursion.json -of json

Descripción:

  • -recursion -recursion-depth 2: Habilita la recursión hasta dos niveles de profundidad.
  • -mc 200,403: Solo realiza recursión si la respuesta tiene códigos de estado 200 o 403.
  • -ms 1500: Filtra respuestas con un tamaño de 1500 bytes.
  • -o conditional_recursion.json -of json: Guarda los resultados en formato JSON.

Uso Práctico

Permite enfocarse en rutas que devuelven respuestas exitosas o específicas, evitando profundizar en áreas irrelevantes o protegidas, optimizando así el tiempo y recursos.

Combinación de Hilos y Matchers Específicos

Optimizar el rendimiento de ffuf combinando un número específico de hilos con matchers diseñados para filtrar respuestas relevantes, asegurando una ejecución eficiente y focalizada.

Comando:

bash
ffuf -w /path/to/wordlist.txt -u https://host.name/FUZZ -t 50 -mc 200,302 -mr "Dashboard|Admin" -o optimized_fuzz.json -of json

Descripción:

  • -t 50: Utiliza 50 hilos concurrentes para maximizar la velocidad.
  • -mc 200,302: Filtra respuestas con códigos de estado 200 y 302.
  • -mr "Dashboard|Admin": Filtra respuestas que contienen las palabras “Dashboard” o “Admin”.
  • -o optimized_fuzz.json -of json: Guarda los resultados en formato JSON.

Uso Práctico

Este comando es ideal para entornos donde se necesita una exploración rápida y focalizada, como identificar paneles administrativos o dashboards que responden con códigos de estado específicos.

Tips Adicionales para Maximizar nuestro Uso de ffuf

  1. Personaliza tus Wordlists: Aunque las wordlists predefinidas son útiles, crear wordlists personalizadas basadas en el contexto de la aplicación objetivo puede aumentar significativamente la efectividad del fuzzing.

  2. Combina con Otras Herramientas: Utiliza ffuf en conjunto con herramientas como Burp Suite, Caido OWASP ZAP, o Nmap para obtener una visión más completa de la seguridad de tu aplicación.

  3. Automatiza tus Pruebas: Integra ffuf en tus pipelines de CI/CD para realizar pruebas automáticas durante el desarrollo.

  4. Monitorea el Rendimiento: La herramienta nos permite controlar los parámetros de tasa y hilos según el rendimiento del servidor objetivo y tus recursos locales para optimizar el tiempo de escaneo sin sobrecargar el sistema.

  5. Analiza los Resultados: Utiliza las opciones de salida en formatos como JSON o CSV para analizar los resultados de manera más eficiente y detectar patrones o anomalías rápidamente.

Con estos consejos y la guía completa de comandos, estás listo para llevar tus pruebas de fuzzing al siguiente nivel con ffuf. ¡Feliz fuzzing!

Recursos Adicionales

Para profundizar en el uso de ffuf y explorar otras opciones, te recomiendo consultar los siguientes recursos:

My avatar

¡Gracias por leer mi entrada del blog! No dudes en consultar mis otras publicaciones o contactarme a través de los enlaces a mis redes sociales que encontrarás al pie de página.

More Posts