Patator: Herramienta de Fuerza Bruta

https://www.onlinetis.com/es/

Patator: Herramienta de Fuerza Bruta

Si estás buscando información sobre Patator en Kali Linux, has llegado al lugar indicado. Patator es una de las herramientas de "fuerza bruta" (brute-force) más flexibles y potentes que existen, diseñada bajo el lema de ser "multi-propósito".

A diferencia de otras herramientas que se especializan en un solo protocolo, Patator es modular. Esto significa que con un solo programa puedes atacar SSH, FTP, HTTP, bases de datos (MySQL, PostgreSQL), SMB y mucho más.

¿Por qué usar Patator en lugar de Hydra o Medusa?

Aunque Hydra es muy popular, Patator suele ser el preferido por usuarios avanzados debido a:

Flexibilidad total: Te permite definir exactamente qué respuesta del servidor se considera un "éxito" o un "fallo".
Modularidad: Soporta muchísimos protocolos mediante módulos.
Limpieza: Es un script de Python que maneja de forma muy eficiente los hilos (threads).

Estructura básica del comando

La sintaxis de Patator puede parecer intimidante al principio. Se ve algo así:

patator [módulo] [parámetros_del_módulo] [opciones_generales]

Ejemplo práctico: Ataque de fuerza bruta a SSH

Si quisieras probar una lista de contraseñas contra un usuario específico en un servidor SSH, el comando sería:

Bash

patator ssh_login host=192.168.1.50 user=admin password=FILE0 0=/ruta/diccionario.txt -x ignore:retry -x ignore:failure

Desglose del comando:

ssh_login: El módulo que vamos a usar.
host=...: La IP de la víctima.
user=admin: El usuario que queremos atacar.
password=FILE0: Le decimos que la contraseña vendrá de un archivo (el índice 0).
0=/ruta/diccionario.txt: Aquí definimos qué archivo es ese "0".
-x ignore:retry: Instrucción para ignorar intentos fallidos comunes y no llenar la pantalla de basura.

Módulos más comunes

Módulo	Descripción
`ftp_login`	Para probar credenciales en servidores FTP.
`http_fuzz`	Excelente para buscar directorios ocultos o probar formularios de login web.
`smb_login`	Para servicios de carpetas compartidas en Windows.
`mysql_login`	Para intentar acceder a bases de datos MySQL.
`dns_forward`	Para hacer descubrimiento de subdominios.

Consejos de uso

Instalación: Si no lo tienes, puedes instalarlo en Kali con sudo apt install patator.
Ayuda: Para ver cómo usar un módulo específico, escribe patator [nombre_del_modulo] prompt_help. Por ejemplo: patator ssh_login prompt_help.
Ética: Recuerda usar esta herramienta solo en entornos controlados o bajo autorización explícita (pentesting ético).

Vamos a configurar un comando para HTTP, que es uno de los usos más potentes y comunes de Patator.

Específicamente, configuraremos un ataque de fuerza bruta contra un formulario de inicio de sesión (Login) en una página web. Este es el escenario donde Patator brilla porque te permite interactuar con variables POST de forma muy precisa.

Escenario: Ataque a un Formulario Web

Imagina que tienes una web en http://192.168.1.100/login.php con dos campos: username y password.

1. Identificar los parámetros

Primero, necesitas saber cómo envía la web los datos. Puedes usar las herramientas de desarrollador del navegador (F12) o Burp Suite para ver que el formulario envía:

Variable de usuario: user
Variable de contraseña: pass
Mensaje de error: "Login failed" (Esto es crucial para que Patator sepa que falló).

2. El comando de Patator

Aquí tienes el comando configurado:

Bash
patator http_fuzz \
    url="http://192.168.1.100/login.php" \
    method=POST \
    body="user=admin&pass=FILE0" \
    0=/usr/share/wordlists/rockyou.txt \
    follow=1 \
    -x ignore:fgrep="Login failed"

Explicación detallada de cada pieza

http_fuzz: El módulo para interactuar con servidores web.
method=POST: Casi todos los formularios de login usan POST para enviar datos de forma "oculta" en el cuerpo de la petición.
body="user=admin&pass=FILE0": Aquí defines los datos del formulario. FILE0 le dice a Patator: "sustituye esto por las líneas de mi diccionario".
0=/ruta/al/diccionario.txt: El archivo que se mapea a FILE0.
follow=1: Muy útil si el sitio web hace redirecciones (HTTP 302) después de intentar loguearse.
-x ignore:fgrep="Login failed": Esta es la clave. Patator mostrará todo por defecto. Con esto, le dices: "Si en la respuesta del servidor aparece el texto 'Login failed', ignóralo". Así, solo verás en pantalla cuando la respuesta sea distinta (es decir, cuando tengas éxito).

Otros ejemplos rápidos por protocolo

Si necesitas otro protocolo, aquí tienes la "receta" rápida:

Para MySQL:
patator mysql_login host=1.2.3.4 user=root password=FILE0 0=passwords.txt
Para encontrar carpetas ocultas (Dir-busting):
patator http_fuzz url="http://1.2.3.4/FILE0" 0=directories.txt -x ignore:code=404
(Aquí ignoramos el error 404 para ver solo lo que sí existe).

Un pequeño consejo de "pro"

Patator es muy rápido. Si el servidor tiene un firewall o un IDS (Sistema de Detección de Intrusos), te banearán la IP en segundos. Puedes añadir el parámetro rate=1 para enviar solo una petición por segundo y ser más sigiloso.

Para generar un diccionario personalizado (ataque de diccionario orientado o target profiling), la herramienta estándar en Kali Linux es CUPP (Common User Passwords Profiler), aunque también podemos usar técnicas de web scraping con CeWL.

Aquí te explico cómo usar ambas dependiendo de si tienes datos específicos de empleados o si prefieres extraer palabras de la web de la empresa.

1. Usando CUPP (Perfilado de personas/empleados)

CUPP es interactivo. Te hace preguntas sobre el objetivo para generar combinaciones lógicas (nombres + fechas + mascotas, etc.).

Instalación:

Bash

sudo apt install cupp

Uso:

Ejecuta el comando con el parámetro -i (interactivo):

Bash

cupp -i

El programa te pedirá:

Nombre y apellido del objetivo.
Apodo.
Fecha de nacimiento.
Nombre de la pareja, hijos o mascotas.
Nombre de la empresa.
Palabras clave (aquí puedes poner el sector de la empresa, ej: "logistica", "seguridad").

CUPP generará un archivo .txt con miles de combinaciones que son mucho más probables que un ataque de fuerza bruta aleatorio.

2. Usando CeWL (Diccionario basado en el sitio web)

Si quieres un diccionario basado en la terminología técnica o corporativa de la empresa, CeWL es la mejor opción. Esta herramienta "araña" (crawls) el sitio web y extrae todas las palabras únicas.

Comando básico:

Bash

cewl -w diccionario_empresa.txt -d 2 -m 6 https://www.la-empresa.com

-w: Archivo de salida.
-d 2: Profundidad (cuántos enlaces internos seguir).
-m 6: Longitud mínima de la palabra (ignora palabras cortas como "el", "de", "con").

3. Combinando y optimizando con Hashcat/John the Ripper

Una vez que tengas tu lista base (ya sea de CUPP o CeWL), puedes hacerla mucho más potente aplicando reglas. Las empresas suelen obligar a cambiar contraseñas añadiendo un año o un carácter especial.

Puedes usar hashcat para expandir tu diccionario:

Bash

hashcat --force diccionario_base.txt -r /usr/share/hashcat/rules/best64.rule --stdout > diccionario_final.txt

Esto tomará cada palabra (ej: "Empresa") y generará variantes como:

Empresa123
empresa2024
E.mpresa!

Resumen de estrategia

CeWL: Extrae palabras clave del sitio corporativo.
CUPP: Genera contraseñas basadas en datos de directivos o empleados clave (obtenidos de LinkedIn, por ejemplo).
Combinación: Une ambos archivos y aplica reglas de transformación.

Nota de seguridad: El uso de estas herramientas para acceder a sistemas sin autorización es ilegal. Estas técnicas se enseñan con fines de auditoría y defensa (Pentesting Ético).

Las reglas de Hashcat son lo que diferencia a un principiante de un profesional. En lugar de tener un diccionario de mil millones de palabras que tarda días en procesar, usas un diccionario pequeño (como el que generaste con CeWL) y le aplicas "mutaciones" sobre la marcha.

Para que todas tus palabras terminen en el año actual (2026) y un signo de exclamación (!), vamos a crear un archivo de reglas personalizado.

1. Crear el archivo de regla (`.rule`)

En tu terminal de Kali, crea un archivo llamado mi_regla.rule:

Bash

nano mi_regla.rule

Dentro del archivo, escribe lo siguiente:

Plaintext

$2$0$2$6$!

Explicación de la sintaxis:

El carácter $ significa "añadir al final" (append).
Cada carácter después del $ se añade uno por uno.
Por lo tanto, $2$0$2$6$! toma la palabra password y la convierte en password2026!.

2. Aplicar la regla a tu diccionario

Ahora, vamos a usar hashcat en modo "stdout". Esto no intenta romper ninguna contraseña todavía, sino que imprime el resultado de aplicar la regla a tu lista de palabras para que puedas guardarlo en un nuevo archivo.

Bash

hashcat --stdout diccionario_empresa.txt -r mi_regla.rule > diccionario_final.txt

3. Llevándolo al siguiente nivel (Reglas Combinadas)

Si quieres ser aún más efectivo, puedes añadir más líneas a tu archivo mi_regla.rule para cubrir más posibilidades en un solo ataque:

Regla (línea en el archivo)	Función	Resultado (ejemplo: Admin)
`c $2$0$2$6$!`	Capitaliza la primera letra y añade 2026!	`Admin2026!`
`$2$0$2$6$! u`	Añade 2026! y pone todo en MAYÚSCULAS	`ADMIN2026!`
`i0S $2$0$2$6$!`	Cambia la primera letra por 'S' y añade 2026!	`Sdmin2026!`
`s ae`	Cambia todas las 'a' por 'e' (sustitución)	`Edmin`

¿Cómo usar este nuevo diccionario en Patator?

Una vez que tengas tu diccionario_final.txt optimizado con estas reglas, simplemente lo cargas en el comando de Patator que vimos antes:

Bash
patator http_fuzz url="http://objetivo.com/login" body="user=admin&pass=FILE0" 0=diccionario_final.txt -x ignore:fgrep="Error"

Pro-Tip: La regla "Best64"

Si no quieres escribir tus propias reglas desde cero, Kali ya trae una colección increíble. La más famosa es best64.rule. Puedes encontrarla en:

/usr/share/hashcat/rules/best64.rule

Esta regla hace de todo: cambia 'a' por '@', 's' por '$', invierte palabras, añade números comunes, etc.

Para automatizar la generación de nombres de usuario basados en un formato corporativo (como nombre.apellido), no necesitamos una herramienta externa compleja; podemos usar un pequeño script en Bash directamente en tu terminal de Kali.

Esto es vital porque, a menudo, el bloqueo de una cuenta no ocurre por probar muchas contraseñas, sino por intentar usuarios que no existen.

1. Crear el generador de usuarios

Supongamos que tienes una lista de nombres reales (nombres.txt) que obtuviste de LinkedIn o de la web de la empresa, con este formato:

Juan Garcia
Maria Lopez

Crea un script llamado gen_users.sh:

Bash

nano gen_users.sh

Pega este código que genera los 3 formatos más comunes en empresas:

Bash
#!/bin/bash
while read p; do
    nombre=$(echo $p | cut -d' ' -f1 | tr '[:upper:]' '[:lower:]')
    apellido=$(echo $p | cut -d' ' -f2 | tr '[:upper:]' '[:lower:]')
    inicial=$(echo $nombre | cut -c1)

    echo "$nombre.$apellido"      # juan.garcia
    echo "$inicial$apellido"      # jgarcia
    echo "$nombre$apellido"       # juangarcia
done < nombres.txt

Ejecútalo para crear tu lista de usuarios:

Bash

chmod +x gen_users.sh
./gen_users.sh > usuarios_final.txt

2. Configurar Patator para "Modo Combinado"

Aquí es donde Patator se vuelve increíblemente útil. En lugar de probar un solo usuario, le diremos que use dos diccionarios simultáneamente: uno para usuarios (FILE0) y otro para contraseñas (FILE1).

El comando final sería:

Bash
patator http_fuzz \
    url="http://192.168.1.100/login.php" \
    method=POST \
    body="user=FILE0&pass=FILE1" \
    0=usuarios_final.txt \
    1=diccionario_final.txt \
    -x ignore:fgrep="Login failed" \
    --threads=10

¿Qué está pasando aquí?

user=FILE0: Toma una línea de usuarios_final.txt.
pass=FILE1: Toma una línea de diccionario_final.txt.
Iteración: Patator probará la primera contraseña para todos los usuarios, luego la segunda para todos, y así sucesivamente (o viceversa, según lo configures). Esto es mejor para evitar bloqueos de cuenta por "demasiados intentos fallidos en un mismo usuario".

3. Evitar el "Baneo" por IP

Si la empresa tiene un WAF (Web Application Firewall), detectará 10 peticiones por segundo y te bloqueará. Para ser más sigiloso, añade estos parámetros:

rate=1: Limita a 1 petición por segundo.
header="User-Agent: Mozilla/5.0...": Cambia el agente de usuario para que parezca un navegador real y no "Patator".

Nota técnica: Si usas 0=usuarios.txt y 1=passwords.txt, Patator hará un producto cartesiano (todas las combinaciones posibles). Si tienes 100 usuarios y 1,000 contraseñas, realizará 100,000 peticiones. Ten esto en cuenta para el tiempo que tomará el ataque.

Cuando dejas un ataque de fuerza bruta corriendo durante horas, no quieres estar pegado a la pantalla esperando a que aparezca la combinación correcta.

Patator tiene una forma muy elegante de manejar los registros (logs). Podemos configurar que guarde solo los éxitos en un archivo limpio y legible.

1. Configurar el guardado automático

Para esto, usaremos el parámetro -w (write) seguido de una condición. Queremos que escriba en un archivo llamado aciertos.txt solo cuando no se cumpla la condición de ignorar (es decir, cuando la contraseña sea válida).

Añade esto a tu comando:

Bash

-w success:fgrep_not="Login failed" -o aciertos.txt

2. El comando "Todo en Uno"

Aquí tienes el comando final, profesional y automatizado, combinando todo lo que hemos aprendido:

Bash
patator http_fuzz \
    url="http://192.168.1.100/login.php" \
    method=POST \
    body="user=FILE0&pass=FILE1" \
    0=usuarios_final.txt \
    1=diccionario_final.txt \
    header="User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64)" \
    -x ignore:fgrep="Login failed" \
    -w success:fgrep_not="Login failed" -o aciertos.txt \
    --threads=5 \
    rate=2

3. ¿Qué significan estos nuevos añadidos?

-o aciertos.txt: Crea el archivo donde se guardarán los resultados.
success:fgrep_not="Login failed": Le dice a Patator: "Si la respuesta NO contiene 'Login failed', guárdala como un éxito".
rate=2: Envía 2 peticiones por segundo (ajústalo según la resistencia del servidor).
threads=5: Usa 5 hilos en paralelo para procesar la cola de trabajo.

Bonus: Cómo leer los resultados

Cuando termine el proceso (o mientras corre), puedes abrir otra terminal y escribir:

Bash

tail -f aciertos.txt

Esto te mostrará en tiempo real cualquier usuario y contraseña que Patator logre encontrar, sin mostrarte los miles de intentos fallidos.

Un último consejo de "Pentester"

Si el sitio web usa HTTPS (que es lo normal hoy en día), asegúrate de que la URL en el comando empiece por https://. Si el certificado es de prueba o no es válido, puede que necesites añadir el parámetro ssl_verify=0 para que Patator no se detenga por errores de seguridad.

Presentar un reporte claro es lo que diferencia a un "hacker" de un Consultor de Seguridad Profesional. Un buen reporte no solo dice "entré", sino que explica cómo lo hiciste, qué herramientas usaste y cómo la empresa puede arreglarlo.

Aquí tienes una estructura profesional en Markdown que puedes copiar y adaptar para tus hallazgos con Patator.

📄 Informe de Hallazgo: Vulnerabilidad de Fuerza Bruta (A07:2021)

1. Resumen Ejecutivo

Durante la fase de pruebas de penetración en el activo http://192.168.1.100, se identificó una falta de mecanismos de bloqueo de cuenta (Account Lockout) y ausencia de un Segundo Factor de Autenticación (2FA). Esto permitió realizar un ataque de fuerza bruta exitoso contra el panel de administración.

2. Detalles Técnicos

Vector de Ataque: HTTP POST Brute Force.
Herramienta Utilizada: Patator v0.7.
Diccionarios Utilizados: * Usuarios: Generados mediante perfilado de empleados con gen_users.sh.
- Contraseñas: Basado en términos corporativos procesados con reglas de Hashcat.

Comando Ejecutado:

Bash
patator http_fuzz url="http://192.168.1.100/login.php" method=POST body="user=FILE0&pass=FILE1" 0=usuarios.txt 1=pass_2026.txt -x ignore:fgrep="Login failed"

3. Resultados Obtenidos

Se logró comprometer la siguiente cuenta con privilegios de administrador:

Usuario	Contraseña	Impacto
`j.garcia`	`Empresa2026!`	Acceso total al panel de control

4. Recomendaciones de Mitigación (Remediación)

Para corregir esta vulnerabilidad, se recomienda implementar las siguientes medidas:

Bloqueo de Cuenta: Configurar el sistema para bloquear temporalmente cualquier cuenta después de 5 intentos fallidos en un periodo de 15 minutos.
Implementar 2FA: Añadir una capa de seguridad adicional (Google Authenticator, SMS, o llaves físicas).
CAPTCHA: Introducir desafíos visuales tras el tercer intento fallido para detener herramientas automatizadas como Patator.
Monitoreo de Logs: Configurar alertas para detectar múltiples intentos de inicio de sesión desde una misma dirección IP en intervalos cortos.

¿Por qué es importante documentar así?

Claridad: El cliente entiende exactamente qué pasó.
Reproducibilidad: Otros técnicos pueden repetir la prueba para verificar que la vulnerabilidad fue arreglada.
Profesionalismo: Muestra que sigues una metodología (como OWASP).