📦 Livrable 1 : Topologie GNS3

Topologie prête à l'emploi pour GNS3. À importer via File → Import portable project.

{
  "name": "TP_VLAN_Segmentation_PME",
  "version": "2.2.0",
  "topology": {
    "nodes": [
      {"node_id": "node1", "name": "Switch_Main", "node_type": "ethernet_switch", "x": 100, "y": 200, "properties": {"ethernet_ports": 24}},
      {"node_id": "node2", "name": "Router_ROAS", "node_type": "qemu", "x": 500, "y": 200, "properties": {"image": "vios-adventerprisek9-m-15.6.1T.iso"}},
      {"node_id": "node3", "name": "PC_ADMIN", "node_type": "vpcs", "x": -150, "y": 100, "properties": {"script": "ip 192.168.10.10/24 192.168.10.254"}},
      {"node_id": "node4", "name": "PC_USER", "node_type": "vpcs", "x": -150, "y": 200, "properties": {"script": "ip 192.168.20.10/24 192.168.20.254"}},
      {"node_id": "node5", "name": "PC_GUEST", "node_type": "vpcs", "x": -150, "y": 300, "properties": {"script": "ip 192.168.30.10/24 192.168.30.254"}}
    ],
    "links": [
      {"link_id": "link1", "nodes": [{"node_id": "node1", "adapter_number": 0, "port_number": 1}, {"node_id": "node3", "adapter_number": 0, "port_number": 0}]},
      {"link_id": "link2", "nodes": [{"node_id": "node1", "adapter_number": 0, "port_number": 2}, {"node_id": "node4", "adapter_number": 0, "port_number": 0}]},
      {"link_id": "link3", "nodes": [{"node_id": "node1", "adapter_number": 0, "port_number": 3}, {"node_id": "node5", "adapter_number": 0, "port_number": 0}]},
      {"link_id": "link4", "nodes": [{"node_id": "node1", "adapter_number": 0, "port_number": 24}, {"node_id": "node2", "adapter_number": 0, "port_number": 0}]}
    ]
  }
}

🐍 Livrable 2 : Script Python de validation

Testeur automatique de VLANs : isolation, connectivité et génération d’un rapport HTML exploitable par une PME.

Installation : pip install colorama

Utilisation : python3 vlan_tester.py --menu ou python3 vlan_tester.py --auto config.json

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Testeur automatique de VLANs - CyberRéseau Pro
Usage PME : vérifier l'isolation, la connectivité et générer un rapport HTML.
"""

import subprocess
import sys
import json
import argparse
from datetime import datetime

try:
    from colorama import init, Fore, Style
    init()
except ImportError:
    class Fore:
        RED = GREEN = YELLOW = CYAN = RESET = ''
    Style = Fore

class VLAN_Tester:
    def __init__(self, config_file=None):
        self.results = []
        self.config = self._load_config(config_file) if config_file else self._default_config()

    def _default_config(self):
        return {
            "vlans": {
                "ADMIN": {"id": 10, "network": "192.168.10.0/24", "gateway": "192.168.10.254", "test_ip": "192.168.10.10"},
                "USERS": {"id": 20, "network": "192.168.20.0/24", "gateway": "192.168.20.254", "test_ip": "192.168.20.10"},
                "GUEST": {"id": 30, "network": "192.168.30.0/24", "gateway": "192.168.30.254", "test_ip": "192.168.30.10"}
            },
            "expected_isolation": {
                "ADMIN": {"USERS": False, "GUEST": True},
                "USERS": {"ADMIN": True, "GUEST": True},
                "GUEST": {"ADMIN": True, "USERS": True}
            }
        }

    def _load_config(self, config_file):
        with open(config_file, 'r', encoding='utf-8') as f:
            return json.load(f)

    def ping_host(self, ip, count=2, timeout=2):
        param = '-n' if sys.platform.lower().startswith('win') else '-c'
        timeout_param = '-w' if sys.platform.lower().startswith('win') else '-W'
        try:
            result = subprocess.run(
                ['ping', param, str(count), timeout_param, str(timeout), ip],
                capture_output=True, text=True, timeout=timeout + 3
            )
            return result.returncode == 0
        except Exception:
            return False

    def run_tests(self):
        self.results = []
        vlans = self.config['vlans']
        expected = self.config['expected_isolation']

        print(f"{Fore.CYAN}🔍 Démarrage des tests VLAN PME...{Style.RESET_ALL}")
        print(f"📅 {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}\n")

        for src_name, src_data in vlans.items():
            for dst_name, dst_data in vlans.items():
                if src_name == dst_name:
                    continue

                dst_ip = dst_data['test_ip']
                expected_isolated = expected.get(src_name, {}).get(dst_name, True)
                can_ping = self.ping_host(dst_ip)
                actual_isolated = not can_ping
                passed = (actual_isolated == expected_isolated)

                self.results.append({
                    "source": src_name,
                    "destination": dst_name,
                    "destination_ip": dst_ip,
                    "expected_isolated": expected_isolated,
                    "actual_isolated": actual_isolated,
                    "passed": passed
                })

                status = f"{Fore.GREEN}✓{Style.RESET_ALL}" if passed else f"{Fore.RED}✗{Style.RESET_ALL}"
                real = "ISOLÉ" if actual_isolated else "CONNEXION"
                print(f"  {status} {src_name} → {dst_name}: {real}")

        return self.results

    def generate_html_report(self, filename="rapport_vlan_pme.html"):
        passed = sum(1 for r in self.results if r['passed'])
        total = len(self.results)
        score = (passed / total) * 100 if total else 0

        html = f"""








📊 Rapport de test VLAN PME
Date : {datetime.now().strftime('%d/%m/%Y à %H:%M:%S')}
Score : {score:.1f}% ({passed}/{total})
"""

        for r in self.results:
            html += f""
            html += f""
            html += f""
            html += f""

        html += "

Source
Destination
IP destination
Attendu
Réel
Statut
{r['source']}
{r['destination']}
{r['destination_ip']}
{'ISOLÉ' if r['expected_isolated'] else 'CONNEXION'}
{'ISOLÉ' if r['actual_isolated'] else 'CONNEXION'}
{'✓ OK' if r['passed'] else '✗ À corriger'}
Généré par VLAN Tester | CyberRéseau Pro
    

      
🎓 Continuer le parmodule sécurité PME
      
Ce module fait partie du Pack TP Sécurité Réseau : VLAN, firewall, VPN, Wi‑Fi sécurisé et 802.1X. L’objectif est de passer d’une configuration isolée à une démarche complète de sécurisation PME.
      Voir tout le Pack TP
      Télécharger le guide gratuit
    
    

    

        
 Validation opérationnelle PME
        
Avant de considérer ce module comme exploitable, vérifiez les points suivants :
        

            
La configuration est sauvegardée et datée.
            
Les flux autorisés et bloqués sont documentés.
            
Les tests de connectivité et d’isolation sont réalisés.
            
Les captures ou rapports sont archivés comme preuves techniques.
            
Les risques résiduels sont notés pour une action ultérieure.
        
        

            Point critique : une configuration non testée donne une fausse impression de sécurité. Le test fait partie du livrable.
        
    



"

        with open(filename, 'w', encoding='utf-8') as f:
            f.write(html)

        print(f"{Fore.GREEN}📄 Rapport généré : {filename}{Style.RESET_ALL}")
        return filename

    def run_menu(self):
        while True:
            print(f"\n{Fore.CYAN}=== TESTEUR AUTOMATIQUE VLAN PME ==={Style.RESET_ALL}")
            print("1. 🔍 Lancer les tests")
            print("2. 📄 Générer rapport HTML")
            print("3. 🚪 Quitter")
            choice = input(f"{Fore.YELLOW}Votre choix : {Style.RESET_ALL}")
            if choice == '1':
                self.run_tests()
            elif choice == '2':
                if self.results:
                    self.generate_html_report()
                else:
                    print(f"{Fore.YELLOW}⚠️ Lancez d'abord les tests{Style.RESET_ALL}")
            elif choice == '3':
                break

def main():
    parser = argparse.ArgumentParser()
    parser.add_argument('--menu', action='store_true')
    parser.add_argument('--auto', type=str)
    args = parser.parse_args()

    tester = VLAN_Tester(args.auto if args.auto else None)

    if args.menu or len(sys.argv) == 1:
        tester.run_menu()
    else:
        tester.run_tests()
        tester.generate_html_report()

if __name__ == "__main__":
    main()

🔧 Livrable 3 : Script Bash de diagnostic

Diagnostic automatique des VLANs et génération d’un rapport texte pour audit interne.

Utilisation : chmod +x diagnostic_vlan.sh && ./diagnostic_vlan.sh --all

#!/bin/bash
RAPPORT="rapport_diag_vlan_pme_$(date +%Y%m%d_%H%M%S).txt"
GREEN='\033[0;32m'
RED='\033[0;31m'
YELLOW='\033[1;33m'
NC='\033[0m'

log() { echo -e "$1" | tee -a "$RAPPORT"; }

log_header() {
    echo "" | tee -a "$RAPPORT"
    log "${YELLOW}═══════════════════════════════════════${NC}"
    log "$1"
    log "${YELLOW}═══════════════════════════════════════${NC}"
}

show_network_state() {
    log_header "État réseau local"
    ip addr show | tee -a "$RAPPORT"
    echo "" | tee -a "$RAPPORT"
    ip route show | tee -a "$RAPPORT"
}

check_gateways() {
    log_header "Tests des passerelles VLAN"
    for ip in 192.168.10.254 192.168.20.254 192.168.30.254; do
        if ping -c 2 -W 1 "$ip" &>/dev/null; then
            log "${GREEN}✓ Passerelle joignable : $ip${NC}"
        else
            log "${RED}✗ Passerelle non joignable : $ip${NC}"
        fi
    done
}

check_isolation() {
    log_header "Test d'isolation VLAN"
    local ips=("192.168.10.10:ADMIN" "192.168.20.10:USERS" "192.168.30.10:GUEST")
    for src in "${ips[@]}"; do
        src_ip="${src%:*}"
        src_name="${src#*:}"
        for dst in "${ips[@]}"; do
            dst_ip="${dst%:*}"
            dst_name="${dst#*:}"
            [ "$src_ip" = "$dst_ip" ] && continue
            if ping -c 1 -W 1 "$dst_ip" &>/dev/null; then
                log "${YELLOW}⚠ CONNEXION détectée : $src_name → $dst_name${NC}"
            else
                log "${GREEN}✓ ISOLATION : $src_name → $dst_name${NC}"
            fi
        done
    done
}

checklist() {
    log_header "CHECKLIST PME"
    cat >> "$RAPPORT" << 'EOF'
□ VLANs créés sur le switch
□ Ports affectés aux bons VLANs
□ Trunk actif vers routeur/firewall
□ VLANs autorisés sur le trunk
□ Native VLAN identique des deux côtés
□ Passerelle par VLAN configurée
□ DHCP ou IP statiques validés
□ Isolation Guest vérifiée
□ Rapport archivé avec date et version
EOF
    tail -15 "$RAPPORT"
}

auto_mode() {
    log_header "DIAGNOSTIC AUTOMATIQUE VLAN PME"
    show_network_state
    check_gateways
    check_isolation
    checklist
    echo -e "${GREEN}✓ Rapport sauvegardé : $RAPPORT${NC}"
}

show_menu() {
    echo ""
    echo -e "${YELLOW}═══════════════════════════════════════${NC}"
    echo -e "         DIAGNOSTIC VLAN PME"
    echo -e "${YELLOW}═══════════════════════════════════════${NC}"
    echo "1. 🔍 Diagnostic complet"
    echo "2. 🌐 État réseau"
    echo "3. 🔒 Tester l'isolation"
    echo "4. 📋 Afficher checklist"
    echo "5. 🚪 Quitter"
    echo -n "Votre choix : "
}

if [ "$1" == "--all" ] || [ "$1" == "-a" ]; then
    auto_mode
else
    while true; do
        show_menu
        read choice
        case $choice in
            1) auto_mode ;;
            2) show_network_state ;;
            3) check_isolation ;;
            4) checklist ;;
            5) echo -e "${GREEN}Au revoir !${NC}"; exit 0 ;;
            *) echo -e "${RED}Choix invalide${NC}" ;;
        esac
    done
fi