IVRE: Reconocimiento de Red en Kali

https://www.onlinetis.com

IVRE: Reconocimiento de Red en Kali

Hablar de IVRE (Instrument de Veille et de Réponse aux Événements) es entrar en el terreno serio del reconocimiento de red. Es, básicamente, una alternativa de código abierto a herramientas como Shodan o Censys, pero que tú controlas por completo.

Aquí tienes una guía rápida para entender qué es y cómo ponerlo en marcha en Kali Linux.

¿Qué es IVRE?

IVRE es un marco de trabajo (framework) para el reconocimiento de red pasivo y activo. Utiliza herramientas estándar de la industria para recolectar datos y los almacena en una base de datos (generalmente MongoDB) para que puedas analizarlos.

Escaneo Activo: Utiliza Nmap y ZMap.
Análisis Pasivo: Puede importar datos de Bro/Zeek, Argus o p0f.
Interfaz: Incluye una interfaz web muy potente para filtrar y visualizar los resultados.

Instalación en Kali Linux

La forma más sencilla y recomendada actualmente es utilizar Docker, ya que IVRE tiene muchas dependencias (Python, MongoDB, servidores web, etc.) que pueden ensuciar tu instalación base.

1. Preparar el entorno

Asegúrate de tener Docker instalado y funcionando:

Bash

sudo apt update
sudo apt install docker.io docker-compose
sudo systemctl start docker

2. Descargar e iniciar IVRE

Puedes usar la imagen oficial para levantar un laboratorio rápidamente:

Bash
# Crear un directorio para el proyecto
mkdir ivre-lab && cd ivre-lab

# Descargar el archivo de composición (opcional, o usar el comando directo)
docker run -d --name ivre-db mongo
docker run -d -p 80:80 --link ivre-db:db --name ivre-web ivre/web

Nota: Para una instalación completa de producción, se recomienda seguir la guía de docker-compose en el repositorio oficial de GitHub de IVRE.

Flujo de trabajo básico

Una vez instalado, el proceso suele ser:

Escanear: Lanzas un escaneo con Nmap y guardas el resultado en formato XML.
nmap -sS -A -oX scan.xml 192.168.1.0/24
Importar: Pasas esos datos a la base de datos de IVRE.
ivre scan2db scan.xml
Analizar: Abres tu navegador en http://localhost y utilizas los filtros para buscar vulnerabilidades o servicios específicos.

¿Por qué usar IVRE en lugar de un simple Nmap?

Característica	Nmap Simple	IVRE
Historial	Difícil de mantener	Almacena cada escaneo en BD
Interfaz	Terminal / Zenmap	Panel web profesional
Escalabilidad	Limitada	Puede manejar millones de hosts
Análisis Pasivo	No	Sí (vía flujos de red)

Advertencia de seguridad: IVRE es una herramienta de doble filo. Asegúrate de tener permiso para escanear las redes que objetivos, ya que el escaneo activo es fácilmente detectable por sistemas IDS/IPS.

Vamos a ensuciarnos las manos. Asumiendo que ya tienes el contenedor o la base de datos lista, aquí tienes la secuencia de comandos para pasar de "no saber nada" a "tener un mapa visual" de tu red.

Paso 1: Realizar el escaneo con Nmap

IVRE necesita que el archivo de salida de Nmap sea en formato XML para poder procesar los metadatos. Vamos a escanear una red local (ajusta el rango 192.168.1.0/24 a la tuya):

Bash

nmap -sV -O -p- -oX mi_escaneo.xml 192.168.1.0/24

-sV: Detecta versiones de servicios.
-O: Intenta identificar el Sistema Operativo.
-p-: Escanea los 65,535 puertos (más lento, pero completo).
-oX: Guarda el resultado en el archivo XML necesario.

Paso 2: Importar los datos a IVRE

Una vez que tienes el archivo .xml, debes decirle a IVRE que lo meta en su base de datos. Si estás usando la versión instalada directamente en el sistema:

Bash

ivre scan2db mi_escaneo.xml

Si estás usando Docker, tendrás que copiar el archivo al contenedor o ejecutar el comando a través de él:

Bash

docker cp mi_escaneo.xml ivre-web:/mi_escaneo.xml
docker exec ivre-web ivre scan2db /mi_escaneo.xml

Paso 3: Generar la vista de red

Para que los resultados aparezcan correctamente en la interfaz web, es buena práctica "limpiar" o actualizar la base de datos de visualización:

Bash

ivre db2view nmap

Paso 4: Explorar los resultados

Abre tu navegador y ve a:

http://localhost (o la IP de tu servidor Kali)

En la interfaz web podrás:

Filtrar por puertos: Escribe port:22 en la barra de búsqueda para ver todos los hosts con SSH.
Filtrar por SO: Escribe os:linux.
Gráficos: Haz clic en la pestaña "Graph" para ver una representación visual de cómo se conectan los servicios.

Un truco útil: Escaneo pasivo (p0f)

Si no quieres hacer ruido con Nmap, puedes importar capturas de tráfico (archivos .pcap) que hayas tomado con Wireshark:

Captura tráfico: sudo tcpdump -i eth0 -w trafico.pcap
Impórtalo: ivre pcap2db trafico.pcap

Dominar los filtros de IVRE es lo que separa a un usuario casual de un analista de seguridad. La sintaxis de búsqueda es muy potente y te permite encontrar "agujas en el pajar".

Aquí tienes cómo buscar versiones vulnerables y servicios específicos usando la barra de búsqueda de la interfaz web.

1. Búsqueda de Versiones Específicas

Si quieres encontrar una versión de Apache que sabes que tiene un exploit conocido (por ejemplo, una versión antigua como la 2.2), usa el operador product:

Búsqueda exacta: product:Apache version:2.2.22
Búsqueda parcial: product:Apache (esto te mostrará todas las variantes de Apache detectadas).

Filtros combinados (Operadores Lógicos)

Puedes encadenar criterios para ser muy preciso. Por ejemplo, buscar servidores con un puerto abierto que NO deberían tenerlo:

port:22 AND NOT os:Linux (Busca SSH abierto en dispositivos que no son Linux, lo cual es sospechoso o inusual).

2. Identificando Superficie de Ataque

Para encontrar servicios que suelen ser vectores de ataque comunes, puedes usar estos "filtros rápidos":

Objetivo	Filtro en IVRE
Bases de datos expuestas	`port:3306` (MySQL) o `port:5432` (PostgreSQL)
Escritorio Remoto	`port:3389` (RDP) o `port:5900` (VNC)
Servicios Web inseguros	`port:80 AND NOT port:443` (Solo HTTP, sin HTTPS)
Dispositivos IoT	`product:GoAhead` o `product:boa` (Servidores web comunes en cámaras y routers)

3. Uso de Scripts de Nmap (NSE)

Si cuando hiciste el escaneo usaste scripts de Nmap (--script vuln), IVRE almacena esos resultados. Puedes buscar hosts que hayan dado positivo en una vulnerabilidad específica:

script:smb-vuln-ms17-010 (Para buscar el famoso EternalBlue).

4. Visualización de "Heatmaps" y Gráficos

Una de las mejores funciones de IVRE es su capacidad de resumir datos visualmente.

Dashboard: Haz clic en el logo de IVRE arriba a la izquierda para ver estadísticas generales (países, tipos de SO, puertos más comunes).
Graph view: Una vez que apliques un filtro (ej. port:80), pulsa en la pestaña "Graph". IVRE dibujará un mapa de nodos que conecta las IPs con sus servicios. Esto es ideal para ver segmentación de red.

Un consejo de "Pro": El poder del filtrado pasivo

Si estás analizando tráfico de red capturado (pcap), puedes usar:

flow:http: Para ver solo los flujos de tráfico que fueron identificados como HTTP.
useragent:python: Para ver si hay scripts automáticos o bots operando en tu red.

Automatizar este proceso te ahorrará mucho tiempo y evitará que olvides los comandos de mantenimiento de la base de datos cada vez que hagas un escaneo.

Vamos a crear un script en Bash llamado autivre.sh. Este script hará tres cosas: escanear, importar los resultados y actualizar la vista web automáticamente.

El Script: `autivre.sh`

Copia este código en tu terminal de Kali:

Bash
#!/bin/bash

# Configuración
TARGET=$1
OUTPUT="scan_$(date +%Y%m%d_%H%M%S).xml"

if [ -z "$TARGET" ]; then
    echo "Uso: ./autivre.sh [IP o Rango]"
    echo "Ejemplo: ./autivre.sh 192.168.1.0/24"
    exit 1
fi

echo "[+] Iniciando escaneo Nmap sobre $TARGET..."
nmap -sV -O --script=banner -oX "$OUTPUT" "$TARGET"

echo "[+] Importando resultados a la base de datos de IVRE..."
# Si usas instalación nativa:
ivre scan2db "$OUTPUT"
# Si usas Docker (descomenta la siguiente línea y comenta la de arriba):
# docker cp "$OUTPUT" ivre-web:/$OUTPUT && docker exec ivre-web ivre scan2db /$OUTPUT

echo "[+] Actualizando visualización (db2view)..."
ivre db2view nmap

echo "[+] ¡Listo! Los datos ya están disponibles en http://localhost"
echo "[+] Archivo guardado como: $OUTPUT"

Cómo prepararlo y usarlo

Crea el archivo:
nano autivre.sh (Pega el código anterior y guarda con Ctrl+O, Enter y Ctrl+X).
Dale permisos de ejecución:
chmod +x autivre.sh
Ejecútalo:
sudo ./autivre.sh 192.168.1.0/24

¿Qué acabamos de hacer?

Al ejecutar este script, estás creando un flujo de trabajo profesional:

Consistencia: Todos tus escaneos tendrán el mismo formato de nombre con fecha y hora.
Automatización de BD: No tienes que recordar el comando db2view, que es el que suele causar confusión cuando los datos no aparecen en la web.
Escalabilidad: Puedes dejar el script corriendo en una tarea programada (cron) si necesitas monitorear una red constantemente.

Un último detalle: Limpieza de datos

Si en algún momento quieres "empezar de cero" porque la base de datos tiene demasiados escaneos viejos, puedes limpiar IVRE con este comando:

ivre scan2db --delete --init

Esta es la parte más "ninja" de IVRE. El reconocimiento pasivo consiste en escuchar el tráfico que ya existe en la red sin enviar ni un solo paquete. Es indetectable porque no interactúas con los objetivos, solo "observas".

Para esto usaremos p0f, una herramienta que analiza las huellas digitales del stack TCP/IP para adivinar el Sistema Operativo y la aplicación de los hosts que se comunican.

1. Captura de tráfico en tiempo real

Primero, necesitamos capturar el tráfico de tu interfaz de red (por ejemplo, eth0 o wlan0) y guardarlo en un archivo que IVRE pueda entender.

Ejecuta este comando en una terminal:

Bash

sudo tcpdump -i eth0 -w captura_pasiva.pcap

Déjalo corriendo unos minutos mientras navegas o usas la red.

2. Importación de huellas (Fingerprinting)

Una vez que detengas el comando anterior (Ctrl+C), procesaremos ese archivo con IVRE. Aquí es donde ocurre la magia:

Bash

ivre pcap2db captura_pasiva.pcap

Este comando hace lo siguiente:

Lee cada paquete del archivo.
Identifica flujos de datos (quién habla con quién).
Extrae el User-Agent (navegadores), banners de servicios y el OS (a través de p0f).

3. Análisis en la Interfaz Web

Ahora vuelve a tu navegador (http://localhost). Notarás que han aparecido nuevos datos. Para ver específicamente lo que capturaste de forma pasiva, usa estos filtros en la barra de búsqueda:

source:p0f: Muestra solo los hosts detectados mediante análisis pasivo de paquetes.
has:useragent: Muestra qué dispositivos están navegando y qué navegador usan (ideal para detectar dispositivos móviles o bots).
flownet:192.168.1.0/24: Muestra el mapa de flujos de comunicación dentro de ese rango.

4. Comparativa: Activo vs. Pasivo

Es muy común combinar ambos en IVRE. Mira esta tabla para decidir cuándo usar cada uno:

Característica	Escaneo Activo (Nmap)	Análisis Pasivo (pcap/p0f)
Visibilidad	Ruidoso (detectable por Firewalls)	Totalmente invisible (sigiloso)
Precisión	Muy alta (pregunta directamente)	Estimada (basada en observación)
Puertos	Encuentra puertos cerrados/filtrados	Solo ve puertos en uso activo
Uso Ideal	Auditoría de seguridad interna	Inteligencia de amenazas / Forense

Pro-Tip: El comando `flow2db`

Si tienes instalado Zeek (antes conocido como Bro) o Argus, puedes importar sus registros directamente a IVRE con ivre flow2db. Esto te permite ver diagramas de red basados en el volumen de datos (quién es el host que más descarga, por ejemplo).

Configurar alertas en IVRE es el paso final para pasar de un análisis estático a una monitorización activa. Aunque IVRE no tiene un botón de "campanita" nativo, su arquitectura basada en Python y MongoDB permite crear alertas muy potentes con pequeños scripts de terminal.

Aquí te explico cómo crear un "Guardián" para tu red.

1. El concepto: Consultas de base de datos

IVRE guarda todo en MongoDB. Para crear una alerta, simplemente le pediremos a la base de datos que busque algo específico (como una base de datos expuesta) y, si encuentra algo, nos envíe un aviso.

Filtros críticos comunes:

Bases de datos: port:3306 (MySQL), port:5432 (PostgreSQL), port:27017 (MongoDB).
Servicios sensibles: port:21 (FTP), port:23 (Telnet), port:3389 (RDP).

2. Script de Alerta Automática (`check_vulns.sh`)

Vamos a crear un script que busque servicios peligrosos y nos imprima un mensaje de alerta en la consola (o podrías enviarlo por email/Telegram si quisieras).

Crea el archivo: nano check_vulns.sh

Bash
#!/bin/bash

# Definimos el servicio crítico a buscar (ejemplo: MySQL expuesto)
CRITICAL_PORT="3306"

echo "[?] Verificando servicios críticos en la base de datos de IVRE..."

# Usamos 'ivre run' para hacer una consulta rápida desde la terminal
RESULTS=$(ivre run "port:$CRITICAL_PORT" | grep "Host:" | wc -l)

if [ "$RESULTS" -gt 0 ]; then
    echo "################################################"
    echo "¡ALERTA DE SEGURIDAD! Se encontraron $RESULTS hosts con el puerto $CRITICAL_PORT abierto."
    echo "Revisa la interfaz web: http://localhost"
    echo "################################################"
    # Aquí podrías añadir una línea para enviar un mail o notificación
else
    echo "[OK] No se detectaron servicios críticos expuestos."
fi

Para ejecutarlo: chmod +x check_vulns.sh y luego ./check_vulns.sh.

3. Automatización con Cron (El toque profesional)

No querrás ejecutar el script a mano cada 5 minutos. Vamos a decirle a Kali que lo haga por ti:

Abre el editor de tareas: crontab -e
Añade esta línea al final para que se ejecute cada hora:
0 * * * * /ruta/a/tu/check_vulns.sh >> /var/log/ivre_alerts.log

4. Visualización de "Riesgo" en la Web

Si prefieres ver las alertas visualmente en la interfaz de IVRE, usa la barra de búsqueda combinando filtros de productos conocidos por ser inseguros:

(port:21 OR port:23) AND NOT (os:Windows)

Esto te mostrará dispositivos (probablemente routers o IoT) que están usando protocolos sin cifrar.

Resumen de tu Laboratorio de Reconocimiento

Ahora tienes un sistema completo en Kali Linux:

Escaneo Activo: Con tu script autivre.sh.
Escaneo Pasivo: Capturando tráfico con tcpdump y p0f.
Análisis Visual: Con la interfaz web y gráficos de nodos.
Alertas: Con el script de monitoreo en segundo plano.

Sugerencia final: Si vas a usar esto en una red real, te recomiendo instalar Zeek junto a IVRE. Zeek extraerá metadatos de archivos descargados y certificados SSL, permitiéndote buscar incluso "Certificados caducados" en tu red con el filtro has:ssl.

Buscar este blog