Führen Sie mit diesem Open-Source-Tool eine Linux-Speicherforensik durch

Ein Hinweis zur Vorsicht: Teil 1 beinhaltet das Kompilieren und Laden eines Kernelmoduls. Mach dir keine Sorgen; es ist nicht so schwierig, wie es sich anhört. Einige Richtlinien:

• Folgen Sie den Schritten.
• Probieren Sie keinen dieser Schritte auf einem Produktionssystem oder Ihrem primären Computer aus.
• Verwenden Sie immer eine virtuelle Testmaschine (VM), um Dinge auszuprobieren, bis Sie mit der Verwendung der Tools vertraut sind und verstehen, wie sie funktionieren.

Installieren Sie die erforderlichen Pakete

Bevor Sie beginnen, installieren Sie die erforderlichen Tools. Wenn Sie eine Debian-basierte Distribution verwenden, verwenden Sie das entsprechende apt-get Befehle. Die meisten dieser Pakete bieten die erforderlichen Kernel-Informationen und Tools zum Kompilieren des Codes:

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

Teil 1:Verwenden Sie LiME, um Speicher zu erwerben und ihn in eine Datei auszugeben

Bevor Sie mit der Analyse des Speichers beginnen können, benötigen Sie einen Speicherabzug, der Ihnen zur Verfügung steht. In einem tatsächlichen forensischen Ereignis könnte dies von einem kompromittierten oder gehackten System stammen. Solche Informationen werden oft gesammelt und gespeichert, um zu analysieren, wie das Eindringen passiert ist und welche Auswirkungen es hat. Da Ihnen wahrscheinlich kein Speicherabbild zur Verfügung steht, können Sie ein Speicherabbild Ihrer Test-VM erstellen und damit eine Speicherforensik durchführen.

Linux Memory Extractor (LiME) ist ein beliebtes Tool zum Abrufen von Speicher auf einem Linux-System. Holen Sie sich LiME mit:

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

Erstelle das LiME-Kernelmodul

Führen Sie make aus Befehl innerhalb des src Mappe. Dadurch wird ein Kernelmodul mit der Erweiterung .ko erstellt. Idealerweise die lime.ko Datei wird in das Format lime-<your-kernel-version>.ko umbenannt am Ende von make :

$ make
make -C /lib/modules/4.18.0-240.el8.x86_64/build M="/root/LiME/src" modules
make[1]:Verzeichnis betreten '/usr/src/kernels/4.18.0-240.el8.x86_64'

<
>

make[1]:Verzeichnis verlassen '/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 root root 25696 Apr 17 14:45 lime-4.18.0-240.el8.x86_64.ko
$ 
$ file lime-4.18.0-240.el8.x86_64.ko
 lime-4.18.0-240.el8.x86_64.ko:ELF 64-Bit LSB verschiebbar, x86-64, Version 1 (SYSV), BuildID[sha1]=1d0b5cf932389000d960a7e6b57c428b8e46c9cf, nicht entfernt
$

Laden Sie das LiME-Kernelmodul

Jetzt ist es an der Zeit, das Kernelmodul zu laden, um den Systemspeicher zu erwerben. Der insmod Befehl hilft beim Laden des Kernelmoduls; Sobald es geladen ist, liest das Modul den Primärspeicher (RAM) auf Ihrem System und speichert den Inhalt des Speichers in der Datei, die im path angegeben ist Verzeichnis auf der Kommandozeile. Ein weiterer wichtiger Parameter ist format; Behalten Sie das Format lime bei , Wie nachfolgend dargestellt. Überprüfen Sie nach dem Einfügen des Kernelmoduls, ob es geladen wurde, indem Sie lsmod verwenden Befehl:

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

Sie sollten sehen, dass die Datei path Befehl erstellt wurde und die Dateigröße (nicht überraschend) mit der physischen Speichergröße (RAM) auf Ihrem System identisch ist. Sobald Sie den Speicherauszug haben, können Sie das Kernelmodul mit rmmod entfernen Befehl:

$ 
$ ls -l ~/LiME/RHEL8.3_64bit.mem
-r--r--r--. 1 root root 4294544480 Apr 17 14:47 /root/LiME/RHEL8.3_64bit.mem
$ 
$ du -sh ~/LiME/RHEL8.3_64bit.mem
4.0G    /root/ Lime / RHEL8.3_64bit.Mem 
 $ 
 $ kostenlos 
 Gesamtgesetze kostenlose freigegebene Buff / Cache verfügbar 
 MEM:3736 220 366 8 3149 3259 
 Swap:4059           8        4051
$ 
$ rmmod lime
$ 
$ lsmod  | grep lime
$ 

Was befindet sich im Speicherabbild?

Diese Dump-Datei besteht nur aus Rohdaten, wie Sie anhand der file sehen können Befehl unten. Sie können manuell nicht viel Sinn daraus machen; Ja, da sind irgendwo ASCII-Strings drin, aber man kann die Datei nicht in einem Editor öffnen und auslesen. Die Hexdump-Ausgabe zeigt, dass die ersten paar Bytes EmiL sind; Dies liegt daran, dass Ihr Anfrageformat im obigen Befehl "lime" war:

$ file ~/LiME/RHEL8.3_64bit.mem
/root/LiME/RHEL8.3_64bit.mem:data
$ 


$ hexdump - C ~/LiME/RHEL8.3_64bit.mem | Kopf
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  |........... .....|
$

Teil 2:Holen Sie sich die Volatilität und analysieren Sie damit Ihren Memory Dump

Nachdem Sie nun einen Beispielspeicherauszug zum Analysieren haben, holen Sie sich die Volatility-Software mit dem folgenden Befehl. Volatility wurde in Python 3 neu geschrieben, aber dieses Tutorial verwendet das ursprüngliche Volatility-Paket, das Python 2 verwendet. Wenn Sie mit Volatility 3 experimentieren möchten, laden Sie es aus dem entsprechenden Git-Repository herunter und verwenden Sie in den folgenden Befehlen Python 3 anstelle von Python 2 :

$ 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 verwendet zwei Python-Bibliotheken für einige Funktionen, also installieren Sie sie bitte mit den folgenden Befehlen. Andernfalls werden möglicherweise einige Importfehler angezeigt, wenn Sie das Volatilitätstool ausführen. Sie können sie ignorieren, es sei denn, Sie führen ein Plugin aus, das diese Bibliotheken benötigt. In diesem Fall gibt das Tool folgende Fehlermeldung aus:

$ pip2 installiere pycrypto
$ pip2 installiere distorm3

Listen Sie die Linux-Profile von Volatility auf

Der erste Volatility-Befehl, den Sie ausführen möchten, listet auf, welche Linux-Profile verfügbar sind. Der Haupteinstiegspunkt zum Ausführen von Volatility-Befehlen ist vol.py Skript. Rufen Sie es mit dem Python 2-Interpreter auf und geben Sie --info an Möglichkeit. Um die Ausgabe einzugrenzen, suchen Sie nach Zeichenfolgen, die mit Linux beginnen. Wie Sie sehen können, sind nicht viele Linux-Profile aufgelistet:

$ python2 vol.py --info  | grep ^Linux
Volatility Foundation Volatility Framework 2.6.1
LinuxAMD64PagedMemory          - Linux-spezifischer AMD 64-Bit-Adressraum.
$

Erstellen Sie Ihr eigenes Linux-Profil

Linux-Distributionen sind vielfältig und für verschiedene Architekturen gebaut. Aus diesem Grund sind Profile unerlässlich – Volatility muss das System und die Architektur kennen, von denen der Speicherauszug erfasst wurde, bevor Informationen extrahiert werden. Es gibt Volatilitätsbefehle, um diese Informationen zu finden; diese Methode ist jedoch zeitaufwändig. Um die Dinge zu beschleunigen, erstellen Sie mit den folgenden Befehlen ein benutzerdefiniertes Linux-Profil.

Wechseln Sie zu tools/linux Verzeichnis im Volatility-Repo und führen Sie make aus Befehl:

$ 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/volatility /tools/linux"-Module
make[1]:Verzeichnis '/usr/src/kernels/4.18.0-240.el8.x86_64' betreten
<
>
make[ 1]:Verzeichnis '/usr/src/kernels/4.18.0-240.el8.x86_64' verlassen
$

Sie sollten ein neues module.dwarf sehen Datei. Außerdem benötigen Sie die System.map Datei aus /boot Verzeichnis, da es alle Symbole enthält, die sich auf den aktuell laufenden Kernel beziehen:

$ ls
kcore  Makefile  Makefile.enterprise  module.c  module.dwarf
$ 
$ ls -l module.dwarf 
-rw-r--r--. 1 root root 3987904 Apr 17 15:17 module.dwarf
$ 
$ ls -l /boot/System.map-4.18.0-240.el8.x86_64 
-rw--- ----. 1 root root 4032815 23. September 2020 /boot/System.map-4.18.0-240.el8.x86_64
$ 
$ 

Um ein benutzerdefiniertes Profil zu erstellen, wechseln Sie zurück in das Volatility-Verzeichnis und führen Sie den folgenden Befehl aus. Das erste Argument stellt eine benutzerdefinierte ZIP-Datei mit einem Dateinamen Ihrer Wahl bereit. Ich habe die Betriebssystem- und Kernel-Versionen im Namen verwendet. Das nächste Argument ist module.dwarf oben erstellte Datei, und das letzte Argument ist die System.map Datei aus /boot Verzeichnis:

$ 
$ cd volatility/
$ 
$ zip volatility/plugins/overlays/linux/Redhat8.3_4.18.0-240.zip tools/linux/module.dwarf /boot/ System.map-4.18.0-240.el8.x86_64 
  Hinzufügen:tools/linux/module.dwarf (deflationiert um 91 %)
  Hinzufügen:boot/System.map-4.18.0-240.el8 .x86_64 (deflationiert um 79 %)
$ 

Ihr benutzerdefiniertes Profil ist jetzt fertig, überprüfen Sie also, ob die ZIP-Datei am oben angegebenen Speicherort erstellt wurde. Wenn Sie wissen möchten, ob Volatility dieses benutzerdefinierte Profil erkennt, führen Sie --info aus erneut befehlen. Dieses Mal sollten Sie das unten aufgeführte neue Profil sehen:

$ 
$ ls -l volatility/plugins/overlays/linux/Redhat8.3_4.18.0-240.zip
-rw-r--r--. 1 root root 1190360 Apr 17 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 - Ein Profil für Linux Redhat8.3_4.18.0-240 x64
$ 
$

Beginnen Sie mit Volatility

Jetzt sind Sie bereit, eine tatsächliche Speicherforensik durchzuführen. Denken Sie daran, dass Volatility aus benutzerdefinierten Plugins besteht, die Sie gegen einen Speicherauszug ausführen können, um Informationen zu erhalten. Das allgemeine Format des Befehls ist:

python2 vol.py -f <memory-dump-file-taken-by-Lime> <plugin-name> --profile=<name-of-our-custom-profile> 

Führen Sie mit diesen Informationen das linux_banner aus Plugin, um zu sehen, ob Sie die richtigen Distributionsinformationen aus dem Speicherauszug identifizieren können:

$ 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-Version 4.18.0-240. el8.x86_64 ([email protected]) (gcc-Version 8.3.1 20191121 (Red Hat 8.3.1-5) (GCC)) #1 SMP Mi 23. Sep 05:13:10 EDT 2020
$ 

Linux-Plugins finden

Das hat gut funktioniert, also sind Sie jetzt wahrscheinlich neugierig, wie Sie alle Namen aller Linux-Plugins finden können. Es gibt einen einfachen Trick:Führen Sie --info aus Befehl und grep für linux_ Schnur. Es gibt eine Vielzahl von Plugins für unterschiedliche Zwecke. Hier ist eine unvollständige Liste:

$ python2 vol.py --info  | grep linux_
Volatility Foundation Volatility Framework 2.6.1
linux_apihooks             - Prüft auf Userland-Apihooks
linux_arp                   - Druckt die ARP-Tabelle
linux_aslr_shift           - Automatische Erkennung der Linux-ASLR-Verschiebung

<
>

linux_banner               - Druckt die Linux-Bannerinformationen
linux_vma_cache            - Sammelt VMAs aus dem vm_area_struct-Cache
linux_volshell             - Shell im Speicherabbild
 linux_yarascan             - Eine Shell im Linux-Speicherabbild
$

Überprüfen Sie mit linux_psaux, welche Prozesse auf dem System ausgeführt wurden, als Sie den Speicherauszug erstellt haben Plugin. Beachten Sie den letzten Befehl in der Liste:Es ist der insmod Befehl, den Sie vor dem Dump ausgeführt haben:

 $ Python2 vol.py -f ~ / lime / rael8.3_64bit.mem linux_psaux --profile =linuxredhat8_3_4_18_0-240x64 
 Volatility Fundament Volatility Framework 2.6.1 
 PID UID GID-Argumente 
 1 0 0 / usr / lib / systemd / systemd - switched-root --system --deserialize 18 
 2 0 0 [kthreadd] 
 3 0 0 [RCU_GP] 
 4 0 0 [RCU_PAR_GP] 
 861 0 0 / usr / libexec / plattform-python -es / usr / sbin / tuned -l -p 
 869 0 0 / usr / bin / rhsmcertd 
 875 0 0 /usr/libexec/sssd/sssd_be --domain implicit_files --uid 0 --gid 0 --logger=files
878    0      0      /usr/libexec/sssd/sssd_nss --uid 0 --gid 0 -- logger=Dateien       

 <<
>> 
 
 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 [Kworsteller / 0:3] 
 228573 0 0 insMod ./lime-4.18.0-240.el8.x86_64.ko path =.. / RHEL8.3_64bit.Mem-Format =Kalk 
 228576 0 0 
 $ 

Möchten Sie mehr über die Netzwerkstatistiken des Systems erfahren? Führen Sie linux_netstat aus Plugin, um den Zustand der Netzwerkverbindungen während des Speicherauszugs zu ermitteln:

$ 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           1  systemd/1        systemd/1     
<
>
$

Verwenden Sie als Nächstes den linux_mount Plugin, um zu sehen, welche Dateisysteme während des Speicherauszugs gemountet wurden:

$ 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/cgroup              ro, nosuid, nodev, noexec 
 CGROUP / SYS / FS / CGROUP / PIDS CGROUP RW, RELATIME, NOSUID, NODEV, NOTECEC 
 SystemD-1 / PROC / SYS / FS / BINFMT_MISC Autofs RW, RELATIME 
 SUNRPC / VAR / LIB / NFS / RPC_PIPEFS RPC_PIPEFS RW, RELATIME 
 / dev / capper / rhel_kvm - 03 - Guest11-root / XFS RW, Relativierung 
 TMPFS / DEV / SHM TMPFS RW ,nosuid,nodev                         
selinuxfs                 /sys/fs/selinux                     selinuxfs    rw,relatime                        
<
>

cgroup                    /sys/fs/cgroup/net_cls,net_prio     cgroup       rw,relatime,nosuid,nodev,noexec         
cgroup                   /  /cgroup/sys/fs CPU, CPUACCT CGROUP RW, RELATIME, NOSUID, NODEV, NOEXEC 
 BPF / SYS / FS / BPF BPF RW, Relativ, Nosuid, NODEV, NOEXEC 
 CGROUD / SYS / FS / CGROUP / MEMORY CGROUP RO, Relativier, Nosuid, Nodev, Noexec 
 CGROUP / SYS / FS / CGROUP / CPUSET CGROUP RW, RELATIME, NOSUID, NODEV, NOEEXEC 
 MQUEUE / DEV / MQUEUE MQUEUE RW, RELATIME 
 $  

 Neugierig, welche Kernel-Module geladen wurden? Volatility hat auch dafür ein Plugin mit dem treffenden Namen 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 NFIT 65536 
 FFFFFFFFC0266280 DM_MIRROR 28672 
 FFFFFFFFC025E040 DM_Region_Hash 20480 
 FFFFFFFC0258180 DM_LOG 20480 
 ffffffffc024bbc0 dm_mod 151552
$
 

 Möchten Sie alle Befehle finden, die der Benutzer ausgeführt hat und die im Bash-Verlauf gespeichert wurden? Führen Sie linux_bash aus Plugin:
 
$ 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      Name                 Befehlszeit               
-------- -------------------- ------------------- ----------- -------
  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                 08.04 :38:24 UTC+0000   cat ~/.vimrc 
  227221 bash                 2021-04-17 18:38:24 UTC+0000   ls
  227221 bash                 2021-04-17:1 0000   cat /proc/817/cwd
  227221 bash                 2021-04-17 18:38:24 UTC+0000   ls -l /proc/817/cwd
  227221 bash               1 4-02 :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                 2021-04-17 10:10 ./a.out 
  227298 bash                 2021-04-17 18:40:30 UTC+0000   vim prt.c
  227298 bash                 2021-04-17 18:40:30 UTC gcc 0 prt. 00 c 
  227298 bash                 2021-04-17 18:40:30 UTC+0000   ./a.out 
  227298 bash                 2021-04-17 18:40:30 UTC+0000 / $ ls 
 

 Möchten Sie wissen, welche Dateien von welchen Prozessen geöffnet wurden? Verwenden Sie linux_lsof Plugin, um diese Informationen aufzulisten:
 
$ 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
Offset             Name                                                   Pfad   br /        >------------------------------- ------------------------------ - -------- ------------- /> 0xFFFF9C83FB1E9F40 RSYSLOGD 71194 0 / dev / null 
 0xFFFF9C83F1E9F40 RSYSLOGD 71194 1 / dev / null 
 0xFFF9C83FB1E9F40 RSYSLOGD 71194 2 / dev / null 
 0xFFFF9C83FB1E9F40 RSYSLOGD 71194 3 / dev / urandom 
 0xFFFF9C83FB1E9F40 RSYSLOGD 71194 4 Sockel:[83565] 
 0xFFFF9C83FB1E9F40 RSYSLOGD 71194 5 / var / log / meldungen 
 0xFFFF9C83FB1E9F40 RSYSLOGD 71194        6 anon_inode:[9063]
0xffff9c83fb1e9f40 rsyslogd                          71194        7 /var/log/sec 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 
 $ 
 
Greifen Sie auf den Speicherort der Linux-Plug-in-Skripte zu
 

 Sie können viel mehr Informationen erhalten, indem Sie den Speicherauszug lesen und die Informationen verarbeiten. Wenn Sie Python kennen und neugierig sind, wie diese Informationen verarbeitet wurden, gehen Sie in das Verzeichnis, in dem alle Plugins gespeichert sind, wählen Sie eines aus, das Sie interessiert, und sehen Sie, wie Volatility diese Informationen erhält:
 
 $ ls Volatilität / Plugins / Linux / 
 Apihooks.py common.py kernel_opened_files.py malfind.py psaux.py 
 apihooks.pyc common.pyc kernel_opened_files.pyc malfind.pyc psaux.pyc malfind.pyc psaux.pyc 
 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             lsof .py      m      aps_rb.py     vma_cache.py
check_syscall.pyc        iomem.pyc            lsof.pyc                 proc_maps_rb.pyc    vma_cache.pyc
$ 
$
 

 Ein Grund, warum ich Volatility mag, ist, dass es viele Sicherheits-Plugins bietet. Diese Informationen wären manuell nur schwer zu beschaffen:
 
linux_hidden_modules       - Schnitzt Speicher, um versteckte Kernel-Module zu finden
linux_malfind              - Sucht nach verdächtigen Prozesszuordnungen
linux_truecrypt_passphrase - Stellt zwischengespeicherte Truecrypt-Passphrasen wieder her
 

 Die Volatilität ermöglicht es Ihnen auch, eine Shell innerhalb des Speicherauszugs zu öffnen, sodass Sie, anstatt alle oben genannten Befehle auszuführen, stattdessen Shell-Befehle ausführen können und dieselben Informationen erhalten:
 
$ 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
Aktueller Kontext:systemd verarbeiten, pid=1 DTB=0x1042dc000
Willkommen bei volshell! Das aktuelle Speicherabbild ist:
file:///root/LiME/RHEL8.3_64bit.mem
Um Hilfe zu erhalten, geben Sie 'hh()' ein
>>> 
>>> sc()
Aktueller Kontext:Prozess systemd, pid=1 DTB=0x1042dc000
>>> 
 
Nächste Schritte
 

 Speicherforensik ist eine gute Möglichkeit, mehr über Linux-Interna zu erfahren. Probieren Sie alle Plugins von Volatility aus und studieren Sie ihre Ausgabe im Detail. Denken Sie dann darüber nach, wie diese Informationen Ihnen helfen können, einen Einbruch oder ein Sicherheitsproblem zu identifizieren. Tauchen Sie ein in die Funktionsweise der Plugins und versuchen Sie vielleicht sogar, sie zu verbessern. Und wenn Sie kein Plugin für das gefunden haben, was Sie tun möchten, schreiben Sie eines und reichen Sie es bei Volatility ein, damit andere es auch verwenden können.