Últimamente le estoy pegando mucho a los retos forenses, ya que definitivamente creo que es con lo que más disfruto en el área de seguridad, y concretamente en una plataforma gratuita llamada Root-Me https://www.root-me.org/
Hoy os traigo la resolución del
reto FIND-ME, de dificultad media/alta por el que nos darán 50 puntos si lo
resolvemos: https://www.root-me.org/en/Challenges/Forensic/Find-me
Ojo comienza el spoiler.
Autor: David Bernal
Twitter: @db3rn4l.
Linkedin: https://www.linkedin.com/in/davidbernal89/
Premisas:
 |
| Maquina Find Me |
El reto indica que tu hijo (no
reconocido, entiendo…) es un geek que quiere demostrarte que tiene habilidades
para ocultarte información. Un buen día te dejaste la sesión abierta y éste
pillo aprovechó para gastarte una broma.
Vaya, que lo que debemos hacer es
encontrar la contraseña de validación de algo en lo que parece ser un volcado
de memoria.
Durante este reto voy a utilizar
Caine y Windows10 con varias herramientas forenses para resolverlo,
principalmente volatility 2.6 en Caine y Volatility Standalone en Windows.
Pulsamos en el botón start hte
challenge y se nos descargará un archivo de nombre ch18.zip el cual, en su
interior, contiene el volcado de memoria.
Análisis de memoria
Realizamos un imageinfo para
obtener el perfil sugerido para trabajar con volatility: vol.py -f dump
imageinfo.
Una vez obtenido el perfil,
podemos comenzar a analizar la memoria. Yo, cuando no tengo ninguna pista más
allá, me gusta empezar echando un primer vistazo a los procesos por si acaso
hay algo que me salte a la vista. Lanzamos un pstree porque me gusta tener una
lista, no solo de los procesos en ejecución, si no de las relaciones que puede
haber entre ellos (por aquello de que puede aparecer un chrome.exe lanzando un
powershell… por ejemplo).
Para sacar el árbol de procesos
ejecutamos el comando:
vol.py -f dump --profile=Win7SP1x86_23418
pstree > pstree.txt
Se me ocurrió que el archivo puede que estuviese en memoria en el momento en el que se realizó la captura por lo que vamos a volcar el área de memoria del proceso truecrypt.exe (pid 3224) y vamos a intentar escarbar en él haciendo uso de strings.
vol.py -f dump --profile=Win7SP1x86_23418 memdump -p 3224 -D ./dir
Como el cifrado, lo ha tenido que haber realizado algún usuario se me ocurrió filtrar por “Users” y echar un vistazo.
strings ./dir/3224 | grep Users
De los datos obtenidos veo que
hay un archivo llamado “findme” justo antes del History.xml de TrueCrypt, ¿coincidencia?
Pues vamos a verlo.
Primero comprobamos si ese
archivo se encuentra en memoria con el plugin filescan.
vol.py -f dump --profile=Win7SP1x86_23418 filescan
| grep findme
Como ha habido suerte procedemos
a extraerlo mediante el plugin dumpfiles, pasándole por parámetros la dirección
física de la memoria en la que se aloja ese archivo.
vol.py -f dump --profile=Win7SP1x86_23418
dumpfiles -Q 0x000000001ee20110 -D ./dir/
El resultado del comando anterior
nos devuelve un archivo.dat (archivo de datos), es decir es el mismo archivo
“findme” solo que Volatility lo renombra de esta manera (https://github.com/volatilityfoundation/volatility/wiki/Command-Reference#dumpfiles).
Pasamos el archivo a la máquina
Windows con TrueCrypt instalado y montamos el mismo introduciéndole la
contraseña obtenida con el plugin “truecryptsummary”.
Una vez montado, nos dirigimos a
la unidad y descubriremos que hay 3 ficheros.
En el txt no hay nada…
En la imagen tampoco…
Sólo nos queda el .odt
Una vez un alumno me comentó que los archivos tanto *.odt como *.docx, son como archivos comprimidos, por lo que se me ocurrió hacer una cosa.
Abrimos ese archivo con Winrar
para ver qué es lo que tenía en su interior y, también, otro archivo *.odt mío
para compararlos a ver si había diferencias y aquí está el resultado:
Hay una carpeta data en su
interior que no suele encontrarse en este tipo de archivos, pues bien,
accedemos a ella y descubrimos un archivo en su interior con nombre “my_safety_box”
del cual no disponemos de ninguna referencia sobre qué puede tratarse.
Llegados a este punto, nos toca investigar qué más cosas puede haber dentro de la máquina que nos permitan intuir qué puede ser este archivo y recordé que en el pstree vi navegación de usuario a través del navegador Firefox.
Para poder extraer la navegación
en memoria, se necesita de un plugin adicional que no se encuentra por defecto
alojado dentro de Volatility, por lo que debemos clonar un repositorio que el
usuario “superponible” ha dejado en su github.
git clone https://github.com/superponible/volatility-plugins
Una vez obtenidos los plugins,
ejecutamos el siguiente comando:
vol.py
--plugin=/home/dfir/Desktop/rootme/volatility-plugins -f dump
--profile=Win7SP1x86_23418 firefoxhistory --output=csv > firefoxhistory.csv
Obteniendo un archivo .CSV que al
analizarlo con cualquier software que procese hojas de cálculo, nos permite ver
que el usuario realizó varias búsquedas sobre keepass.
Para sacarnos de dudas, usamos el comando file de Linux con el que se nos sugiere que el tipo de archivo que tenemos delante es una base de datos de tipo KDBX, es decir, de tipo Keepass.
Lo siguiente es hallar la contraseña para poder abrir la base de datos de keepass, tras un rato revisando la memoria se me ocurrió que se podría intentar sacar los hashes de los usuarios del sistema y después crackearlos, ya que en la navegación del usuario se había accedido a Crackstation.net.
Para extraer los hashes, primero
necesitamos obtener las direcciones virtuales de memoria de los hives del
sistema SYSTEM y SAM, para esto debemos utilizar el plugin hivelist:
vol.py -f dump --profile=Win7SP1x86_23418 hivelist
Una vez obtenidas las direcciones
de memoria procedemos a volcar los hashes NTLM de las contraseñas de los
usuarios, para esto utilizamos el plugin hashdump y le pasamos las direcciones
de memoria, con la opción -y la del SYSTEM y con la opción -s de la SAM.
vol.py -f dump --profile=Win7SP1x86_23418
hashdump -y 0x88c1a280 -s 0x901de008
Tras obtenerlas comprobamos una por una en Crackstarion.net obteniendo que la contraseña del usuario info es #1Gogfather.
Volvemos a la máquina Windows, abrimos Keepass, seleccionamos el archivo y probamos a pasarle la contraseña obtenida.
Y por suerte la base de datos se
abre y aparecen unos 4240 registros en la sección Internet.
Como son demasiadas para probar una por una las exportamos a CSV para revisarlas detenidamente.
Y filtramos por cada uno de los
campos comprobando si hay alguna incongruencia y curiosamente en el campo de
las contraseñas existe un registro que es mucho más grande que los demás.
Mirándolo muy de cerca se puede
observar que acaba en “=” lo que hace suponer que pueda tratarse de un string
encodeado en base64.
Lo intentamos decodear en caine con el comando à echo “string” | base64 --decode y nos un nuevo string en base64.
Como es una locura decodear esto
de forma manual, se me ocurrió crear un pequeño script en Shellscript que
tomase como referencia un archivo en el que escribo el base64 original y vaya
decodeando un número limitado de veces.
Para ello creamos un archivo
llamado base64code0
Pegamos el string
Creamos un fichero script llamado scriptdecode.sh que realice la operación de decodear el string, mandarlo a un archivo vacío y retomarlo, en este caso durante unas 30 veces.
Otorgamos permisos de ejecución
Lo ejecutamos.
Al finalizar la ejecución vamos a
obtener unos 30 archivos como resultado, por lo que nos tocará revisarlos uno
por uno.
En mi caso, accedemos al número 21 y ahí se encontrará la contraseña que necesitamos introducir en root-me para obtener los 50 puntos del reto.
Espero que os haya gustado.
Un saludo.