Las pruebas que he realizado han sido sobre sistemas Debian y Ubuntu, pero perfectamente sería aplicable para equipos basados en Red Hat, con un par de modificaciones. Lo primero que necesitamos hacer para leer el contenido de la memoria RAM, es realizar un volcado de ésta en un fichero, para luego leer éste a placer. A lo largo del tiempo han habido diferentes métodos para volcar la memoria RAM, pero el más usado a día de hoy es el uso de LiME (Linux Memory Extractor); principalmente debido a que trabaja a nivel de Kernel y puede usarse para realizar un volcado de la memoria RAM de todo sistema que trabaje con un Kernel Linux, incluidos los móviles Android.
Dependiendo de la distribución que tengamos y de la versión de ésta, podemos vernos obligados por instalar LiME a mano, pero generalmente, las últimas versiones de la mayoría de las distribuciones nos permiten instalar la herramienta desde los repositorios; cosa altamente recomendable, ya que el instalarla a mano nos puede dar problemas debido a que suele requerir de ciertas dependencias externas. Para instalar la herramienta desde los repositorios basados en Debian, junto con una serie de dependencias que son importantes tener instaladas, habría que escribir el siguiente comando:
apt-get installmake build-essential lime-forensics-dkms
La instalación es automática y a primera vista, no apreciaremos ningún cambio; es más, no veremos ningún comando que haga referencia a LiME. Esto es debido a que LiMe trabaja como si se tratase de un módulo del Kernel; un módulo que tendría que ser cargado a mano, ya que dicho módulo tiene la función de volcar la memoria, y es un módulo que no funciona de la misma forma que el resto. Aún así vayamos por pasos... ¿Donde se halla dicho módulo? Para no andar volviéndonos locos buscando éste, nuestra mejor opción es recurrir al comando modinfo:
modinfo lime
Gracias a este comando, lograríamos ver la información de dicho módulo, esté o no cargado en el kernel, cosa interesante, ya seas para conocer la ubicación de este módulo como la de cualquier otro. Este módulo en concreto tendría la siguiente ubicación (válida para cualquier Kernel): /lib/modules/$(uname -r)/updates/dkms/lime.ko.
A sabiendas de donde tenemos dicho módulo, tendríamos que cargarlo en el kernel; si bien el método para cargarlo es ligeramente diferente al habitual. La forma para cargar el módulo y, al mismo tiempo, realizar el volcado de la memoria RAM, sería:
insmod /lib/modules/$(uname-r)/updates/dkms/lime.ko "path=/tmp/RAM.lime format=lime"
El proceso tardaría desde unos segundos a varios minutos, dependiendo de la cantidad de RAM a volcar. Es importante tener en cuenta que tras terminar el proceso de volcado, el módulo lime quedaría cargado, pero no estaría continuando volcando memoria; es decir que tras cargar el módulo lime, tendríamos un volcado completo de la RAM.
Si deseasemos optar por un volcado desde un equipo remoto, tendríamos que cargar el módulo de la siguiente forma:
insmod /lib/modules/$(uname-r)/updates/dkms/lime.ko "path=tcp:4444 format=lime"
Para después desde un equipo remoto obtener el volcado de memoria. Imaginemos que hemos realizado el volcado de memoria de esta forma en un equipo con IP: 192.168.1.2; para obtener remotamente dicho volcado, el otro equipo tendría que tener netcat instalado y poder acceder a dicha IP y puerto (4444). Cumpliendo dichos requisitos, desde el otro equipo haríamos:
pastebin 192.168.1.2 4444>/tmp/RAM.lime
Como veis la obtención de la información de la memoria RAM no es difícil, si bien obviamente dicho volcado no es "legible"; es decir que no es un volcado en texto plano, sino que requiere de herramientas especiales que tengan la capacidad de leer la información existente en el archivo. Para este punto la mejor alternativa sería recurrir a la herramienta de lectura de volcados de memoria más famosa en Linux: Volatility.
Esta herramienta es famosa por ser Open Source y estar preparada para leer volcados de memoria extraídos tanto de Windows, Linux y Mac; siendo una herramienta de lo más versátil. Dicha utilidad puede ser descargada desde GitHub, pero al igual que con LiME, yo recomiendo que a ser posible se descargue desde los repositorios, ya que te descarga todas las librerías necesarias para ser plenamente operativa; cosa recomendable para evitarnos posibles problemas. La instalación de esta herramienta es muy sencilla, y debe de ir acompañada de otra utilidad que trabaja estrechamente con ésta, llamada dwardump; con lo que para instalar ambas herramientas juntas haríamos:
apt-get install dwarfdump volatility
Ahora bien, con tener esto instalado no basta; ya que Volatility trabaja con perfiles para leer la memoria; con lo que ésta tiene que tener un perfil que sea compatible con el volcado de memoria que se quiere leer. Un perfil sería un archivo, comprimido en formato zip, que contiene tanto la estructura como la información de un kernel, haciendo que Volatility sepa donde y cómo buscar la información en la RAM; sin dicho perfil Volatility no sabría qué buscar ni donde hacerlo. Volatility incluye perfiles Windows por defecto, pero por desgracia no tiene ni un solo perfil de Linux incluido por defecto con lo que tenemos dos opciones:
- Descargarnos un perfil "preconstruido" desde:
- Crearnos nuestro propio perfil; cosa que generalmente se recomienda, ya que los perfiles que hay online son genéricos y se han creado bajo una versión de kernel y una CPU que no tiene por qué ser compatible con lo que nosotros tenemos.
Es importante tener en cuenta que el perfil tiene que ser del mismo "tipo" que del sistema del que hemos extraído el volcado de memoria, ya que en caso contrario volatility será incapaz de leer el volcado de memoria. Por ejemplo si hemos hecho una extracción desde un Fedora; un perfil Debian no sería válido para leerlo.
En este caso en concreto esa posible incompatibilidad no se va a dar ya que vamos a hacer un perfil propio nosotros mismos y al querer leer una captura de memoria RAM realizada en nuestro propio equipo, la compatibilidad va a ser del 100%.
Para crear el perfil, lo primero que tendremos que hacer será crear un módulo dwarf especialmente diseñado para nuestro sistema. Dicho módulo se encargaría de leer la información del sistema y hacerla legible para la herramienta, y es uno de los componentes del perfil que necesitamos crear para la lectura de la memoria. Para ello haremos lo siguiente:
- cd /usr/src/volatility-tools/linux/
- make
En caso de no habernos dado ningún mensaje de error, debería de haber creado dentro de la carpeta /usr/src/volatility-tools/linux, el fichero module.dwarf.
Ahora que tenemos el fichero creado, es hora de crear nuestro perfil, que se trata de un archivo comprimido que contiene el fichero que hemos creado y nuestro System.map. Dicho perfil se almacena dentro de /usr/lib/python2.7/dist-packages/volatility/plugins/overlays/linux (siempre y cuando lo hayamos instalado desde los repositorios) y para crearlo realizaríamos el siguiente comando:
- zip /usr/lib/python2.7/dist-packages/volatility/plugins/overlays/linux/Perfil.zip \
- /usr/src/volatility-tools/linux/module.dwarf /boot/System.map-$(uname -r)
Con el fichero comprimido alojado en la ubicación correcta, pasaríamos a usar Volatility. Lo primero que deberíamos hace sería mirar que, efectivamente, el perfil está preparado para ser usado. La mejor forma de saberlo sería con el comando de a continuación:
volatility --info|grep Linux
En este caso, veremos un perfil con nombre LinuxDebianx64 en cuya descripción dice claramente el tipo de perfil que es. Si os fijáis bien, el nombre que se ha puesto al perfil no importa (en mi caso he puesto antes como nombre Perfil.zip) ya que lo que le importa a Volatility es el contenido de dicho fichero zip. A sabiendas que tenemos un perfil válido, leeríamos el volcado de memoria, si bien antes de nada hay que tener en cuenta que la sintaxis de Volatility para leer un volcado es la siguiente:
volatility -f fichero.lime --profile nombre_perfil acción
Por ejemplo:
volatility -f/tmp/RAM.lime --profile LinuxDebianx64 linux_bash
Con este comando en concreto lo que haríamos sería obtener el historial de los últimos comandos realizados; una información que a primera vista puede parecer inofensiva, pero que puede ser muy valiosa... Pero no solo podemos obtener el historial; dependiendo de la acción que elijamos podemos obtener datos de lo más curiosos; hay muchísimas acciones pero las más útiles serían:
- linux_pstree: Lista los procesos que estaban corriendo en el sistema cuando se realizó el volcado de la memoria.
- linux_lsmod: Lista los módulos que estaban cargados en el kernel en el momento que se extrajo la memoria.
- linux_netstat: Muy útil; con este se conocen los puertos abiertos en el equipo; una información muy valiosa y al mismo peligrosa.
- linux_arp: Muestra la tabla ARP del equipo del que se ha realizado el volcado... Dicha información puede parecer inofensiva, pero recordad que la tabla ARP muestra la IP y la MAC de los "vecinos" de aquel equipo.
- linux_ifconfig: La RAM también almacena la IP del equipo, con lo que obviamente es una información que puede extraerse de ésta.
Existen muchas más acciones que las que he mencionado, pero estas son mi opinión las más interesantes; ya que ofrecen una información de lo más curiosa... Y valiosa.
Con este artículo no quiero dar a entender que la memoria RAM sea más o menos vulnerable que otros elementos de un equipo, pero sí que creo que es útil conocer lo valiosa que puede resultar como fuente de información dicha memoria; un factor que muchas veces no se tiene en cuenta.
Espero que os haya resultado útil.
Saludos.
Puzzle Bobble
Karate Blazers
Puzzle De Bloques
Magical Cat Adventure