Realice análisis forense de memoria de Linux con esta herramienta de código abierto

Una nota de precaución: La Parte 1 consiste en compilar y cargar un módulo del kernel. No te preocupes; no es tan difícil como parece. Algunas pautas:

• Siga los pasos.
• No intente ninguno de estos pasos en un sistema de producción o en su máquina principal.
• Utilice siempre una máquina virtual (VM) de prueba para probar las cosas hasta que se sienta cómodo usando las herramientas y entienda cómo funcionan.

Instalar los paquetes requeridos

Antes de comenzar, instale las herramientas necesarias. Si está usando una distribución basada en Debian, use el equivalente apt-get comandos La mayoría de estos paquetes proporcionan la información y las herramientas necesarias del kernel para compilar el código:

$ yum install kernel-headers kernel-devel gcc elfutils-libelf-devel make git libdwarf-tools python2-devel.x86_64-y 

Parte 1:Use LiME para adquirir memoria y volcarla en un archivo

Antes de que pueda comenzar a analizar la memoria, necesita un volcado de memoria a su disposición. En un evento forense real, esto podría provenir de un sistema comprometido o pirateado. Dicha información a menudo se recopila y almacena para analizar cómo ocurrió la intrusión y su impacto. Dado que probablemente no tenga un volcado de memoria disponible, puede tomar un volcado de memoria de su VM de prueba y usarlo para realizar análisis forense de memoria.

Linux Memory Extractor (LiME) es una herramienta popular para adquirir memoria en un sistema Linux. Obtén LiME con:

$ git clon https://github.com/504ensicsLabs/LiME.git
$
$ cd LiME/src/
$ 
$ ls
desinflar .c  disk.c  hash.c  lime.h  main.c  Makefile  Makefile.sample  tcp.c
$

Construir el módulo del kernel de LiME

Ejecute make comando dentro del src carpeta. Esto crea un módulo de kernel con una extensión .ko. Idealmente, el lime.ko el archivo será renombrado usando el formato lime-<your-kernel-version>.ko al final de make :

$ make
make -C /lib/modules/4.18.0-240.el8.x86_64/build M="/root/LiME/src" módulos
make[1]:Entrando al directorio '/usr/src/kernels/4.18.0-240.el8.x86_64'

<
>

make[1]:Dejando el directorio '/usr/ src/kernels/4.18.0-240.el8.x86_64'
strip --strip-unneeded lime.ko
mv lime.ko lime-4.18.0-240.el8.x86_64.ko
$ 
$ 
$ ls -l lime-4.18.0-240.el8.x86_64.ko
-rw-r--r--. 1 raíz raíz 25696 17 de abril 14:45 lime-4.18.0-240.el8.x86_64.ko
$ 
$ archivo lime-4.18.0-240.el8.x86_64.ko
 lime-4.18.0-240.el8.x86_64.ko:ELF LSB de 64 bits reubicable, x86-64, versión 1 (SYSV), BuildID[sha1]=1d0b5cf932389000d960a7e6b57c428b8e46c9cf, no eliminado
$

Cargar el módulo del kernel de LiME

Ahora es el momento de cargar el módulo del kernel para adquirir la memoria del sistema. El insmod el comando ayuda a cargar el módulo del núcleo; una vez cargado, el módulo lee la memoria principal (RAM) en su sistema y vuelca el contenido de la memoria al archivo provisto en la path directorio en la línea de comando. Otro parámetro importante es format; mantén el formato lime , Como se muestra abajo. Después de insertar el módulo del kernel, verifique que se cargó usando lsmod comando:

$ lsmod  | grep lime
$ 
$ insmod ./lime-4.18.0-240.el8.x86_64.ko "path=../RHEL8.3_64bit.mem format=lime"
$ 
$ lsmod  | grep lima
lima                   16384  0
$

Deberías ver que el archivo dado a la path Se creó el comando y el tamaño del archivo es (como era de esperar) el mismo que el tamaño de la memoria física (RAM) en su sistema. Una vez que tenga el volcado de memoria, puede eliminar el módulo del kernel usando rmmod comando:

$ 
$ ls -l ~/LiME/RHEL8.3_64bit.mem
-r--r--r--. 1 raíz raíz 4294544480 17 de abril 14:47 /root/LiME/RHEL8.3_64bit.mem
$ 
$ du -sh ~/LiME/RHEL8.3_64bit.mem
4.0G    /root/ Lime / rhel8.3_64bit.mem 
 $ 
 $ Free -M 
 Total usado gratis Buff / caché compartido disponible 
 MEM:3736 220 366 8 3149 3259 
 Cambiar:4059           8        4051
$ 
$ rmmod cal
$ 
$ lsmod  | grep lima
$ 

¿Qué hay en el volcado de memoria?

Este archivo de volcado son solo datos sin procesar, como puede ver usando el file comando a continuación. No puede encontrarle mucho sentido manualmente; sí, hay algunas cadenas ASCII en alguna parte, pero no puede abrir el archivo en un editor y leerlo. La salida de hexdump muestra que los pocos bytes iniciales son EmiL; esto se debe a que el formato de su solicitud era "lima" en el comando anterior:

$ archivo ~/LiME/RHEL8.3_64bit.mem
/root/LiME/RHEL8.3_64bit.mem:datos
$ 


$ hexdump - C ~/LiME/RHEL8.3_64bit.mem | cabeza
00000000  45 4d 69 4c 01 00 00 00  00 10 00 00 00 00 00 00  |EMiL............|
00000010  ff fb 09 00 00 00 00 00 00 00 00 00 00 00 00 00  |................|
00000020  b8 fe 4c cd 21 44 00 32  20 00 00 2a 2a 2a 2a 2a  |.. L.!D.2 ..*****|
00000030  2a 2a 2a 2a 2a 2a 2a 2a  2a 2a 2a 2a 2a 2a 2a 2a  |*************** **|
00000040  2a 2a 2a 2a 2a 2a 2a 2a  2a 2a 2a 2a 2a 20 00 20  |************* . |
00000050  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00  |................|
*
00000080 00 00 00 00 00 00 00 00  00 00 00 00 70 78 65 6c  |............pxel|
00000090  69 6e 75 78 2e 30 00 00  00 00 00 00 00 00 00 00  |inux.0..........|
000000a0  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00  |........... .....|
$

Parte 2:obtenga Volatility y utilícelo para analizar su volcado de memoria

Ahora que tiene un volcado de memoria de muestra para analizar, obtenga el software Volatility con el siguiente comando. Volatility se reescribió en Python 3, pero este tutorial usa el paquete Volatility original, que usa Python 2. Si desea experimentar con Volatility 3, descárguelo del repositorio Git apropiado y use Python 3 en lugar de Python 2 en los siguientes comandos :

$ git clone https://github.com/volatilityfoundation/volatility.git
$ 
$ cd volatility/
$ 
$ ls
AUTHORS.txt contrib      LEGAL.txt    Makefile     PKG-INFO     pyinstaller.spec  resources  tools       vol.py
CHANGELOG.txt  CREDITS.txt  LICENSE.txt  MANIFEST.in  pyinstaller  README.txt        setup.py  $volatility
 

 Volatility usa dos bibliotecas de Python para algunas funciones, así que instálelas usando los siguientes comandos. De lo contrario, es posible que vea algunos errores de importación cuando ejecute la herramienta de volatilidad; puede ignorarlos a menos que esté ejecutando un complemento que necesite estas bibliotecas; en ese caso, la herramienta generará un error:
 
$ pip2 instalar pycrypto
$ pip2 instalar distorm3
 
Lista de perfiles de Linux de Volatility
 

 El primer comando Volatility que querrá ejecutar enumera qué perfiles de Linux están disponibles. El principal punto de entrada para ejecutar cualquier comando de volatilidad es vol.py texto. Invóquelo usando el intérprete de Python 2 y proporcione el --info opción. Para limitar la salida, busque cadenas que comiencen con Linux. Como puede ver, no se enumeran muchos perfiles de Linux:
 
$ python2 vol.py --info  | grep ^Linux
Volatility Foundation Volatility Framework 2.6.1
LinuxAMD64PagedMemory          :espacio de direcciones AMD de 64 bits específico de Linux.
$
 
Cree su propio perfil de Linux
 

 Las distribuciones de Linux son variadas y están diseñadas para varias arquitecturas. Esta es la razón por la que los perfiles son esenciales:la volatilidad debe conocer el sistema y la arquitectura de los que se adquirió el volcado de memoria antes de extraer la información. Hay comandos de volatilidad para encontrar esta información; sin embargo, este método requiere mucho tiempo. Para acelerar las cosas, cree un perfil de Linux personalizado con los siguientes comandos.
 

 Vaya a tools/linux directorio dentro del repositorio Volatility y ejecute el make comando:
 
$ cd tools/linux/
$ 
$ pwd
/root/volatility/tools/linux
$ 
$ ls
kcore  Makefile  Makefile .enterprise  module.c
$ 
$ make
make -C //lib/modules/4.18.0-240.el8.x86_64/build CONFIG_DEBUG_INFO=y M="/root/volatilidad /tools/linux" módulos
make[1]:Ingresando al directorio '/usr/src/kernels/4.18.0-240.el8.x86_64'
<
>
make[ 1]:dejando el directorio '/usr/src/kernels/4.18.0-240.el8.x86_64'
$
 

 Debería ver un nuevo module.dwarf expediente. También necesita el System.map archivo desde el /boot directorio, ya que contiene todos los símbolos relacionados con el kernel que se está ejecutando actualmente:
 
$ ls
kcore  Makefile  Makefile.enterprise  module.c  module.dwarf
$ 
$ ls -l module.dwarf 
-rw-r--r--. 1 raíz raíz 3987904 17 de abril 15:17 module.dwarf
$ 
$ ls -l /boot/System.map-4.18.0-240.el8.x86_64 
-rw--- ----. 1 raíz raíz 4032815 23 de septiembre de 2020 /boot/System.map-4.18.0-240.el8.x86_64
$ 
$ 
 

 Para crear un perfil personalizado, vuelva al directorio Volatility y ejecute el siguiente comando. El primer argumento proporciona un .zip personalizado con un nombre de archivo de su elección. Usé el sistema operativo y las versiones del kernel en el nombre. El siguiente argumento es module.dwarf archivo creado anteriormente, y el argumento final es System.map archivo desde el /boot directorio:
 
$ 
$ cd volatilidad/
$ 
$ zip volatilidad/plugins/overlays/linux/Redhat8.3_4.18.0-240.zip tools/linux/module.dwarf /boot/ System.map-4.18.0-240.el8.x86_64 
  agregando:tools/linux/module.dwarf (desinflado 91%)
  agregando:boot/System.map-4.18.0-240.el8 .x86_64 (desinflado 79%)
$ 
 

 Su perfil personalizado ya está listo, así que verifique que el archivo .zip se haya creado en la ubicación indicada anteriormente. Si desea saber si Volatility detecta este perfil personalizado, ejecute --info comando de nuevo. Esta vez, debería ver el nuevo perfil a continuación:
 
$ 
$ ls -l volatility/plugins/overlays/linux/Redhat8.3_4.18.0-240.zip
-rw-r--r--. 1 root root 1190360 17 de abril 15:20 volatility/plugins/overlays/linux/Redhat8.3_4.18.0-240.zip
$ 
$ 
$ python2 vol.py --info  | grep Redhat
Volatility Foundation Volatility Framework 2.6.1
LinuxRedhat8_3_4_18_0-240x64:un perfil para Linux Redhat8.3_4.18.0-240 x64
$ 
$
 
Empieza a usar la volatilidad
 

 Ahora ya está todo listo para hacer un análisis forense real de la memoria. Recuerde, Volatility se compone de complementos personalizados que puede ejecutar en un volcado de memoria para obtener información. El formato general del comando es:
 
python2 vol.py -f <memory-dump-file-taken-by-Lime> <plugin-name> --profile=<name-of-our-custom-profile> 
 

 Armado con esta información, ejecute linux_banner complemento para ver si puede identificar la información de distribución correcta del volcado de memoria:
 
$ python2 vol.py -f ~/LiME/RHEL8.3_64bit.mem linux_banner --profile=LinuxRedhat8_3_4_18_0-240x64
Volatility Foundation Volatility Framework 2.6.1
Linux versión 4.18.0-240. el8.x86_64 ([email protected]) (gcc versión 8.3.1 20191121 (Red Hat 8.3.1-5) (GCC)) #1 SMP miércoles 23 de septiembre 05:13:10 EDT 2020
$ 
 
Buscar complementos de Linux
 

 Eso funcionó bien, por lo que ahora probablemente tenga curiosidad sobre cómo encontrar todos los nombres de todos los complementos de Linux. Hay un truco fácil:ejecute --info comando y grep para linux_ cuerda. Hay una variedad de complementos disponibles para diferentes usos. Aquí hay una lista parcial:
 
$ python2 vol.py --info  | grep linux_
Volatility Foundation Volatility Framework 2.6.1
linux_apihooks             - Comprueba si hay apihooks de usuario
linux_arp                  - Imprime la tabla ARP
linux_aslr_shift           - Detecta automáticamente el cambio ASLR de Linux

<
>

linux_banner               - Imprime la información del banner de Linux
linux_vma_cache             - Recopila los VMA de la memoria caché vm_area_struct
linux_volshell             - Shell en la imagen de memoria
 linux_yarascan             - Un shell en la imagen de memoria de Linux
$
 

 Verifique qué procesos se estaban ejecutando en el sistema cuando realizó el volcado de memoria usando linux_psaux enchufar. Observe el último comando en la lista:es el insmod comando que ejecutó antes del volcado:
 
 $ python2 vol.py -f ~ / lime / rhel8.3_64bit.mem linux_psaux --profile =linuxredhat8_3_4_18_0-240x64 
 Marco de volatilidad de la Fundación de volatilidad 2.6.1 
 PID uid gid argumentos 
 1 0 0 / USR / LIB / Systemd / Systemd --Sswitched-root --system --deserialize 18 
 2 0 0 [kthreadd] 
 3 0 0 [rcu_gp] 
 4 0 0 [RCU_PAR_GP] 
 861 0 0 / USR / LIBEXEC / Plataforma-Python -es / USR / SBIN / SUNED -L -P 
 869 0 0 / usr / bin / rhsmcertd 
 875 0 0 /usr/libexec/sssd/sssd_be --dominio archivos_implícitos --uid 0 --gid 0 --logger=archivos
878    0      0      /usr/libexec/sssd/sssd_nss --uid 0 --gid 0 -- registrador=archivos       

 <<<<<<<<>> 
 
 11064 89 89 QMGR -L -T UNIX -U 
 227148 0 0 [KWORKER / 0:0] 
 227298 0 0 - bash 
 227374 0 0 [kworker / u2:1] 
 227375 0 0 [kworker / 0:2] 
 227884 0 0 [kworker / 0:3] 
 228573 0 0 insmod ./lime-4.18.0-240.el8.x86_64.ko ruta =.. / rhel8.3_64bit.mem Format =Lime 
 228576 0 
 $ 
 

 ¿Quiere saber acerca de las estadísticas de red del sistema? Ejecute linux_netstat complemento para encontrar el estado de las conexiones de red durante el volcado de memoria:
 
$ python2 vol.py -f ~/LiME/RHEL8.3_64bit.mem linux_netstat --profile=LinuxRedhat8_3_4_18_0-240x64
Volatility Foundation Volatility Framework 2.6.1
UNIX 18113              systemd/1     /run/ systemd/private
UNIX 11411              systemd/1     /run/systemd/notify
UNIX 11413              systemd/1     /run/systemd/cgroups-agent
UNIX 11415              systemd  UNI X6 systemd/1     
<>
$
 

 A continuación, utilice el linux_mount complemento para ver qué sistemas de archivos se montaron durante el volcado de memoria:
 
$ python2 vol.py -f ~/LiME/RHEL8.3_64bit.mem linux_mount --profile=LinuxRedhat8_3_4_18_0-240x64
Volatility Foundation Volatility Framework 2.6.1
tmpfs                     /sys/fs/c                                                                                                                                    RO, NOSUID, NOVE, NOEXEC 
 CGROUP / SYS / SYS / FS / CGROUP / PIDS CGROUP RW, RELATIMA, NOSUID, NOVE, NOEXEC 
 SystemD-1 / PROC / SYSION-1 / PROC / SYS / FS / BINFMT_MISM AUTOFS RW, RELATIME 
 SUNRPC / VAR / LIB / NFS / RPC_PIPEFS RPC_PIPEFS RW, RELATIMO 
 / DEV / MAPPER / RHEL_KVM - 03 - Guest11-root / xfs rw, relatime 
 tmpfs / dev / shm tmpfs rw Nosuid,nodev 
<
>

cgroup                    /sys/fs/cgroup/net_cls,net_prio     cgroup       rw,relatime,nosuid,nodev,noexec         
cgroup                    /group/sys CPU, CPUACCT CGROUP RW, RELATIMA, NOSUID, NOVEV, NOEXEC 
 BPF / SYS / FS / BPF BPF RW, RELATIMA, NOSUID, NOVEB, NOEXEC 
 CGROUP / SYS / FS / CGROUP / MEMORY CGROUP RO, Relatime, Nosuid, Nodov, NOEXEC 
 CGROUP / SYS / FS / CGROUP / CPUSTET CGROUP RW, RELATIMO, NOSUID, NOVE, NOEXEC 
 MQUEUE / DEV / MQUEUE MQUEUE RW, RELATIME 
 $ 
 

 ¿Tiene curiosidad por saber qué módulos del kernel se cargaron? Volatility también tiene un complemento para eso, acertadamente llamado linux_lsmod :
 
$ python2 vol.py -f ~/LiME/RHEL8.3_64bit.mem linux_lsmod --profile=LinuxRedhat8_3_4_18_0-240x64
Volatility Foundation Volatility Framework 2.6.1
ffffffffc0535040 lime 20480
ffffffffc0530540 binfmt_misc 20480 
 ffffffffc05e8040 sunrpc 479232 
 <
> 
 ffffffffc04f9540 nfits 65536 
 ffffffffc0266280 dm_mirror 28672 
 ffffffffc025e040 dm_region_hash 20480 
 FFFFFFFFC0258180 DM_LOG 20480 
 ffffffffc024bbc0 dm_mod 151552
$
 

 ¿Quiere encontrar todos los comandos que ejecutó el usuario que estaban almacenados en el historial de Bash? Ejecute linux_bash complemento:
 
$ python2 vol.py -f ~/LiME/RHEL8.3_64bit.mem linux_bash --profile=LinuxRedhat8_3_4_18_0-240x64 -v
Volatility Foundation Volatility Framework 2.6.1
Pid      Nombre                 Hora del comando             Comando   
-------- -------------------- ------------------- ----------- -------
  227221 bash                 2021-04-17 18:38:24 UTC+0000   lsmod 
  227221 bash                 2021-04-17 18 :38:24 UTC+0000   rm -f .log
  227221 bash                 2021-04-17 18:38:24 UTC+0000   ls -l /etc/zzz 
  227221 bash                 4-2021 :38:24 UTC+0000   cat ~/.vimrc 
  227221 bash                 2021-04-17 18:38:24 UTC+0000   ls
  227221 bash                 2021-04:+18:23 UTC 0000   cat /proc/817/cwd
  227221 bash                 2021-04-17 18:38:24 UTC+0000   ls -l /proc/817/cwd
  227221 bash                 4-2028 :24 UTC+0000   ls /proc/817/
<>
  227298 bash                 2021-04-17 18 :40:30 UTC+0000   gcc prt.c 
  227298 bash                 2021-04-17 18:40:30 UTC+0000   ls
  227298 bash                 0 2021-08:40-17 30 UTC:+04-17 ./a.out 
  227298 bash                 2021-04-17 18:40:30 UTC+0000   vim prt.c
  227298 bash                 2021-04-17 18:40:30 UTC g0cc0 prt. c 
  227298 bash                 2021-04-17 18:40:30 UTC+0000   ./a.out 
  227298 bash                 2021-04-17 18:40:30 UTC+0000$
 l 
 

 ¿Quiere saber qué archivos fueron abiertos por qué procesos? Usa el linux_lsof complemento para listar esa información:
 
$ python2 vol.py -f ~/LiME/RHEL8.3_64bit.mem linux_lsof --profile=LinuxRedhat8_3_4_18_0-240x64
Volatility Foundation Volatility Framework 2.6.1
Compensación             Nombre                                                                                >------------------------ ------------------------------ - ------- -------- ---- 
 0xfffff9c83fb1e9f40 rsyslogd 71194 0 / dev / null 
 0xffff9c83fb1e9f40 rsyslogd 71194 1 / dev / null 
 0xfffff9c83fb1e9f40 rsyslogd 71194 2 / dev / null 
 0xffff9c83fb1e9f40 rsyslogd 71194 3 / dev / urandom 
 0xfff9c83fb1e9f40 rsyslogd 71194 4 socket:[83565] 
 0xffff9c83fb1e9f40 rsyslogd 71194 5 / var / log / mensajes 
 0xffff9c83fb1e9f40 rsyslogd 71194        6 anon_inode:[9063]
0xffff9c83fb1e9f40 rsyslogd                          71194        7 /var/log/seg ure 
 
 <
> 
 
 0xffff9c8365761f40 insmod 228573 0 / dev / pts / 0 
 0xffff9c8365761f40 insmod 228573 1 / dev / pts / 0 
 0xffff9c8365761f40 insmod 228573 2 / dev / pts / 0 
 0xffff9c8365761f40 insmod 228573 3 /root/lime/src/lime-4.18.0-240.el8.x86_64.ko 
 $ 
 
Acceda a la ubicación de los scripts de complementos de Linux
 

 Puede obtener mucha más información leyendo el volcado de memoria y procesando la información. Si conoce Python y tiene curiosidad sobre cómo se procesó esta información, vaya al directorio donde se almacenan todos los complementos, elija uno que le interese y vea cómo Volatility obtiene esta información:
 
 $ ls volatilidad / complementos / linux / 
 apihooks.py common.py kernel_oplened_files.py malfind.py psaux.py 
 apihooks.pyc common.pyc kernel_oplened_files.pyc malfind.pyc psaux.pyc 
Arp.py cpuinfo.py keyboard_notifiers.py mount_cache.py psenv.py 
 arp.pyc cpuinfo.pyc keyboard_notifiers.pyc mount_cache.pyc psenv.pyc 
 aslr_shift.py dentry_cache.py ld_env.py mount.py pslist_cache.py 
 aslr_shift.pyc dentry_cache.pyc ld_env.pyc mount.pyc pslist_cache.pyc 
 <
> 
 check_syscall_arm.py __init__.py lsmod.py proc_maps.py tty_check.py
check_syscall_arm.pyc    __init__.pyc         lsmod.pyc                proc_maps.pyc       tty_check.pyc
check_syscall.py         iomem.py                  proc_ aps_rb.py     vma_cache.py
check_syscall.pyc        iomem.pyc            lsof.pyc                 proc_maps_rb.pyc    vma_cache.pyc
$ 
$
 

 Una de las razones por las que me gusta Volatility es que proporciona muchos complementos de seguridad. Esta información sería difícil de adquirir manualmente:
 
linux_hidden_modules       - Extrae la memoria para encontrar módulos ocultos del kernel
linux_malfind              - Busca mapeos de procesos sospechosos
linux_truecrypt_passphrase - Recupera frases de contraseña de Truecrypt almacenadas en caché
 

 La volatilidad también le permite abrir un shell dentro del volcado de memoria, por lo que en lugar de ejecutar todos los comandos anteriores, puede ejecutar comandos de shell y obtener la misma información:
 
$ python2 vol.py -f ~/LiME/RHEL8.3_64bit.mem linux_volshell --profile=LinuxRedhat8_3_4_18_0-240x64 -v
Volatility Foundation Volatility Framework 2.6.1
Contexto actual:proceso systemd, pid=1 DTB=0x1042dc000
¡Bienvenido a volshell! La imagen de memoria actual es:
file:///root/LiME/RHEL8.3_64bit.mem
Para obtener ayuda, escriba 'hh()'
>>> 
>>> sc()
Contexto actual:proceso systemd, pid=1 DTB=0x1042dc000
>>> 
 
Siguientes pasos
 

 El análisis forense de la memoria es una buena manera de aprender más sobre las funciones internas de Linux. Pruebe todos los complementos de Volatility y estudie sus resultados en detalle. Luego, piense en las formas en que esta información puede ayudarlo a identificar una intrusión o un problema de seguridad. Sumérjase en cómo funcionan los complementos, y tal vez incluso intente mejorarlos. Y si no encontró un complemento para lo que quiere hacer, escriba uno y envíelo a Volatility para que otros también puedan usarlo.