Exegol MCP Server

Un serveur MCP (Model Context Protocol) qui fournit un accès sécurisé aux outils de pentesting Exegol pour les compétitions CTF et l'apprentissage du Red Team.

Objectif

Ce serveur MCP permet aux assistants IA d'effectuer des tests de pénétration web, de la reconnaissance réseau, du cracking de mots de passe, de l'analyse OSINT, et bien plus encore à des fins éducatives dans le cadre CTF.

SECTION 2: INSTRUCTIONS D'INSTALLATION POUR L'UTILISATEUR

Construire l'Image Docker

cd ./exegol-mcp-server/exegol/Exegol-images
docker build --no-cache -t exegol-mcp-server:latest .

Note : Cette étape peut prendre 10-15 minutes car l'image Exegol est volumineuse (~plusieurs GB).

creer le network

''''bash docker network create exegol_net ''''

lancer l'image

''''bash docker run -d --name mcp_server
--network exegol_net
-v $(pwd)/results:/results
-p 8080:8080
exegol-mcp-server:latest ''''

verification ''''bash docker ps '''' logs ''''bash docker logs <container_id> ''''

Construire le container

''''bash cd ../../ docker build --no-cache -t exegol-mcp-server:latest . ''''

lancer le containeur

''''bash docker run -d
--name mcp_server
-p 8080:8080
-v $(pwd)/results:/results
exegol-mcp-server:latest ''''

Créer le Catalogue Personnalisé

# Créer le répertoire des catalogues s'il n'existe pas
mkdir -p ~/.docker/mcp/catalogs

# Créer ou éditer custom.yaml
nano ~/.docker/mcp/catalogs/custom.yaml

Ajoutez cette entrée à custom.yaml :

version: 2
name: custom
displayName: Custom MCP Servers
registry:
  exegol:
    description: "Advanced penetration testing toolkit for CTF competitions with Exegol"
    title: "Exegol Pentest Toolkit"
    type: server
    dateAdded: "2025-01-15T00:00:00Z"
    image: exegol-mcp-server:latest
    ref: ""
    readme: ""
    toolsUrl: ""
    source: ""
    upstream: ""
    icon: ""
    tools:
      - name: nmap_scan
      - name: gobuster_dir
      - name: ffuf_scan
      - name: whatweb_scan
      - name: sqlmap_scan
      - name: nikto_scan
      - name: wpscan_scan
      - name: reverse_shell_generator
      - name: linpeas_analyze
      - name: hash_identify
      - name: john_crack
      - name: hashcat_crack
      - name: decode_encode
      - name: whois_lookup
      - name: dns_enum
      - name: subdomain_enum
      - name: theHarvester_scan
      - name: steghide_extract
      - name: exiftool_analyze
      - name: binwalk_analyze
      - name: hydra_bruteforce
      - name: medusa_bruteforce
      - name: list_saved_results
      - name: read_saved_result
      - name: custom_command
    environment:
      - name: OBSIDIAN_EXEGOL_PATH
        env: OBSIDIAN_EXEGOL_PATH
        example: /path/to/obsidian/vault/EXEGOL
    metadata:
      category: security
      tags:
        - pentesting
        - ctf
        - security
        - hacking
        - red-team
        - reconnaissance
        - exploitation
      license: MIT
      owner: local

Mettre à Jour le Registry

# Éditer le fichier registry
nano ~/.docker/mcp/registry.yaml

Ajoutez cette entrée sous la clé existante registry: :

registry:
  # ... serveurs existants ...
  exegol:
    ref: ""

IMPORTANT : L'entrée doit être sous la clé registry:, pas au niveau racine.

Créer le Dossier EXEGOL dans Obsidian

Dans votre vault Obsidian, créez un dossier nommé EXEGOL :

1. Ouvrez Obsidian

2. Naviguez vers votre vault

3. Créez un nouveau dossier appelé EXEGOL

4. Notez le chemin complet (exemple : /Users/votreusername/Documents/ObsidianVault/EXEGOL)

Configurer Claude Desktop

Trouvez votre fichier de configuration Claude Desktop :

• macOS : ~/Library/Application Support/Claude/claude_desktop_config.json

• Windows : %APPDATA%\Claude\claude_desktop_config.json

• Linux : ~/.config/Claude/claude_desktop_config.json

Éditez le fichier et ajoutez votre catalogue personnalisé dans "mcpServers" avec le montage du vault Obsidian :

{
  "mcpServers": {
    "mcp-toolkit-gateway": {
      "command": "docker",
      "args": [
        "run",
        "-i",
        "--rm",
        "--network=host",
        "-v", "/var/run/docker.sock:/var/run/docker.sock",
        "-v", "[VOTRE_HOME]/.docker/mcp:/mcp",
        "-v", "[CHEMIN_OBSIDIAN_VAULT]/EXEGOL:/results",
        "docker/mcp-gateway",
        "--catalog=/mcp/catalogs/docker-mcp.yaml",
        "--catalog=/mcp/catalogs/custom.yaml",
        "--config=/mcp/config.yaml",
        "--registry=/mcp/registry.yaml",
        "--tools-config=/mcp/tools.yaml",
        "--transport=stdio"
      ],
      "env": {
        "OBSIDIAN_EXEGOL_PATH": "/results"
      }
    }
  }
}

Remplacez :

• [VOTRE_HOME] par :

  • macOS : /Users/votre_username

  • Windows : C:\\Users\\votre_username (double backslashes, apres le caractere : utiliser des slash \ )

  • Linux : /home/votre_username

• [CHEMIN_OBSIDIAN_VAULT] par le chemin complet vers votre vault Obsidian

Exemple macOS :

"-v", "/Users/jean/Documents/ObsidianVault/EXEGOL:/results",

Exemple Windows :

"-v", "C:\\Users\\johnDoe\\Documents\\ObsidianVault\\EXEGOL:/results",

Redémarrer Claude Desktop

1. Quittez complètement Claude Desktop

2. Relancez Claude Desktop

3. Vos nouveaux outils Exegol devraient apparaître !

Vérifiez que le serveur apparaît dans la liste :

docker mcp server list

Vous devriez voir exegol dans la liste.

Vérifier les logs du serveur : ''''bash docker logs -f mcp_server ''''

Premier Test

Dans Claude Desktop, essayez une commande simple :

Liste tous les résultats sauvegardés dans mon vault Obsidian

Ou testez un scan basique :

Génère un reverse shell bash vers 127.0.0.1 port 4444

Dépannage

Le serveur n'apparaît pas

# Vérifier que l'image est construite
docker images | grep exegol

# Vérifier les logs
docker ps -a
docker logs <container_id>

Erreurs de permissions Obsidian

# Vérifier les permissions du dossier EXEGOL
ls -la /path/to/obsidian/vault/EXEGOL

# Donner les bonnes permissions si nécessaire
chmod 777 /path/to/obsidian/vault/EXEGOL

Problèmes réseau

# Vérifier que --network=host est bien dans la config
# Certains scans nécessitent l'accès réseau de l'hôte

Timeout sur les scans longs

Les timeouts sont déjà configurés généreusement :

• Reconnaissance : 5-10 minutes

• Exploitation : 15 minutes

• Cracking : 60 minutes

Si nécessaire, utilisez l'outil custom_command pour plus de contrôle.

Fonctionnalités

Reconnaissance (8 outils)

nmap_scan - Scanner les réseaux avec Nmap (quick, full, stealth, vuln) gobuster_dir - Brute-force de répertoires web ffuf_scan - Fuzzing web avancé (directories, vhosts, paramètres) whatweb_scan - Identification de technologies web et CMS

Exploitation Web (4 outils)

sqlmap_scan - Test d'injection SQL automatique nikto_scan - Scan de vulnérabilités web wpscan_scan - Audit de sécurité WordPress

Post-Exploitation (2 outils)

reverse_shell_generator - Génération de reverse shells (bash, python, php, powershell, nc, perl, ruby) linpeas_analyze - Analyse d'escalade de privilèges Linux

Cryptographie (4 outils)

hash_identify - Identification de types de hash john_crack - Cracking avec John the Ripper hashcat_crack - Cracking GPU avec Hashcat decode_encode - Encodage/décodage (base64, hex, URL, ROT13)

OSINT (4 outils)

whois_lookup - Recherche WHOIS de domaines dns_enum - Énumération DNS subdomain_enum - Découverte de sous-domaines (subfinder, assetfinder, amass) theHarvester_scan - Collecte d'emails, sous-domaines, IPs

Stéganographie (3 outils)

steghide_extract - Extraction de données cachées dans images exiftool_analyze - Analyse de métadonnées de fichiers binwalk_analyze - Analyse de fichiers pour données embarquées

Brute Force (2 outils)

hydra_bruteforce - Brute-force de credentials (SSH, FTP, HTTP, SMB, RDP) medusa_bruteforce - Alternative à Hydra pour brute-force

Utilitaires (3 outils)

list_saved_results - Liste les résultats sauvegardés read_saved_result - Lit un fichier de résultat spécifique custom_command - Exécute une commande personnalisée dans Exegol

Prérequis

Docker Desktop avec MCP Toolkit activé Docker MCP CLI plugin (docker mcp command) Accès à un dossier Obsidian pour sauvegarder les résultats

Installation

[Voir les instructions pas-à-pas](## SECTION 2: INSTRUCTIONS D'INSTALLATION POUR L'UTILISATEUR)

Configuration Obsidian

Le serveur sauvegarde automatiquement tous les résultats de scan dans votre vault Obsidian. Vous devez configurer le chemin du dossier EXEGOL dans votre vault. Par défaut, les fichiers seront sauvegardés avec le format : YYYYMMDD_HHMMSS_outil_cible.txt

Exemples d'utilisation

Dans Claude Desktop, vous pouvez demander : Reconnaissance:

"Scanne le réseau 192.168.1.0/24 avec nmap en mode rapide" "Fais un scan gobuster sur http://target.com avec la wordlist medium" "Utilise ffuf pour trouver des vhosts sur example.com" "Identifie les technologies sur https://target.com"

Exploitation Web:

"Lance sqlmap sur http://target.com/page.php?id=1" "Scanne http://target.com avec nikto" "Analyse le site WordPress http://blog.target.com"

Post-Exploitation:

"Génère un reverse shell bash vers 10.10.14.5 port 4444" "Crée un reverse shell python vers mon IP 192.168.1.100" "Lance linpeas pour analyser les privilèges"

Cryptographie:

"Identifie ce hash : 5f4dcc3b5aa765d61d8327deb882cf99" "Cracke ce hash MD5 avec john : 5f4dcc3b5aa765d61d8327deb882cf99" "Décode cette chaîne base64 : SGVsbG8gV29ybGQ=" "Encode 'password123' en base64"

OSINT:

"Fais un whois lookup sur example.com" "Énumère les sous-domaines de target.com avec subfinder" "Utilise theHarvester pour collecter des infos sur example.com depuis google" "Récupère les enregistrements MX de domain.com"

Stéganographie:

"Analyse les métadonnées de /path/to/image.jpg" "Extrais les données cachées de image.png avec steghide" "Utilise binwalk sur firmware.bin et extrais le contenu"

Brute Force:

"Brute-force SSH sur 192.168.1.50 avec l'utilisateur admin" "Lance hydra sur le FTP de 10.10.10.100 avec rockyou"

Utilitaires:

"Liste tous mes résultats de scan sauvegardés" "Montre-moi le résultat du scan nmap_20250115_143022_192.168.1.1.txt" "Exécute la commande 'ls -la /tmp'"

Architecture

Claude Desktop → MCP Gateway → Exegol MCP Server → Outils Exegol ↓ Obsidian Vault (Résultats sauvegardés)

Développement

Tests Locaux bash# Définir les variables d'environnement export OBSIDIAN_EXEGOL_PATH="/path/to/your/obsidian/vault/EXEGOL"

Exécuter directement

python3 exegol_server.py

Tester le protocole MCP

echo '{"jsonrpc":"2.0","method":"tools/list","id":1}' | python3 exegol_server.py

### Ajouter de Nouveaux Outils

1. Ajoutez la fonction à `exegol_server.py`
2. Décorez avec `@mcp.tool()`
3. Utilisez une docstring d'une seule ligne
4. Mettez à jour l'entrée du catalogue avec le nouveau nom d'outil
5. Reconstruisez l'image Docker

## Dépannage

### Les outils n'apparaissent pas
- Vérifiez que l'image Docker a été construite avec succès
- Vérifiez les fichiers catalog et registry
- Assurez-vous que la config Claude Desktop inclut le catalogue custom
- Redémarrez Claude Desktop

### Erreurs de sauvegarde des résultats
- Vérifiez que la variable OBSIDIAN_EXEGOL_PATH est correctement définie
- Assurez-vous que le dossier existe et a les bonnes permissions
- Vérifiez les logs Docker : `docker logs <container_name>`

### Timeouts sur les scans longs
- Les timeouts par défaut sont : 5min (reconnaissance), 15min (exploitation), 60min (cracking)
- Utilisez `custom_command` pour des commandes nécessitant plus de temps
- Augmentez les timeouts dans le code si nécessaire

### Problèmes de permissions
- Le serveur s'exécute en tant qu'utilisateur non-root dans le container
- Certains outils nécessitent des capabilities réseau spéciales
- Montez les volumes avec les bonnes permissions

## Considérations de Sécurité

- ⚠️ **UNIQUEMENT À DES FINS ÉDUCATIVES** - N'utilisez ces outils que sur des systèmes que vous possédez ou avez l'autorisation de tester
- Tous les résultats sont sauvegardés localement dans votre vault Obsidian
- Aucune donnée sensible n'est loggée
- Les commandes sont exécutées dans un container Docker isolé
- Utilisez un VPN lors de la participation à des CTF

## Wordlists Incluses

- **RockYou** : `/usr/share/wordlists/rockyou.txt`
- **DirBuster** : `/usr/share/wordlists/dirbuster/`
- **SecLists** : `/usr/share/seclists/`
- **Metasploit** : `/usr/share/wordlists/metasploit/`

## Ressources pour CTF

### Plateformes recommandées
- HackTheBox (https://hackthebox.com)
- TryHackMe (https://tryhackme.com)
- Root-Me (https://root-me.org)
- PicoCTF (https://picoctf.org)

### Documentation utile
- Exegol Documentation : https://exegol.readthedocs.io
- PayloadsAllTheThings : https://github.com/swisskyrepo/PayloadsAllTheThings
- HackTricks : https://book.hacktricks.xyz

## Licence

MIT License

## Avertissement

Ce serveur MCP est conçu pour un usage éducatif dans le cadre de compétitions CTF et d'apprentissage de la sécurité informatique. L'utilisation de ces outils sur des systèmes sans autorisation explicite est illégale. L'auteur et les contributeurs ne sont pas responsables de toute utilisation abusive de ces outils.

Conseils pour CTF

1. Organisez vos notes : Créez des sous-dossiers dans EXEGOL pour chaque CTF

2. Documentez tout : Les résultats sont automatiquement sauvegardés et horodatés

3. Utilisez des wordlists adaptées : Rockyou est grosse, commencez par common

4. Soyez méthodique : Reconnaissance → Exploitation → Post-exploitation

5. Légalité : N'utilisez ces outils QUE sur des systèmes autorisés (CTF, labs, vos propres machines)

Bon hacking éthique ! 🔒🚩