Hola gente, no se si corresponde esto aca pero creo que es el subforo mas adecuado. Estoy siguiendo lo de buffer overflow el texto de Aleph y en ejemplo el tiene el sgte codigo en C:
void funcion(){
char buffer1[5];
char buffer2{10];
}
Genera el codigo ensamblador y sale lo sgte:
...
pushl %ebp
movl %esp,%ebp
subl $20,%esp
...
La memoria guarda los datos en multiplos de word. En este caso su word vale 4 bytes, ya que (5 bytes de la primer variable se guardan en 2 word, y 10 bytes de la segunda var se guardan en 3 word) En total tengo 5 word que multiplicados por 4, reservo un espacio de 20 bytes subl $20,%esp
Ahora, yo genero en mi pc el mismo codigo y me sale lo siguiente:
pushl %ebp
movl %esp, %ebp
subl $40, %esp
Cuanto valdria mi word? Cuanto reserva para la primer variable (char buffer1[5]) y cuanto reserva para la segunda (char buffer2[10])?
Muchas gracias de antemano.
Un char (caracter) ocupa un byte unicamente, el tema esta en el alineamiento en memoria pero en x86 una palabra son 2 bytes, una doble palabra (DWORD) son 4 bytes.
Habria que ver que modificadores estas usando para el compilador, si yo genero ESE codigo con VC++ no hace nada al optimizarlo ...
Hola, gracias por contestar. El tema es que me quiero posicionar sobre la ret. Es decir
PILA
buf2|buf1|SBP|ret
si yo me posiciono en buf1 estoy a ¿cuanto de ret? el SBP ocuparia 4bytes? dire de memoria ret = dire de buf1 + 4bytes?
Corro con Ubuntu, compilo en gcc
Muchas gracias
Si, la direccion de retorno ocupa 4 bytes, esta en la pila, cuando la funcion es llamada equivale justamente a ESP. Para obtenerla DENTRO de la funcion, cuando el prologo ya se ejecuto y el epilogo todavia no lo hizo tenes que sumarle el tamaño de bytes que resto (subl $40, %esp) mas 4 (pushl %ebp).
ret = esp + (X + 4)
Siguiendo tu logica:
buf1|buf2|ESP|ret
ret = buf1 + sizeof(buf2) + 4
Lo mejor que podes hacer es depurarlo para comprobarlo.
Muchas gracias por contestar, a ver si voy entendiendo y disculpen por el codigo en c.
Sea el sgte codigo:
#include <stdio.h>
void function(){
int i;
int* p;
p=&i+2; //Estaria apuntando al ret
}
void main(){
int j;
function();
j=5;
printf("\n%d\n",j);
j=6;
printf("\n%d\n",j);
}
Al desamblar el main:
Dump of assembler code for function main:
0x080483fc <main+0>: push %ebp
0x080483fd <main+1>: mov %esp,%ebp
0x080483ff <main+3>: and $0xfffffff0,%esp
0x08048402 <main+6>: sub $0x20,%esp
0x08048405 <main+9>: call 0x80483e4 <function>
0x0804840a <main+14>: movl $0x5,0x1c(%esp) -> ESTA SERIA LA DIRE DE RETORNO
0x08048412 <main+22>: mov $0x8048510,%eax
0x08048417 <main+27>: mov 0x1c(%esp),%edx
0x0804841b <main+31>: mov %edx,0x4(%esp)
0x0804841f <main+35>: mov %eax,(%esp)
0x08048422 <main+38>: call 0x804831c <printf@plt>
0x08048427 <main+43>: movl $0x6,0x1c(%esp)
0x0804842f <main+51>: mov $0x8048510,%eax
0x08048434 <main+56>: mov 0x1c(%esp),%edx
0x08048438 <main+60>: mov %edx,0x4(%esp)
0x0804843c <main+64>: mov %eax,(%esp)
0x0804843f <main+67>: call 0x804831c <printf@plt>
0x08048444 <main+72>: leave
0x08048445 <main+73>: ret
End of assembler dump.
Ahora yo quiero modificar la direccion de retorno para llegar a que salte el primer printf y ejecute el 2do j=6;
Es decir, correctamente la ret es:
0x0804840a <main+14>: movl $0x5,0x1c(%esp)
yo quiero modificarla y que caiga en:
0x08048427 <main+43>: movl $0x6,0x1c(%esp)
Estoy a 43-14 bytes = 29 bytes de diferencia entre la ret correcta y la ret que quiero donde caiga.Esto es correcto? Tendria que aumentar en 29 bytes la ret para caer aqui?Pero 29 no es multiplo de word, se podria aumentar?
Gracias !!!
Asi me funciona:
#include <stdio.h>
void function(){
int i;
unsigned char *p = (unsigned char*)&i+0xC;
*p += 0x1A;
}
void main(){
int j;
function();
j=5;
printf("\n%d\n",j);
j=6;
printf("\n%d\n",j);
}Siendo main:
0x080483f3 <main+0>: lea 0x4(%esp),%ecx
0x080483f7 <main+4>: and $0xfffffff0,%esp
0x080483fa <main+7>: pushl -0x4(%ecx)
0x080483fd <main+10>: push %ebp
0x080483fe <main+11>: mov %esp,%ebp
0x08048400 <main+13>: push %ecx
0x08048401 <main+14>: sub $0x24,%esp
0x08048404 <main+17>: call 0x80483d4 <function>
0x08048409 <main+22>: movl $0x5,-0x8(%ebp) ;direccion original
0x08048410 <main+29>: mov -0x8(%ebp),%eax
0x08048413 <main+32>: mov %eax,0x4(%esp)
0x08048417 <main+36>: movl $0x8048510,(%esp)
0x0804841e <main+43>: call 0x8048310 <printf@plt>
---Type <return> to continue, or q <return> to quit---
0x08048423 <main+48>: movl $0x6,-0x8(%ebp) ;direccion a la que queremos saltar
0x0804842a <main+55>: mov -0x8(%ebp),%eax
0x0804842d <main+58>: mov %eax,0x4(%esp)
0x08048431 <main+62>: movl $0x8048510,(%esp)
0x08048438 <main+69>: call 0x8048310 <printf@plt>
0x0804843d <main+74>: add $0x24,%esp
0x08048440 <main+77>: pop %ecx
0x08048441 <main+78>: pop %ebp
0x08048442 <main+79>: lea -0x4(%ecx),%esp
0x08048445 <main+82>: ret
Y function:
0x080483d4 <function+0>: push %ebp
0x080483d5 <function+1>: mov %esp,%ebp
0x080483d7 <function+3>: sub $0x10,%esp
0x080483da <function+6>: lea -0x8(%ebp),%eax
0x080483dd <function+9>: add $0xc,%eax
0x080483e0 <function+12>: mov %eax,-0x4(%ebp)
0x080483e3 <function+15>: mov -0x4(%ebp),%eax
0x080483e6 <function+18>: movzbl (%eax),%eax
0x080483e9 <function+21>: lea 0x1a(%eax),%edx
0x080483ec <function+24>: mov -0x4(%ebp),%eax
0x080483ef <function+27>: mov %dl,(%eax)
0x080483f1 <function+29>: leave
0x080483f2 <function+30>: ret
0x23-0x9=0x1A.
Sos groso Eternal Idol, sabelo!
Muchas gracias por tu tiempo !!!
Saludos
De nadas ;D