Introduction
Dans ce laboratoire, vous apprendrez comment les attaquants maintiennent un accès persistant et contournent les détections de base. Bien que des frameworks automatisés comme Metasploit utilisent Meterpreter pour migrer en toute transparence des charges utiles vers des processus Windows stables (tels que explorer.exe ou svchost), les environnements Linux nécessitent une approche différente.
Le principe général est indépendant de la plateforme : les attaquants préfèrent se dissimuler au sein de contextes d'exécution durables et d'apparence ordinaire plutôt que dans des processus instables ou manifestement suspects.
Sous Linux, les attaquants atteignent les mêmes objectifs d'évasion en identifiant des processus système stables et en utilisant l'« usurpation de nom de processus » (Process Name Spoofing) pour masquer leurs charges utiles malveillantes. Vous apprendrez à effectuer une reconnaissance sur les processus en cours d'exécution, à identifier les composants système de confiance et à exécuter une charge utile qui se fait passer pour un thread noyau légitime afin d'échapper à la détection.
Il s'agit ici autant de stabilité que de perception humaine. Les défenseurs qui examinent de longues listes de processus sont plus susceptibles de négliger des noms qui se fondent dans le bruit habituel du système.
Afficher les processus en cours (ps)
Dans cette étape, vous apprendrez à lister et à analyser les processus en cours d'exécution sur un système Linux. Les attaquants utilisent cette phase de reconnaissance pour comprendre l'environnement et trouver des processus légitimes qu'ils peuvent usurper.
Encore une fois, l'énumération est primordiale. Vous ne pouvez pas choisir un processus de camouflage crédible si vous ne savez pas à quoi ressemble la « normale » sur l'hôte.
La commande ps (process status) est l'outil standard pour visualiser les processus actifs. Pour obtenir une vue complète de tous les processus en cours d'exécution sur le système, vous pouvez utiliser les options aux.
Exécutez la commande suivante dans votre terminal pour afficher les processus en cours :
ps aux | head -n 15
L'option a affiche les processus de tous les utilisateurs, u affiche le format orienté utilisateur (incluant l'utilisation du processeur et de la mémoire), et x affiche les processus non attachés à un terminal. Nous redirigeons la sortie vers head -n 15 pour ne montrer que les 15 premières lignes, afin de garder la sortie lisible.
Vous devriez obtenir un résultat similaire à celui-ci :
USER PID %CPU %MEM VSZ RSS TTY STAT START TIME COMMAND
root 1 0.0 0.1 167008 11468 ? Ss 10:00 0:01 /sbin/init
root 2 0.0 0.0 0 0 ? S 10:00 0:00 [kthreadd]
root 3 0.0 0.0 0 0 ? I< 10:00 0:00 [rcu_gp]
root 4 0.0 0.0 0 0 ? I< 10:00 0:00 [rcu_par_gp]
root 5 0.0 0.0 0 0 ? I< 10:00 0:00 [slub_flushwq]
root 6 0.0 0.0 0 0 ? I< 10:00 0:00 [netns]
root 8 0.0 0.0 0 0 ? I< 10:00 0:00 [kworker/0:0H-events_highpri]
root 10 0.0 0.0 0 0 ? I< 10:00 0:00 [mm_percpu_wq]
root 11 0.0 0.0 0 0 ? S 10:00 0:00 [rcu_tasks_rude_]
root 12 0.0 0.0 0 0 ? S 10:00 0:00 [rcu_tasks_trace]
root 13 0.0 0.0 0 0 ? S 10:00 0:00 [ksoftirqd/0]
root 14 0.0 0.0 0 0 ? I 10:00 0:00 [rcu_sched]
root 15 0.0 0.0 0 0 ? S 10:00 0:00 [migration/0]
root 16 0.0 0.0 0 0 ? S 10:00 0:00 [idle_inject/0]
Remarquez les processus entre crochets, tels que [kthreadd] ou [kworker/0:0H-events_highpri]. Ce sont des threads noyau. Ils sont extrêmement stables, s'exécutent en continu et sont rarement inspectés par les administrateurs système, ce qui en fait des candidats parfaits pour l'évasion.
Identifier des processus cibles stables
Dans cette étape, vous allez identifier des processus spécifiques idéaux pour l'évasion. Un processus stable est généralement un démon système ou un service de bureau qui démarre automatiquement et reste actif pendant une longue période.
Si la charge utile d'un attaquant plante, il perd son accès. En déguisant sa charge utile en processus stable, il évite d'éveiller les soupçons. Dans certains environnements Linux, les entrées kworker sont faciles à observer et constituent un modèle de nommage pratique, car leurs noms semblent techniques et se fondent dans les longues listes de processus.
Vérifions si cet environnement affiche des noms de type kworker. Exécutez la commande suivante :
ps -ef | grep kworker | head -n 5
L'option -e sélectionne tous les processus, et -f permet un affichage au format complet. Nous utilisons grep pour filtrer uniquement les lignes contenant "kworker".
Si l'environnement expose des entrées de travailleurs du noyau (kernel worker), vous pourriez voir une sortie similaire à celle-ci :
root 8 2 0 10:00 ? 00:00:00 [kworker/0:0H-events_highpri]
root 25 2 0 10:00 ? 00:00:00 [kworker/1:0H-events_highpri]
root 31 2 0 10:00 ? 00:00:00 [kworker/2:0H-events_highpri]
root 37 2 0 10:00 ? 00:00:00 [kworker/3:0H-events_highpri]
root 43 2 0 10:00 ? 00:00:00 [kworker/0:1-events]
Si vous ne voyez que la commande grep et aucune entrée kworker réelle, cela est acceptable dans cet environnement de laboratoire. Nous utiliserons tout de même le style de nommage familier [kworker/X:Y] à l'étape suivante, car l'objectif est d'apprendre comment fonctionne l'usurpation de nom de processus, et non de dépendre de la visibilité d'un thread noyau spécifique.
Migrer vers un processus stable
Dans cette étape, vous allez simuler une migration de processus en lançant un processus de longue durée et en usurpant son nom.
Une charge utile fictive nommée malicious_payload.sh a été préparée pour vous dans ~/project, mais il y a un détail important sous Linux. Lorsque vous exécutez un script shell, la liste des processus affiche généralement l'interpréteur, tel que /bin/bash /home/labex/project/malicious_payload.sh. Ce comportement rend le nom usurpé difficile à observer clairement dans cet environnement.
Pour faciliter la vérification de l'usurpation, nous utiliserons plutôt une commande simple de longue durée. Le concept de sécurité reste le même : nous donnons à un processus un nom visible trompeur afin qu'il se fonde dans la liste des processus.
Exécutez la commande suivante pour lancer un processus d'arrière-plan déguisé :
bash -c 'exec -a "[kworker/u4:2]" sleep 600' &
La partie bash -c démarre un nouveau processus Bash et exécute la chaîne de commande qui suit. exec -a "[kworker/u4:2]" remplace ce processus Bash par sleep 600, mais indique au système d'exploitation d'afficher le nom du processus comme étant [kworker/u4:2]. La commande sleep 600 maintient le processus actif assez longtemps pour que vous puissiez l'inspecter. Le & à la fin exécute le processus en arrière-plan.
Vous verrez une courte sortie indiquant le numéro de tâche en arrière-plan et l'identifiant du processus (PID), similaire à :
[1] 1337
Votre processus déguisé s'exécute maintenant silencieusement en arrière-plan et devrait apparaître avec le nom usurpé.
Vérifier la persistance et l'accès
Dans cette dernière étape, vous vérifierez que votre processus déguisé est visible sous son identité usurpée, puis vous le nettoierez.
Recherchez le nom usurpé que vous avez attribué à l'étape précédente :
ps aux | grep "kworker/u4:2"
Vous devriez obtenir un résultat similaire à celui-ci :
labex 1337 0.0 0.0 7008 1536 pts/0 S 10:15 0:00 [kworker/u4:2]
labex 1345 0.0 0.0 6480 2272 pts/0 S+ 10:16 0:00 grep --color=auto kworker/u4:2
Dans cet environnement, le processus déguisé n'est qu'une démonstration créée avec sleep, et non un véritable travailleur du noyau. Le point important est que le nom visible dans la liste des processus ressemble désormais à un composant système de confiance.
Enfin, nettoyez le processus de démonstration en terminant la ligne de commande qui contient le nom usurpé. Exécutez la commande suivante :
pkill -f "kworker/u4:2"
Vous pouvez exécuter ps aux | grep "kworker/u4:2" une fois de plus pour confirmer que le processus déguisé a été correctement terminé.
Résumé
Félicitations ! Vous avez terminé avec succès le laboratoire sur la migration de processus et l'évasion.
Vous avez appris comment les attaquants analysent les processus en cours d'exécution pour identifier des composants système stables et de confiance. Vous avez également appris à utiliser l'usurpation de nom de processus (exec -a) pour déguiser une charge utile malveillante en thread noyau légitime, simulant ainsi efficacement les techniques d'évasion utilisées par des frameworks avancés comme Meterpreter. Enfin, vous avez vérifié la furtivité du processus usurpé et appris à le terminer correctement. Ces compétences sont essentielles pour comprendre comment les menaces persistantes se cachent au sein d'un environnement Linux.
