Nipper-ng: Análisis de Configuraciones de Red
Nipper-ng: Análisis de Configuraciones de Red
Nipper-ng es una herramienta excelente para cualquier auditoría de seguridad. Básicamente, es la evolución "open source" del Nipper original y se utiliza para analizar archivos de configuración de dispositivos de red (routers, switches, firewalls) en busca de vulnerabilidades o errores de configuración.
En lugar de probar ataques contra el dispositivo, Nipper-ng lee el archivo de texto de la configuración y te dice: "Oye, esto es peligroso".
1. ¿Cómo instalarlo en Kali Linux?
Aunque es un clásico, a veces no viene preinstalado en las versiones más ligeras. Puedes instalarlo rápidamente desde la terminal:
sudo apt update
sudo apt install nipper-ng
2. ¿Cómo funciona? (Uso básico)
Para usarlo, primero necesitas exportar el archivo de configuración de tu dispositivo (por ejemplo, un config.txt de un router Cisco).
La sintaxis básica es:
nipper --input=<archivo> --output=<reporte.html>
Ejemplo práctico para un router Cisco:
nipper --cisco --input=config_router.txt --output=auditoria.html
3. Dispositivos compatibles
Nipper-ng es versátil y soporta varios fabricantes:
Cisco: Routers (IOS), Firewalls (ASA, PIX).
Juniper: Firewalls Netscreen.
CheckPoint: Firewalls FW-1.
Nokia: Firewalls IP.
SonicWall: Firewalls.
4. ¿Qué analiza Nipper-ng?
Cuando ejecutas la herramienta, el reporte resultante (que suele ser un HTML muy limpio) te mostrará:
Reglas de Firewall: Si hay reglas demasiado permisivas (ej. un "Permit Any").
Servicios inseguros: Si tienes activos protocolos viejos como Telnet o SNMPv1.
Contraseñas: Si las contraseñas están en texto plano o usan algoritmos de cifrado débiles.
Acceso remoto: Fallos en la configuración de SSH o Timeout de sesiones.
Nota importante: Nipper-ng dejó de actualizarse hace tiempo, por lo que puede que no reconozca comandos de firmwares muy modernos (como versiones muy nuevas de Cisco IOS-XE). Para equipos modernos, muchos profesionales saltan a la versión comercial (Titania Nipper), pero para aprender y para equipos estándar,
nipper-ngsigue siendo una joya.
Exportar la configuración depende totalmente de la marca del dispositivo, pero el proceso estándar en entornos de auditoría con Kali Linux suele ser mediante TFTP, SCP o simplemente copiando el texto desde la consola (CLI).
Aquí tienes los pasos para los fabricantes más comunes que soporta Nipper-ng:
1. Cisco (IOS / ASA)
Es el método más común. Necesitas entrar al modo privilegiado.
Opción A: Copiar el texto (Más rápido)
Conéctate por SSH o consola.
Ejecuta:
show running-config.Copia todo el texto que aparece en pantalla y guárdalo en un archivo
.txten tu máquina con Kali.
Opción B: Usar TFTP (Más profesional)
Si tienes un servidor TFTP corriendo en Kali:
Bashcopy running-config tftp: Address or name of remote host? [IP_DE_TU_KALI] Destination filename? [nombre_archivo.txt]
2. Juniper (NetScreen / ScreenOS)
Para los modelos antiguos de Juniper que Nipper-ng maneja mejor:
Conéctate a la CLI.
Ejecuta el comando:
get config.Al igual que en Cisco, copia la salida de la terminal a un archivo de texto.
3. CheckPoint (Nokia IPSO)
Si estás auditando un firewall CheckPoint sobre plataformas Nokia:
Accede mediante SSH.
El archivo de configuración suele estar en la ruta:
/config/active.Puedes usar
scpdesde tu terminal de Kali para traerlo:Bashscp admin@IP_DEL_FIREWALL:/config/active ./checkpoint_config.txt
Flujo de trabajo con Nipper-ng
Una vez que tengas el archivo (supongamos que se llama router_config.txt), el proceso en Kali se ve así:
Obtención: Extraes el
.txtdel router.Procesamiento: Ejecutas nipper en la terminal.
Resultado: Abres el reporte en el navegador.
Ejemplo de comando final:
nipper --cisco --input=router_config.txt --output=reporte_final.html
Un pequeño consejo de "vieja escuela": Antes de exportar la configuración de un cliente o de tu empresa, asegúrate de eliminar o anonimizar las contraseñas reales (hashes) del archivo de texto si vas a compartir el reporte, por pura higiene de seguridad.
Tener un servidor TFTP (Trivial File Transfer Protocol) en tu máquina Kali es la forma más "limpia" y rápida de recibir archivos de configuración de routers y switches sin andar copiando y pegando texto.
Aquí tienes los pasos para configurar uno en menos de dos minutos:
1. Instalar el servidor TFTP
Usaremos atftpd (Advanced TFTP server), que es ligero y muy fiable en Kali.
sudo apt update
sudo apt install atftpd
2. Preparar el directorio de recepción
Necesitas una carpeta donde el router depositará los archivos. Debemos darle permisos de escritura para que el router pueda "escribir" el archivo desde fuera.
sudo mkdir /tftpboot
sudo chmod -R 777 /tftpboot
sudo chown -R nobody /tftpboot
3. Iniciar el servicio
Lanza el servidor especificando la ruta que acabas de crear:
sudo atftpd --daemon --port 69 /tftpboot
(Nota: El puerto por defecto es el 69. Asegúrate de que tu firewall en Kali no lo esté bloqueando).
4. El momento de la verdad (Desde el Router)
Ahora, entra en la consola de tu router (Cisco, por ejemplo) y dile que envíe su configuración a tu IP de Kali:
En el Router:
BashRouter# copy running-config tftp: Address or name of remote host []? [TU_IP_DE_KALI] Destination filename [router-confg]? mi_configuracion.txtEn tu Kali:
Revisa la carpeta y verás el archivo listo para procesar:
Bashls /tftpboot
5. Ejecutar Nipper-ng
Ahora que ya tienes el archivo mi_configuracion.txt en tu carpeta /tftpboot, solo te queda generar el informe:
nipper --cisco --input=/tftpboot/mi_configuracion.txt --output=auditoria_red.html
Al terminar, puedes abrir el archivo .html con Firefox en Kali para ver todos los fallos de seguridad encontrados.
Leer un reporte de Nipper-ng puede ser abrumador al principio porque es muy directo, pero hay secciones que son "puntos críticos" en cualquier auditoría.
Aquí te explico qué buscar y cómo interpretarlo para que tu reporte sea realmente útil:
1. Seguridad de Contraseñas (Password Security)
Esta es la primera sección que debes mirar. Nipper-ng analizará cómo se guardan las claves en la configuración.
Lo que busca: Si usas
service password-encryption(que usa el algoritmo Type 7, muy fácil de descifrar) o si las contraseñas están en texto plano.El consejo pro: Busca que el reporte mencione Type 5 (MD5) o, mejor aún, Type 8/9 (SHA-256/Scrypt). Si ves "Type 7", el reporte te marcará una vulnerabilidad crítica porque existen webs que las descifran en un segundo.
2. Servicios de Acceso Remoto (Remote Access)
Nipper-ng revisa cómo entran los administradores al equipo.
Puntos rojos: Si detecta que Telnet o HTTP están habilitados. Estos envían todo en texto plano por la red.
Lo ideal: El reporte debería confirmar el uso de SSH (versión 2) y HTTPS. Si el reporte dice "Telnet is enabled", esa es una de tus primeras recomendaciones de seguridad.
3. Reglas de Filtrado (Filtering / ACLs)
Esta es la parte más técnica. Nipper-ng analiza las Listas de Control de Acceso (ACL).
"Permit Any": Si tienes una regla que permite todo el tráfico (
permit ip any any), Nipper te dará un tirón de orejas virtual.Reglas redundantes: A veces te dirá que una regla nunca se usa porque otra regla anterior ya está bloqueando ese tráfico. Esto te ayuda a limpiar la configuración y hacer que el router procese el tráfico más rápido.
4. Protocolos de Red Débiles (SNMP y otros)
SNMP: Si usas las comunidades por defecto como
publicoprivate, Nipper-ng las resaltará en rojo. Un atacante podría usar esto para leer toda la topología de tu red.CDP/LLDP: Si estos protocolos de descubrimiento están activos en interfaces que dan a internet o a zonas públicas, el reporte te sugerirá desactivarlos para no dar pistas a intrusos.
¿Cómo se ve una vulnerabilidad en el reporte?
El reporte HTML suele seguir este esquema:
Finding (Hallazgo): "Telnet is enabled".
Impact (Impacto): "Traffic is sent in clear text, including passwords".
Recommendation (Recomendación): "Disable Telnet and use SSH instead".
Tip de experto: Nipper-ng a veces es un poco "exagerado" (paranoico). No todos los fallos que marca como High lo son en tu contexto específico, así que usa tu criterio profesional para priorizar.
En seguridad defensiva, cerrar las puertas innecesarias es el primer paso para fortalecer (hacer hardening) cualquier equipo.
Vamos a enfocarnos en los "pecados capitales" que Nipper-ng suele detectar en routers Cisco y cómo solucionarlos desde la terminal del router (config t).
1. Cambiar Telnet por SSH (Crítico)
Telnet envía tu contraseña en texto plano. Si alguien está escuchando en la red, la verá.
Para desactivar Telnet y activar SSH:
Router# configure terminal
# 1. Definir un nombre de dominio (necesario para las llaves)
Router(config)# ip domain-name tuempresa.com
# 2. Generar las llaves de cifrado (elige 2048 para buena seguridad)
Router(config)# crypto key generate rsa
How many bits in the modulus [512]: 2048
# 3. Forzar el uso de SSH versión 2
Router(config)# ip ssh version 2
# 4. Entrar a las líneas de terminal y prohibir Telnet
Router(config)# line vty 0 4
Router(config-line)# transport input ssh
Router(config-line)# exit
2. Desactivar el servidor Web (HTTP)
Muchos routers traen una interfaz web activada por defecto que suele tener vulnerabilidades viejas.
Para desactivarlo:
Router(config)# no ip http server
Router(config)# no ip http secure-server
Si realmente necesitas usar la web, asegúrate de activar solo el secure-server (HTTPS).
3. Fortalecer el cifrado de contraseñas
Como vimos antes, el comando service password-encryption es débil. Es mejor usar un algoritmo moderno para la contraseña de "enable".
Para usar un cifrado fuerte (Type 5 o superior):
# Esto usa MD5 en lugar de texto plano o Type 7
Router(config)# enable secret TU_CONTRASEÑA_FUERTE
4. Desactivar protocolos de descubrimiento (CDP)
El Cisco Discovery Protocol (CDP) le dice a cualquiera en el cable qué modelo de router tienes y qué versión de software usas. Es útil para administración, pero peligroso si da hacia internet.
Para desactivarlo globalmente o en una interfaz específica:
# Globalmente (lo apaga en todo el router)
Router(config)# no cdp run
# Solo en la interfaz que va a Internet (ejemplo GigabitEthernet0/0)
Router(config)# interface GigabitEthernet0/0
Router(config-if)# no cdp enable
El ciclo de mejora
Una vez que apliques estos cambios, el flujo ideal de un auditor es el siguiente:
Aplicar cambios: Ejecutas los comandos anteriores.
Guardar: No olvides hacer
copy running-config startup-config.Re-auditar: Vuelve a sacar la configuración y pásala por Nipper-ng.
Verificar: El nuevo reporte debería mostrar muchas menos alertas rojas.
Configurar una ACL (Access Control List) de administración es como poner un portero en la puerta de tu router: aunque alguien robe tu contraseña, si no intenta entrar desde una IP autorizada, el router simplemente ignorará la conexión.
Aquí tienes los pasos para proteger el acceso por SSH en un router Cisco:
1. Crear la Lista de Acceso (ACL)
Primero, definimos qué IPs tienen permiso para administrar el equipo. Supongamos que tu IP de Kali Linux es 192.168.1.50.
Router(config)# ip access-list standard ADMIN_ONLY
Router(config-std-nacl)# permit 192.168.1.50
Router(config-std-nacl)# remark Solo mi equipo de auditoria tiene acceso
Router(config-std-nacl)# deny any log
Router(config-std-nacl)# exit
Nota: El deny any log bloquea a todos los demás y genera un aviso en los logs si alguien intenta entrar.
2. Aplicar la ACL a las líneas VTY
Las líneas "VTY" son las terminales virtuales por donde entra el SSH. Es aquí donde aplicamos el filtro.
Router(config)# line vty 0 4
Router(config-line)# access-class ADMIN_ONLY in
Router(config-line)# exit
3. ¿Cómo verificar que funcionó?
Una vez que apliques esto, intenta entrar desde otra IP que no sea la tuya. El router debería rechazar la conexión inmediatamente.
Puedes ver si alguien ha intentado saltarse la regla con este comando:
Router# show access-lists ADMIN_ONLY
Verás un contador de "matches" en la línea de deny any, lo que significa que la ACL está haciendo su trabajo.
El "Checklist" Final de Hardening
Después de aplicar todo lo que hemos visto, tu configuración de seguridad debería verse así en el próximo reporte de Nipper-ng:
| Servicio | Estado Recomendado | Comando Clave |
| Telnet | Desactivado | transport input ssh |
| HTTP Server | Desactivado | no ip http server |
| Passwords | Cifradas (Type 5/8/9) | enable secret ... |
| CDP | Desactivado (en WAN) | no cdp enable |
| Acceso Administrativo | Restringido por ACL | access-class ... in |
Automatizar el proceso de Nipper-ng para obtener un PDF es un paso lógico, ya que la herramienta nativamente genera HTML o texto plano. En Kali Linux, la forma más eficiente de hacer esto es encadenar Nipper con un conversor de documentos como wkhtmltopdf o pandoc.
Aquí te muestro cómo configurar un pequeño script para que, con un solo comando, proceses la configuración y obtengas el PDF.
1. Instalar el conversor de PDF
Primero, necesitamos una herramienta que pueda renderizar el HTML que genera Nipper-ng en un archivo PDF profesional. wkhtmltopdf es ideal para esto:
sudo apt update
sudo apt install wkhtmltopdf
2. El comando "Maestro"
Puedes hacerlo manualmente en una sola línea combinando ambos comandos. Supongamos que tu archivo de configuración se llama router.conf:
nipper --cisco --input=router.conf --output=reporte.html && wkhtmltopdf reporte.html reporte_final.pdf
3. Crear un Script de Automatización (.sh)
Si auditas muchos equipos, lo mejor es crear un script que automatice todo el flujo. Crea un archivo llamado auto_nipper.sh:
nano auto_nipper.sh
Pega el siguiente código (ajustado para ser flexible):
#!/bin/bash
# Uso: ./auto_nipper.sh archivo_config.txt
INPUT=$1
OUTPUT_HTML="temp_report.html"
OUTPUT_PDF="${INPUT%.*}_reporte.pdf"
echo "[+] Procesando configuración con Nipper-ng..."
nipper --cisco --input=$INPUT --output=$OUTPUT_HTML
echo "[+] Convirtiendo reporte a PDF..."
wkhtmltopdf --quiet $OUTPUT_HTML $OUTPUT_PDF
echo "[+] Reporte generado con éxito: $OUTPUT_PDF"
# Limpieza del archivo temporal HTML
rm $OUTPUT_HTML
Dale permisos de ejecución:
chmod +x auto_nipper.sh
4. ¿Por qué automatizar esto?
Automatizar el reporte no es solo por comodidad, te permite:
Estandarización: Todos tus reportes tendrán el mismo formato y apariencia.
Histórico: Puedes programar tareas (cron jobs) que descarguen la configuración cada semana y generen un PDF, permitiéndote ver cómo mejora (o empeora) la seguridad con el tiempo.
Entrega Profesional: Un PDF es mucho más fácil de enviar a un cliente o a tu jefe que un archivo HTML con carpetas de imágenes separadas.
5. Personalización extra
Si quieres que el PDF se vea aún mejor, wkhtmltopdf permite añadir opciones como:
--page-size Letter: Ajustar el tamaño del papel.--footer-center [page]: Añadir números de página.--grayscale: Si necesitas imprimirlo en blanco y negro para ahorrar tinta.
Automatizar el análisis de toda una carpeta es la diferencia entre pasar una tarde entera frente a la terminal o terminar el trabajo en lo que tardas en beber un café.
Este script buscará todos los archivos con extensión .conf o .txt en una carpeta, ejecutará Nipper-ng para cada uno y te entregará una carpeta llena de PDFs organizados.
El Script: nipper_masivo.sh
Copia este código en un nuevo archivo:
#!/bin/bash
# Directorio de entrada y salida
INPUT_DIR="./configs"
OUTPUT_DIR="./reportes_pdf"
# Crear carpeta de salida si no existe
mkdir -p $OUTPUT_DIR
echo "------------------------------------------"
echo "INICIANDO AUDITORÍA MASIVA CON NIPPER-NG"
echo "------------------------------------------"
# Bucle para procesar cada archivo .conf o .txt
for file in $INPUT_DIR/*.{conf,txt}; do
# Verificar si existen archivos para evitar errores
[ -e "$file" ] || continue
FILENAME=$(basename "$file")
NAME="${FILENAME%.*}"
echo "[*] Analizando: $FILENAME"
# 1. Generar HTML temporal
nipper --cisco --input="$file" --output="$OUTPUT_DIR/$NAME.html"
# 2. Convertir a PDF (con retoques visuales)
wkhtmltopdf --quiet --footer-center "Página [page] de [toPage]" "$OUTPUT_DIR/$NAME.html" "$OUTPUT_DIR/$NAME.pdf"
# 3. Borrar el HTML temporal
rm "$OUTPUT_DIR/$NAME.html"
echo "[OK] Reporte generado: $OUTPUT_DIR/$NAME.pdf"
done
echo "------------------------------------------"
echo "PROCESO FINALIZADO. Revisa la carpeta $OUTPUT_DIR"
Cómo prepararlo en tu Kali Linux:
Crea la estructura:
Bashmkdir auditoria_red cd auditoria_red mkdir configs reportes_pdfGuarda el script: Pega el código anterior en un archivo llamado
nipper_masivo.sh.Dale permisos:
chmod +x nipper_masivo.sh.Pon tus archivos: Mueve todas las configuraciones de tus routers/switches a la carpeta
/configs.Ejecuta:
./nipper_masivo.sh.
¿Por qué esto es mejor que hacerlo uno a uno?
Escalabilidad: No importa si son 5 o 500 dispositivos; el esfuerzo para ti es el mismo.
Reporte Ejecutivo: Al finalizar, tendrás una carpeta lista para ser comprimida en un
.zipy enviada como entregable de auditoría.Limpieza: El script se encarga de borrar los archivos HTML intermedios, manteniendo tu espacio de trabajo ordenado.
Un pequeño "truco" de auditor:
Si algunos de tus archivos no son Cisco (por ejemplo, son Juniper o SonicWall), Nipper-ng podría fallar si usas la bandera --cisco. Podrías mejorar el script añadiendo una lógica que detecte el fabricante basado en el nombre del archivo, pero para redes homogéneas, este script es "oro puro".
Añadir una notificación por email es el toque final para un script de auditoría profesional. Así puedes dejar el servidor de Kali trabajando en una lista larga de dispositivos y recibir el aviso en tu móvil cuando todo esté listo.
Para esto, usaremos una herramienta llamada ssmtp o mailutils. Es la forma más sencilla de enviar correos desde la terminal de Linux usando una cuenta de Gmail o Outlook.
1. Configurar el envío de correo (sSMTP)
Primero, instalamos lo necesario:
sudo apt update
sudo apt install ssmtp mailutils
Ahora, configura los datos de tu servidor de correo (usaremos el ejemplo de Gmail) editando el archivo de configuración:
sudo nano /etc/ssmtp/ssmtp.conf
Copia y ajusta estos valores:
root=tu_correo@gmail.com
mailhub=smtp.gmail.com:587
AuthUser=tu_correo@gmail.com
AuthPass=tu_password_de_aplicacion
UseSTARTTLS=YES
hostname=kali
Nota de seguridad: Si usas Gmail, no uses tu contraseña normal; crea una "Contraseña de Aplicación" en los ajustes de seguridad de tu cuenta de Google.
2. El Script Mejorado: nipper_masivo_email.sh
He modificado el script anterior para que cuente cuántos archivos procesó y te envíe un resumen al finalizar:
#!/bin/bash
INPUT_DIR="./configs"
OUTPUT_DIR="./reportes_pdf"
EMAIL_DESTINO="tu_correo_personal@gmail.com"
mkdir -p $OUTPUT_DIR
COUNT=0
echo "--- INICIANDO AUDITORÍA ---"
for file in $INPUT_DIR/*.{conf,txt}; do
[ -e "$file" ] || continue
FILENAME=$(basename "$file")
NAME="${FILENAME%.*}"
# Procesamiento
nipper --cisco --input="$file" --output="$OUTPUT_DIR/$NAME.html"
wkhtmltopdf --quiet "$OUTPUT_DIR/$NAME.html" "$OUTPUT_DIR/$NAME.pdf"
rm "$OUTPUT_DIR/$NAME.html"
((COUNT++))
echo "[OK] $FILENAME procesado."
done
# --- NOTIFICACIÓN POR EMAIL ---
ASUNTO="Auditoría Nipper-ng Finalizada"
CUERPO="Hola, el proceso de auditoría en Kali Linux ha terminado.\n\nTotal de archivos procesados: $COUNT\nLos reportes PDF están listos en la carpeta: $OUTPUT_DIR"
echo -e "$CUERPO" | mail -s "$ASUNTO" "$EMAIL_DESTINO"
echo "--- PROCESO FINALIZADO Y EMAIL ENVIADO ---"
3. ¿Por qué es útil esto en auditoría?
Multitarea: Puedes lanzar el script en un servidor remoto o en tu Kali y dedicarte a otra fase de la auditoría (como pruebas de penetración web) sin estar pendiente de la consola.
Confirmación: Si el script falla o se interrumpe por falta de batería o conexión, el hecho de no recibir el correo te indicará que algo salió mal.
Reporte inmediato: Sabrás exactamente cuántos archivos se analizaron con éxito.
Programar tareas en Linux es una de las habilidades más útiles para un auditor de seguridad. Para esto utilizamos Cron, un administrador de procesos en segundo plano que ejecuta comandos en intervalos de tiempo específicos.
El archivo donde se guardan estas instrucciones se llama crontab.
1. Preparar el script para Cron
Antes de programarlo, debemos asegurarnos de que el script funcione sin supervisión humana. Cron no sabe dónde están herramientas como nipper o wkhtmltopdf a menos que usemos rutas absolutas.
Modifica las rutas en tu script nipper_masivo_email.sh:
En lugar de
./configs, usa/home/tu_usuario/auditoria/configs.En lugar de
nipper, usa/usr/bin/nipper(puedes encontrar la ruta exacta escribiendowhich nipperen la terminal).
2. Configurar el Crontab
Para abrir el editor del programador de tareas, ejecuta:
crontab -e
(Si es la primera vez que lo abres, elige la opción de nano por ser la más sencilla).
3. La línea "Mágica" para los Lunes a las 8:00 AM
Ve al final del archivo y añade la siguiente línea:
00 08 * * 1 /bin/bash /home/tu_usuario/scripts/nipper_masivo_email.sh
¿Qué significa cada número?
00: Minuto (0).
08: Hora (8 AM).
*: Día del mes (Todos).
*: Mes (Todos).
1: Día de la semana (1 es Lunes, 0 o 7 es Domingo).
Ruta: La ubicación completa de tu script.
4. Anatomía de una tarea programada
Para que no lo olvides, el orden de los campos en Cron siempre es el mismo:
| Campo | Minuto | Hora | Día/Mes | Mes | Día/Semana | Comando |
| Rango | 0-59 | 0-23 | 1-31 | 1-12 | 0-7 | /ruta/script.sh |
5. Verificar que la tarea quedó guardada
Una vez guardes y cierres el editor, puedes verificar que tu tarea está programada con:
crontab -l
Un consejo de seguridad (Logs)
Como el script se ejecutará solo mientras tú quizás no estás frente al equipo, es buena idea guardar un registro de lo que pasó. Puedes modificar la línea del crontab para que guarde un log de errores:
00 08 * * 1 /bin/bash /home/tu_usuario/scripts/nipper_masivo_email.sh >> /home/tu_usuario/scripts/nipper.log 2>&1
Esto enviará tanto los mensajes de éxito como los errores al archivo nipper.log.
Vamos a cerrar el círculo de la automatización. Para adjuntar archivos desde la terminal, usaremos el comando mutt, que es mucho más potente que mail para manejar archivos adjuntos.
Aquí tienes cómo preparar tu sistema y el script final para que el reporte llegue directamente a tu bandeja de entrada cada lunes.
1. Instalar Mutt
Mutt es un cliente de correo para la terminal que se integra perfectamente con el ssmtp que ya configuramos.
sudo apt update
sudo apt install mutt
2. El Script Definitivo: nipper_auto_adjunto.sh
Este script no solo procesa los archivos, sino que comprime todos los PDFs generados en un solo archivo .zip y te lo envía adjunto. Así no recibes 20 correos si tienes 20 routers.
#!/bin/bash
# Configuración de rutas absolutas (importante para Cron)
BASE_DIR="/home/tu_usuario/auditoria"
INPUT_DIR="$BASE_DIR/configs"
OUTPUT_DIR="$BASE_DIR/reportes_pdf"
ZIP_FILE="$BASE_DIR/reportes_auditoria_$(date +%F).zip"
EMAIL_DESTINO="tu_correo@gmail.com"
mkdir -p $OUTPUT_DIR
# Limpiar PDFs antiguos antes de empezar
rm -f $OUTPUT_DIR/*.pdf
rm -f $ZIP_FILE
echo "[+] Iniciando auditoría..."
for file in $INPUT_DIR/*.{conf,txt}; do
[ -e "$file" ] || continue
FILENAME=$(basename "$file")
NAME="${FILENAME%.*}"
# Procesar con Nipper y convertir a PDF
/usr/bin/nipper --cisco --input="$file" --output="$OUTPUT_DIR/$NAME.html"
/usr/bin/wkhtmltopdf --quiet "$OUTPUT_DIR/$NAME.html" "$OUTPUT_DIR/$NAME.pdf"
rm "$OUTPUT_DIR/$NAME.html"
done
# --- COMPRIMIR Y ENVIAR ---
if [ "$(ls -A $OUTPUT_DIR)" ]; then
echo "[+] Comprimiendo reportes..."
zip -j $ZIP_FILE $OUTPUT_DIR/*.pdf
echo "Adjunto encontrarás el resumen de la auditoría de red de esta semana." | \
mutt -s "Reporte de Auditoría Semanal ($(date +%F))" -a "$ZIP_FILE" -- "$EMAIL_DESTINO"
echo "[OK] Email enviado con adjunto."
else
echo "[!] No se encontraron archivos para procesar." | mail -s "Error en Auditoría" "$EMAIL_DESTINO"
fi
3. Ajuste Final en Cron
Como ahora el script genera un archivo .zip con la fecha actual, asegúrate de que la línea en tu crontab -e apunte al nombre correcto del script:
00 08 * * 1 /bin/bash /home/tu_usuario/auditoria/nipper_auto_adjunto.sh
¿Qué hemos logrado?
Ahora tienes un sistema de Auditoría Continua:
Cada Lunes a las 8:00 AM, Kali se despierta.
Busca las configuraciones que hayas dejado en la carpeta
/configs.Las analiza con Nipper-ng.
Crea PDFs profesionales.
Los empaqueta en un ZIP.
Te los envía por email mientras tú quizás sigues tomando café.
Un último consejo de "Hacker Ético"
Si quieres que este sistema sea perfecto, podrías configurar tus routers para que envíen su configuración automáticamente a tu Kali cada domingo por la noche (usando el comando archive en Cisco).
Esta es la "guinda del pastel". En lugar de que tú tengas que ir al router a buscar la configuración, vamos a programar al router Cisco para que él mismo se encargue de enviarla a tu servidor Kali.
Para esto utilizaremos una función nativa de Cisco IOS llamada archive. Es extremadamente útil porque permite programar copias de seguridad automáticas (backups) de forma periódica.
1. Requisitos previos en tu Kali Linux
Asegúrate de que tu servidor TFTP esté corriendo (como configuramos al principio):
sudo atftpd --daemon --port 69 /tftpboot
sudo chmod -R 777 /tftpboot
2. Configuración en el Router Cisco
Entra en el modo de configuración (conf t) y activa el archivado automático. Supongamos que tu IP de Kali es 192.168.1.50:
Router(config)# archive
Router(config-archive)# path tftp://192.168.1.50/config_router.txt
Router(config-archive)# write-memory
Router(config-archive)# time-period 10080
Router(config-archive)# exit
¿Qué acabamos de configurar?
path: Le dice al router a dónde enviar el archivo y cómo llamarlo.write-memory: ¡Súper útil! Cada vez que alguien guarde cambios conwrocopy run start, el router enviará automáticamente una copia actualizada a tu Kali.time-period 10080: Esto le dice al router que envíe la configuración automáticamente cada 10,080 minutos (que es exactamente 7 días).
3. Sincronización Total (El Ciclo Perfecto)
Ahora que el router tiene su propio "cron", el flujo de trabajo es 100% autónomo:
Domingo noche (Router): El router envía su
config_router.txta tu carpeta/tftpbooten Kali vía TFTP.Lunes 08:00 AM (Kali): Tu tarea de Cron se activa.
Lunes 08:01 AM (Nipper-ng): Se procesa el archivo, se genera el PDF y se comprime.
Lunes 08:02 AM (Email): Recibes el correo con el reporte de seguridad en tu bandeja de entrada.
4. ¿Cómo probar que el envío funciona?
No tienes que esperar 7 días para saber si funciona. Puedes forzar el envío manual desde el router para verificar:
Router# archive config
Si todo está bien, deberías ver el archivo aparecer en /tftpboot/ de tu máquina Kali inmediatamente.
Resumen de tu Sistema de Auditoría
Has pasado de usar una herramienta manual en la terminal a construir un ecosistema de auditoría continua:
Hardening: Sabes cómo cerrar servicios inseguros (SSH, ACLs, Telnet).
Análisis: Usas Nipper-ng para detectar fallos.
Reporting: Generas PDFs profesionales y automáticos.
Cloud/Remote: Recibes todo por email.
Zero-Touch: El router se encarga de enviarte los datos.
