Le système d'exploitation et les applications d'un ordinateur utilisent la mémoire principale (ou RAM) pour effectuer diverses tâches. Cette mémoire volatile, contenant une mine d'informations sur les applications en cours d'exécution, les connexions réseau, les modules du noyau, les fichiers ouverts et à peu près tout le reste, est effacée à chaque redémarrage de l'ordinateur.
Plus de ressources Linux
- Aide-mémoire des commandes Linux
- Aide-mémoire des commandes Linux avancées
- Cours en ligne gratuit :Présentation technique de RHEL
- Aide-mémoire sur le réseau Linux
- Aide-mémoire SELinux
- Aide-mémoire sur les commandes courantes de Linux
- Que sont les conteneurs Linux ?
- Nos derniers articles Linux
La criminalistique de la mémoire est un moyen de trouver et d'extraire ces précieuses informations de la mémoire. Volatility est un outil open source qui utilise des plugins pour traiter ce type d'informations. Cependant, il y a un problème :avant de pouvoir traiter ces informations, vous devez vider la mémoire physique dans un fichier, et Volatility n'a pas cette capacité.
Par conséquent, cet article comporte deux parties :
- La première partie traite de l'acquisition de la mémoire physique et de son vidage dans un fichier.
- La deuxième partie utilise Volatility pour lire et traiter les informations de ce vidage mémoire.
J'ai utilisé le système de test suivant pour ce tutoriel, mais il fonctionnera sur n'importe quelle distribution Linux :
$ cat /etc/redhat-release
Red Hat Enterprise Linux version 8.3 (Ootpa)
$
$ uname -r
4.18.0-240.el8.x86_64
$
Avertissement : La partie 1 implique la compilation et le chargement d'un module noyau. Ne vous inquiétez pas; ce n'est pas aussi difficile qu'il y paraît. Quelques lignes directrices :
- Suivez les étapes.
- N'essayez aucune de ces étapes sur un système de production ou sur votre ordinateur principal.
- Utilisez toujours une machine virtuelle (VM) de test pour essayer les choses jusqu'à ce que vous soyez à l'aise avec les outils et que vous compreniez leur fonctionnement.
Installer les packages requis
Avant de commencer, installez les outils requis. Si vous utilisez une distribution basée sur Debian, utilisez l'équivalent apt-get commandes. La plupart de ces packages fournissent les informations et les outils nécessaires au noyau pour compiler le code :
$ yum install kernel-headers kernel-devel gcc elfutils-libelf-devel make git libdwarf-tools python2-devel.x86_64-y Partie 1 :Utiliser LiME pour acquérir de la mémoire et la vider dans un fichier
Avant de pouvoir commencer à analyser la mémoire, vous avez besoin d'un vidage mémoire à votre disposition. Dans un événement médico-légal réel, cela pourrait provenir d'un système compromis ou piraté. Ces informations sont souvent collectées et stockées pour analyser comment l'intrusion s'est produite et son impact. Étant donné que vous n'avez probablement pas de vidage de mémoire disponible, vous pouvez effectuer un vidage de mémoire de votre machine virtuelle de test et l'utiliser pour effectuer des analyses de mémoire.
Linux Memory Extractor (LiME) est un outil populaire pour acquérir de la mémoire sur un système Linux. Obtenez LiME avec :
$ 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
$
Créer le module du noyau LiME
Exécutez le make commande à l'intérieur du src dossier. Cela crée un module de noyau avec une extension .ko. Idéalement, le lime.ko le fichier sera renommé au format lime-<your-kernel-version>.ko à la fin de make :
$ make
make -C /lib/modules/4.18.0-240.el8.x86_64/build M="/root/LiME/src" modules
make[1] :Entrer dans le répertoire '/usr/src/kernels/4.18.0-240.el8.x86_64'
<>
make[1] :Départ du répertoire '/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 racine racine 25696 17 avril 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 bits LSB déplaçable, x86-64, version 1 (SYSV), BuildID[sha1]=1d0b5cf932389000d960a7e6b57c428b8e46c9cf, non supprimé
$
Charger le module du noyau LiME
Il est maintenant temps de charger le module du noyau pour acquérir la mémoire système. Le insmod la commande aide à charger le module du noyau ; une fois chargé, le module lit la mémoire primaire (RAM) de votre système et vide le contenu de la mémoire dans le fichier fourni dans le path répertoire sur la ligne de commande. Un autre paramètre important est le format; conserver le format lime , comme indiqué ci-dessous. Après avoir inséré le module du noyau, vérifiez qu'il a été chargé à l'aide de lsmod commande :
$ lsmod | grep lime
$
$ insmod ./lime-4.18.0-240.el8.x86_64.ko "path=../RHEL8.3_64bit.mem format=lime"
$
$ lsmod | grep citron vert
citron vert 16384 0
$
Vous devriez voir que le fichier donné au path La commande a été créée et la taille du fichier est (sans surprise) la même que la taille de la mémoire physique (RAM) de votre système. Une fois que vous avez le vidage de la mémoire, vous pouvez supprimer le module du noyau en utilisant le rmmod commande :
$
$ ls -l ~/LiME/RHEL8.3_64bit.mem
-r--r--r--. 1 racine racine 4294544480 17 avril 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
TAX TOTAL utilisé Buff / CACHE APPLIQUÉ
MEM:3736 220 366 8 3149 3259
Swap:4059 8 4051
$
$ rmmod citron vert
$
$ lsmod | grep lime
$
Qu'y a-t-il dans le vidage mémoire ?
Ce fichier de vidage n'est que des données brutes, comme vous pouvez le voir en utilisant le file commande ci-dessous. Vous ne pouvez pas en tirer beaucoup de sens manuellement; oui, il y a des chaînes ASCII quelque part, mais vous ne pouvez pas ouvrir le fichier dans un éditeur et le lire. La sortie hexdump montre que les premiers octets sont EmiL; c'est parce que le format de votre requête était "lime" dans la commande ci-dessus :
$ fichier ~/LiME/RHEL8.3_64bit.mem
/root/LiME/RHEL8.3_64bit.mem :données
$
$ hexdump - C ~/LiME/RHEL8.3_64bit.mem | tête
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 |........... .....|
$
Partie 2 :Obtenez Volatility et utilisez-le pour analyser votre vidage mémoire
Maintenant que vous avez un exemple de vidage mémoire à analyser, obtenez le logiciel Volatility avec la commande ci-dessous. Volatility a été réécrit en Python 3, mais ce didacticiel utilise le package Volatility d'origine, qui utilise Python 2. Si vous souhaitez expérimenter Volatility 3, téléchargez-le à partir du dépôt Git approprié et utilisez Python 3 au lieu de Python 2 dans les commandes suivantes. :
$ git clone https://github.com/volatilityfoundation/volatility.git
$
$ cd volatilité/
$
$ 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 volatilité
$
Volatility utilise deux bibliothèques Python pour certaines fonctionnalités, veuillez donc les installer à l'aide des commandes suivantes. Sinon, vous risquez de rencontrer des erreurs d'importation lorsque vous exécutez l'outil Volatilité ; vous pouvez les ignorer à moins que vous n'exécutiez un plugin qui a besoin de ces bibliothèques ; dans ce cas, l'outil affichera une erreur :
$ pip2 install pycrypto
$ pip2 install distorm3
Liste des profils Linux de Volatility
La première commande Volatility que vous voudrez exécuter répertorie les profils Linux disponibles. Le principal point d'entrée pour exécuter toutes les commandes Volatility est le vol.py scénario. Invoquez-le à l'aide de l'interpréteur Python 2 et fournissez le --info option. Pour affiner la sortie, recherchez les chaînes commençant par Linux. Comme vous pouvez le constater, peu de profils Linux sont répertoriés :
$ python2 vol.py --info | grep ^Linux
Volatility Foundation Volatility Framework 2.6.1
LinuxAMD64PagedMemory - Espace d'adressage AMD 64 bits spécifique à Linux.
$
Créez votre propre profil Linux
Les distributions Linux sont variées et conçues pour diverses architectures. C'est pourquoi les profils sont essentiels - Volatility doit connaître le système et l'architecture à partir desquels le vidage de la mémoire a été acquis avant d'extraire des informations. Il existe des commandes de volatilité pour trouver ces informations ; cependant, cette méthode prend du temps. Pour accélérer les choses, créez un profil Linux personnalisé à l'aide des commandes suivantes.
Déplacez-vous vers tools/linux répertoire dans le référentiel Volatility et exécutez le make commande :
$ 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" modules
make[1] :Entrer dans le répertoire '/usr/src/kernels/4.18.0-240.el8.x86_64'
<>
make[ 1] :Départ du répertoire '/usr/src/kernels/4.18.0-240.el8.x86_64'
$
Vous devriez voir un nouveau module.dwarf dossier. Vous avez également besoin du System.map fichier de /boot répertoire, car il contient tous les symboles liés au noyau en cours d'exécution :
$ ls
kcore Makefile Makefile.enterprise module.c module.dwarf
$
$ ls -l module.dwarf
-rw-r--r--. 1 racine racine 3987904 17 avril 15:17 module.dwarf
$
$ ls -l /boot/System.map-4.18.0-240.el8.x86_64
-rw--- ----. 1 racine racine 4032815 23 septembre 2020 /boot/System.map-4.18.0-240.el8.x86_64
$
$
Pour créer un profil personnalisé, revenez au répertoire Volatility et exécutez la commande ci-dessous. Le premier argument fournit un .zip personnalisé avec un nom de fichier de votre choix. J'ai utilisé les versions du système d'exploitation et du noyau dans le nom. Le prochain argument est le module.dwarf fichier créé ci-dessus, et l'argument final est le System.map fichier de /boot répertoire :
$
$ cd volatilité/
$
$ zip volatilité/plugins/overlays/linux/Redhat8.3_4.18.0-240.zip tools/linux/module.dwarf /boot/ System.map-4.18.0-240.el8.x86_64
ajout :tools/linux/module.dwarf (dégonflé à 91 %)
ajout :boot/System.map-4.18.0-240.el8 .x86_64 (dégonflé à 79 %)
$
Votre profil personnalisé est maintenant prêt, alors vérifiez que le fichier .zip a été créé à l'emplacement indiqué ci-dessus. Si vous voulez savoir si Volatility détecte ce profil personnalisé, exécutez le --info commander à nouveau. Cette fois, vous devriez voir le nouveau profil listé ci-dessous :
$
$ ls -l volatilité/plugins/overlays/linux/Redhat8.3_4.18.0-240.zip
-rw-r--r--. 1 racine racine 1190360 17 avril 15:20 volatilité/plugins/overlays/linux/Redhat8.3_4.18.0-240.zip
$
$
$ python2 vol.py --info | grep Redhat
Framework de volatilité Volatility Foundation 2.6.1
LinuxRedhat8_3_4_18_0-240x64 - Un profil pour Linux Redhat8.3_4.18.0-240 x64
$
$
Commencer à utiliser la volatilité
Vous êtes maintenant prêt à faire de l'investigation de la mémoire. N'oubliez pas que Volatility est composé de plugins personnalisés que vous pouvez exécuter sur un vidage de mémoire pour obtenir des informations. Le format général de la commande est :
python2 vol.py -f <memory-dump-file-taken-by-Lime> <plugin-name> --profile=<name-of-our-custom-profile> Armé de ces informations, exécutez le linux_banner plugin pour voir si vous pouvez identifier les informations de distribution correctes à partir du vidage mémoire :
$ 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 Wed Sep 23 05:13:10 EDT 2020
$
Rechercher des plugins Linux
Cela a bien fonctionné, alors maintenant vous êtes probablement curieux de savoir comment trouver tous les noms de tous les plugins Linux. Il existe une astuce simple :exécutez le --info commande et grep pour linux_ corde. Il existe une variété de plugins disponibles pour différentes utilisations. Voici une liste partielle :
$ python2 vol.py --info | grep linux_
Volatility Foundation Volatility Framework 2.6.1
linux_apihooks - Vérifie les apihooks de l'espace utilisateur
linux_arp - Imprime la table ARP
linux_aslr_shift - Détecte automatiquement />br />< >
linux_banner - Imprime les informations de la bannière Linux
linux_vma_cache - Rassemble les VMA à partir du cache vm_area_struct
linux_volshell - Shell dans l'image mémoire
linux_yarascan - Un shell dans l'image mémoire Linux
$
Vérifiez quels processus étaient en cours d'exécution sur le système lorsque vous avez effectué le vidage de la mémoire à l'aide de linux_psaux brancher. Remarquez la dernière commande de la liste :c'est le insmod commande que vous avez exécutée avant le vidage :
$ python2 vol.py -f ~ / lime / rhel8.3_644bit.mem linux_psaux --profile =linuxredhat8_3_4_18_0-240x64
Fonds de volatilité de la volatilité 2.6.1
PID UID GID Arguments
1 0 0 / USR / LIB / SYSTEMD / SYSTEMD - Foncteur-racine --System --Deserialize 18
2 0 0 [kthreadd]
3 0 0 [RCU_GP]
4 0 0 0 0 [rcu_par_gp]
861 0 0 / usr / libexec / plateforme-python -es / usr / sbin / à réglage -l -l -p 869 0 0 / usr / bin / rhsmcertd
875 0 0 /usr/libexec/sssd/sssd_be --domain implicite_files --uid 0 --gid 0 --logger=fichiers
878 0 0 /usr/libexec/sssd/sssd_nss --uid 0 --gid 0 -- logger=fichiers
<<>>
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 chemin =.. / rhel8.3_64bit.mem Format =citron vert /> 228576 0 0
$
Vous voulez connaître les statistiques réseau du système ? Exécutez le linux_netstat plugin pour trouver l'état des connexions réseau lors du vidage mémoire :
$ 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/privé
UNIX 11411 systemd/1 /run/systemd/notify
UNIX 11413 systemd/1 /run/systemd/cgroups-agent
UNIX 11415 systemd/1 systemd/1
<>
$
Ensuite, utilisez le linux_mount plugin pour voir quels systèmes de fichiers ont été montés lors du vidage de la mémoire :
$ 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, NOEXEC
SystemD-1 / ProC / SYS / FS / BINFMT_MISC AUTOFS RW, Relatime
SUNRPC / VAR / LIB / NFS / RPC_PIPIPIPIPESFS RPC_PIPIPESFS RW, Relatima
/ MAPPER / RHEL_KVM - 03 - Guest11-Root / XFS RW, relatime
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 /sys/fs/cgroup/ CPU, CPuacct Cgroup RW, relatime, Nosuid, NODEV, NOEXEC
BPF / SYS / FS / BPF BPF RW, relatime, NOEID, NODEV, NOEXEC
CGROUP / SYS / FS / CGROUP / mémoire CGROUP RO, relatime, Nosuid, NODEV, NOEXEC
CGROUP / SYS / FS / CGROUP / CPUSET CGROUP RW, relatime, NOEUID, NODEV, NOEXEC
MONUE / DEV / MONUE MONUE RW, Relatima
$Curieux de savoir quels modules du noyau ont été chargés ? Volatility a également un plugin pour cela, bien nommé 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
FFFFFFFC05E8040 SUNRPFC 479232
<>>
FFFFFFC04F9540 NFIT 65536
FFFFFFFC0266280 DM_MIRROR 28672
FFFFFFFC025E040 DM_REGIVE_HASH 20480
FFFFFFFC0258180 DM_LOG 20480
ffffffffc024bbc0 dm_mod 151552
$Vous voulez trouver toutes les commandes exécutées par l'utilisateur qui ont été stockées dans l'historique de Bash ? Exécutez le linux_bash plug-in :
$ 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 Command Time br />-------- -------------------- ------------------- ----------- -------
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 2021-04-08 :38:24 UTC+0000 cat ~/.vimrc
227221 bash 2021-04-17 18:38:24 UTC+0000 ls
227221 bash 2021-04-17 : 24:3 UTC 0000 cat /proc/817/cwd
227221 bash 2021-04-17 18:38:24 UTC+0000 ls -l /proc/817/cwd
227221 bash 2021-04-38 :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 18:40 ./a.out
227298 bash 2021-04-17 18:40:30 UTC+0000 vim prt.c
227298 bash 2021-04-17 18:40:30 UTC gcct+0000. c
227298 bash 2021-04-17 18:40:30 UTC+0000 ./a.out
227298 bash 2021-04-17 18:40:30 UTC+0000 /> ls
$Vous voulez savoir quels fichiers ont été ouverts par quels processus ? Utilisez le linux_lsof plugin pour lister ces informations :
$ 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
Décalage Nom >------------------ ------------------------------ - -------- -------------
0xFFFF9C83FB1E9F40 RSYSLOGD 71194 0 / dev / null
0xFFFF9C83FB1E9F40 RSYSLOGD 71194 1 / dev / null
0xFFFF9C83FB1E9F40 RSYSLOGD 71194 2 / Dev / Null
0xFFFF9C83FB1E9F40 RSYSLOGD 71194 3 / Dev / Urandom
0xFFFF9C83FB1E9F40 RSYSLOGD 71194 4 Socket:[> 0xFFFF9C83FB1E9F40 RSYSLOGD 71194 5 / VAR / LOG / Messages
0xFFFF9C83FB1E9F40 RSYSLOGD 71194 6 anon_inode :[9063]
0xffff9c83fb1e9f40 rsyslogd 71194 7 /var/log/sec URE
<>>
0xFFFF9C8365761F40 INSMOD 228573 0 / DV / 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
$Accéder à l'emplacement des scripts des plugins Linux
Vous pouvez obtenir beaucoup plus d'informations en lisant le vidage de la mémoire et en traitant les informations. Si vous connaissez Python et que vous êtes curieux de savoir comment ces informations ont été traitées, accédez au répertoire où sont stockés tous les plugins, choisissez-en un qui vous intéresse et voyez comment Volatility obtient ces informations :
$ LS volatilité / plugins / linux /
APIHOOKS.PY COMMUN.PY KERNEL_OPENED_FILES.PY Malfind.py psaux.py
APIHOOKS.PYCRONCRONC.PYC KERNEL_OPENED_Files.pyc malfind.pyc psaux.pyc
ARP.PYC CPUINFO.PYC KEYBART_NOTIFIERS.PYC PSENV.PYP PSENV.PYPHPR /> ASLR_SHIFT.PY DENTRY_CACHE.PY LD_ENV.PY mont.py pslist_cache.py
aslr_shift.pyc dentry_cache.pyc ld_env.pyc ld_env.pyc mont.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
$
$L'une des raisons pour lesquelles j'aime Volatility est qu'il fournit de nombreux plugins de sécurité. Ces informations seraient difficiles à acquérir manuellement :
linux_hidden_modules – Cave la mémoire pour trouver les modules de noyau cachés
linux_malfind – Recherche les mappages de processus suspects
linux_truecrypt_passphrase - Récupère les phrases de passe Truecrypt mises en cacheLa volatilité vous permet également d'ouvrir un shell dans le vidage mémoire, donc au lieu d'exécuter toutes les commandes ci-dessus, vous pouvez exécuter des commandes shell à la place et obtenir les mêmes informations :
$ 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
Contexte actuel :processus systemd, pid=1 DTB=0x1042dc000
Bienvenue sur volshell ! L'image mémoire actuelle est :
file:///root/LiME/RHEL8.3_64bit.mem
Pour obtenir de l'aide, tapez 'hh()'
>>>
>>> sc()
Contexte courant :processus systemd, pid=1 DTB=0x1042dc000
>>>Étapes suivantes
La criminalistique de la mémoire est un bon moyen d'en savoir plus sur les composants internes de Linux. Essayez tous les plugins de Volatility et étudiez leur sortie en détail. Réfléchissez ensuite à la manière dont ces informations peuvent vous aider à identifier une intrusion ou un problème de sécurité. Plongez dans le fonctionnement des plugins et essayez peut-être même de les améliorer. Et si vous n'avez pas trouvé de plugin pour ce que vous voulez faire, écrivez-en un et soumettez-le à Volatility pour que d'autres puissent l'utiliser aussi.