ngrep: Análisis de Tráfico de Red

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

ngrep: Análisis de Tráfico de Red

ngrep (Network Grep) es una herramienta de análisis de red increíblemente útil que combina la potencia de grep con la capacidad de interceptar tráfico en tiempo real. Básicamente, te permite buscar patrones específicos (palabras, frases o código) dentro de los paquetes que pasan por tu interfaz de red.

Aquí tienes una guía rápida en español para dominarlo en Kali Linux.

1. Instalación y Sintaxis Básica

Aunque Kali suele traerlo preinstalado, puedes asegurarte con:

sudo apt install ngrep

La estructura del comando es:

ngrep [opciones] "patrón_a_buscar" [filtro_bpf]

Patrón: Lo que quieres encontrar (texto o hex).
Filtro BPF: (Opcional) Filtros estilo Wireshark/tcpdump (ej. port 80, host 192.168.1.1).

2. Opciones más comunes

Opción	Descripción
`-q`	Quiet mode: No muestra "hashes" (#) por cada paquete que no coincide.
`-d [interfaz]`	Especifica la interfaz (ej. `eth0`, `wlan0`).
`-W byline`	Muestra los saltos de línea correctamente (hace la lectura mucho más humana).
`-i`	Ignora mayúsculas y minúsculas.
`-x`	Muestra el contenido en formato Hexadecimal además de ASCII.
`-v`	Inversión: muestra los paquetes que no coinciden con el patrón.

3. Ejemplos Prácticos

Capturar tráfico HTTP (Buscando una palabra)

Si quieres ver si alguien está navegando y buscando la palabra "password" en sitios web no cifrados (HTTP):

sudo ngrep -q -W byline "password" port 80

Monitorear peticiones GET o POST

Ideal para ver qué datos está enviando un formulario:

sudo ngrep -W byline "GET|POST" tcp port 80

Buscar en una interfaz específica

Si estás usando una tarjeta de red externa en modo monitor:

sudo ngrep -d wlan1 "admin" tip 23 (Busca "admin" en tráfico Telnet).

Leer desde un archivo .pcap

Si ya capturaste tráfico con Wireshark y quieres filtrar rápido:

ngrep -I trafico_red.pcap "error" port 443

4. Diferencia clave: ngrep vs. tcpdump

Mientras que tcpdump es excelente para analizar la estructura de los paquetes (cabeceras, flags, tiempos), ngrep está diseñado para mirar el contenido (payload) del paquete. Es como usar un detector de metales en una maleta en lugar de solo mirar la etiqueta de envío.

Nota de seguridad: Recuerda que gran parte del tráfico moderno (HTTPS) está cifrado. ngrep verá el contenido como basura ilegible a menos que el tráfico sea en texto plano (HTTP, FTP, Telnet, SMTP).

Vamos a enfocarnos en DNS y Bases de Datos (MySQL), que son dos de los casos más interesantes para usar ngrep porque revelan mucha información sobre lo que está pasando en una red.

1. Monitoreo de Consultas DNS

El protocolo DNS (puerto 53) es perfecto para ngrep porque casi siempre viaja en texto plano. Esto te permite ver qué dominios están intentando resolver los dispositivos de tu red.

El comando:

sudo ngrep -d eth0 -t -W byline "" udp port 53

"": Al dejar las comillas vacías, ngrep captura todo el tráfico en ese puerto.
-t: Añade una marca de tiempo (timestamp) a cada paquete.
udp port 53: El filtro estándar para DNS.

2. Sniffing de Base de Datos (MySQL/MariaDB)

Si una aplicación se conecta a una base de datos sin usar SSL/TLS (algo común en redes locales de desarrollo), puedes ver las consultas SQL literales (SELECT, INSERT, DELETE).

Para capturar peticiones de lectura (SELECT):

sudo ngrep -i "select" port 3306

Para ver todo el tráfico de la base de datos de forma legible:

sudo ngrep -W byline -d any port 3306

3. Filtrando por una IP específica

Si quieres vigilar lo que hace un dispositivo concreto en tu red (por ejemplo, la IP 192.168.1.50), puedes combinar el patrón de búsqueda con un filtro de host.

El comando:

sudo ngrep -q "google" host 192.168.1.50

Esto solo mostrará paquetes que contengan la palabra "google" y que provengan o vayan hacia esa IP.

Resumen de sintaxis útil

Para que no lo olvides, aquí tienes una tabla rápida de filtros BPF (Berkeley Packet Filter) que puedes añadir al final de tus comandos:

Filtro	Qué hace
`icmp`	Captura Pings.
`port 21`	Tráfico FTP (ideal para ver usuarios y contraseñas en claro).
`src host [IP]`	Solo tráfico que sale de esa IP.
`dst host [IP]`	Solo tráfico que llega a esa IP.
`tcp and port 80`	Solo tráfico web TCP.

Guardar la salida de ngrep es fundamental para realizar auditorías o análisis forenses más detallados sin tener que estar pegado a la pantalla viendo pasar el texto.

Aquí tienes las dos formas principales de hacerlo en Kali Linux:

1. Guardar como archivo de texto (Lectura humana)

Esta es la opción ideal si quieres abrir el resultado con un editor de notas (Mousepad, Leafpad, VS Code) y buscar palabras clave más tarde.

El comando:

sudo ngrep -d eth0 -W byline "GET" port 80 > captura_http.txt

>: Este símbolo de Linux "redirecciona" la salida. En lugar de mostrarla en la terminal, la escribe en el archivo captura_http.txt.
Importante: Con este método, no verás nada en la pantalla mientras el comando se ejecuta.

¿Y si quiero verlo en pantalla Y guardarlo al mismo tiempo?

Para eso usamos el comando tee:

sudo ngrep -d eth0 -q "password" | tee registro.txt

2. Guardar en formato PCAP (Análisis profesional)

Si necesitas analizar los paquetes después con Wireshark o NetworkMiner, lo mejor es guardar el tráfico en formato binario .pcap.

El comando:

sudo ngrep -d eth0 -O mi_captura.pcap "login"

-O (O mayúscula): Indica que quieres volcar (Output) los paquetes coincidentes a un archivo crudo de red.
Ventaja: Este archivo conserva metadatos como flags TCP, números de secuencia y tiempos exactos que un archivo de texto plano pierde.

3. Leer un archivo guardado con ngrep

Si ya tienes un archivo .pcap (generado por ngrep, tcpdump o Wireshark), puedes usar ngrep para buscar dentro de él de forma ultra rápida sin abrir herramientas gráficas pesadas.

El comando:

ngrep -I mi_captura.pcap -W byline "SELECT" port 3306

-I (I mayúscula): Indica "Input". Lee desde el archivo en lugar de la tarjeta de red.

Resumen de redirección

Método	Comando	Uso principal
Texto (`>`)	`ngrep ... > file.txt`	Informes rápidos y lectura simple.
Binario (`-O`)	`ngrep ... -O file.pcap`	Análisis profundo posterior en Wireshark.
Dual (`tee`)	`ngrep ... \| tee file.txt`	Ver en vivo y respaldar a la vez.

Para monitorear múltiples protocolos a la vez, subimos un escalón en la complejidad de los filtros. Aquí es donde ngrep se vuelve realmente potente, ya que puedes usar operadores lógicos como and, or y not.

1. Monitorear HTTP y FTP simultáneamente

Si quieres vigilar cualquier movimiento de archivos o navegación web en texto plano, puedes agrupar los puertos.

El comando:

sudo ngrep -W byline "" "port 80 or port 21"

"": Buscamos cualquier contenido (sin filtro de texto inicial).
"port 80 or port 21": El filtro BPF le dice a la tarjeta de red que solo nos interesan esos dos servicios.

2. Filtrar tráfico EXCEPTO uno específico

A veces, tu terminal se llena de ruido porque tú mismo estás conectado por SSH al servidor. Puedes decirle a ngrep que ignore tu propia conexión.

El comando:

sudo ngrep -v "" "port 22"

-v: Invierte la selección (muestra todo lo que no sea puerto 22).

3. El "Súper Filtro": Combinando Texto y Puertos

Imagina que quieres buscar la palabra "user" pero solo en correos electrónicos (SMTP) o transferencias de archivos (FTP), ignorando el resto.

El comando:

sudo ngrep -i "user" "port 25 or port 21"

4. Guardar resultados de múltiples puertos

Si quieres dejar esto corriendo durante una hora para analizar qué pasó en esos servicios, combinamos lo que aprendimos antes:

sudo ngrep -t -W byline "" "port 80 or port 21 or port 445" -O auditoria_red.pcap

-t: Nos dará la hora exacta de cada evento.
port 445: Añadimos el puerto de Samba/Windows (muy útil en redes locales).

Resumen de Operadores Lógicos en Filtros

Operador	Uso	Ejemplo de filtro
`or`	Cualquiera de las dos condiciones.	`port 80 or port 443`
`and`	Ambas condiciones deben cumplirse.	`host 192.168.1.10 and port 80`
`not`	Excluye una condición.	`not port 22`

Truco de Pro: Si el tráfico es demasiado rápido y la pantalla se llena de texto ilegible, usa siempre -q (quiet mode) para que ngrep solo hable cuando encuentre exactamente lo que buscas.

Crear un pequeño script en Bash te permitirá ejecutar estas auditorías con un solo comando, organizando todo automáticamente por fecha y hora. Esto es muy útil si dejas la máquina encendida realizando pruebas de penetración o monitoreo.

Aquí tienes un script sencillo que puedes copiar y usar.

1. Crear el archivo del script

Abre tu terminal en Kali y escribe:

nano monitor_red.sh

2. Copiar el código

Pega el siguiente contenido dentro del editor:

Bash
#!/bin/bash

# Generar nombre de archivo con fecha y hora actual
FECHA=$(date +"%Y-%m-%d_%H-%M-%S")
ARCHIVO="captura_$FECHA.txt"

echo "---------------------------------------------------"
echo " Iniciando monitoreo de red con ngrep..."
echo " Guardando resultados en: $ARCHIVO"
echo " Presiona CTRL+C para detener."
echo "---------------------------------------------------"

# Ejecutamos ngrep buscando palabras clave en puertos comunes (HTTP, FTP, SMTP)
# -d any: escucha en todas las interfaces
# -W byline: mantiene el formato de saltos de línea
sudo ngrep -d any -t -W byline "user|pass|login|SELECT|GET|POST" "port 80 or port 21 or port 25 or port 3306" | tee "$ARCHIVO"

3. Dar permisos de ejecución

Para que Linux te permita correr el script como un programa, guarda el archivo (Ctrl+O, Enter, Ctrl+X) y ejecuta:

chmod +x monitor_red.sh

4. Ejecutar el script

Ahora, cada vez que quieras empezar a monitorear, solo escribe:

./monitor_red.sh

¿Qué hace exactamente este script?

Automatización de nombres: Crea un archivo único cada vez (ej. captura_2024-05-20_14-30-00.txt), así no sobrescribes tus pruebas anteriores.
Filtro Multicapa: Busca simultáneamente términos críticos como "user", "pass", "login" o comandos SQL como "SELECT".
Doble Visibilidad (tee): Verás lo que está pasando en la terminal en tiempo real, pero todo quedará registrado en el archivo para que lo revises después.

Un pequeño consejo "Pro"

Si quieres que el script sea aún más potente, puedes cambiar la extensión a .pcap y usar la opción -O de ngrep en lugar de tee, pero recuerda que los archivos .pcap no se pueden leer con un editor de texto normal, sino con Wireshark.

Programar una tarea en Linux se hace a través de cron. Es la herramienta estándar para automatizar scripts, copias de seguridad o, en este caso, auditorías de red con ngrep.

Aquí tienes cómo configurar tu script para que se ejecute solo, por ejemplo, todos los días a una hora específica.

1. Abrir el editor de Crontab

En tu terminal de Kali, escribe el siguiente comando:

sudo crontab -e

Nota: Si es la primera vez que lo abres, te preguntará qué editor usar. Te recomiendo elegir nano (suele ser la opción 1).

2. Entender la sintaxis de Cron

Al final del archivo que se abre, debes añadir una línea siguiendo este formato de 5 columnas:

minuto hora día_mes mes día_semana comando

3. Ejemplos prácticos para tu script de ngrep

Si quieres que el monitoreo empiece automáticamente en estos escenarios, añade la línea correspondiente al final del archivo:

Todos los días a las 11:30 PM:
30 23 * * * /home/kali/monitor_red.sh
De lunes a viernes a las 9:00 AM:
00 09 * * 1-5 /home/kali/monitor_red.sh
Cada vez que se reinicie la máquina (Muy útil para persistencia):
@reboot /home/kali/monitor_red.sh

4. Guardar y Verificar

Una vez añadida la línea:

Presiona Ctrl+O y Enter para guardar.
Presiona Ctrl+X para salir.
Verifica que tu tarea está programada con: sudo crontab -l

Un detalle técnico importante: El PATH

Cuando cron ejecuta un script, no siempre sabe dónde están los comandos como ngrep. Para evitar errores, te recomiendo editar tu script monitor_red.sh y poner la ruta completa de ngrep.

Puedes saber cuál es escribiendo en la terminal: which ngrep.

Normalmente es /usr/bin/ngrep. Así que en tu script, cambia sudo ngrep por /usr/bin/ngrep.

Tip de Seguridad: Como cron ya se está ejecutando como root (porque usamos sudo crontab), no necesitas poner la palabra sudo dentro del script.

¡Esta es una de las aplicaciones más potentes de ngrep para la ciberseguridad! Al buscar caracteres especiales y palabras clave que los atacantes usan para "romper" formularios web, puedes detectar intentos de intrusión en tiempo real.

Aquí te presento cómo configurar estos filtros avanzados:

1. Detectar Inyección SQL (SQLi)

Los ataques de SQLi suelen incluir comillas simples ('), guiones dobles (--), o la palabra UNION.

El comando:

sudo /usr/bin/ngrep -i -W byline "UNION|SELECT|OR 1=1|'|--" "port 80 or port 443"

OR 1=1: Es el clásico truco para saltarse inicios de sesión.
--: Se usa para comentar el resto de una consulta SQL original.
' : La comilla simple es el carácter más común para testear vulnerabilidades.

2. Detectar Cross-Site Scripting (XSS)

El XSS ocurre cuando un atacante intenta inyectar código JavaScript (normalmente etiquetas <script>) en una web.

El comando:

sudo /usr/bin/ngrep -i -W byline "<script|alert\(|javascript:" "port 80"

<script: Busca la apertura de la etiqueta de script.
alert\(: Muchos atacantes usan alert() para demostrar que la vulnerabilidad existe (PoC).
javascript:: Busca intentos de inyectar código en atributos de enlaces (como href).

3. Detectar Directory Traversal

Este ataque intenta acceder a archivos sensibles del sistema (como /etc/passwd) usando secuencias de "subir carpeta" (../).

El comando:

sudo /usr/bin/ngrep -W byline "\.\./\.\./|/etc/passwd|/windows/win.ini" "port 80"

\.\./: Escapamos los puntos con una barra invertida para que ngrep los busque literalmente.
/etc/passwd: El objetivo principal de los atacantes en sistemas Linux.

4. Combinando todo en un "IDS Casero"

Puedes actualizar tu script anterior para que busque todos estos patrones de ataque a la vez y te avise si detecta algo sospechoso:

Bash
# Patrones combinados: SQLi, XSS y Traversal
PATRONES="UNION|SELECT|OR 1=1|--|<script|alert\(|\.\./\.\./|/etc/passwd"

# Ejecutar y guardar en un log de alertas
sudo /usr/bin/ngrep -i -t -W byline "$PATRONES" "port 80" | tee alertas_ataque.log

Un recordatorio importante

ngrep es excelente para ver el tráfico en claro (HTTP). Si el sitio usa HTTPS (puerto 443), el tráfico estará cifrado y ngrep solo verá datos aleatorios. En entornos profesionales, para ver ataques en HTTPS, se suele usar un Proxy (como Burp Suite) o se analiza el tráfico justo cuando llega al servidor web (donde ya se ha descifrado).

Detectar un escaneo de puertos (como los que hace Nmap) con ngrep es un poco diferente a buscar palabras clave, porque un escaneo no suele enviar "texto", sino que toca muchos puertos rápidamente para ver cuáles están abiertos.

Sin embargo, podemos usar ngrep para detectar las "huellas" de herramientas de escaneo o intentos masivos de conexión. Aquí tienes cómo hacerlo:

1. Detectar el "User-Agent" de Nmap

Cuando alguien usa Nmap para hacer un escaneo de servicios (con -sV), Nmap envía paquetes HTTP para identificarlos. Muchos de estos paquetes llevan una firma que podemos capturar.

El comando:

sudo ngrep -i "nmap" port 80

Si ves resultados, significa que alguien está escaneando tu servidor web específicamente con Nmap sin ocultar su identidad.

2. Detectar escaneos de "Banner Grabbing"

Muchos escáneres intentan forzar una respuesta del servidor enviando cadenas genéricas como Help, Stats o caracteres aleatorios.

El comando:

sudo ngrep -W byline "HELP|STATS|QUIT" "tcp port 21 or tcp port 25 or tcp port 110"

3. Detectar inundación de paquetes (Syn Flood)

Aunque ngrep no es una herramienta de estadísticas, si ves que tu terminal se llena de paquetes vacíos (solo cabeceras) desde una misma IP hacia muchos puertos distintos, estás ante un escaneo.

Para verlo más claro, busca paquetes que no tengan contenido pero que estén activos:

sudo ngrep -q -d any . "tcp"

Si ves que aparecen cientos de líneas con la misma IP de origen (S de SYN) en milisegundos, esa IP te está escaneando.

4. Crear una "Trampa" (Honeypot) con ngrep

Una técnica avanzada es monitorizar un puerto que sabes que nadie debería usar en tu red (por ejemplo, el puerto 23 de Telnet, que es antiguo y poco seguro). Si alguien lo toca, es casi seguro que es un atacante o un escáner.

El comando para tu "alarma":

sudo ngrep -t -d any "" "dst port 23"

Cualquier salida en este comando significa que algo o alguien está "olfateando" servicios vulnerables en tu máquina.

Resumen de detección de intrusos

Qué detectas	Filtro de ngrep	Por qué funciona
Escaneo Nmap	`"nmap"`	Captura la firma del software.
Fuerza bruta FTP	`"USER	PASS"`
Escaneo de Directorios	`"dirbuster	gobuster"`
Puertos Prohibidos	`dst port 23`	Detecta actividad en puertos "trampa".

Tu siguiente paso

Ahora que ya sabes capturar, filtrar, guardar y hasta detectar ataques.

Cuando dejas ngrep ejecutándose mucho tiempo, el archivo de texto resultante puede ser enorme y difícil de leer. Aquí es donde entran los "cirujanos" de la terminal de Kali: grep, awk, cut y uniq.

Estas herramientas te permitirán extraer, por ejemplo, una lista limpia de todas las direcciones IP que han intentado interactuar con tu máquina.

1. Extraer solo las direcciones IP

Si tienes un archivo llamado alertas.txt generado por ngrep, verás que las líneas de cabecera tienen un formato como este:

T 192.168.1.15:54322 -> 192.168.1.50:80 [AP]

Para extraer solo la IP del atacante (la que está antes de la flecha ->), usamos este comando:

El comando:

grep "->" alertas.txt | cut -d' ' -f2 | cut -d':' -f1 | sort | uniq

¿Qué hace cada parte?

grep "->": Selecciona solo las líneas que indican transferencia de paquetes.
cut -d' ' -f2: Corta por espacios y se queda con la segunda columna (la IP de origen con puerto).
cut -d':' -f1: Elimina el puerto (lo que hay después de los dos puntos) para dejar la IP limpia.
sort | uniq: Ordena las IPs y elimina las duplicadas para que cada una aparezca solo una vez.

2. Contar cuántos ataques hizo cada IP

Si quieres saber quién es el atacante más insistente, solo hay que añadir un pequeño cambio al final:

El comando:

uniq -c: Cuenta cuántas veces aparece cada IP.
sort -nr: Ordena numéricamente de mayor a menor.
Resultado: Verás algo como 150 192.168.1.15, indicando que esa IP generó 150 alertas.

3. Buscar "Palabras Prohibidas" en el log

Si quieres filtrar tu archivo guardado para ver solo las líneas donde alguien intentó usar la palabra admin o root:

El comando:

awk '/admin|root/ {print $0}' alertas.txt

awk es increíblemente rápido procesando archivos de texto pesados y te mostrará el bloque completo donde se encontró la coincidencia.

4. Crear un reporte rápido (Resumen)

Puedes combinar todo en un comando que genere un pequeño reporte de "Sospechosos":

Bash
echo "--- REPORTE DE ACTIVIDAD SOSPECHOSA ---" > reporte.txt
echo "Top IPs atacantes:" >> reporte.txt
grep "->" alertas.txt | cut -d' ' -f2 | cut -d':' -f1 | sort | uniq -c | sort -nr >> reporte.txt

Tabla de comandos de limpieza rápida

Herramienta	Función principal
`grep`	Filtrar líneas por texto.
`cut`	Cortar columnas (como en Excel).
`awk`	Procesamiento avanzado de datos y lógica.
`sort`	Ordenar alfabética o numéricamente.
`uniq`	Eliminar repetidos o contar frecuencias.

¡Esto es genial para no tener que estar mirando la terminal constantemente! En Kali Linux (que usa habitualmente XFCE o GNOME), podemos usar el comando notify-send para lanzar alertas visuales en la esquina de tu pantalla.

Para lograr esto, vamos a crear un "puente" entre la salida de ngrep y el sistema de notificaciones.

1. El Comando Mágico: `notify-send`

Primero, asegúrate de que funciona. Escribe esto en tu terminal:

notify-send "Seguridad" "Intruso detectado en puerto 80"

Deberías ver una pequeña ventana emergente en tu escritorio.

2. Creando el script de Alerta en Tiempo Real

Vamos a crear un script llamado alerta_ngrep.sh que escuche el tráfico y, cada vez que encuentre un patrón sospechoso, nos envíe una notificación.

El código:

Bash
#!/bin/bash

# Definimos el patrón de ataque (ejemplo: SQLi o acceso a admin)
PATRON="admin|password|UNION|SELECT|script"

echo "Monitoreando y enviando alertas al escritorio..."

# Usamos un bucle 'while' para leer la salida de ngrep línea por línea
sudo ngrep -d any -q -W byline "$PATRON" "port 80" | while read -r line
do
    # Si la línea contiene la flecha "->", significa que es una cabecera de paquete
    if [[ $line == *"->"* ]]; then
        notify-send --urgency=critical "⚠️ ALERTA DE RED" "Actividad sospechosa detectada: $line"
    fi
done

¿Cómo funciona este script?

ngrep -q: El modo "quiet" es vital aquí para que el script no se vuelva loco con los caracteres #.
while read -r line: Toma cada línea que ngrep encuentra y la procesa.
--urgency=critical: Hace que la notificación resalte más (dependiendo de tu configuración, puede cambiar de color a rojo).

3. Hacerlo más profesional: Sonido de alerta

Si además de verlo quieres escucharlo (al estilo de una sala de monitoreo), puedes añadir un sonido. En Kali puedes usar paplay para reproducir un archivo .wav del sistema.

Modifica la línea del notify-send así:

Bash

notify-send "⚠️ ALERTA" "Ataque detectado"; paplay /usr/share/sounds/freedesktop/stereo/alarm-clock-elapsed.oga

4. Ejecución de fondo

Si quieres que este sistema de alarma esté funcionando mientras tú haces otras cosas en Kali, ejecútalo con un & al final:

./alerta_ngrep.sh &

Esto enviará el proceso al fondo (background) y podrás seguir usando tu terminal. Si quieres detenerlo después, usa el comando fg para traerlo al frente y presiona Ctrl+C.

Resumen de herramientas para alertas

Herramienta	Función
`notify-send`	Crea la ventana emergente visual.
`paplay`	Reproduce sonidos de alerta por los altavoces.
`while read`	Permite reaccionar a cada hallazgo de `ngrep` al instante.

¡Esta es una función clásica de "sniffing" de archivos! Ver qué archivos entran o salen de una red te permite detectar exfiltración de datos o la descarga de malware.

Para esto, nos enfocaremos en las cabeceras HTTP y los comandos FTP.

1. Rastrear descargas por HTTP

Cuando alguien descarga un archivo vía HTTP, el servidor envía una respuesta que incluye el nombre del archivo o el tipo de contenido.

El comando:

sudo ngrep -W byline ".exe|.zip|.pdf|.docx" port 80

Si quieres ser más técnico y ver qué archivos específicos están pidiendo (el método GET), usa:

sudo ngrep -i "GET /.*\.(exe|zip|pdf|docx)" port 80

\.: Escapamos el punto para que busque la extensión literal.
|: Es el operador "O" para buscar varios formatos a la vez.

2. Rastrear transferencias por FTP

El protocolo FTP es oro puro para ngrep porque todo viaja en texto plano. Los comandos clave aquí son RETR (para descargar/retirar un archivo) y STOR (para subir/almacenar un archivo).

Para ver qué archivos se están bajando:

sudo ngrep -i "RETR " port 21

Para ver qué archivos están subiendo a tu servidor:

sudo ngrep -i "STOR " port 21

3. Extraer solo los nombres de archivos (Limpieza avanzada)

Si dejas esto corriendo y guardas el log, puedes usar awk para crear una lista limpia de los archivos detectados. Supongamos que guardaste la salida en descargas.txt:

El comando:

grep -iE "GET|RETR|STOR" descargas.txt | awk '{print $2}' | sort | uniq

-iE: Busca de forma insensible a mayúsculas usando expresiones regulares extendidas.
awk '{print $2}': Normalmente, el nombre del archivo es la segunda palabra tras el comando GET o RETR.

4. Detectar extensiones peligrosas en tiempo real

Podemos modificar nuestro script de notificaciones anterior para que solo nos avise si alguien descarga un archivo potencialmente peligroso (como un .sh, .exe o .php).

Script rápido:

Bash
sudo ngrep -q -W byline "\.exe|\.sh|\.php|\.py" "port 80 or port 21" | while read -r line
do
    if [[ $line == *"GET"* || $line == *"RETR"* ]]; then
        notify-send --urgency=critical "⚠️ TRANSFERENCIA DE RIESGO" "Archivo detectado: $line"
    fi
done

Resumen de palabras clave para archivos

Protocolo	Comando/Patrón	Acción
HTTP	`GET`	El cliente pide un archivo.
HTTP	`Content-Disposition`	El servidor fuerza la descarga de un archivo.
FTP	`RETR`	El cliente descarga (Retrieve).
FTP	`STOR`	El cliente sube (Store).
SMB	`.(exe	dll)`

Capturar cookies de sesión es uno de los usos más clásicos de ngrep en auditorías de seguridad. Las cookies son pequeños fragmentos de datos que los servidores web envían al navegador para "recordar" quién eres. Si un sitio no utiliza HTTPS, estas cookies viajan en texto plano y pueden ser interceptadas.

A esto se le conoce como Session Hijacking (Secuestro de Sesión), ya que si un atacante obtiene tu cookie de sesión, puede pegarla en su propio navegador y entrar a tu cuenta sin necesidad de contraseña.

1. Comando para capturar Cookies HTTP

En el protocolo HTTP, las cookies se envían en una cabecera llamada Cookie:. Podemos filtrar específicamente por esa palabra.

El comando:

sudo ngrep -l -q -W byline "Cookie:" port 80

-l: Hace que la salida sea más rápida al no esperar a que se llene el búfer de red.
-q: Evita los caracteres # para ver solo los datos reales.
"Cookie:": El patrón exacto que buscamos en las cabeceras.

2. Capturar el inicio de sesión (Set-Cookie)

Cuando un usuario pone su usuario y contraseña correctamente, el servidor le responde con una nueva cookie para identificarlo en el futuro. Esa cabecera se llama Set-Cookie.

El comando:

sudo ngrep -W byline "Set-Cookie:" port 80

Si ves esto en tu terminal, estarás viendo el momento exacto en que el servidor le otorga una "identidad" al usuario.

3. Filtrar por un sitio web específico

Si hay mucho tráfico en la red y solo te interesa ver las cookies de un sitio en particular (por ejemplo, un panel de administración interno), puedes combinarlo con el nombre del host.

El comando:

sudo ngrep -W byline "Cookie:" "port 80 and host 192.168.1.100"

4. Limpiar los datos para extraer la Cookie

Como la salida de ngrep puede ser un poco sucia, podemos usar grep y awk para extraer únicamente el valor de la sesión de un archivo guardado (cookies_log.txt).

El comando:

grep "Cookie:" cookies_log.txt | awk -F'Cookie: ' '{print $2}' | sort -u

Esto te devolverá una lista limpia de cadenas como session_id=abc123xyz..., listas para ser analizadas.

🛡️ Nota importante sobre Seguridad y Ética

Hoy en día, la mayoría de los sitios importantes usan HTTPS y la bandera HttpOnly en las cookies.

HTTPS: Cifra todo el tráfico, por lo que ngrep solo verá datos ilegibles.
HttpOnly: Es una medida de seguridad que evita que scripts (como ataques XSS) accedan a la cookie, aunque en un ataque de red (sniffing) si el sitio es HTTP, la cookie sigue siendo visible.

Resumen de cabeceras de sesión

Cabecera	Dirección	Función
`Cookie`	Cliente → Servidor	El navegador se identifica ante el servidor.
`Set-Cookie`	Servidor → Cliente	El servidor asigna una nueva sesión al usuario.
`PHPSESSID`	Ambas	Nombre común de la cookie en sitios PHP.
`sessionid`	Ambas	Nombre común en aplicaciones Django/Python.

Detectar ataques de fuerza bruta con ngrep es sumamente útil porque te permite ver en tiempo real cómo un bot o un atacante intenta adivinar contraseñas enviando cientos de peticiones POST a una página de login.

Aquí te muestro cómo identificar este patrón y cómo diferenciarlo del tráfico normal.

1. Identificar peticiones de Login (POST)

Casi todos los formularios de inicio de sesión envían los datos mediante el método POST. En una red normal, un usuario hace uno o dos POSTs. En un ataque de fuerza bruta, verás decenas de ellos por segundo desde la misma IP.

El comando:

sudo ngrep -W byline "POST" port 80

Si ves que tu pantalla se desplaza sin parar con la misma estructura de datos, estás ante un ataque.

2. Filtrar por palabras clave de formularios

Para ser más preciso y evitar capturar otros POSTs (como subir una imagen), busca palabras que suelen ir en los campos de login: user, password, pwd, login.

El comando:

sudo ngrep -i -W byline "user|pass|pwd|login" "port 80 and tcp"

-i: Ignora si está en mayúsculas o minúsculas.
"user|pass...": Busca cualquiera de estos términos en el cuerpo del paquete.

3. Detectar el ataque "en ráfaga"

Si quieres ver si una IP específica te está atacando, podemos usar ngrep para contar cuántas peticiones hace en pocos segundos.

Truco de terminal:

sudo ngrep -q -W byline "POST" port 80 | grep "->" | cut -d' ' -f2 | cut -d':' -f1 | uniq -c

Este comando te mostrará un contador en tiempo real:
- 1 192.168.1.15 (Normal)
- 450 192.168.1.66 (¡Ataque detectado!)

4. Script de Alerta de Fuerza Bruta

Podemos crear un script que nos avise si detecta un volumen inusual de intentos de login.

Bash
#!/bin/bash
# Script para detectar fuerza bruta básica
echo "Vigilando intentos de login masivos..."

# Filtramos por POST y palabras clave, y procesamos la IP de origen
sudo ngrep -q -l -W byline "POST" port 80 | while read -r line
do
    if [[ $line == *"->"* ]]; then
        IP=$(echo $line | cut -d' ' -f2 | cut -d':' -f1)
        notify-send "⚠️ POSIBLE FUERZA BRUTA" "La IP $IP está enviando múltiples peticiones POST"
        echo "[$(date)] Intento desde: $IP" >> log_fuerza_bruta.txt
    fi
done

¿Cómo defenderte si detectas esto?

Si ngrep te confirma que alguien está atacando tu servicio en el puerto 80, el siguiente paso en Kali (o cualquier servidor Linux) sería bloquear esa IP usando el cortafuegos (iptables):

sudo iptables -A INPUT -s [IP_DEL_ATACANTE] -j DROP

Resumen de señales de alerta

Señal	Qué significa
Muchos POSTs seguidos	Un bot probando usuarios y contraseñas.
Misma IP, diferentes "users"	Ataque de diccionario clásico.
Diferentes IPs, mismo "user"	Ataque de "Credential Stuffing" (fuerza bruta distribuida).

Detectar el envío de Spam (correo no deseado) es crucial, ya que si un equipo de tu red está infectado con un botnet, podría estar enviando miles de correos por segundo, lo que provocaría que tu dirección IP fuera bloqueada en listas negras (Blacklists).

El protocolo principal para enviar correos es SMTP (Simple Mail Transfer Protocol), que utiliza tradicionalmente el puerto 25.

1. Monitorear comandos SMTP en tiempo real

En una comunicación SMTP normal, verás comandos específicos como HELO, MAIL FROM (quién envía) y RCPT TO (a quién va dirigido).

El comando para ver remitentes y destinatarios:

sudo ngrep -i -W byline "MAIL FROM|RCPT TO" port 25

Si ves que una sola dirección IP interna está generando cientos de RCPT TO hacia dominios diferentes en pocos segundos, es una señal clara de un Spam-bot.

2. Capturar el "Asunto" de los correos

Para confirmar si el contenido es Spam, puedes buscar la cabecera Subject:. Esto te permitirá ver de qué tratan los correos sin leer todo el cuerpo.

El comando:

sudo ngrep -i -W byline "Subject:" port 25

Señales de alerta: Asuntos con palabras como "VIAGRA", "URGENT", "WINNER", o cadenas de caracteres aleatorios.

3. Detectar intentos de Relay Abierto

Un "Open Relay" es un servidor de correo mal configurado que permite que cualquier persona envíe correos a través de él. Los atacantes buscan estos servidores constantemente.

Si ves muchas conexiones externas intentando usar tu puerto 25 con el comando VRFY (para verificar si existe un usuario) o EXPN, alguien está escaneando tu servidor.

El comando:

sudo ngrep -i "VRFY|EXPN" port 25

4. Script de detección de Spam masivo

Podemos crear un filtro que cuente cuántos correos intenta enviar cada IP de tu red local.

El código:

Bash
#!/bin/bash
echo "Vigilando posible actividad de SPAM (Puerto 25)..."

# Filtramos por el comando que inicia el envío de un correo
sudo ngrep -q -l "MAIL FROM" port 25 | while read -r line
do
    if [[ $line == *"->"* ]]; then
        # Extraemos la IP de origen
        ORIGEN=$(echo $line | cut -d' ' -f2 | cut -d':' -f1)
        echo "[$(date)] Posible envío de correo desde: $ORIGEN" | tee -a log_spam.txt
        notify-send "📧 ALERTA DE CORREO" "La IP $ORIGEN está enviando correos."
    fi
done

¿Qué hacer si detectas Spam?

Identificar el equipo: La IP de origen que muestra ngrep es el dispositivo infectado.
Aislar: Desconecta ese equipo de la red inmediatamente.
Bloquear temporalmente: Si no puedes desconectarlo, bloquea su salida al puerto 25 en el router o con iptables:
sudo iptables -A FORWARD -s [IP_INFECTADA] -p tcp --dport 25 -j DROP

Resumen de puertos de correo a vigilar

Puerto	Protocolo	Uso
25	SMTP	Envío de correo (Texto plano, el más usado por bots).
587	SMTP Submission	Envío de correo moderno (Suele requerir cifrado TLS).
465	SMTPS	Envío de correo cifrado (Difícil de analizar con ngrep).
110/143	POP3 / IMAP	Recepción de correos (Puedes ver quién está leyendo correos).

Capturar búsquedas en tiempo real es fascinante para entender qué información fluye por la red. Aunque hoy casi todo es HTTPS, todavía existen redes locales, aplicaciones antiguas, dispositivos IoT o portales cautivos (como los de hoteles o aeropuertos) que usan HTTP.

Cuando alguien busca algo en un buscador no cifrado, los términos suelen viajar en la URL tras parámetros como q= (de query) o s= (de search).

1. Filtrar términos de búsqueda en Google/Bing (HTTP)

La mayoría de los buscadores pasan la consulta en la URL. Usaremos ngrep para "cazar" esos parámetros específicos.

El comando:

sudo ngrep -i -W byline "q=|search?p=|s=" port 80

q=: Es el estándar de Google y muchos otros.
search?p=: Formato común en Yahoo.
s=: Muy común en buscadores internos de blogs y sitios WordPress.

2. Ver búsquedas en sitios WordPress o Foros

Muchos sitios web tienen su propio buscador interno. Si el sitio es http://ejemplo.com, al buscar "manual kali", la URL cambia a http://ejemplo.com/?s=manual+kali.

El comando para limpiar la salida:

sudo ngrep -l -q -W byline "s=" port 80 | grep -i "GET"

Esto te mostrará líneas como:

GET /?s=como+instalar+nmap HTTP/1.1

3. Decodificando los espacios (`+` y `%20`)

Verás que las búsquedas no tienen espacios, sino signos de suma (+) o códigos como %20. Para leerlo de forma humana en tu terminal de Kali, podemos usar un pequeño truco de Python unido a ngrep.

Comando avanzado de "Traducción":

sudo ngrep -l -q -W byline "s=|q=" port 80 | python3 -c "import sys, urllib.parse; [print(urllib.parse.unquote(l.strip())) for l in sys.stdin]"

Este comando toma la salida de ngrep y, gracias a Python, convierte los %20 en espacios reales y los + en texto legible al instante.

4. Script: El "Monitor de Curiosidad"

Si quieres dejar esto corriendo y que te guarde una lista limpia de lo que la gente busca en la red:

Bash
#!/bin/bash
echo "Monitorizando búsquedas en la red (HTTP)..."

sudo ngrep -l -q -W byline "q=|s=|search=" port 80 | while read -r line
do
    if [[ $line == *"GET"* ]]; then
        # Extraemos la parte de la query y la guardamos
        BUSQUEDA=$(echo $line | cut -d' ' -f2)
        echo "[$(date)] Búsqueda detectada: $BUSQUEDA" >> historial_busquedas.txt
        notify-send "🔍 Nueva Búsqueda" "Alguien buscó: $BUSQUEDA"
    fi
done

¿Por qué a veces no veo nada? (HSTS)

Muchos sitios modernos usan una tecnología llamada HSTS. Esto obliga al navegador a usar siempre HTTPS, incluso si el usuario escribe http://. En esos casos, ngrep no podrá ver el contenido. Sin embargo, en auditorías de red, esto te ayuda a identificar qué sitios de tu propia empresa o cliente son inseguros y necesitan actualizarse a SSL.

Tu siguiente paso

Hemos cubierto casi todo el espectro de ngrep: desde instalaciones básicas hasta detección de ataques, archivos, cookies y búsquedas.

Aquí tienes tu Guía Maestra de ngrep (Cheat Sheet) en español. Puedes copiar esto en un archivo de notas o imprimirlo para tenerlo al lado mientras trabajas en Kali Linux.

⚡ Guía Rápida de ngrep: Referencia de Comandos

Categoría	Comando de ngrep	Propósito
Básico	`ngrep -q -W byline "patrón" port 80`	Buscar texto en tráfico HTTP de forma legible.
Archivos	`ngrep -i ".exe	.zip
Sesiones	`ngrep -l -W byline "Cookie:" port 80`	Capturar cookies de sesión (Session Hijacking).
Seguridad	`ngrep -i "UNION	SELECT
Seguridad	`ngrep -i "<script	alert(" port 80`
Ataques	`ngrep -i "POST" port 80`	Identificar ráfagas de Fuerza Bruta en logins.
Red	`ngrep -i "MAIL FROM	RCPT TO" port 25`
Red	`ngrep -t "" udp port 53`	Monitorizar todas las consultas DNS.
Privacidad	`ngrep -i "q=	s=" port 80`

🛠️ Opciones de Modificación (Flags)

-q (Quiet): Oculta los caracteres #, ideal para scripts.
-W byline: Respeta los saltos de línea (hace que el texto sea legible).
-i: Ignora mayúsculas/minúsculas.
-v: Invierte la búsqueda (muestra lo que no coincide).
-t: Añade la hora exacta a cada paquete.
-d [interfaz]: Especifica la tarjeta de red (ej. eth0, wlan0).
-O [archivo.pcap]: Guarda el tráfico en formato binario para Wireshark.
-I [archivo.pcap]: Lee y filtra un archivo de captura ya existente.

💡 Recordatorios de "Pro"

Operadores Lógicos: Puedes combinar filtros al final del comando usando "port 80 or port 21" o "host 192.168.1.10 and port 80".
Cifrado: Recuerda que si el tráfico es HTTPS (puerto 443), ngrep verá datos cifrados (ilegibles). Solo funciona al 100% con protocolos en claro (HTTP, FTP, Telnet, SMTP, DNS).
Permisos: Siempre debes ejecutarlo con sudo en Kali para tener acceso a la interfaz de red.

¿Cómo seguir mejorando?

Ahora que dominas ngrep, el siguiente paso natural en el mundo del análisis de tráfico es aprender Wireshark para análisis gráfico profundo o Bettercap para ataques de red más complejos.

Interceptar credenciales de FTP (File Transfer Protocol) es uno de los ejercicios más reveladores en seguridad de redes, porque este protocolo es antiguo y envía absolutamente todo (usuario y contraseña) en texto claro.

Cualquier persona en la misma red que use ngrep puede ver estas credenciales en segundos.

1. El comando para cazar logins de FTP

En FTP, el cliente envía primero el comando USER seguido del nombre de usuario, y luego el comando PASS seguido de la contraseña.

El comando:

sudo ngrep -i -W byline "USER|PASS" port 21

"USER|PASS": Busca cualquiera de estas dos palabras clave.
port 21: El puerto estándar de control de FTP.

2. Capturar y guardar para auditoría

Si quieres dejar esto corriendo para documentar una vulnerabilidad en un servidor, lo mejor es guardar solo las líneas que contienen las credenciales con una marca de tiempo.

El comando:

sudo ngrep -t -l -q -W byline "USER|PASS" port 21 | tee credenciales_ftp.txt

Cuando alguien se conecte, verás algo como esto en tu archivo:

Plaintext

T 2026/03/25 20:30:05.123456 192.168.1.15:50231 -> 192.168.1.100:21 [AP]
USER admin
##
T 2026/03/25 20:30:08.654321 192.168.1.15:50231 -> 192.168.1.100:21 [AP]
PASS 12345678

3. ¿Cómo protegerse de esto? (La corrección técnica)

Como experto en Kali, tu labor no es solo "ver" el tráfico, sino saber cómo asegurar la red. La solución para evitar que ngrep capture esto es dejar de usar FTP y pasar a:

SFTP (SSH File Transfer Protocol): Todo el tráfico (incluido el login) viaja cifrado dentro de un túnel SSH (puerto 22).
FTPS (FTP over SSL/TLS): Añade una capa de cifrado al protocolo FTP tradicional.

Si intentas usar ngrep contra SFTP, solo verás caracteres aleatorios e ilegibles.

4. Reto Final: El comando "Todo en Uno"

Si quieres un comando que vigile HTTP, FTP y Telnet (los tres grandes protocolos inseguros) en busca de la palabra "password" al mismo tiempo:

sudo ngrep -i -q -W byline "pass|pwd|login|user" "port 80 or port 21 or port 23"

¡Has completado el entrenamiento de ngrep! 🎓

Has pasado de no conocer el comando a crear scripts automatizados, sistemas de alerta visual y filtros de ciberseguridad avanzada.