Tamaño de word

[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:

Código [Seleccionar] Expandir


void funcion(){
char buffer1[5];
char buffer2{10];
}
Genera el codigo ensamblador y sale lo sgte:

Código [Seleccionar] Expandir


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

Código [Seleccionar] Expandir

subl $20,%esp

Ahora, yo genero en mi pc el mismo codigo y me sale lo siguiente:

Código [Seleccionar] Expandir


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]

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

[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]

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.

[Kerber0]

Muchas gracias por contestar, a ver si voy entendiendo y disculpen por el codigo en c.

Sea el sgte codigo:

Código [Seleccionar] Expandir


#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:

Código [Seleccionar] Expandir


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:

Código (c) [Seleccionar] Expandir

#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.

[Kerber0]

Sos groso Eternal Idol, sabelo!

Muchas gracias por tu tiempo !!!

Saludos

[Eternal Idol]

De nadas