By H*ckYou! - ITESM Puebla
Download ship here.
Se procede a analizar el binario obteniendo
la mayor cantidad de información posible.
Strings ship:
objdump -M intel -d ship
Dónde se identifica una función get flag que
podría obtener la bandera
Adicionalmente, en la función main se
identifica la función vulnerable “gets”, por lo que se procede a buscar un
desbordamiento de buffer:
Siendo confirmada la existencia de la
vulnerabilidad con la ejecución del binario:
Una vez identificada la vulnerabilidad, se
busca explotarla de forma que nos permita desviar la dirección de retorno a la
función deseada
Para lo cual se diseña un payload como el
mostrado a continuación:
Se escribe el payload a un archivo y se
ejecuta el binario:
Tras lo cual se procedió a ejecutar el
exploit contra el sitio habilitado para este objetivo.
---------------------------------------------------------------------------------------------------------------------------
By FinalBoss - IPN CIC
En este reto se da un binario y se
menciona que se debe enviar el exploit
a un servidor, lo que da idea de que se debe manipular la stack, y debido a que es un reto de 100 puntos seguramente es un stack
overflow básico. Para iniciar se
revisa el tipo de archivo lo que lleva a conocer la arquitectura del sistema.
Como se muestra en la Figura 1 es un
binario de 32 bits para un sistema Linux.
Figura 1. Comprobar el tipo de archivo con el comando file
Antes de continuar, se hace un
análisis estático, haciendo el análisis de las cadenas legibles usando el
comando strings. En la Figura 2 se muestra que existe una cadena de nombre get_flag, que es muy probable sea una
función y que se comprueba analizando el desensamblado.
Figura
2. Identificar cadenas ASCII dentro del binario
Se
realiza la ejecución para conocer el comportamiento del binario. La Figura 3 muestra la ejecución del binario, que
recibe una cadena y termina.
Figura
3. Ejecución del binario
Se intenta conocer si es posible
desbordar la memoria debido al análisis previo (que es un reto de 100 puntos es
decir fácil). Haciendo uso de un ciclo for que manda a la entrada de la
ejecución del binario de 1 a 100 A como se muestra en la Figura 4.
Figura
4. Prueba de buffer overflow
En la Figura 5 se aprecia que al
escribir 77 ‘A’ se tiene un Segmentation fault. Es donde comienza el juego, una
vez conocido esto se intenta manipular la pila.
Figura
5. Segmentation fault en el binario
Para probar el número de A
necesarias para reescribir la pila, en específico la ESP, se usa el comando strace. Poniendo como entrada A*76+BBBB
y conocer en qué punto ESP toma el valor de BBBB
Figura 6. Análisis del segmentation fault usando strace
En la Figura 7 se aprecia que las
letras B después de las 76 A, sobre escribe si_addr. Así es posible modificar
el flujo del binario.
Figura
7. Análisis del Segmentation fault
Ahora que se sabe que es posible
modificar el flujo del binario, el siguiente punto a analizar es a donde debe
continuar. Se hace uso del debugger para
analizar la función encontrada de nombre get_flag.
Se aprecia que existe una llamada al
sistema system que seguramente hace
la ejecución de la cadena encontrada de nombre /home/ship/flag.
Figura
8. Desensamblado de la función get_flag
La dirección a la que es necesario
saltar es la mostrada haciendo uso de break en gdb.
Una vez que se conoce el número de A
para usar como offset, y la dirección a la que se quiere saltar, se obtiene el
exploit mostrado en la Figura 10.
Se aprecia que se hace la ejecución
de cat /home/ship/flag, archivo que se encuentra en el servidor al que se debe
enviar el exploit.
Finalmente se envía el exploit al
servidor para obtener el flag, teniendo el resultado mostrado en la figura 11.
Figura
11. Envío del exploit al servidor
Comments
Post a Comment