PARTIE 2 : ANALYSE D’UN DUMP MEMOIRE

LECON 1 : RECUPEREZ LES INFORMATIONS IMPORTANTES DE LA MEMOIRE WINDOWS

POUR L'ANALYSE
Après avoir collecté les informations, vous pouvez procéder à l’analyse. Nous allons d’abord
commencer par l'analyse du dump de la mémoire. Pour ce faire, bien vouloir télécharger le fichier
memdump.mem en cliquant ici. Ce fichier contient la mémoire vive brute du PC juste après l'attaque. Ainsi,
vous pourrez mener l'investigation en suivant le cours.
Note : dans la suite, nous analyserons le disque dur et vous aurez aussi besoin de télécharger le fichier
de copie du disque dur, mais celui-ci est très lourd, Alors démarrez le téléchargement dès maintenant en
cliquant ici.
Dans cette leçon, nous verrons quelles sont les informations que nous pouvons extraire de la
mémoire Windows. Nous découvrirons également comment utiliser le framework Volatility pour
débuter l’analyse mémoire.
1.1. Débutez l’analyse mémoire avec Volatility
Les données de traitement d'un ordinateur sont toujours stockées dans la mémoire RAM (Random
Access Memory) car elle possède un temps d'accès beaucoup plus faible que la mémoire disque. Ces données
permettent à l’analyste de retrouver des informations concernant des connexions réseaux, des clés de
registre, des mots de passe ou encore des processus en cours d’exécution. Lors d’une analyse Forensic,
l’étude de l’image mémoire d’un système avec des outils spécifiques peut s’avérer utile, car elle
permettra d’extraire des informations difficilement exploitables lorsque le système est en
fonctionnement. C’est ce qui vous permettra de comprendre quelles actions ont été effectuées. Dans notre
situation, nous savons que l'infection est survenue à la suite de l'ouverture d'une pièce jointe reçue par
email1. Il faudra alors orienter nos recherches dans cette direction et identifier si un logiciel malveillant a été
exécuté, et de quelle manière. Pour extraire ces informations sur le dump mémoire que nous avons réalisé,
nous utiliserons le framework open source Volatility.
1.2. Prise en main de Volatility
Volatility peut être téléchargé sur le site de Volatility Foundation. Il existe une version pour
Windows, Mac et Linux. Dans votre machine d’analyse SIFT, Volatility est préinstallé ! Pour lancer
Volatility, il suffit d’ouvrir un terminal et d’entrer par exemple la commande Volatility -h pour
afficher les options disponibles (le retour de cette commande est très long, en voici le début).

1
Voir l’activité préliminaire au point 2 la leçon introductive
12
Usage: Volatility - A memory Forensics analysis platform.
Options:
-h, --help list all available options and their default values.
Default values may be set in the configuration file
(/etc/Volatilityrc)
--conf-file=/home/rocfor/.Volatilityrc
User based configuration file
-d, --debug Debug Volatility
--plugins=PLUGINS Additional plugin directories to use (colon separated)
--info Print information about all registered objects
--cache-directory=/home/rocfor/.cache/Volatility
[...]
Il existe une multitude d’options disponibles que vous pouvez explorer depuis l’aide. Ces options
permettent d’explorer le contenu de la mémoire et de reconstruire les structures de données pour en extraire
les informations pertinentes. Le wiki du projet Volatility présente chaque option.
1.3. Récupérez le profil de l'image avec ImageInfo
La première étape pour pouvoir analyser un dump mémoire est de récupérer les informations de
l’image qui permettront à Volatility de correctement parser les données, c'est-à-dire déterminer
son profile.
Parser les données renvoi à les lire et les interpréter afin de comprendre ce qu'elles signifient. Selon le type
de profil que vous signalez à Volatility, il n'interprétera pas les données de la même manière. Pour cela,
nous allons utiliser l'option ImageInfo de Volatility sur notre dump mémoire avec la commande :
Volatility -f memdump.mem imageinfo.
$ Volatility -f memdump.mem imageinfo
Suggested Profile(s) : Win7SP1x86_23418, Win7SP0x86, Win7SP1x86
AS Layer1 : IA32PagedMemoryPae (Kernel AS)
AS Layer2 : FileAddressSpace (/home/rocfor/Forensic_case001/memdump.mem)
PAE type : PAE
DTB : 0x185000L
KDBG : 0x82b39c28L
Number of Processors : 1
Image Type (Service Pack) : 1
KPCR for CPU 0 : 0x82b3ac00L
KUSER_SHARED_DATA : 0xffdf0000L
Image date and time : 2019-07-31 13:45:40 UTC+0000
Image local date and time : 2019-07-31 15:45:40 +0200
Cette option vous permettra d’obtenir les informations de profil de votre image. Comme vous
pouvez le voir sur la sortie console ci-dessus, le champ « suggested profile » propose des suggestions de profils
qu’il faudra ensuite préciser à Volatility avec l’option « --profile= ». Ce profil correspond au système
d’exploitation de votre dump mémoire. Volatility suggère ici un système Windows 7 SP1 en 32 bits qui
correspond bien à notre système cible. Nous pourrons donc lui spécifier par la suite de traiter le dump avec
l’option –-profile=Win7SP1x86. Maintenant que nous avons déterminé le profil de notre image, c'est-
à-dire le type de machine, nous pouvons commencer à en extraire des informations.
1.4. Récupérez la liste des processus
L’OS est responsable de la gestion, de la suspension et de la création de processus, c'est-à-dire
des instances d’un programme. Lorsqu'un programme s'exécute, un nouveau processus est créé et associé à
son propre ensemble d’attributs, y compris un ID de processus unique (PID) propre à chacun, et un espace
13
d'adressage. L’espace mémoire d’un processus devient un conteneur pour le code de l’application, les
bibliothèques partagées, les données dynamiques et la pile d'exécution. Un aspect important de l’analyse
de la mémoire consiste à énumérer les processus qui s'exécutent sur un système et analyser les données
stockées dans leur espace d'adressage. L'objectif est de dénicher les processus correspondant à des
programmes potentiellement malveillants, ainsi que comprendre leur fonctionnement, leur origine, et les
analyser en détail. Attention, pour effectuer des actions malveillantes, un malware doit être exécuté mais
il peut dissimuler son fonctionnement derrière un processus légitime, via de l’injection de code, par
exemple. Pour extraire la liste des processus, il est possible d’utiliser l’option pslist.
$ Volatility -f memdump.mem –-profile=Win7SP1x86 pslist
Offset(V) Name PID PPID Thds Hnds Sess Wow64
Start Exit
---------- -------------------- ------ ------ ------ -------- ------ ------ ---------------------
0x848338e8 System 4 0 90 547 ------ 0 2019-07-31 11:49:59 UTC+0000
0x87002020 smss.exe 272 4 2 29 ------ 0 2019-07-31 11:49:59 UTC+0000
0x8673f030 csrss.exe 360 352 9 381 0 0 2019-07-31 11:50:00 UTC+0000
0x867f7030 wininit.exe 412 352 3 74 0 0 2019-07-31 11:50:01 UTC+0000
0x867f55f8 csrss.exe 420 404 11 388 1 0 2019-07-31 11:50:01 UTC+0000
0x86879d40 winlogon.exe 468 404 3 110 1 0 2019-07-31 11:50:01 UTC+0000
0x8684a6c0 services.exe 512 412 8 209 0 0 2019-07-31 11:50:01 UTC+0000
[...]
0x84b5a030 msdtc.exe 1632 512 12 143 0 0 2019-07-31 12:17:50 UTC+0000
0x84b1c030 WINWORD.EXE 3544 588 13 621 1 0 2019-07-31 12:45:34 UTC+0000
0x84e19030 rad5163B.tmp.exe 1416 3544 11 472 1 0 2019-07-31 12:45:47 UTC+0000
[...]
0x84aeebf8 cscript.exe 2728 1416 5 198 1 0 2019-07-31 12:53:57 UTC+0000
0x84f04030 conhost.exe 2876 420 1 33 1 0 2019-07-31 12:53:57 UTC+0000
0x84d165e8 rfhyMVOQxfc.exe 1292 2728 0 -------- 1 0 2019-07-31 12:53:57 UTC+0000 2019-
07-31 13:45:12 UTC+0000
0x84ad3a08 cmd.exe 2204 1416 0 -------- 1 0 2019-07-31 12:55:36 UTC+0000 2019-
07-31 12:58:21 UTC+0000
0x84e6fa90 cmd.exe 1896 1416 0 -------- 1 0 2019-07-31 13:00:28 UTC+0000 2019-
07-31 13:01:09 UTC+0000
[...]
0x84a835a8 whoami.exe 2100 3992 0 -------- 1 0 2019-07-31 13:40:09 UTC+0000 2019-
07-31 13:40:09 UTC+0000
0x86e1dcd0 whoami.exe 3972 2772 0 -------- 1 0 2019-07-31 13:40:10 UTC+0000 2019-
07-31 13:40:10 UTC+0000
0x84dc3d40 rfhyMVOQxfc.exe 1808 2728 3 91 1 0 2019-07-31 13:45:17 UTC+0000

Cette option nous permet d’afficher la liste des processus en cours de fonctionnement lors du dump.
Vous retrouvez ici plusieurs informations, dont voici les plus importantes :
 offset : l’adresse mémoire du processus ;
 name : le nom du processus en cours d’exécution ;
 PID (Process IDentification) : le numéro d’identification du processus ;
 PPID (Parent Process ID) : le PID du processus parent ;
 start : la date et l’heure de lancement du processus.
Dans notre cas, nous pouvons déjà identifier plusieurs processus suspects, comme les
processus rad5163B.tmp.exe et rfhyMVOQxfc.exe. Lors de l’analyse des processus Windows, on peut vite
se rendre compte qu’il existe tout un tas de processus en cours d’exécution. Lors d’une analyse mémoire,
il est nécessaire de pouvoir identifier les processus légitimes et ceux qui ne le sont pas. Dans notre cas par
exemple, nous pouvons voir les différents processus système en cours d'exécution tels que

14
smss.exe, winlogon.exe ou encore services.exe. En revanche, le processus rfhyMVOQxfc.exe semble
suspect, à cause de son nom avec des lettres aléatoires. À noter toutefois que le nom ne suffit pas à identifier
si un processus est légitime ou non mais c'est un premier signe. Pour déceler les processus malveillants des
processus légitimes, rendez-vous sur ce document du SANS (un organisme spécialisé dans la sécurité
informatique) qui répertorie les différents processus de Windows. Si vous décelez un processus qui n'en fait
pas partie, creusez vos recherches, car il peut être malveillant.

1.5. Listez les DLL d'un processus

Les DLL, pour Dynamic Link Library, sont les librairies dans Windows. Ce sont des fonctions
préalablement codées et disponibles sur le système. Pour éviter de recoder certaines fonctions, l’API
Windows fournit une liste de DLL permettant de manipuler des données, de faire des connexions réseau ou
encore d’écrire des fichiers. Un logiciel malveillant va également utiliser ces API pour effectuer des actions
sur le système. Via l’analyse mémoire, il sera possible de lister les DLL utilisées par un processus permettant
de déduire son fonctionnement sur le système. Avec Volatility, il est possible d’extraire les DLL utilisées
pour un processus donné, avec l’option dlllist. Par exemple, pour le processus avec le PID 1808 que nous
avons précédemment identifié comme étant suspect :
$ Volatility -f memdump.mem –-profile=Win7SP1x86 dlllist -p 1808
************************************************************************
rfhyMVOQxfc.ex pid: 1808
Command line : "C:\Users\johnoc\AppData\Local\Temp\rad41020.tmp\rfhyMVOQxfc.exe"
Service Pack 1
Base Size LoadCount LoadTime Path
---------- ---------- ---------- ------------------------------ ----
0x00400000 0x16000 0xffff 1970-01-01 00:00:00 UTC+0000 C:\Users\johnoc\AppData\Local\Temp\rad41020.tmp\rfhyMVOQxfc.exe
0x777d0000 0x13c000 0xffff 1970-01-01 00:00:00 UTC+0000 C:\Windows\SYSTEM32\ntdll.dll
0x773f0000 0xd4000 0xffff 2019-07-31 13:45:17 UTC+0000 C:\Windows\system32\kernel32.dll
0x75ac0000 0x4a000 0xffff 2019-07-31 13:45:17 UTC+0000 C:\Windows\system32\KERNELBASE.dll
[...]
0x72160000 0xd000 0x1 2019-07-31 13:45:18 UTC+0000 C:\Windows\system32\dhcpcsvc6.DLL
0x72140000 0x12000 0x1 2019-07-31 13:45:18 UTC+0000 C:\Windows\system32\dhcpcsvc.DLL
Nous pouvons voir ici que l'emplacement du fichier C:\Users\johnoc\AppData\Local\Temp\rad41020.tmp\rfhyMVOQxfc.exe n'est pas
commun. Ce qui nous donne des indices pour notre investigation.

Il va donc falloir analyser le registre. Le registre contient divers paramètres et configurations pour
le système d'exploitation Windows. En tant que composant principal de Windows, il est accédé en
permanence pendant le temps d'exécution. Ainsi, il est logique que le système place en mémoire tout ou partie
des fichiers du registre. En outre, le registre Windows détient une mine d'informations utiles à des fins
d’analyses. Par exemple, il sera possible de déterminer les programmes récemment exécutés, d’extraire les
hash de mots de passe à des fins d'audit, ou encore d'étudier les clés et les valeurs introduites par un code
malveillant dans le système. Avec Volatility, il est possible d’extraire les informations du registre et de
lister les fichiers correspondants avec l’option hivelist.
$ Volatility -f memdump.mem –-profile=Win7SP1x86 hivelist
Virtual Physical Name
---------- ---------- ----
0x95281008 0x675df008 \??\C:\Users\johnoc\AppData\Local\Microsoft\Windows\UsrClass.dat
0x95289008 0x6c12a008 \??\C:\Users\johnoc\ntuser.dat
[...]
0x8f091900 0x006a5900 \Device\HarddiskVolume1\Boot\BCD
0x8f100098 0x0734d098 \SystemRoot\System32\Config\SOFTWARE

15
 Avec ces informations et l’option hashdump, il sera possible de dumper les hash des mots de passe
des comptes Windows.
$ Volatility -f memdump.mem --profile=Win7SP1x86 hashdump -y 0x8981c008 -s 0x8a6579c8
Administrator:500:aad3b435b51404eeaad3b435b51404ee:31d6cfe0d16ae931b73c59d7e0c089c0:::
Guest:501:aad3b435b51404eeaad3b435b51404ee:31d6cfe0d16ae931b73c59d7e0c089c0:::
johnoc:1000:aad3b435b51404eeaad3b435b51404ee:8846f7eaee8fb117ad06bdd830b7586c:::

1.6. Analysez les connexions réseaux

Presque tous les logiciels malveillants peuvent communiquer sur le réseau avec leur serveur de
Command et de Control, pour se propager, ou encore pour la mise en place d’une porte dérobée. Ces actions
utilisent les API réseaux de Windows, ce qui laisse inévitablement des traces en mémoire. L’analyse
mémoire du réseau permettra de recouvrer des informations telle que des connexions d’IP distantes, les ports
de connexion et même certaines données échangées. Volatility propose plusieurs options permettant
d’extraire des informations de connexion. Les options connections, sockscan et socket fonctionnent
uniquement sur des systèmes antérieurs à Windows 7. Toutefois, il est possible de lister les connexions réseaux
actives sur les systèmes plus récents, avec l’option netscan.
$ Volatility -f memdump.mem --profile=Win7SP1x86 netscan
Volatility Foundation Volatility Framework 2.6.1
Offset(P) Proto Local Address Foreign Address State Pid Owner Created
0x19472208 UDPv4 0.0.0.0:3702 *:* 1488 svchost.exe 2019-07-31 12:43:12 UTC+0000
0x19472208 UDPv6 :::3702 *:* 1488 svchost.exe 2019-07-31 12:43:12 UTC+0000
0x24d773a0 UDPv4 0.0.0.0:5355 *:* 1240 svchost.exe 2019-07-31 13:43:08 UTC+0000
0x5d30e208 UDPv4 0.0.0.0:3702 *:* 1488 svchost.exe 2019-07-31 12:43:12 UTC+0000
0x5d30e208 UDPv6 :::3702 *:* 1488 svchost.exe 2019-07-31 12:43:12 UTC+0000
[…]
0x6ec043a0 UDPv4 0.0.0.0:5355 *:* 1240 svchost.exe 2019-07-31 13:43:08 UTC+0000
0x7beddf50 UDPv6 ::1:1900 *:* 1488 svchost.exe 2019-07-31 12:43:10 UTC+0000
0x7ecfd7c8 UDPv4 0.0.0.0:5355 *:* 1240 svchost.exe 2019-07-31 13:43:08 UTC+0000
0x7ecfd7c8 UDPv6 :::5355 *:* 1240 svchost.exe 2019-07-31 13:43:08 UTC+0000
0x7f0ddc70 UDPv6 ::1:62503 *:* 1488 svchost.exe 2019-07-31 12:43:10 UTC+0000
0x7f175890 UDPv4 172.16.169.167:137 *:* 4 System 2019-07-31 12:43:11 UTC+0000
0x7f32cc28 UDPv4 172.16.169.167:138 *:* 4 System 2019-07-31 12:43:11 UTC+0000
0x7f3a6f50 UDPv6 fe80::94b5:ad60:33d0:3773:62502 *:* 1488 svchost.exe 2019-07-31 12:43:10 UTC+0000
0x7f5e8e28 UDPv4 127.0.0.1:1900 *:* 1488 svchost.exe 2019-07-31 12:43:10 UTC+0000
0x7ee2edf8 TCPv4 172.16.169.167:49848 172.16.169.164:4444 ESTABLISHED 1416 rad5163B.tmp.e
0x7eeb9138 TCPv4 172.16.169.167:49850 172.16.169.164:4444 CLOSED 1292 rfhyMVOQxfc.ex
0x7ef91008 TCPv4 172.16.169.167:49858 172.16.169.164:4444 ESTABLISHED 1808 rfhyMVOQxfc.ex
0x7f1a9820 TCPv4 172.16.169.167:49857 172.16.169.164:4444 CLOSED 24
0x7f224220 TCPv4 172.16.169.167:49852 66.102.1.108:993 ESTABLISHED 3476 OUTLOOK.EXE
0x7f34f278 TCPv4 -:49789 54.154.128.160:443 CLOSED 2472 systeminfo.exe
0x7f3c9568 TCPv4 172.16.169.167:49855 172.16.169.164:4444 CLOSED 2708 bVwHCYX.exe
Ici, nous pouvons voir que les processus identifiés effectuent plusieurs connexions vers l'adresse IP
172.16.169.164:4444. L’analyse mémoire permet de révéler énormément de choses sur
l’environnement infecté. Un processus malveillant sera plus facile à détecter et à analyser sur un dump
mémoire que sur un environnement en cours de fonctionnement. Par ailleurs, il sera possible d’accéder à
d’autres informations cruciales sur le système.

1.7. Découvrez les différents fichiers de mémoire

Il existe différent type de fichiers qui peuvent être utilisés pour l’analyse mémoire. Windows utilise
des fichiers système pour pouvoir stocker certaines informations qui sont propres à des fonctionnalités
internes, telles que l’hibernation ou la pagination.

16
 1.7.1. Le fichier Hiberfil.sys
Hiberfil.sys est le fichier utilisé par défaut par Windows pour enregistrer l'état de la
machine dans le cadre du processus d'hibernation. Ce processus permet de restaurer l'état de la machine, c'est-
à-dire sa mémoire vive, au moment du démarrage, pour retrouver l'état lors de la mise hors tension. Le système
d'exploitation conserve également un descripteur de fichiers ouverts sur ce fichier afin qu'aucun utilisateur, y
compris l'administrateur, ne puisse lire le fichier lorsque le système est en cours d'exécution. Le fichier
Hiberfil.sys est par défaut compressé ; pour pouvoir l'analyser avec Volatility, il faudra d’abord
utiliser l’option imagecopy pour décompresser l’image. Pour cela il faut lancer la commande :
$ Volatility -f Hiberfil.sys -–profile=Win7SP1x64 imagecopy -O hiberfil.dmp

1.7.2. La fichier Pagefile.sys

La pagination est un concept qui permet d’étendre la mémoire RAM disponible en stockant dans un
fichier des éléments de la RAM qui ne sont pas utilisés. Windows utilise le fichier système Pagefile.sys
pour stocker ces informations, qui peuvent également être exploitées durant l’investigation. Bien que
Windows prenne en charge jusqu'à 16 fichiers de pagination, en pratique un seul est utilisé. Ce fichier, stocké
dans « %SystemDrive%\Pagefile.sys », est un fichier système caché. Étant donné que le système
d'exploitation maintient ce fichier ouvert pendant son fonctionnement normal, il ne peut jamais être lu ou
consulté par un utilisateur. Toutefois, il peut contenir des informations intéressantes lors d’une analyse post
mortem, une fois extrait.
Le fichier Pagefile.sys ne peut pas être parsé par Volatility. Toutefois, il est possible
d’extraire des informations avec la commande strings. Attention, notez que ceci peut être extrêmement
long et qu’il est préférable de coupler la commande "strings" avec la commande "grep". On a donc :
$ strings Pagefile.sys | grep http://

17
 LECON 2 : ANALYSEZ UN DUMP MEMOIRE EN PROFONDEUR
Nous venons de voir comment fonctionne la mémoire sous Windows et comment utiliser le Framework
Volatility pour l'analyse de base. Dans cette leçon, nous verrons un peu plus en détail l’exploration de la
mémoire Windows.
2.1. Analysez en détail les processus avec Volatility
Dans les leçons précedentes, nous avons vu quelques commandes de base pour extraire des
informations liées aux processus en cours de fonctionnement. Il existe de nombreuses autres commandes
permettant l’exploration et l’analyse des processus. Certaines de ces informations nécessitent de connaître un
peu plus en détail les structures de données utilisées. Nous n’allons donc pas détailler ces éléments dans ce
cours. Mais si vous voulez aller plus loin dans l'analyse, je vous invite à lire le livre « Windows Internals »,
édité par Microsoft.
2.1.1. Affichez l'arborescence des processus avec pstree
Nous avons vu qu’il était possible de lister les processus en cours de fonctionnement dans le dump
mémoire avec la commande pslist. Il existe toutefois une autre commande, pstree, qui permet d’afficher
la liste des processus sous forme d’arborescence. L’option pstree peut s’avérer très utile car elle
permettra d’identifier les processus parents d’un processus en particulier. Ainsi, vous pourrez noter les
structures suspectes. Par exemple, il n'est pas normal qu’un CMD soit un processus fils d’Internet Explorer.
Voici la commande à exécuter pour afficher l'arborescence des processus :
$ Volatility -f memdump.mem –-profile=Win7SP1x64 pstree
Name Pid PPid Thds Hnds Time
-------------------------------------------------- ------ ------ ------ ------ ----
0x867f7030:wininit.exe 412 352 3 74 2019-07-31 11:50:01 UTC+0000
. 0x8684a6c0:services.exe 512 412 8 209 2019-07-31 11:50:01 UTC+0000
.. 0x84a49a80:taskhost.exe 1644 512 9 205 2019-07-31 11:56:18 UTC+0000
.. 0x86a46030:svchost.exe 780 512 18 502 2019-07-31 11:50:01 UTC+0000
.. 0x85c4e030:svchost.exe 728 512 9 310 2019-07-31 11:50:01 UTC+0000
[…]
... 0x868b8030:dwm.exe 1176 876 3 70 2019-07-31 11:56:18 UTC+0000
.. 0x86b754d0:svchost.exe 1384 512 18 313 2019-07-31 11:50:02 UTC+0000
.. 0x8690e190:svchost.exe 636 512 10 361 2019-07-31 11:50:01 UTC+0000
. 0x868d7960:lsm.exe 528 412 10 150 2019-07-31 11:50:01 UTC+0000
0x8673f030:csrss.exe 360 352 9 381 2019-07-31 11:50:00 UTC+0000
0x867f3030:explorer.exe 588 288 31 945 2019-07-31 11:56:18 UTC+0000
. 0x84948030:OUTLOOK.EXE 3476 588 26 1643 2019-07-31 11:56:34 UTC+0000
. 0x84b1c030:WINWORD.EXE 3544 588 13 621 2019-07-31 12:45:34 UTC+0000
.. 0x84e19030:rad5163B.tmp.e 1416 3544 11 472 2019-07-31 12:45:47 UTC+0000
... 0x84a46030:systeminfo.exe 2472 1416 0 ------ 2019-07-31 12:51:36 UTC+0000
... 0x84aeebf8:cscript.exe 2728 1416 5 198 2019-07-31 12:53:57 UTC+0000
.... 0x84d165e8:rfhyMVOQxfc.ex 1292 2728 0 ------ 2019-07-31 12:53:57 UTC+0000
.... 0x84dc3d40:rfhyMVOQxfc.ex 1808 2728 3 91 2019-07-31 13:45:17 UTC+0000
... 0x84ad3a08:cmd.exe 2204 1416 0 ------ 2019-07-31 12:55:36 UTC+0000
... 0x84aca030:reg.exe 3360 1416 0 ------ 2019-07-31 12:51:38 UTC+0000
... 0x84dbcd40:reg.exe 3300 1416 0 ------ 2019-07-31 12:52:35 UTC+0000
... 0x84f58030:cmd.exe 2192 1416 0 ------ 2019-07-31 13:11:32 UTC+0000
... 0x86e61c88:cmd.exe 3860 1416 0 ------ 2019-07-31 13:16:12 UTC+0000
[…]
0x86e1dcd0:whoami.exe 3972 2772 0 ------ 2019-07-31 13:40:10 UTC+0000
0x84f30648:whoami.exe 596 2304 0 ------ 2019-07-31 13:39:52 UTC+0000

Nous pouvons voir énormément de processus en cours de fonctionnement sur le système. Il sera ainsi
possible d’identifier un processus suspect. Par exemple, dans notre cas, nous pouvons voir que le processus

18
avec le PID 1416 précédemment identifié est fils du process avec le PID 3544 correspondant au processus
Winword.
2.1.2. Affichez les processus cachés avec psxview
Une autre commande qui peut être utilisée pour lister les processus est psxview. Cette commande
permet d’afficher les processus cachés.
$ Volatility -f memdump.mem –-profile=Win7SP1x86 psxview
Offset(P) Name PID pslist psscan thrdproc pspcid csrss session deskthrd ExitTime
---------- -------------------- ------ ------ ------ -------- ------ ----- ------- -------- --------
0x7d4d6b80 lsass.exe 520 True False True True True True False
0x7d27cd00 svchost.exe 876 True False True True True True False
0x7ef04030 conhost.exe 2876 True False True True True True False
[...]
0x7ce1a9f0 whoami.exe 1880 True False False True False True False 2019-07-31 13:40:09 UTC+0000
0x7d083030 whoami.exe 2924 True False False True False True False 2019-07-31 13:38:22 UTC+0000
0x7f2f7030 net1.exe 4052 True False False True False True False 2019-07-31 12:51:28 UTC+0000

Si un processus est caché, la colonne pslist, psscan sera marquée comme False.
2.1.3. Détectez l'injection de code avec malfind
La commande malfind peut être utilisée pour détecter de l’injection de code malveillant. Pour cela,
utilisez cette commande :
$Volatility -f memdump.mem –-profile=Win7SP1x86 malfind
Process:rad5163B.tmp.ePid:1416Address:0x18b0000
VadTag:VadSProtection:PAGE_EXECUTE_READWRITE
Flags:CommitCharge:33,MemCommit:1,PrivateMemory:1,Protection:6
0x018b00004d5a90000300000004000000ffff0000MZ..............
0x018b0010b8000000000000004000000000000000........@.......
0x018b002000000000000000000000000000000000................
0x018b0030000000000000000000000000e8000000................
0x018b00004dDECEBP
0x018b00015aPOPEDX
0x018b000290NOP
0x018b00030003ADD[EBX],AL
0x018b00050000ADD[EAX],AL
0x018b0007000400ADD[EAX+EAX],AL
0x018b000a0000ADD[EAX],AL
0x018b000cffDB0xff
0x018b000dff00INCDWORD[EAX]
0x018b000f00b800000000ADD[EAX+0x0],BH
0x018b00150000ADD[EAX],AL
0x018b0017004000ADD[EAX+0x0],AL
0x018b001a0000ADD[EAX],AL
0x018b001c0000ADD[EAX],AL
0x018b001e0000ADD[EAX],AL
0x018b00200000ADD[EAX],AL
0x018b00220000ADD[EAX],AL
0x018b00240000ADD[EAX],AL
0x018b00260000ADD[EAX],AL
0x018b00280000ADD[EAX],AL
0x018b002a0000ADD[EAX],AL
0x018b002c0000ADD[EAX],AL
0x018b002e0000ADD[EAX],AL
0x018b00300000ADD[EAX],AL
0x018b00320000ADD[EAX],AL
0x018b00340000ADD[EAX],AL
0x018b00360000ADD[EAX],AL
0x018b00380000ADD[EAX],AL
0x018b003a0000ADD[EAX],AL
0x018b003ce8DB0xe8
0x018b003d0000ADD[EAX],AL
0x018b003f00DB0x0
Ici, nous pouvons voir un extrait de l’en-tête du processus avec le PID1416. Nous pouvons voir ici
qu’il s’agit d’un exécutable avec l’en-tête MZ. L’injection de code permet de dissimuler un processus
malveillant dans un processus légitime. Ces techniques sont largement utilisées par les malwares pour se

19
dissimuler et contourner les solutions de sécurité sur le poste. Il existe une multitude de techniques
d’injection, telles que la technique « Process Hollowing » ou encore la technique « Process
Doppelganging ». L’analyse de la mémoire peut permettre de détecter ces injections de codes.

2.2. Process dump avec procdump

Lors de l’analyse mémoire, il sera possible de dumper un processus en particulier pour l’analyser
en détail. Il est également possible de réaliser un dump mémoire d’un processus en cours d’exécution. Ce
dump est un instantané d’un processus en cours d'exécution et contient les modules chargés pour
l’application à un moment donné. Volatility possède une option permettant de dumper un processus
spécifique.
$ Volatility -f memdump.mem –-profile=Win7SP1x86 procdump -D dir/ -p 1416
Les dumps de processus sont principalement utilisés pour résoudre les problèmes de machines
auxquelles les développeurs n’ont pas accès. Toutefois, ils peuvent s’avérer très utile, pour l’analyse détaillée
d’un processus malveillant, par exemple. Gardez bien ce dump, car nous l'analyserons plus
tard. L’investigation de la mémoire pour la détection et l’analyse de processus malveillants permet d’extraire
des informations qui peuvent être difficilement récupérables avec une analyse statique. Volatility
permet également d’analyser d’autres éléments qui peuvent être intéressants.

2.3. Listez les mutex avec mutantscan

Il est également possible de lister les mutex (Mutual Exclusion) avec la commande mutantscan.
Un mutex est une primitive de synchronisation. C'est un outil utilisé en programmation informatique pour
éviter que des ressources partagées d'un système ne soient utilisées en même temps. Les mutex peuvent
être utilisés par des logiciels malveillants pour ne pas réinfecter une même machine. Ce type d’information
permet également d’identifier un malware en particulier, c’est un indicateur de compromission.
La commande mutantscan permet de scanner les mutex dans la mémoire. Pour cela, lancer la commande :
$ Volatility -f memdump.mem –-profile=Win7SP1x86 mutantscan
Offset(P) #Ptr #Hnd Signal Thread CID Name
------------------ -------- -------- ------ ---------- --------- ----
0x000000000ed801f0 2 1 1 0x00000000 ASP.NET_4.0.30319_Perf_Library_Lock_PID_63c
0x000000000f124030 1 1 1 0x00000000
0x00000000165e1180 1 1 1 0x00000000
[...]
0x000000007f5d2228 1 1 1 0x00000000
0x000000007f5d4cb8 1 1 1 0x00000000
0x000000007f5eb6f8 2 1 1 0x00000000 SMSvcHost 4.0.0.0_Perf_Library_Lock_PID_14c

2.4. Extraction des services

La commande svcscan permet de lister les services sur la machine en cours d’investigation. Les
malwares peuvent utiliser les services Windows comme moyen de persistance permettant de survivre au
redémarrage. Il peut être intéressant d’analyser ces éléments pour détecter un mécanisme de
persistance. Le malware Emotet utilisait cette techniques pour se réexécuter.

20
 2.5. Allez plus loin avec d'autres options de Volatility
Volatility permet une analyse en profondeur de la mémoire. Nous n'allons pas voir en détail toutes les
options possibles, mais voici quelques autres commandes qui pourront vous servir :
 cmdscan pour extraire l’historique des commandes entrées dans l’invite de commande, et donc voir
quelles ont été les dernières commandes entrées avant l'incident. Si vous détectez une commande
suspecte entrée juste avant l'incident, vous avez peut-être trouvé le déclencheur du malware !
 yarascan permettant d'utiliser des YARA rules. Les YARA rules sont un moyen de chercher des
caractéristiques particulières des malwares dans des fichiers, afin de détecter des fichiers malveillants.
Ce sont des techniques particulières, mais sachez que vous pouvez les utiliser avec Volatility.
Nous vous invitons à consulter cette page sur les YARA rules pour en savoir un peu plus.

2.6. Les plugins Volatility

Il est également possible de développer et d’utiliser des plugins complémentaires, par exemple pour
extraire des informations relatives à un malware en particulier. Pour utiliser un plugin, il suffit de spécifier
l’emplacement du plugin avec l’option --plugins=“”. Nous pouvons voir ici un exemple avec le
plugin autoruns. Ce plugin permet d’extraire les clés de registre Run permettant l’exécution de
programmes à chaque démarrage. En d'autres termes, il vous permet de détecter quelles sont les manières dont
le malware persiste sur la machine.
$ vol.py --plugins="/home/rocfor/Forensic_case001/Volatility-autoruns/" -
f memdump.mem --profile=Win7SP1x86_23418 autoruns

Volatility Foundation Volatility Framework 2.6.1

Autoruns==========================================

Hive: \SystemRoot\System32\Config\SOFTWARE
Microsoft\Windows\CurrentVersion\Run (Last modified: 2019-07-31 12:34:18 UTC+0000)
"C:\Program Files\VMware\VMware Tools\vmtoolsd.exe" -n vmusr : VMware User Process (PIDs: 2500)
[...]
Hive: \??\C:\Windows\ServiceProfiles\NetworkService\NTUSER.DAT
Software\Microsoft\Windows\CurrentVersion\RunOnce (Last modified: 2019-07-24 04:59:44 UTC+0000)
C:\Windows\System32\mctadmin.exe : mctadmin (PIDs: )

Hive: \??\C:\Users\johnoc\ntuser.dat
Software\Microsoft\Windows\CurrentVersion\Run (Last modified: 2019-07-31 12:53:57 UTC+0000)
C:\Users\johnoc\AppData\Local\Temp\krtYMkVgyjNdd.vbs : YPDKhVAXzZSU (PIDs: 2728)

Winlogon (Shell)==================================

Shell: explorer.exe
Default value: Explorer.exe
PIDs: 588
Last write time: 2019-07-31 11:50:01 UTC+0000

Winlogon (Userinit)===============================

Userinit: C:\Windows\system32\userinit.exe,
Default value: userinit.exe
PIDs:
Last write time: 2019-07-31 11:50:01 UTC+0000

Services==========================================

Service: clr_optimization_v4.0.30319_32 - Microsoft .NET Framework NGEN v4.0.30319_X86 (Win32_Own_Process -

Auto Start)

21
 Image path: C:\Windows\Microsoft.NET\Framework\v4.0.30319\mscorsvw.exe (Last modified: 2019-07-31 12:16:55
UTC+0000)
PIDs:
[...]
Service: VMware Physical Disk Helper Service - VMware Physical Disk Helper Service (Win32_Own_Process - Auto
Start)
Image path: "C:\Program Files\VMware\VMware Tools\vmacthlp.exe" (Last modified: 2019-07-23 19:06:13 UTC+0000)
PIDs: 696
Hive: \??\C:\Users\johnoc\ntuser.dat
Software\Microsoft\Windows\CurrentVersion\Run (Last modified: 2019-07-31 12:53:57 UTC+0000)
C:\Users\johnoc\AppData\Local\Temp\krtYMkVgyjNdd.vbs : YPDKhVAXzZSU (PIDs: 2728)

Active Setup======================================

Command line: %SystemRoot%\system32\unregmp2.exe /ShowWMP

Last-written: 2010-11-20 21:35:23 UTC+0000 (PIDs: )

Command line: C:\Windows\System32\ie4uinit.exe -UserIconConfig

Last-written: 2019-07-24 04:59:42 UTC+0000 (PIDs: )

[...]

Ici, nous pouvons voir qu'une clé autorun a été identifiée et démarre un fichier VBS dans le
répertoire C:\Users\johnoc\AppData\Local\Temp\krtYMkVgyjNdd.vbs. Il existe de nombreux plugins
que vous pourrez utiliser au cas par cas selon vos besoins. Vous pourrez trouver une liste des plugins
Volatility sur cette page. Développer un plugin sur Volatility n'est pas tâche facile, mais vous
pourrez trouver des informations et des conseils sur cette page GitHub.

22