Este
trabajo tenía que haber sido publicado antes, pero Blogger ha decidido que no
sea así al eliminar, hasta en dos ocasiones, el contenido del borrador, según
avanzaba en su desarrollo.
Cuando publiqué el artículo “Elija
bien su arma. Calcule el impacto.”, en el que hice una comparativa
de algunas herramientas gratuitas para realizar un volcado de memoria, teniendo
en cuenta el tiempo invertido en el proceso y los recursos del sistema usados,
dije muchas tonterías. Algunas de esas estupideces que dije
fueron que los datos pueden sobrevivir
en la memoria durante un determinado tiempo, que se pueden obtener datos clave para la resolución satisfactoria del caso,
que se pueden llevar a cabo las mismas
acciones sobre un volcado de memoria que sobre una imagen forense de un disco
duro, o que a veces no basta con
analizar los datos no volátiles. Dije un montón de sandeces más,
pero les invito a que lean
ustedes el artículo que, dicho sea de paso, algunas personas han
creído interesante.
Después de publicar el artículo, algunos usuarios me
dijeron que les gustaría que publicara algo relacionado con ese tipo de despropósitos.
Igualmente, llevo algún tiempo observando cómo hay algunas personas que tienen
problemas para identificar correctamente un perfil de un volcado de memoria con
Volatility.
Así pues, he decidido realizar este pequeño trabajo
sobre unos ‘primeros pasos con Volatility’, en el que haré especial hincapié en
la correcta identificación de un perfil, (puesto
que es un paso crítico en el análisis), y mostraré qué tipo de información,
y cómo, se puede extraer de un volcado de memoria.
No voy a llevar a cabo un complejo análisis de un súper-mega-ultra
malware avanzado. Voy a mostrar un ejemplo práctico, sobre un usuario,
objetivo de una investigación. Voy a… investigarme a mí mismo
Introducción
¿Por qué Volatility? Es cierto
que pueden ustedes procesar el volcado de memoria con Bulk Extractor, tal y como
expliqué en el artículo “¿Quién
es el Señor ‘X’? Averigüémoslo con #BulkExtractor y #Patterns de #Egrep (Somos
lo que navegamos)”. También es cierto que existen algunas suites
forenses que son capaces de procesar un volcado de memoria. Pero prefiero mostrarles a ustedes un trabajo
manual, que parece ser que genera más impacto que los ‘botones gordos’ en
una exposición. Volatility es un
Framework capaz de trabajar con volcados de memoria de sistemas de
32 y de 64 bits, de Windows, MacOS, Linux y Android. Posee un diseño modular,
por lo que tiene una buena adaptación a nuevas versiones de los distintos
sistemas. Es de código abierto, lo que se traduce en que es muy útil para
entender cómo trabaja de fondo, cómo funciona un análisis de un volcado. Está
escrito en Python, por lo que puede funcionar en cualquier sistema que soporte
este lenguaje. Soporta una buena lista de formatos de archivo de memoria. Y,
quizás lo más importante, cuenta con un buen apoyo y contribución por parte de
la comunidad DFIR.
Para el desarrollo de este trabajo he optado por usar
mi propio sistema, como objetivo de estudio. Tras iniciar sesión, levanté
ejecuté unas cuantas aplicaciones, (procesos),
y capturé la memoria RAM con DumpIT, en su versión 3.0.20190124.1.
Para efectuar el análisis he optado por utilizar la máquina virtual SIFT WorkStation,
que pueden ustedes descargar desde su sitio oficial.
Si se fijan ustedes en la imagen anterior, podrán ver
que DumpIt genera un reporte en el que, entre otra serie de datos interesantes,
se muestra la información de la versión del sistema que se ha capturado. En
este caso se trata de un Windows 10, en su versión 17763, tal y como se puede
apreciar en el apartado “osVersion”. Pero les
pido que obvien esta información, porque no todas las herramientas les
dirán de qué versión se trata, o es posible que el volcado lo haya llevado a
cabo una tercera persona y no les haya comunicado la versión del sistema.
Antes de comenzar, deben saber ustedes que tienen que
actualizar su sistema y sus aplicaciones. En el caso de Volatility, podrán ver
ustedes que no es lo mismo utilizar una versión 2.6, que una versión 2.6.1,
dado que no reconocen el mismo número y tipo de perfiles. Las actualizaciones en las herramientas se realizan por algún motivo.
Así que, lo primero que deben hacer ustedes, es clonar el último repositorio
disponible desde su sitio de GitHub.
Identificando un perfil, versión larga
Si tienen ustedes un volcado de memoria y lo quieren
identificar, quizás podrían empezar por utilizar el plugin ‘imageinfo’.
Este plugin les va a proporcionar un pequeño resumen del volcado, en el que se
incluyen la hora del volcado de memoria y una lista de perfiles sugeridos. Entre
estos perfiles sugeridos se encuentran las últimas versiones de Windows.
python Volatility/vol.py -f N4RR34N6-20190307-072825.dmp imageinfo
Una vez haya terminado la ejecución del plugin ‘imageinfo’,
¿Cómo determinar cuál es el perfil correcto? Pues pueden ustedes utilizar el
plugin ‘crashinfo’.
Este plugin les mostrará la información del encabezado del volcado, con otra
serie de datos, como el tipo de volcado o el tiempo que lleva el sistema
iniciado en esa última sesión. Para ejecutar este plugin pueden ustedes
especificar cualquier perfil de los sugeridos por el plugin ‘imageinfo’.
python Volatility/vol.py -f N4RR34N6-20190307-072825.dmp --profile=Win10x64 crashinfo
Si se fijan ustedes en el valor que presenta el
parámetro “Minorversion”, podrán observar que les indica que se trata de una
versión de Windows 10, 17763. Así que el perfil que se utilizará en este caso
es el “--profile=Win10x64_17763”. Entonces, con esta información, ¿Podrían
ustedes comenzar a listar procesos en ejecución? Pueden verlo a continuación.
python Volatility/vol.py -f N4RR34N6-20190307-072825.dmp --profile=Win10x64_17763 pslist
Tal y como pueden ustedes ver en la imagen anterior, a
pesar de indicarle a Volatility el perfil correcto, ha mostrado un error que
indica “Could not list task, please verify your --profile with kdbgscan”,
(No se ha podido listar la tarea, por
favor verifique su --profile con kdbgscan). Esto ocurre porque algunos
plugins de Volatility buscan una serie de valores en la estructura del KDBG,
que es una estructura mantenida por el kernel de Windows y que se usa con fines
de depuración. Es un error común cuando se encuentran varios perfiles sugeridos
o se trabaja con un volcado de memoria de un tamaño elevado. KDBG contiene una
lista de procesos en ejecución y de módulos del núcleo cargados. Así que, deben
usar ustedes el plugin ‘kdbgscan’,
que escanea la cabecera del KDBG para cada perfil disponible y mostrará, entre
otra serie de datos, como el perfil escaneado, información de una dirección de
memoria que deberá ser indicada más tarde. Como ya disponen ustedes de la
versión del sistema, (un Windows 10, 17763), pueden indicarlo cuando ejecuten
el plugin ‘kdbgscan’
para que, únicamente, escanee ese perfil en lugar de todos los disponibles.
Será un proceso más rápido.
python Volatility/vol.py -f N4RR34N6-20190307-072825.dmp --profile=Win10x64_17763 kdbgscan
Cuando este plugin finalice su ejecución, deben
ustedes buscar que el parámetro “Build string (NtBuildLab)” contenga
información. La información que contiene se corresponde con la versión del perfil
del sistema. En este ejemplo, el valor que presenta dicho parámetro es de
“17763.1.amdfre.rs5_release180”. Justo debajo de ese parámetro podrán ver
ustedes otro, que lleva por nombre “PsActiveProcessHead”, que les van a indicar
el número de procesos que se encuentran en ejecución. No puede existir un valor
sin el otro. Es decir, donde haya información de la versión del perfil, deberá
haber información de los procesos en ejecución y esto les llevará a la
dirección KDBG, que se encuentra en el parámetro “KdCopyDataBlock” y que deben
anotar. En este caso, dicha dirección de memoria es “0xf8051f3391b8”.
Es decir. En el caso que les voy a exponer en este
artículo se va a utilizar como base para trabajar con Volatility la línea,
python Volatility/vol.py -f N4RR34N6-20190307-072825.dmp --profile=Win10x64_17763 --kdbg=0xf8051f3391b8
Tengan ustedes en cuenta que esta dirección de memoria
se pueden encontrar en varios perfiles.
python Volatility/vol.py -f N4RR34N6-20190307-072825.dmp kdbgscan | egrep .-B 3 0xf8051f3391b8
Pero ello no significa que puedan usar ustedes
cualquier perfil, con indicación de la dirección de memoria del KDBG, porque se
pueden encontrar ustedes con que un plugin trabaje bien con un perfil correcto
y con un perfil erróneo, pero después se pueden encontrar con que otro plugin
únicamente funcione correctamente con el perfil correcto y no con el erróneo. Y
quizás esto les dé a ustedes algún dolor de cabeza.
python Volatility/vol.py -f N4RR34N6-20190307-072825.dmp --profile=Win10x64_15063 --kdbg=0xf8051f3391b8 pslist | egrep DumpItpython Volatility/vol.py -f N4RR34N6-20190307-072825.dmp --profile=Win10x64_15063 --kdbg=0xf8051f3391b8 timeliner --output=body | egrep DumpItpython Volatility/vol.py -f N4RR34N6-20190307-072825.dmp --profile=Win10x64_17763 --kdbg=0xf8051f3391b8 pslist | egrep DumpItpython Volatility/vol.py -f N4RR34N6-20190307-072825.dmp --profile=Win10x64_17763 --kdbg=0xf8051f3391b8 timeliner --output=body | egrep DumpIt
Identificando un perfil, versión corta
Existe un método más sencillo para identificar
correctamente un perfil de memoria con Volatility, con el que se pueden ahorrar
algunos pasos, pero he creído oportuno explicar un paso a paso para que vean
ustedes cómo se maneja esa información. Tengan en cuenta que, si no identifican un perfil correctamente,
no podrán procesar el volcado de memoria correctamente. Así que es un paso
crítico.
Lo que pueden hacer ustedes es ejecutar directamente
el plugin ‘kdbgscan’, sin ningún parámetro más.
python Volatility/vol.py -f N4RR34N6-20190307-072825.dmp kdbgscan
Basta ver un sólo perfil para poder ver cuál es el
correcto, con la dirección de memoria del KDBG con la que se debe trabajar.
Únicamente deben fijarse en dos parámetros. El primero de ellos es “Build string
(NtBuildLab)” que, como les he dicho anteriormente, contiene la información de
la versión del sistema, (17763.1.amdfre.rs5_release.180). Si ese parámetro de
ese perfil contiene información, tan sólo tienen que desplazarse ocho líneas
más arriba, donde podrán encontrar la dirección de memoria que deben usar junto
a los plugin pertinentes, (0xf8051f3391b8).
Vista la correcta identificación del volcado de
memoria es hora de ir al siguiente nivel.
Antes de comenzar con el análisis, propiamente dicho,
les voy a decir a ustedes que en la
memoria RAM no sólo se graba información relativa a esa última sesión activa.
Y antes de comenzar, quiero que vean ustedes lo que yo veía en pantalla antes
de generar el volcado de memoria.
Carving
Adoro comenzar un análisis de un volcado de memoria
realizando un carving, una recuperación de ficheros en bruto. Del carving se
puede extraer información muy interesante. En lo personal, me es indiferente
usar Foremost,
foremost -t all -i N4RR34N6-20190307-072825.dmp -o Foremost
O Photorec,
sudo photorec N4RR34N6-20190307-072825.dmp
Les voy a explicar este aspecto con un par de claros
ejemplos.
Por ejemplo, pueden ustedes extraer imágenes que han
sido abiertas, o vistas en miniaturas de imágenes que no han sido abiertas, que
simplemente se han previsualizado en una carpeta, o capturas de pantalla que ha
tomado el objetivo y que ni siquiera ha previsualiado.
Pueden ustedes extraer imágenes que se corresponden a
los sitios web que el objetivo ha visitado, aunque no los estuviera
visualizando en el momento de la captura de la memoria.
O, para terminar con estos ejemplos, pueden ustedes
extraer accesos directos, que les dirán qué actividad ha tenido el objetivo,
con nombres de ficheros y rutas completas.
Toda esta realización de carving no les llevará más de
unos minutos y podrán ver contenido, tanto completo como fragmentado, que les
darán pistas, (al igual que las líneas de
tiempo), sobre el tipo de actividad ha llevado a cabo el objetivo de la
investigación. Información que, en algunos tipos de investigaciones, podría ser
objeto de un posterior análisis OSINT, (una
rama muy relacionada al análisis forense en algunos casos).
Procesos
Volatility tiene varias opciones interesantes para la
visualización de procesos en ejecución, terminados, ocultos, …
Así pues, podrían usar ustedes el plugin ‘pslist’,
para realizar un listado de procesos en ejecución, con fechas de comienzo y de
salida, si procede.
python Volatility/vol.py -f N4RR34N6-20190307-072825.dmp --profile=Win10x64_17763 --kdbg=0xf8051f3391b8 pslist
O pueden usar el plugin ‘pstree’
para realizar una visualización en vista de árbol, en un entorno gráfico, donde
se muestra la información de fechas, con procesos padres y procesos hijos.
python Volatility/vol.py -f N4RR34N6-20190307-072825.dmp --profile=Win10x64_17763 --kdbg=0xf8051f3391b8 pstree --output=dot --output-file=pstree.dot
Así, por ejemplo, pueden ustedes ver que el objetivo a
ejecutado, a través del Explorador de Windows, las aplicaciones Outlook,
Keepass, Winword, Telegram, … con sus fechas de ejecución.
Una vez que han visto ustedes los procesos que se
encuentran en el sistema, pueden ver por ejemplo, que se encuentran varias
instancias, (procesos), al navegador
Edge. Una instancia por cada pestaña abierta en el navegador. Estos procesos
los pueden filtrar con egrep para después usar el plugin ‘vaddump’
y extraer el rango de todas las páginas de memoria que se corresponden a esa
lista de procesos.
python Volatility/vol.py -f N4RR34N6-20190307-072825.dmp --profile=Win10x64_17763 --kdbg=0xf8051f3391b8 pslist | egrep Edgepython Volatility/vol.py -f N4RR34N6-20190307-072825.dmp --profile=Win10x64_17763 --kdbg=0xf8051f3391b8 vaddump -p 6268, 7580, 7704, 6364, 7276, 9756, 9900, 10080, 10228, 4636, 10416, 10688, 10912, 11072, 11516, 11880, 12360, 12804, 13040, 1448, 13588, 13772, 6564, 7040 --dump-dir=Edge
Una vez que ha terminado el proceso de extracción de
las páginas de memoria correspondientes a las instancias del navegador Edge,
pueden comenzar ustedes con la búsqueda de información, haciendo uso de egrep y
de strings. Así, por ejemplo, pueden buscar cadenas de texto directamente sobre
el directorio, mediante strings.
strings Edge/MicrosoftEdgeC.23ab41080.0x0000025a71600000-0x0000025a717fffff.dmp | egrep -in “Password|Referer|Date”
Para encontrar credenciales de acceso de algunos
sitios web, en texto plano, con el nombre de usuario, el sitio en cuestión y
algunas marcas de tiempo.
O pueden ustedes extraer las cadenas de texto de ese
directorio para realizar, posteriormente, búsquedas más rápidas, utilizando el
mismo método que anteriormente.
cat Edge.txt | egrep -n --colour=never ‘”ID”: |”Order”: |”Subject”: |”Address”: |”Name”: ‘
Para extraer, por ejemplo, alguna información relativa
a una sesión de un servicio tan seguro como es el servicio de email de
Protonmail. Un servicio en el que me encontraba logueado, sin abrir ningún
correo electrónico.
Incluso pueden ustedes ver el texto de los sitios web
que tenía abiertos el objetivo de la investigación, sin necesidad de que los
tuviera en pantalla.
cat Edge.txt | egrep –i “toolcatalog” | uniqcat Edge.txt | egrep –I “The primary goal” | uniq
Por ejemplo, han podido ver que se encontraba en
ejecución una aplicación tan segura como es Keepass, un gestor de contraseñas
de un uso muy extendido. Bueno. Podrían ustedes intentar extraer la información
haciendo uso de KeeFarce, o podrían,
simplemente, buscar en el directorio oportuno tras extraer su rango de páginas
de memoria, mediante el plugin ‘vaddump’.
egrep –i ‘</KeePassFile>’ KeePass/*strings KeePass/KeePass.exe.276ba5080.0x00000000033b0000-0x000000001b3affff.dmp | egrep -i -B 50 -A 50 '</KeePassFile>'
O, por ejemplo, han podido ver ustedes que el objetivo
tenía en ejecución la aplicación Microsoft Word, por lo que pueden descargar
ese rango de páginas de memoria para buscar, después, el contenido del
documento que tenía abierto.
python volatility/vol.py -f N4RR34N6-20190307-072825.dmp --profile=Win10x64_17763 --kdbg=0xf8051f3391b8 vaddump -p 14172 --dump-dir=Winwordfile Winword/WINWORD.EXE.216b70080.0x00000000135a0000-0x000000001369ffff.dmpstrings Winword/WINWORD.EXE.216b70080.0x00000000135a0000-0x000000001369ffff.dmp | egrep DFIR
Vaddump es un plugin muy potente y de muchísima
utilidad. Un analista puede encontrar información muy interesante mediante este
método, y más teniendo en cuenta los hábitos de algunos usuarios.
Me resulta muy curiosa la manera en la que funciona la
memoria compartida entre procesos. Si ustedes no encuentran algo que están
buscando pueden ustedes, por ejemplo, usar el plugin ‘memdump’,
que es el hermano pequeño de ‘vaddump’
porque realiza la misma función pero sólo extrae todo el contenido a un único
fichero. Y una vez extraído pueden realizar un tipo de búsqueda de un contenido
que, en principio, no tendría que tener relación con las páginas de memoria del
proceso en cuestión.
python Volatility/vol.py -f N4RR34N6-20190307-072825.dmp --profile=Win10x64_17763 --kdbg=0xf8051f3391b8 memdump -p 15260 -D nirsoftstrings nirsoft/15260.dmp | egrep -o "\b[a-zA-Z0-9.-]+@[a-zA-Z0-9.-]+\.[a-zA-Z0-9.-]+\b" | egrep -i 'gmail|protonmail|hotmail' | sort | uniqstrings nirsoft/15260.dmp | egrep -Eo "(http|https|www)://[a-zA-Z0-9./?=_-]*" | egrep -i 'Minion|DFIR|Google|StartPage|Forensic' | sort | uniq
Líneas de tiempo
Ya saben ustedes, porque me gusta decirlo mucho, que las
líneas de tiempo son muy útiles para obtener rápidamente una relación de toda
la actividad. Volatility también dispone de algunos métodos para generar líneas
de tiempo, con algunas opciones en la salida de los ficheros. Pueden ustedes
usar el plugin ‘timeliner’
para generar esa visualización de eventos en orden cronológico.
python Volatility/vol.py -f N4RR34N6-20190307-072825.dmp --profile=Win10x64_17763 --kdbg=0xf8051f3391b8 timeliner --output=body --output-file=timeliner.txtmactime –b timeliner.txt >> Timeline.csvcat Timeline.csv | headcat Timeline.csv | tail
El plugin ‘timeliner’
también permite la generación de líneas de tiempo de un único tipo de
artefactos. Así, por ejemplo, pueden generar una línea de tiempo del Registro o
una línea de tiempo con las marcas de tiempo de los distintos ejecutables.
python Volatility/vol.py -f N4RR34N6-20190307-072825.dmp --profile=Win10x64_17763 --kdbg=0xf8051f3391b8 timeliner --output=body --output-file=timestamp.txt --type=TimeDateStamppython Volatility/vol.py -f N4RR34N6-20190307-072825.dmp --profile=Win10x64_17763 --kdbg=0xf8051f3391b8 timeliner --output=body --output-file=timeline_registry.txt --type=Registry --user=Marcosmactime –b timeline_registry.txt >> Timeline_Registry.csvcat Timeline_Registry.csv | head -n 20cat Timeline_Registry.csv | tail -n 20
En cualquier caso, la salida de ese fichero será una
línea de tiempo que debe ser objeto de estudio y que pueden tratar con mactime
para hacerla legible, e incluso pueden formatear esa línea de tiempo para
realizar una visualización
con Gource.
Registro
Volatility dispone de algunas opciones muy
interesantes para estudiar el Registro del sistema. Para empezar, pueden
ustedes usar el plugin ‘hivelist’
para listar las colmenas del Registro disponibles, con su ruta completa.
python Volatility/vol.py -f N4RR34N6-20190307-072825.dmp --profile=Win10x64_17763 --kdbg=0xf8051f3391b8 hivelist
Una vez que tienen en pantalla las colmenas
disponibles, con su ruta completa y la dirección de memoria, pueden ir
navegando ustedes por ellas, haciendo uso del plugin ‘printkey’,
que les mostrará a ustedes las distintas claves y subclaves, valores y tipos de
datos.
python Volatility/vol.py -f N4RR34N6-20190307-072825.dmp --profile=Win10x64_17763 --kdbg=0xf8051f3391b8 printkey -o 0xffffe681b57ae000python Volatility/vol.py -f N4RR34N6-20190307-072825.dmp --profile=Win10x64_17763 --kdbg=0xf8051f3391b8 printkey -o 0xffffe681b57ae000 -K “Root”
Hasta que encuentren ustedes aquello que estén
buscando como, por ejemplo, dispositivos que el objetivo haya conectado al
sistema, no necesariamente en esa última sesión, estudiando la colmena
Amcache.hve.
python Volatility/vol.py -f N4RR34N6-20190307-072825.dmp --profile=Win10x64_17763 --kdbg=0xf8051f3391b8 printkey -o 0xffffe681b57ae000 -K “Root\InventoryDevicePnp\usbstor/disk&ven_&prod_usb_disk_3.0&rev_pmap/070b59bb1cb22334&0”
Pueden generar ustedes una lista de claves y subclaves
recursiva de cuantas colmenas deseen, siempre que se las muestre el plugin ‘hivelist’,
haciendo uso del plugin ‘hivedump’.
Y si listan varias colmenas, las pueden ustedes unificar a un único fichero.
python Volatility/vol.py -f N4RR34N6-20190307-072825.dmp --profile=Win10x64_17763 --kdbg=0xf8051f3391b8 hivedump -o 0xffffe681af64a000 >> System.csvpython Volatility/vol.py -f N4RR34N6-20190307-072825.dmp --profile=Win10x64_17763 --kdbg=0xf8051f3391b8 hivedump -o 0xffffe681b21e1000 >> Software.csvpython Volatility/vol.py -f N4RR34N6-20190307-072825.dmp --profile=Win10x64_17763 --kdbg=0xf8051f3391b8 hivedump -o 0xffffe681b57ae000 >> Amcache.csvpython Volatility/vol.py -f N4RR34N6-20190307-072825.dmp --profile=Win10x64_17763 --kdbg=0xf8051f3391b8 hivedump -o 0xffffe681b56dd000 >> Usrclass.csvcat *.csv >> Hivedump.csv
De esa forma pueden ustedes estudiar ese listado en
busca de una alguna clave que estén buscando o que les llame la atención y
estudiarla después directamente con el plugin ‘printkey’.
cat Hivedump.csv | headcat Hivedump.csv | tailpython volatility/vol.py -f N4RR34N6-20190307-072825.dmp --profile=Win10x64_17763 --kdbg=0xf8051f3391b8 printkey -K "Microsoft\Windows\CurrentVersion\Authentication\Credential Providers\{D6886603-9D2F-4EB2-B667-1971041FA96B}\S-1-5-21-2873627039-561819860-3666567838-1001\UserNames"
Por último, tienen ustedes también la opción de
utilizar el plugin ‘dumpregistry’,
para volcar todas las colmenas del Registro disponibles en memoria, al disco.
python volatility/vol.py -f N4RR34N6-20190307-072825.dmp --profile=Win10x64_17763 --kdbg=0xf8051f3391b8 dumpregistry -D Registry/
Y este punto es muy interesante porque les va a
permitir a ustedes estudiar el Registro con las herramientas pertinentes, como RegRipper,
de la que hablé en el artículo “¿Registro
de Windows? ¡Prepara la cafetera! Uso de #RegRipper”.
perl rip.pl -r Registry/registry.0xffffe681af64a000.SYSTEM.reg -p mountdevperl rip.pl -r Registry/registry.0xffffe681b21e1000.SOFTWARE.reg -p removdev
Logs de eventos
Disponen ustedes de un par de métodos para extraer y estudiar los ficheros ‘.evtx’ cargados en la memoria de un sistema. El primer método consiste en el uso de evtxtract, que escaneará y extraerá todos los logs de eventos del sistema, desde el primero hasta el último, a un único fichero en formato ‘.xml’.
evtxtract N4RR34N6-20190307-072825.dmp
Otro método que tienen disponible ustedes consiste en
el uso del plugin ‘dumpfiles’,
que permite descargar ficheros almacenados en la cache de la memoria, (ficheros mapeados), especificando con
regex el tipo de fichero que quieren ustedes extraer. Y disponen de varios
métodos para jugar con el plugin ‘dumpfiles’
y regex.
python volatility/vol.py -f N4RR34N6-20190307-072825.dmp --profile=Win10x64_17763 --kdbg=0xf8051f3391b8 dumpfiles --regex=.evtx$ --ignore-case --name --dump-dir evtxpython volatility/vol.py -f N4RR34N6-20190307-072825.dmp --profile=Win10x64_17763 --kdbg=0xf8051f3391b8 dumpfiles -D EVTX/ -r evtx -i -n -S EVTX/Summary.txt
Y de esta forma podrán ustedes comenzar a buscar la
información que deseen como, por ejemplo, las redes a las que el objetivo se ha
conectado, con las fechas de conexión, haciendo uso de la herramienta evtx_dump.
evtx_dump.py EVTX/file.1596.0xffffc306331e1be0.vacb | egrep -i -A 7 -B 15 Movistar
O pueden por ejemplo, buscar ustedes a través un ID de
evento para saber, por ejemplo, qué usuarios tienen asignado unos privilegios
de administración en el sistema, la fecha en la que se generó dicho evento.
evtx_dump.py EVTX/file.1596.0xffffc30632fc6d60.vacb | egrep -i -B 1 -A 31 4672
MFT
La MFT también puede, y debe, ser objeto de una línea
de tiempo, tal y como expliqué en el artículo “Sobre
las líneas de tiempo: El límite, tu imaginación”. Volatility dispone
de un plugin para estudiar este artefacto de Windows. Se trata del plugin ‘mftparser’,
que posee algunas opciones interesantes.
Lo primero que podrían hacer ustedes es generar una línea
de tiempo de la MFT, del mismo modo que se hizo anteriormente con el plugin ‘timeliner’.
De hecho, ambos plugins se pueden combinar provocando una salida a un único
fichero.
python volatility/vol.py -f N4RR34N6-20190307-072825.dmp --profile=Win10x64_17763 --kdbg=0xf8051f3391b8 mftparser --output=body --output-file=mft.txtmactime -b mft.txt >> MFT.csvcat MFT.csv | headcat MFT.csv | tail
Tienen ustedes disponibles varias opciones para jugar
con este plugin. Por ejemplo, pueden ustedes ver ustedes de una manera legible
el contenido de la MFT, extraído a un fichero de texto y, a su vez, descargar
los archivos de datos residentes. En el primer caso podría ser útil para ver
alguna información relativa a ficheros alojados en la MFT.
python volatility/vol.py -f N4RR34N6-20190307-072825.dmp --profile=Win10x64_17763 --kdbg=0xf8051f3391b8 mftparser --output-file=MFTVerbose.txt -D MFT/cat mft_verbose.txt | egrep –colour=never -i -B 2 “NameCh”
O examinar el contenido descargado de esos datos que
se encontraban residentes en la cache de la memoria porque, les aseguro, que se
llevarán más de una grata sorpresa. Por ejemplo, se pueden encontrar con datos
relativos a sitios web que el objetivo a visitado.
egrep fuentesmartinez MFT/*strings MFT/file.0x159250c00.data0.dmp
O pueden ustedes buscar direcciones IP, comenzando por
la IP local del sistema, con información del equipo físico.
egrep IPAddress MFT/*strings MFT/file.0x1e3104c00.data0.dmp
O se podrían encontrar ustedes con algunas imágenes
que les pudieran resultar de interés
file MFT/* egrep “PNG image data, 32 x 32, 8-bit/color RGB, non-interlaced”strings MFT/file.0x4068f7000.data0.dmp
Para terminar con la MFT, también tienen ustedes la
opción de descargar la MFT en bruto, haciendo uso del plugin ‘filescan’,
que lista todos los archivos que se encuentran abiertos, con egrep y del plugin
‘dumpfiles’,
con indicación de la dirección de memoria del fichero MFT.
Actualmente
he tenido problemas para descargar ficheros mediante el plugin ‘dumpfiles’ con
indicación de la dirección de memoria. Pueden ver ustedes el issue en
el sitio correspondiente de GitHub.
Descarga de ficheros cacheados
Volatility dispone de una función muy útil que consiste en la descarga de ficheros cacheados en la memoria. Esta acción, como ya he mencionado anteriormente, se lleva a cabo con el plugin ‘dumpfiles’. Ustedes tienen la opción de descargar todos los ficheros residentes en la memoria, de una sola vez.
python volatility/vol.py -f N4RR34N6-20190307-072825.dmp --profile=Win10x64_17763 --kdbg=0xf8051f3391b8 dumpfiles -S DumpfilesSummary.txt -n -D Dumpfiles
De esta manera, podrían ustedes encontrarse con
algunos logs de algunas aplicaciones que ha usado el objetivo.
egrep -io “Telegram” Dumpfiles/*strings Dumpfiles/file.14868.0xffffc3063a1d2c40.log.txt.vscb
O bien podrían encontrarse con ese documento ofimático
que tenía abierto el objetivo
y que pueden ustedes abrir en un entorno gráfico.
Listado de ficheros abiertos
Como ya les he mencionado anteriormente, pueden ustedes hacer uso del plugin ‘filescan’ para ver qué ficheros tenía abiertos el objetivo. De este modo, pueden ustedes combinar el uso de ese plugin con egrep para buscar tipos de elementos y descargarlos.
python volatility/vol.py -f N4RR34N6-20190307-072825.dmp --profile=Win10x64_17763 --kdbg=0xf8051f3391b8 filescan | egrep -i ‘[.]docx|[.]pst’file Dumpfiles/* | egrep ‘Interview.docx’file Dumpfiles/* | egrep ‘[.]pst’
Tipos de elementos que, una vez descargados, pueden
ustedes estudiar con las herramientas apropiadas. Por ejemplo, en este caso
puede ver algunos ficheros ‘.pst’ que pertenecen a la aplicación Outlook y que
pueden comenzar a estudiar, por ejemplo, con la herramienta readpst.
file PST/*ls -s PST/*readpst -o PST -r PST/*
O pueden buscar otro tipo de artefactos, como los
eventos de rastreo, para proceder a su descarga y estudio, tal y como expliqué
en el artículo “"UserNotPresent",
¿Cuándo entiende Windows que el usuario no está presente?”, para
ver, por ejemplo, qué tipo de actividad ha presentado el sistema del objetivo.
python volatility/vol.py -f N4RR34N6-20190307-072825.dmp --profile=Win10x64_17763 --kdbg=0xf8051f3391b8 filescan | egrep -i '[.]etl'
Cadenas de texto
Si por alguna razón no encuentran ustedes lo que
quieren, quizás puedan recurrir a las cadenas de texto. Primeramente deberán
extraer todo el texto del volcado de memoria y generar la salida a un fichero
de texto. Un fichero de texto que será estudiado mediante cat y egrep. De este
modo, si saben lo que buscan, podrán realizar búsquedas muy precisas, con
información que han podido ver ustedes anteriormente, en alguno de los métodos
descritos.
strings Strings.txt | egrep -i "DFIR Review "strings Strings.txt | egrep -i "Practicing DFIR"strings Strings.txt | egrep -i "[\]Device[\]HarddiskVolume6[\]" | sort | uniqstrings Strings.txt | egrep -i "[\]Device[\]HarddiskVolume4[\].*Marcos.Downloads" | egrep -vi Telegram | sort | uniq
Conclusiones
Esto son solo algunos ejemplos básicos para analizar
un volcado de memoria, porque Volatility tiene mucho más potencial, pero…
Han podido ver ustedes, la memoria contiene una cantidad ingente de información que puede ser perdida si no se captura. Han visto la cantidad de acciones que se pueden llevar a cabo sobre un volcado de memoria, como el carving, la generación de líneas de tiempo, el estudio del Registro, la búsqueda de un determinado evento, la descarga de páginas de memoria con información muy volátil, el listado de ficheros abiertos, la descarga de contenido almacenado en la cache de la memoria… Casi cualquier acción que se pueda llevar a cabo sobre una imagen forense de un disco duro, se puede llevar a cabo sobre un volcado de memoria.
Han podido ver ustedes, la memoria contiene una cantidad ingente de información que puede ser perdida si no se captura. Han visto la cantidad de acciones que se pueden llevar a cabo sobre un volcado de memoria, como el carving, la generación de líneas de tiempo, el estudio del Registro, la búsqueda de un determinado evento, la descarga de páginas de memoria con información muy volátil, el listado de ficheros abiertos, la descarga de contenido almacenado en la cache de la memoria… Casi cualquier acción que se pueda llevar a cabo sobre una imagen forense de un disco duro, se puede llevar a cabo sobre un volcado de memoria.
Han podido ver ustedes que la información que se puede
encontrar en un volcado de memoria es información crítica para la posible
resolución de un caso. Datos que podrían no encontrarse en otros artefactos
dentro del disco duro.
Han podido ver ustedes que no sólo se cachea
información relativa a esa última sesión activa del sistema. Que se almacena
información tanto antigua como reciente, tanto visionada por el objetivo, como
no visionada por el objetivo.
Por todo ello, tal y como les dije a ustedes en el
artículo “Elija
bien su arma. Calcule el impacto.”, la memoria RAM puede, y debe, ser analizada en cualquier caso,
porque lo datos realmente pueden sobrevivir en la memoria un determinado
tiempo. Por ello es también vital actuar con rapidez.
Referencias:
Eso es
todo.
Entradas
No hay comentarios:
Publicar un comentario