Hola chicos!

Estoy lidiando con un programa que tiene un fallo de integer overflow y no soy precisamente un 'experto' en estos temas del reversing.. u.u

Me estoy basando en este texto para aprender sobre el asunto: http://phrack.org/issues/60/10.html

Por lo que entiendo en este code (que esta muy bien explicado):

    /* width1.c - exploiting a trivial widthness bug */
    #include <stdio.h>
    #include <string.h>
 
    int main(int argc, char *argv[]){
            unsigned short s;
            int i;
            char buf[80];
 
            if(argc < 3){
                    return -1;
            }
 
            i = atoi(argv[1]);
            s = i;
 
            if(s >= 80){            /* [w1] */
                    printf("Oh no you don't!\n");
                    return -1;
            }
 
            printf("s = %d\n", s);
 
            memcpy(buf, argv[2], i);
            buf[i] = '\0';
            printf("%s\n", buf);
 
            return 0;
    }

El problema esta cuando se le pasa como argumento a ese programa un numero mayor que 65535, ya que luego se va a tratar como un "unsigned short",, aca el disassembly:

CPU Disasm
Address   Hex dump                  Command                                  Comments
009012B8  |.  FF73 04               PUSH DWORD PTR DS:[EBX+4]                ; /Arg1 = ASCII "65536"
009012BB  |.  FF15 B8309000         CALL DWORD PTR DS:[<&MSVCR120.atoi>]     ; \MSVCR120.atoi
009012C1  |.  8BF8                  MOV EDI,EAX
009012C3  |.  83C4 04               ADD ESP,4
009012C6  |.  66:83FF 50            CMP DI,50
009012CA  |.  72 17                 JB SHORT 009012E3
009012CC  |.  68 8C319000           PUSH OFFSET 0090318C     ; "Oh no youdon't!"
009012D1  |.  FF15 B4309000         CALL DWORD PTR DS:[<&MSVCR120.printf>]
009012D7  |.  83C4 04               ADD ESP,4
009012DA  |.  83C8 FF               OR EAX,FFFFFFFF
009012DD  |.  5F                    POP EDI
009012DE  |.  5B                    POP EBX
009012DF  |.  8BE5                  MOV ESP,EBP
009012E1  |.  5D                    POP EBP
009012E2  |.  C3                    RETN
009012E3  |>  0FB7C7                MOVZX EAX,DI
009012E6  |.  50                    PUSH EAX
009012E7  |.  68 A0319000           PUSH OFFSET 009031A0    ; ASCII "s = %d"
009012EC  |.  FF15 B4309000         CALL DWORD PTR DS:[<&MSVCR120.printf>]

Bueno, a mi entender el mayor problema es la linea 7. Comparar el valor 10000 con 50 (hexadecimal), el programa se saltea el " if (s >= 80) " y luego falla en memcpy, mas precisamente aca:

CPU Disasm
Address   Hex dump                   Command                                            Comments
58D2F608  />  F3:A5                  REP MOVS DWORD PTR ES:[EDI],DWORD PTR DS:[ESI]

Se copia de esi a edi un valor muy grande y su respectiva violacion de segmento.

En el texto aclara esto:


Y tambien aclara esto:


Cuando yo pruebo el programa que estoy tratando de arreglar, a veces logro ejecutar los tipicos '41414141' y otras veces no, o sea.. el programa falla en direcciones diferentes todas las veces, tiene remedio eso? Puedo forzar la direccion donde quiero que falle??

1 - Yo me quedo con la duda de como es posible que sin saber el resultado final del buffer igual sea posible ejecutar codigo arbitrario.. dice que con metodos estandar se puede, pero yo no encuentro forma..

2 - Asi que no siempre es explotable esta situacion?

Gracias por leer todo eso!! Saludos!!!

Se me ocurre que el problema esta en el memcpy de argv[2] pero realmente estoy tambien bastante verde en el tema de reversing..

Hi! 

Gracias por responder chicos! Les cuento hasta donde entiendo..


En realidad entiendo porque falla el programa, digamos que tiene un "mal diseño",, y me explico mejor:

1 - i es integer y se obtiene desde la consola (argv[1])
2 - si el valor introducido es (por ejemplo) 65536,, cuando se hace i = atoi(argv[1]); i vale 10000
3 - cuando se pone en s el valor de i, s solo puede guardar los ultimos 4 valores (0000), por lo cual la condicion de la linea 17 es salteada.
4 - Luego se copia a buf, pero con el valor de i que es mucho mayor,, y.. buffer overflow.


Estoy desde windows, lo compile en visual studio 2013 con la seguridad desactivada..

Lo que yo quisiera saber es si este tipo de situacion es explotable,, si existe una forma de controlar el fallo y poder ejecutar codigo arbitrario.. a memcpy se le pasa un valor grande para copiar (10000) y el buffer (buf) se desborda porque solo tiene 80,, pero como se puede llegar a "sacar ventaja" del buffer overflow es lo que me esta intrigando mucho 

Entiendo que el "shellcode" tendria que ser pasado por argv[2]. 

Saludos!!! Gracias!

PD: Este codigo es un ejemplo de integer overflow, el fallo que yo busco esta en otro programa, pero es comparable uno con otro. No es que precise arreglar ese codigo, ni es mio.. digo por las dudas..

Hi!!


Exacto!


Ok, algo entendi.. ¿pero que ventaja tendria si he pisado el puntero a funcion? No se que es triguerear,, algo como juntar trigo? xD

Bueno, ya igual me voy haciendo la idea que esta muy complejo esto.. y que un integer overflow a veces y solo a veces es explotable, digamos.. si se alinean los planetas..


Dudo que vuelva a buscar un integer overflow en mi vida xD

Gracias!! Saludos!!

Comparto, es solo que no estoy tan familiarizado con la jerga de ingeniería inversa xD

Justo cuando entre a responder, el foro me propuso (ahi en mensajes similares) que vea el siguiente tema:

http://foro.elhacker.net/desafios_wargames/desafioreto_para_avanzados_explotacion_por_integer_overflow-t15164.0.html

Extraña coincidencia de la vida, el programa es bastante parecido a ese que puse de ejemplo,, y al parecer el reto es meter un shellcode! Asi que voy a ver si tiene solucion (que supongo que si, claro) para aprender sobre el tema.

Muchas gracias a todos! A seguir aprendiendo

EDITADO:

Parece que en el enlace que puse, Rojodos y p5il0cyb3 entran en duelo a muerte y no me termina de quedar claro si sirve o si no,, pero sigue siendo informacion util.