Tamaño de word

Iniciado por Kerber0, 17 Noviembre 2009, 06:55 AM

0 Miembros y 1 Visitante están viendo este tema.

Kerber0

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.

Eternal Idol

#1
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 ...
La economía nunca ha sido libre: o la controla el Estado en beneficio del Pueblo o lo hacen los grandes consorcios en perjuicio de éste.
Juan Domingo Perón

Kerber0

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

Eternal Idol

#3
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.
La economía nunca ha sido libre: o la controla el Estado en beneficio del Pueblo o lo hacen los grandes consorcios en perjuicio de éste.
Juan Domingo Perón

Kerber0

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

Eternal Idol

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.
La economía nunca ha sido libre: o la controla el Estado en beneficio del Pueblo o lo hacen los grandes consorcios en perjuicio de éste.
Juan Domingo Perón

Kerber0

Sos groso Eternal Idol, sabelo!

Muchas gracias por tu tiempo !!!

Saludos

Eternal Idol

La economía nunca ha sido libre: o la controla el Estado en beneficio del Pueblo o lo hacen los grandes consorcios en perjuicio de éste.
Juan Domingo Perón