Tendrias que poner el desensamblado de tu funcion. Para mi debe ser por la alineacion de 16 bytes de la pila, pero no estoy seguro. argv es mas grande y las direcciones de las variables locales se corren (mas abajo), y capaz que sp se te paso a la siguiente alineacion.

haha felicitaciones!! ya estas listo pianawan

Los 200 espacios te sirven en caso de que la direccion al string /bin/sh cambie un toque, el exploit te va a seguir funcionando. Es decir, que le pases "  /bin/sh" o "         /bin/sh" a system(), el resultado es el mismo.

Asi es, lo de system/exit/tobinsh es para que lo reemplaces con las direcciones y le des al FIXME hasta que veas que sobreescribiste con la dir de system el eip.

Sip, cuando llamas a system le tenes que pasar un puntero a un string y para eso vas a tener que buscar la direccion de argv[1] en vuln.

Ah, bueno como te decia agregale el if y busca la dir de system en la plt:

#include <stdio.h>
#include <string.h>
 
fvuln(char *temp1, char *temp2)
{
   char name[512];
 
   strcpy(name, temp2);
   printf("Hello, %s %s\n", temp1, name);
}
 
int main(int argc, char *argv[])
{
   fvuln(argv[1],argv[2]);
   printf("Bye %s %s\n", argv[1], argv[2]);
 
   if (argc < 0)
      system("");
 
 
   return 0;
}
 

Y en gdb la sacas asi:

p 'system@plt'
 

El hecho que haya bytes nulos te complica la vida, si es que es una cadena que le estas pasando.
La direccion es corta porque debe ser la que va directamente hacia libc, a mi me pasa lo mismo en linux. Danos mas detalles, que programa intentas explotar?

Una solucion para tener una direccion sin bytes nulos seria usar la PLT del programa vulnerable, pero la entrada de system no la vas a tener si no es usada por el programa. Si es algo que escribiste vos para testear el ret2libc podes probar de agregarla a mano:

if (argc < 0)
 system("no se va a ejecutar");
 

Y ahi te deberia aparecer. En gdb la sacas con "x system" y te deberia dar una direccion dentro del espacio del programa vulnerable.

Proba asi, sino va a ser mas dificil explotarlo.

Saludos.

Hola pianista,


Lo codeaste vos ret2libc? Porque no entiendo bien que es lo que intenta hacer. Todos los valores de retorno (sc) se meten al principio mientras que deberian ir al final. La direccion que se saca con find_start() tampoco es muy fiable que digamos, en principio deberia darte la direccion de la ultima variable declarada, pero ni tampoco porque la funcion find_start no es __naked, o sea te diria que lo hagas a manopla con perl ya que te va a resultar mas facil. La sola complicacion, y tampoco es gran cosa, es meter el puntero hacia "/bin/sh".

Hace una cosa, hacete una cadena asi:

print " " x 200 . "/bin/sh;" . "A" x FIXME . "SYSTEM()" . "EXIT()" . "TOBINSH";
 

Los 200 espacios antes de /bin/sh te dan un poco de juego cuando elijas la direccion al string /bin/sh, ya que system() no los tiene en cuenta. El punto y coma despues de /bin/sh te permite meter cualquier cosa despues. En FIXME mete un valor hasta llegar a hitear eip con la direccion "SYSTEM()", o sea ahi pone la direccion de system que encontraste.
Y en TOBINSH tenes que poner la direccion al principio de ese buffer en el programa vulnerable.


mm ni idea si son esos los codigos, lo siento.


No conocia memfetch. La de system como hiciste? corriste vuln con gdb e hicistes un "x system" ?

Esa direccion es codigo ejecutable y no la vas a poder escribir, es justo donde esta el call strcpy en main. EDIT: Al mejor te referias a ese valor en el stack?

Arranca de a poco sino. El que te arma el egg dejalo de lado, usa perl por el momento.

$./vuln `perl -e 'print "A" x 512 . "\xSY\xST\xEM\xAD" x 10;'`

512 para llenar bien little_array, y despues 10 veces la dir de system() para asegurarse que eip la tome bien (tenes ebp antes y despues deberia venir eip). Despues si queres fijate bien el offset para hitear justo eip.

Probalo en gdb primero

$gdb --args ./vuln `perl -e 'print "A" x 512 . "\xSY\xST\xEM\xAD" x 10;'`

break en el ret de main

b *0x080483a8 

print del stack

x/64x $esp 

Ahi te deberia aparecer la direccion de system que pusiste repetida 10 veces. El primer valor es el que va a tomar eip para el ret.

Intenta todo esto y decime como te fue.

Sino, hay varios detalles antes de poder explotar bien el codigo que pusiste.
1- Como sacaste la direccion de system() ?
2- La direccion de /bin/sh puede variar segun lo ejecutes en gdb o solo.

Saludos

No podes meter bytes nulos?
La pila no es ejecutable ?
Si no podes pasar bytes nulos podes intentar buscando pedazos de codigos, en las libs o tu modulo, que te sean utiles para formar la direccion de system que buscas a partir de bytes no nulos.

Estas en windows o linux?

Hola pianista,

Eso eso, el ret de strcpy __no vas a poder sobrescribirlo__, el que tenes que buscar es el del main. strcpy te va a servir para sobreescribir el ret de main.

Si miras el call stack te vas a dar cuenta (dirs crecientes de arriba para abajo):

* variables locales de strcpy()
* ret strcpy (call strcpy)
* variables locales (little_array[512])
* ret main (call main)

Como ves, cuando queres hacer un bof de little_array lo que logras sobreescribir es el ret main puesto que vas hacia direccions crecientes. El ret de strcpy te es inaccesible.

Si. Mete un breakpoint a la vuelta de strcpy y justo antes del ret de main para ver si sobreescribiste bien las cosas.

Saludos!

Buenas exploiters!

Bueno queria compartir con ustedes un documento que habia escrito hace unos meses sobre las tecnicas "actuales" de bypass de DEP en windows, con un ejemplo practico sobre la utilizacion de una de ellas.

Data Execution Prevention (DEP) bypassing en Windows

Espero que lo disfruten y les sea de utilidad. Cualquier critica, correcion, evolucion es bienvenida!

Saludos.