Que tal...

Bueno, tengo una duda: En la mayoría de ejemplos sobre STACK OVERFLOWS ponen algo como:

Código:

...
int main(int argc,char **argv){
char buffer[1024];
strcpy(buffer,argv[1]);
}

Lógicamente vemos que pasando los 1024 bytes de buffer, más 8 bytes de alineamiento (si es compilado con las nuevas versiones de GCC , creo q apartir de la 3) y mas 8 bytes de registros a sobreescribir correspondientes ($EBP & $EIP) pues nos da el SEGMENTATION FAULT (SIGSEGV)... o sea, con tan solo 1040 bytes se desborda y podremos poner la shellcode dentro de 1032 bytes (ya que no podemos meter la shellcode en $ebp ni $eip por que en $eip va la direccion de memoria de nuestra shellcode ok).

Ahora mi duda es...

Código:

...
int main(int argc,char **argv){
char foo[12],nitro[8],lame[24],buffer[1024];
strcpy(buffer,argv[1]);
}
 
 
Entonces akí, para "OVERFLOWEAR" xD dicho programa, como en la stack fueron declarados primero dichos arreglos de tipo char, pues tendríamos que sobreeescribir los (1024+8)+(24+8)+(8+8)+(12+8)+(8..estos son los de los registros EBP Y EIP)... todos esos 8s sumados son los bytes de alineamiento ok... entonces tendríamos que meter 1108 bytes para obtener el desborde... Entonces puedo usar todos esos arreglos para meter mi shellcode ??

Y otra más.. como se la dirección donde he almacenado mi shellcode ??

En el texto de DEX
http://www.hakim.ws/textos/stackofdex.txt
Donde dice:
Citar:
Woops!, ya llenamos todo el buffer, ya sabemos que hacer con los 967
bytes restantes, ya sabemos que shellcode usar, pero... QUE DIRECCIONES
VAMOS A PONER?
Bueno, hay una forma de hacerlo sacando la dirección automáticamente de
%esp con una instrucción en ensamblador, que usan muchos exploits
locales:
-----------------------------------------------
void get_esp() {
__asm__("movl %esp, %eax");
}
-------------------------------------------------
 
 

Alguien podría poner alguna url sobre la explicación de dicha función ya que he buscado en google y no encuentro anda parecido :S... o si alguien ha visto un exploit usando esta función (yo si lo he visto por ahi pero no recuerdo que exploit), asi que si alguien tiene algún exploit x ahi, que pastee la url para analizarlo....

salu2...

-----------------------------------------------
void get_esp() {
__asm__("movl %esp, %eax");
}
-------------------------------------------------


es muy simple, como ia han dixo, pone eax en esp, pero ¿para qeu lo hace?, o sea, ¿de qeu sirve?, la respuesta es facil, al hacer eso, obtenemos la direccion del puntero de la pila, el qal sera la direccion a la qeu apunte la shellcode.

Haber, Mr. Potato.

Esto dices tu:

Pero esto dice http://www.hackemate.com.ar/mirrors/karpoff/archivos/CURSOASM.txt

Segun yo entiendo -> tu dices que pone el primero en el segundo y el texto dice que pone el segundo en el primero...

Ahora que estoy aprendiendo ASm, ¿CON CUAL ME QUEDO?

vale, partamos de que es un movl y no un mov usea at&t:

En la sintaxis de AT&T el destino de una operacion se pone en el segundo parametro y la origen se pone en el primer parametro. (Al reves que en los Intel).
 
El nombre de los registros es precedido por el caracter porcentaje ("%").
 
Los valores inmediatos han de ser precedidos por el caracter "$".
 
El tamaqo de los operandos se especifica mediante un ultimo caracter de la instruccion:"b" (8-bits) | "w" (16-bits) | "l" (32-bits).

+ info aqui: http://www.publispain.com/supertutoriales/programacion/ensamblador/cursos/1/linasm.htm y en google.

Muy bien...

entonces la funcion get_esp() RETORNA la dirección de %eax y ahi es dond debo apuntar a %eip ya q ahi irán los nops y/o shellcode o me ekivoco?? pero he buscado ejemplos de como lo usan en exploits y aun no encuentro alguno....

y si, lo estuve testeando en FreeBSD y pues tuve q buscar shellcodes (execve("/bin/sh"))para Free BSD x86 y ya la tengo, ahora solamente necesito la MALDITA dirección a apuntar %eip... salu2