PCTAMALOU

🔬 Mission pratique – Laboratoire (2 heures)

Scénario : Construction d'un laboratoire cybersécurité enterprise

Vous êtes chargé de construire un laboratoire complet pour une équipe de pentest. Votre mission : créer un environnement isolé, reproductible et professionnel avec toutes les composantes nécessaires.

# Vérification ressources
echo "=== VÉRIFICATION RESSOURCES ==="
free -h | grep Mem
df -h / | tail -1
grep -c ^processor /proc/cpuinfoCopier

Étapes détaillées : Construction professionnelle

1. Configuration avancée des réseaux VirtualBox
   Créez une architecture réseau professionnelle :

   echo "=== CONFIGURATION RÉSEAUX VIRTUALBOX ==="
   
   # 1. Liste réseaux existants
   echo "1. Réseaux existants:"
   VBoxManage list hostonlyifs
   
   # 2. Création réseaux spécialisés
   echo -e "\n2. Création réseaux lab:"
   
   # Réseau principal (Host-Only)
   VBoxManage hostonlyif create
   VBoxManage hostonlyif ipconfig vboxnet0 --ip 192.168.56.1 --netmask 255.255.255.0
   
   # Réseau DMZ (Internal)
   VBoxManage dhcpserver add --network=LabDMZ --server-ip=10.10.10.1 --lower-ip=10.10.10.100 --upper-ip=10.10.10.200 --netmask=255.255.255.0
   VBoxManage natnetwork add --netname LabDMZ --network "10.10.10.0/24" --enable --dhcp on
   
   # Réseau Management (Internal)
   VBoxManage dhcpserver add --network=LabMgmt --server-ip=172.16.10.1 --lower-ip=172.16.10.100 --upper-ip=172.16.10.200 --netmask=255.255.255.0
   VBoxManage natnetwork add --netname LabMgmt --network "172.16.10.0/24" --enable --dhcp on
   
   # 3. Vérification
   echo -e "\n3. Vérification configuration:"
   VBoxManage list hostonlyifs
   VBoxManage list natnetworks
   
   # 4. Sauvegarde configuration
   VBoxManage list hostonlyifs > virtualbox_networks_backup.txt
   echo "Configuration sauvegardée"Copier

2. Téléchargement et préparation des images
   Téléchargez et préparez les VMs nécessaires :

   echo "=== TÉLÉCHARGEMENT IMAGES ==="
   
   # Création dossier lab
   mkdir -p ~/pctamalou_lab/{isos,vms,scripts,backups}
   cd ~/pctamalou_lab
   
   # 1. Kali Linux (si non déjà)
   echo "1. Vérification Kali Linux..."
   if [ ! -f "isos/kali-linux-2024.iso" ]; then
       echo "Téléchargement Kali Linux..."
       # Note: Téléchargez depuis https://www.kali.org/get-kali/
       echo "Veuillez télécharger manuellement depuis: https://www.kali.org/get-kali/#kali-virtual-machines"
       echo "Placez le fichier dans ~/pctamalou_lab/isos/"
       read -p "Appuyez sur Entrée quand c'est fait..."
   fi
   
   # 2. Metasploitable2
   echo -e "\n2. Téléchargement Metasploitable2..."
   if [ ! -f "isos/Metasploitable2-Linux.ova" ]; then
       wget -O isos/Metasploitable2-Linux.ova \
           "https://downloads.sourceforge.net/project/metasploitable/Metasploitable2/Metasploitable2-Linux.ova" \
           || echo "Échec téléchargement, téléchargez manuellement"
   fi
   
   # 3. Ubuntu Server
   echo -e "\n3. Téléchargement Ubuntu Server..."
   if [ ! -f "isos/ubuntu-24.04-live-server-amd64.iso" ]; then
       wget -O isos/ubuntu-24.04-live-server-amd64.iso \
           "https://releases.ubuntu.com/24.04/ubuntu-24.04-live-server-amd64.iso" \
           || echo "Échec téléchargement, téléchargez manuellement"
   fi
   
   # 4. OWASP Juice Shop (Docker)
   echo -e "\n4. Préparation OWASP Juice Shop..."
   cat > scripts/setup_juice_shop.sh << 'EOF'
   #!/bin/bash
   # Script pour déployer Juice Shop
   docker pull bkimminich/juice-shop
   docker run -d -p 3000:3000 --name juice-shop bkimminich/juice-shop
   echo "Juice Shop disponible sur http://localhost:3000"
   EOF
   chmod +x scripts/setup_juice_shop.sh
   
   # 5. Inventaire
   echo -e "\n5. Inventaire images:"
   ls -la isos/
   echo -e "\nImages prêtes pour installation"Copier

3. Création automatisée des VMs avec scripts
   Automatisez la création avec VBoxManage :

   echo "=== CRÉATION AUTOMATISÉE VMs ==="
   
   # Script création Kali Linux
   cat > scripts/create_kali_vm.sh << 'EOF'
   #!/bin/bash
   VM_NAME="Kali-PCTAMALOU"
   VM_RAM="4096"
   VM_CPUS="2"
   VM_DISK="40"
   ISO_PATH="$HOME/pctamalou_lab/isos/kali-linux-2024.iso"
   
   echo "Création VM: $VM_NAME"
   
   # Création VM
   VBoxManage createvm --name "$VM_NAME" --ostype "Debian_64" --register
   
   # Configuration
   VBoxManage modifyvm "$VM_NAME" --memory $VM_RAM --cpus $VM_CPUS
   VBoxManage modifyvm "$VM_NAME" --nic1 hostonly --hostonlyadapter1 vboxnet0
   VBoxManage modifyvm "$VM_NAME" --nic2 nat --natnet2 "192.168.56.0/24"
   
   # Création disque
   VBoxManage createmedium disk --filename "$HOME/VirtualBox VMs/$VM_NAME/${VM_NAME}.vdi" --size $((VM_DISK * 1024))
   
   # Attachement disque
   VBoxManage storagectl "$VM_NAME" --name "SATA Controller" --add sata --controller IntelAhci
   VBoxManage storageattach "$VM_NAME" --storagectl "SATA Controller" --port 0 --device 0 --type hdd --medium "$HOME/VirtualBox VMs/$VM_NAME/${VM_NAME}.vdi"
   
   # Attachement ISO
   VBoxManage storagectl "$VM_NAME" --name "IDE Controller" --add ide
   VBoxManage storageattach "$VM_NAME" --storagectl "IDE Controller" --port 0 --device 0 --type dvddrive --medium "$ISO_PATH"
   
   echo "VM $VM_NAME créée avec succès"
   EOF
   
   # Script création Ubuntu Server
   cat > scripts/create_ubuntu_vm.sh << 'EOF'
   #!/bin/bash
   VM_NAME="Ubuntu-Server-PCTAMALOU"
   VM_RAM="2048"
   VM_CPUS="2"
   VM_DISK="30"
   ISO_PATH="$HOME/pctamalou_lab/isos/ubuntu-24.04-live-server-amd64.iso"
   
   echo "Création VM: $VM_NAME"
   
   # Création VM
   VBoxManage createvm --name "$VM_NAME" --ostype "Ubuntu_64" --register
   
   # Configuration
   VBoxManage modifyvm "$VM_NAME" --memory $VM_RAM --cpus $VM_CPUS
   VBoxManage modifyvm "$VM_NAME" --nic1 hostonly --hostonlyadapter1 vboxnet0
   
   # Création disque
   VBoxManage createmedium disk --filename "$HOME/VirtualBox VMs/$VM_NAME/${VM_NAME}.vdi" --size $((VM_DISK * 1024))
   
   # Attachement disque
   VBoxManage storagectl "$VM_NAME" --name "SATA Controller" --add sata --controller IntelAhci
   VBoxManage storageattach "$VM_NAME" --storagectl "SATA Controller" --port 0 --device 0 --type hdd --medium "$HOME/VirtualBox VMs/$VM_NAME/${VM_NAME}.vdi"
   
   # Attachement ISO
   VBoxManage storagectl "$VM_NAME" --name "IDE Controller" --add ide
   VBoxManage storageattach "$VM_NAME" --storagectl "IDE Controller" --port 0 --device 0 --type dvddrive --medium "$ISO_PATH"
   
   echo "VM $VM_NAME créée avec succès"
   EOF
   
   # Exécution scripts
   chmod +x scripts/*.sh
   echo "Scripts de création prêts"
   echo "Exécutez: ./scripts/create_kali_vm.sh"
   echo "Exécutez: ./scripts/create_ubuntu_vm.sh"Copier

4. Import et configuration de Metasploitable2
   Importez et configurez la cible vulnérable :

   echo "=== IMPORT METASPLOITABLE2 ==="
   
   # 1. Import OVA
   if [ -f "isos/Metasploitable2-Linux.ova" ]; then
       echo "Import Metasploitable2..."
       VBoxManage import isos/Metasploitable2-Linux.ova --vsys 0 --vmname "Metasploitable2-PCTAMALOU"
       
       # 2. Configuration réseau
       echo "Configuration réseau..."
       VBoxManage modifyvm "Metasploitable2-PCTAMALOU" --nic1 hostonly --hostonlyadapter1 vboxnet0
       
       # 3. Configuration mémoire/CPU
       VBoxManage modifyvm "Metasploitable2-PCTAMALOU" --memory 2048 --cpus 1
       
       echo "Metasploitable2 importé avec succès"
   else
       echo "Fichier Metasploitable2 non trouvé"
   fi
   
   # 4. Création VM Windows cible (script exemple)
   cat > scripts/create_windows_vm.sh << 'EOF'
   #!/bin/bash
   # Script exemple pour Windows - nécessite ISO Windows
   echo "Pour Windows, téléchargez une image d'évaluation depuis:"
   echo "https://www.microsoft.com/fr-fr/evalcenter/"
   echo "Puis utilisez l'interface VirtualBox graphique"
   EOF
   chmod +x scripts/create_windows_vm.shCopier

5. Configuration réseau avancée et tests
   Testez et validez la connectivité :

   echo "=== CONFIGURATION ET TESTS RÉSEAU ==="
   
   # 1. Démarrage VMs (si VirtualBox en CLI)
   echo "1. Démarrage des VMs..."
   echo "Démarrez manuellement depuis l'interface VirtualBox:"
   echo "- Kali-PCTAMALOU"
   echo "- Ubuntu-Server-PCTAMALOU" 
   echo "- Metasploitable2-PCTAMALOU"
   
   read -p "Appuyez sur Entrée quand les VMs sont démarrées..."
   
   # 2. Script de test réseau
   cat > scripts/test_network.sh << 'EOF'
   #!/bin/bash
   echo "=== TEST RÉSEAU LAB PCTAMALOU ==="
   echo "Date: $(date)"
   echo ""
   
   # Adresses IP attendues (ajuster selon configuration)
   KALI_IP="192.168.56.10"
   METASPLOITABLE_IP="192.168.56.101"
   UBUNTU_IP="192.168.56.102"
   GATEWAY_IP="192.168.56.1"
   
   echo "1. Vérification connectivité hôte:"
   ping -c 2 $GATEWAY_IP && echo "✅ Gateway accessible" || echo "❌ Gateway inaccessible"
   
   echo -e "\n2. Scan réseau lab:"
   echo "Adresses actives:"
   for i in {1..254}; do
       ip="192.168.56.$i"
       ping -c 1 -W 1 $ip >/dev/null 2>&1 && echo "   • $ip - ACTIVE" &
   done
   wait
   
   echo -e "\n3. Test isolation Internet:"
   ping -c 2 8.8.8.8 >/dev/null 2>&1
   if [ $? -eq 0 ]; then
       echo "⚠️  ATTENTION: Internet accessible depuis le lab"
       echo "   Vérifiez la configuration réseau Host-Only"
   else
       echo "✅ Lab correctement isolé d'Internet"
   fi
   
   echo -e "\n4. Services ouverts (scan rapide):"
   echo "Ports ouverts sur Metasploitable (attendu):"
   nmap -p 21,22,23,25,80,443,445,3306,5432 $METASPLOITABLE_IP 2>/dev/null | grep -E "(open|filtered)" | head -10
   
   echo -e "\n5. Test SSH vers Metasploitable:"
   timeout 5 ssh msfadmin@$METASPLOITABLE_IP "echo 'SSH test successful'" 2>/dev/null && echo "✅ SSH fonctionnel" || echo "❌ SSH échec"
   
   echo -e "\n=== TEST TERMINÉ ==="
   EOF
   
   chmod +x scripts/test_network.sh
   echo "Script de test réseau créé: ./scripts/test_network.sh"Copier

6. Script Python de gestion du laboratoire
   Créez un outil de gestion professionnel :

   #!/usr/bin/env python3
   """
   PCTAMALOU - Semaine 10 : Gestionnaire de laboratoire virtuel
   Outils pour gérer et automatiser un lab cybersécurité
   """
   
   import subprocess
   import json
   import os
   from datetime import datetime
   
   class VirtualLabManager:
       """Gestionnaire de laboratoire virtuel"""
       
       def __init__(self, lab_path="~/pctamalou_lab"):
           self.lab_path = os.path.expanduser(lab_path)
           self.config_file = os.path.join(self.lab_path, "lab_config.json")
           self.load_config()
       
       def load_config(self):
           """Charge la configuration du lab"""
           if os.path.exists(self.config_file):
               with open(self.config_file, 'r') as f:
                   self.config = json.load(f)
           else:
               self.config = {
                   "name": "PCTAMALOU Cybersecurity Lab",
                   "created": datetime.now().isoformat(),
                   "networks": [],
                   "vms": [],
                   "snapshots": []
               }
       
       def save_config(self):
           """Sauvegarde la configuration"""
           os.makedirs(self.lab_path, exist_ok=True)
           with open(self.config_file, 'w') as f:
               json.dump(self.config, f, indent=2)
       
       def list_vms(self):
           """Liste les VMs VirtualBox"""
           try:
               result = subprocess.run(
                   ["VBoxManage", "list", "vms"],
                   capture_output=True,
                   text=True,
                   check=True
               )
               vms = []
               for line in result.stdout.strip().split('\n'):
                   if line:
                       name = line.split('"')[1]
                       vms.append(name)
               return vms
           except subprocess.CalledProcessError as e:
               return f"Erreur: {e}"
       
       def get_vm_info(self, vm_name):
           """Récupère les informations d'une VM"""
           try:
               # Informations générales
               info_cmd = ["VBoxManage", "showvminfo", vm_name, "--machinereadable"]
               result = subprocess.run(info_cmd, capture_output=True, text=True, check=True)
               
               info = {}
               for line in result.stdout.split('\n'):
                   if '=' in line:
                       key, value = line.split('=', 1)
                       info[key] = value.strip('"')
               
               # État
               state_cmd = ["VBoxManage", "showvminfo", vm_name]
               state_result = subprocess.run(state_cmd, capture_output=True, text=True, check=True)
               
               for line in state_result.stdout.split('\n'):
                   if "State:" in line:
                       info['state'] = line.split(":")[1].strip()
                   elif "Memory size:" in line:
                       info['memory'] = line.split(":")[1].strip()
                   elif "Number of CPUs:" in line:
                       info['cpus'] = line.split(":")[1].strip()
               
               return info
               
           except subprocess.CalledProcessError as e:
               return {"error": str(e)}
       
       def create_snapshot(self, vm_name, snapshot_name="clean"):
           """Crée un snapshot d'une VM"""
           try:
               cmd = [
                   "VBoxManage", "snapshot", vm_name, "take",
                   snapshot_name,
                   "--description", f"Snapshot PCTAMALOU - {datetime.now().isoformat()}"
               ]
               result = subprocess.run(cmd, capture_output=True, text=True, check=True)
               
               # Ajout au journal
               self.config["snapshots"].append({
                   "vm": vm_name,
                   "snapshot": snapshot_name,
                   "timestamp": datetime.now().isoformat()
               })
               self.save_config()
               
               return f"Snapshot '{snapshot_name}' créé pour {vm_name}"
               
           except subprocess.CalledProcessError as e:
               return f"Erreur création snapshot: {e}"
       
       def restore_snapshot(self, vm_name, snapshot_name="clean"):
           """Restaure un snapshot"""
           try:
               cmd = ["VBoxManage", "snapshot", vm_name, "restore", snapshot_name]
               result = subprocess.run(cmd, capture_output=True, text=True, check=True)
               return f"Snapshot '{snapshot_name}' restauré pour {vm_name}"
           except subprocess.CalledProcessError as e:
               return f"Erreur restauration snapshot: {e}"
       
       def network_scan(self, network="192.168.56.0/24"):
           """Scan le réseau du lab"""
           try:
               import ipaddress
               import threading
               
               active_hosts = []
               lock = threading.Lock()
               
               def ping_host(ip):
                   try:
                       result = subprocess.run(
                           ["ping", "-c", "1", "-W", "1", str(ip)],
                           capture_output=True,
                           text=True
                       )
                       if result.returncode == 0:
                           with lock:
                               active_hosts.append(str(ip))
                   except:
                       pass
               
               # Scan des 20 premières adresses (pour le lab)
               threads = []
               network_obj = ipaddress.ip_network(network)
               hosts = list(network_obj.hosts())[:20]
               
               for host in hosts:
                   thread = threading.Thread(target=ping_host, args=(host,))
                   thread.start()
                   threads.append(thread)
               
               for thread in threads:
                   thread.join()
               
               return sorted(active_hosts)
               
           except ImportError:
               return ["Erreur: module ipaddress requis"]
       
       def generate_lab_report(self):
           """Génère un rapport du lab"""
           report = {
               "timestamp": datetime.now().isoformat(),
               "lab_name": self.config.get("name", "Unnamed Lab"),
               "virtual_machines": [],
               "network_status": {},
               "recommendations": []
           }
           
           # Informations VMs
           vms = self.list_vms()
           if isinstance(vms, list):
               for vm in vms:
                   info = self.get_vm_info(vm)
                   report["virtual_machines"].append({
                       "name": vm,
                       "info": info if isinstance(info, dict) else str(info)
                   })
           
           # Scan réseau
           report["network_status"]["hosts"] = self.network_scan()
           
           # Recommandations
           if not report["network_status"]["hosts"]:
               report["recommendations"].append("Aucune VM détectée - Vérifiez la configuration réseau")
           
           pctamalou_vms = [vm for vm in vms if isinstance(vms, list) and "PCTAMALOU" in vm]
           if len(pctamalou_vms) < 2:
               report["recommendations"].append("Moins de 2 VMs PCTAMALOU détectées - Considérez en ajouter")
           
           return report
   
   def main():
       print("🏗️ PCTAMALOU - Gestionnaire de laboratoire virtuel")
       print("=" * 60)
       
       manager = VirtualLabManager()
       
       while True:
           print("\n📋 MENU PRINCIPAL:")
           print("1. Lister les VMs")
           print("2. Informations VM")
           print("3. Créer snapshot")
           print("4. Restaurer snapshot")
           print("5. Scanner le réseau")
           print("6. Générer rapport")
           print("7. Quitter")
           
           choice = input("\nChoix (1-7): ").strip()
           
           if choice == "1":
               print("\n📦 VIRTUAL MACHINES:")
               vms = manager.list_vms()
               if isinstance(vms, list):
                   for i, vm in enumerate(vms, 1):
                       print(f"  {i}. {vm}")
               else:
                   print(f"  {vms}")
           
           elif choice == "2":
               vm_name = input("Nom de la VM: ").strip()
               print(f"\n📊 INFORMATIONS {vm_name}:")
               info = manager.get_vm_info(vm_name)
               if isinstance(info, dict):
                   for key, value in info.items():
                       print(f"  • {key}: {value}")
               else:
                   print(f"  {info}")
           
           elif choice == "3":
               vm_name = input("Nom de la VM: ").strip()
               snapshot_name = input("Nom du snapshot (défaut: clean): ").strip() or "clean"
               result = manager.create_snapshot(vm_name, snapshot_name)
               print(f"\n📸 {result}")
           
           elif choice == "4":
               vm_name = input("Nom de la VM: ").strip()
               snapshot_name = input("Nom du snapshot à restaurer: ").strip()
               result = manager.restore_snapshot(vm_name, snapshot_name)
               print(f"\n🔄 {result}")
           
           elif choice == "5":
               network = input("Réseau à scanner (défaut: 192.168.56.0/24): ").strip() or "192.168.56.0/24"
               print(f"\n🔍 SCAN RÉSEAU {network}:")
               hosts = manager.network_scan(network)
               if hosts:
                   for host in hosts:
                       print(f"  • {host} - ACTIVE")
               else:
                   print("  Aucun hôte actif détecté")
           
           elif choice == "6":
               print("\n📄 GÉNÉRATION RAPPORT...")
               report = manager.generate_lab_report()
               
               print(f"\n📊 RAPPORT LAB - {report['lab_name']}")
               print(f"Date: {report['timestamp']}")
               
               print(f"\n🏷️ VIRTUAL MACHINES ({len(report['virtual_machines'])}):")
               for vm in report['virtual_machines']:
                   print(f"  • {vm['name']}")
               
               print(f"\n🌐 RÉSEAU ({len(report['network_status']['hosts'])} hôtes actifs):")
               for host in report['network_status']['hosts']:
                   print(f"  • {host}")
               
               if report['recommendations']:
                   print(f"\n💡 RECOMMANDATIONS:")
                   for i, rec in enumerate(report['recommendations'], 1):
                       print(f"  {i}. {rec}")
               
               # Export JSON
               report_file = os.path.join(manager.lab_path, f"lab_report_{datetime.now().strftime('%Y%m%d_%H%M%S')}.json")
               with open(report_file, 'w') as f:
                   json.dump(report, f, indent=2)
               print(f"\n💾 Rapport exporté: {report_file}")
           
           elif choice == "7":
               print("\n👋 Au revoir!")
               break
           
           else:
               print("\n❌ Choix invalide")
   
   if __name__ == "__main__":
       main()Copier