Serveur Wazuh MCP - Parlez à votre SIEM

Un serveur basé sur Rust conçu pour combler le fossé entre un système de gestion des informations et des événements de sécurité (SIEM) Wazuh et les applications nécessitant des données de sécurité contextuelles, spécifiquement adaptées à l'intégration Claude Desktop en utilisant le protocole Model Context Protocol (MCP).

Vue d'ensemble

Les assistants modernes d'IA comme Claude peuvent bénéficier de manière significative d'un contexte en temps réel sur l'environnement de sécurité de l'utilisateur. Le serveur Wazuh MCP comble cette lacune en fournissant un accès complet aux données SIEM de Wazuh par le biais d'interactions en langage naturel.

Ce serveur transforme les réponses complexes de l'API Wazuh en format compatible MCP, ce qui permet aux assistants IA d'y accéder :

• Alertes et événements de sécurité provenant de l'indexeur Wazuh pour la détection des menaces et la réponse aux incidents
• Gestion et surveillance des agents, y compris l'état de santé, les processus système et les ports réseau
• Données d'évaluation des vulnérabilités pour la gestion des risques et la priorisation des correctifs
• Règles de sécurité et configuration pour l'optimisation de la détection et la validation de la conformité
• Statistiques et mesures deperformance du système pour la surveillance opérationnelle et les pistes d'audit
• Capacités d'analyse des journaux et de criminalistique pour les enquêtes sur les incidents et les rapports de conformité
• Santé et gestion des clusters pour les exigences de fiabilité et de disponibilité de l'infrastructure
• Surveillance de la conformité et analyse des écarts pour les cadres réglementaires tels que PCI-DSS, HIPAA, SOX et GDPR

Plutôt que d'avoir recours à des appels d'API manuels ou à des requêtes complexes, les équipes de sécurité peuvent désormais poser des questions en langage naturel telles que " Montrez-moi les vulnérabilités critiques sur les serveurs web ", " Quels sont les processus en cours d'exécution sur l'agent 001 ? " ou " Sommes-nous conformes aux exigences de journalisation PCI-DSS ? " et recevoir des données structurées et exploitables de leur déploiement Wazuh.

Cette approche est particulièrement précieuse pour les équipes de conformité qui ont besoin d'évaluer rapidement la posture de sécurité, d'identifier les lacunes dans la couverture de surveillance, de valider l'efficacité des règles et de générer des preuves pour les exigences d'audit à travers l'infrastructure distribuée.

Exemples de cas d'utilisation

Le serveur Wazuh MCP fournit un accès direct aux données de sécurité de Wazuh par le biais d'interactions en langage naturel, ce qui permet plusieurs cas d'utilisation pratiques :

Analyse des alertes de sécurité

• Triage et investigation des alertes : Interroger les alertes de sécurité récentes avec get_wazuh_alert_summary pour identifier rapidement les menaces nécessitant une attention immédiate et les classer par ordre de priorité.
• Reconnaissance des modèles d'alerte : Analyser les tendances et les modèles d'alerte pour identifier les problèmes de sécurité récurrents ou les campagnes d'attaque potentielles.

Gestion des vulnérabilités

• Évaluation de la vulnérabilité des agents : Utilisez get_wazuh_vulnerability_summary et get_wazuh_critical_vulnerabilities pour évaluer la posture de sécurité d'agents spécifiques et prioriser les efforts de correction.
• Hiérarchisation des vulnérabilités en fonction du risque : Corréler les données de vulnérabilité avec la criticité et l'exposition de l'agent pour concentrer les efforts de remédiation.

Surveillance du système et analyse judiciaire

• Analyse des processus : Recherche des processus en cours sur les agents à l'aide de get_wazuh_agent_processes pour la chasse aux menaces et l'analyse du système.
• Évaluation de la sécurité du réseau : Surveillez les ports ouverts et les services réseau avec get_wazuh_agent_ports pour identifier les vecteurs d'attaque potentiels.
• Surveillance de la santé des agents : Suivez l'état et la connectivité des agents à l'aide de get_wazuh_running_agents pour garantir une couverture de sécurité complète.

Intelligence des opérations de sécurité

• Analyse de l'efficacité des règles : Examinez et analysez les règles de détection de sécurité avec get_wazuh_rules_summary pour optimiser les capacités de détection.
• Surveillance des performances du gestionnaire : Suivez les performances et les statistiques du système à l'aide d'outils tels que get_wazuh_weekly_stats, get_wazuh_remoted_stats et get_wazuh_log_collector_stats.
• Gestion de la santé du cluster : Surveillez l'état des clusters Wazuh avec get_wazuh_cluster_health et get_wazuh_cluster_nodes pour assurer la fiabilité opérationnelle.

Réponse aux incidents et analyse médico-légale

• Analyse des journaux : Recherche et analyse des journaux des gestionnaires à l'aide de search_wazuh_manager_logs et get_wazuh_manager_error_logs pour l'investigation des incidents.
• Investigation spécifique à l'agent : Combinez plusieurs outils pour établir des profils complets d'agents spécifiques lors d'incidents de sécurité.
• Requêtes de sécurité en langage naturel : Posez des questions de sécurité complexes en langage naturel et recevez des données structurées de plusieurs composants Wazuh.

Efficacité opérationnelle

• Rapports automatisés : Générer des rapports de sécurité et des résumés par le biais d'interfaces conversationnelles sans appels manuels à l'API.
• Analyse inter-composants : Corréler les données de Wazuh Indexer (alertes) et de Wazuh Manager (agents, règles, vulnérabilités) pour obtenir des informations complètes sur la sécurité.
• Opérations de sécurité multilingues : Accédez aux données de Wazuh et obtenez des informations dans plusieurs langues pour les équipes de sécurité internationales.

Collecte de renseignements sur les menaces et réponse

Pour améliorer les capacités de renseignement sur les menaces, le serveur MCP Wazuh peut être associé au serveur MCP Cortex afin de créer un puissant écosystème d'analyse de la sécurité.

Capacités améliorées grâce à l'intégration de Cortex :

• Analyse des artefacts : Analyse automatique des fichiers, URL, domaines et adresses IP suspects détectés dans les alertes Wazuh à l'aide des plus de 140 analyseurs de Cortex
• Enrichissement des IOC : Enrichissement des indicateurs de compromission (IOC) des alertes Wazuh avec des renseignements sur les menaces provenant de sources multiples, notamment VirusTotal, Shodan, MISP, etc
• Chasse automatisée aux menaces : Combinez les capacités de détection de Wazuh avec les moteurs d'analyse de Cortex pour enquêter automatiquement sur les menaces et les classer
• Renseignements multi-sources : Exploitez les analyseurs pour les contrôles de réputation, l'analyse des logiciels malveillants, l'analyse des domaines et l'analyse comportementale
• Orchestration de la réponse : Utilisation des résultats d'analyse pour informer les actions de réponse automatisées et la hiérarchisation des alertes

Exemple de flux de travail :

1. Wazuh détecte un hachage de fichier ou une connexion réseau suspects dans une alerte
2. L'assistant IA interroge automatiquement le serveur Cortex MCP pour analyser l'artefact à l'aide de plusieurs analyseurs
3. Les résultats de VirusTotal, de l'analyse hybride, de la réputation de domaine et d'autres sources sont corrélés
4. L'intelligence combinée fournit un contexte pour les décisions de réponse aux incidents
5. Les résultats peuvent être utilisés pour mettre à jour les règles Wazuh ou déclencher une surveillance supplémentaire

Exigences

• Un client LLM compatible MCP (Model Context Protocol) (par exemple, Claude Desktop)
• Un serveur Wazuh en fonctionnement (v4.12 recommandé) avec l'API activée et accessible.
• Une connectivité réseau entre ce serveur et l'API Wazuh (si l'interaction API est utilisée).

Installation

Option 1 : Télécharger le binaire préconstruit (recommandé)

1. Téléchargez le binaire
   • Allez sur la page Releases du dépôt GitHub mcp-server-wazuh.
   • Téléchargez le binaire approprié pour votre système d'exploitation (par exemple, mcp-server-wazuh-linux-amd64, mcp-server-wazuh-macos-amd64, mcp-server-wazuh-windows-amd64.exe).
   • Rendez le binaire téléchargé exécutable (par exemple, chmod +x mcp-server-wazuh-linux-amd64).
   • (Facultatif) Renommez-le en quelque chose de plus simple comme mcp-server-wazuh et déplacez-le dans un répertoire du PATH de votre système pour en faciliter l'accès.

Option 2 : Docker

1. Tirez l'image Docker :

   docker pull ghcr.io/gbrigandi/mcp-server-wazuh:latest

Option 3 : Construire à partir des sources

1. Prérequis :

   • Installer Rust : https://www.rust-lang.org/tools/install

2. Construire :

   git clone https://github.com/gbrigandi/mcp-server-wazuh.git cd mcp-server-wazuh cargo build --release

   Le binaire sera disponible dans target/release/mcp-server-wazuh.

Configurer votre client LLM

La méthode de configuration de votre client LLM varie en fonction du client lui-même. Pour les clients qui supportent le MCP (Model Context Protocol), vous devrez généralement indiquer au client le chemin de l'exécutable mcp-server-wazuh.

Exemple pour Claude Desktop :

Configurez votre fichier claude_desktop_config.json:

{ "mcpServers" : { "wazuh" : { "command" : "/path/to/mcp-server-wazuh", "args" : [], "env" : { "WAZUH_API_HOST" : "your_wazuh_manager_api_host", "WAZUH_API_PORT" : "55000", "WAZUH_API_USERNAME" : "your_wazuh_api_user", "WAZUH_API_PASSWORD" : "votre_wazuh_api_password", "WAZUH_INDEXER_HOST" : "your_wazuh_indexer_host", "WAZUH_INDEXER_PORT" : "9200", "WAZUH_INDEXER_USERNAME" : "your_wazuh_indexer_user", "WAZUH_INDEXER_PASSWORD" : "your_wazuh_indexer_password", "WAZUH_VERIFY_SSL" : "false", "WAZUH_TEST_PROTOCOL" : "https", "RUST_LOG" : "info" } } }

Remplacez /path/to/mcp-server-wazuh par le chemin réel de votre binaire et configurez les variables d'environnement comme indiqué dans la section Configuration.

Une fois configuré, votre client LLM devrait être en mesure de lancer et de communiquer avec le serveur mcp-wazuh pour accéder aux données de sécurité Wazuh.

Si vous utilisez Docker, créez un fichier .env avec votre configuration Wazuh :

WAZUH_API_HOST=your_wazuh_manager_api_host
WAZUH_API_PORT=55000
WAZUH_API_USERNAME=your_wazuh_api_user
WAZUH_API_PASSWORD=your_wazuh_api_password
WAZUH_INDEXER_HOST=your_wazuh_indexer_host
WAZUH_INDEXER_PORT=9200
WAZUH_INDEXER_USERNAME=your_wazuh_indexer_user
WAZUH_INDEXER_PASSWORD=your_wazuh_indexer_password
WAZUH_VERIFY_SSL=false
WAZUH_TEST_PROTOCOL=https
RUST_LOG=info

Configurez votre fichier claude_desktop_config.json:

{ "mcpServers" : { "wazuh" : { "command" : "docker", "args" : [ "run", "--rm", "-i", "--env-file", "/path/to/your/.env", "ghcr.io/gbrigandi/mcp-server-wazuh:latest" ] } }

Configuration

La configuration est gérée par des variables d'environnement. Un fichier .env peut être placé à la racine du projet pour le développement local.

Note sur WAZUH_VERIFY_SSL: Pour les environnements de production, il est fortement recommandé de définir WAZUH_VERIFY_SSL=true et d'assurer une validation correcte des certificats pour les connexions à l'API Wazuh Manager et à l'indexeur Wazuh. La valeur false désactive la vérification des certificats, ce qui n'est pas sûr. La mention "Required : Oui" indique que ces variables sont essentielles pour que le serveur puisse se connecter aux composants Wazuh respectifs. Bien que des valeurs par défaut soient fournies, il est peu probable qu'elles correspondent à une configuration de production ou non locale.

Construction

Conditions préalables

• Installer Rust : https://www.rust-lang.org/tools/install
• Installer Docker et Docker Compose (optionnel, pour un déploiement conteneurisé) : https://docs.docker.com/get-docker/

Développement local

1. Cloner le dépôt :

   git clone https://github.com/gbrigandi/mcp-server-wazuh.git cd mcp-server-wazuh

2. Configurez (si vous utilisez l'API Wazuh)
   • Copiez le fichier d'environnement d'exemple : cp .env.example .env
   • Editez le fichier .env avec les détails de votre API Wazuh (par exemple WAZUH_API_HOST, WAZUH_API_PORT).
3. Construire :

   cargo build

4. Run :

   cargo run # Ou utiliser le script run (qui peut mettre en place le mode stdio) : # ./run.sh

Architecture

Le serveur est construit en utilisant le cadre rmcp et facilite la communication entre les clients MCP (par exemple, Claude Desktop, les extensions IDE) et le serveur Wazuh MCP via le transport stdio. Le serveur interagit avec les APIs Wazuh Indexer et Wazuh Manager pour récupérer les alertes de sécurité et d'autres données.

sequenceDiagram participant ClientApp en tant qu'application client (par ex, IDE Extension / Claude Desktop) participant WazuhMCPServer en tant que serveur Wazuh MCP (cette application) participant WazuhAPI en tant qu'API Wazuh ClientApp->>+WazuhMCPServer : (stdio) MCP Initialize WazuhMCPServer-->>-ClientApp : (stdout) MCP Initialized ClientApp->>+WazuhMCPServer : (stdio) MCP Request (tools/list) WazuhMCPServer->>WazuhMCPServer : Analyse la requête MCP WazuhMCPServer->>WazuhMCPServer : Process internal WazuhMCPServer-->>-ClientApp : (stdout) MCP Response (available tools) ClientApp->>+WazuhMCPServer : (stdio) MCP Request (tools/call for wazuhAlerts) WazuhMCPServer->>WazuhMCPServer : Analyse la requête MCP WazuhMCPServer->>+WazuhAPI : Demande d'alertes Wazuh (avec WAZUH_USER, WAZUH_PASS) WazuhAPI-->>-WazuhMCPServer : Données d'alerte Wazuh (JSON) WazuhMCPServer->>WazuhMCPServer : Transformer les alertes Wazuh en format MCP WazuhMCPServer-->>-ClientApp : (stdout) Réponse MCP (alertes)

Flux de données (focus stdio) :

1. Une application (par exemple, une extension IDE, un outil CLI) lance le serveur Wazuh MCP en tant que processus enfant.
2. L'application envoie des requêtes (commandes) au format MCP à l'entrée stdin du serveur.
3. Le serveur Wazuh MCP lit la commande à partir de stdin.
4. Traitement
   • Le serveur analyse la commande MCP.
   • Si la commande nécessite l'extraction de données de Wazuh (par exemple, "obtenir les dernières alertes")
     • Le serveur se connecte à l'API de Wazuh (en s'authentifiant si nécessaire à l'aide des informations d'identification configurées telles que WAZUH_USER, WAZUH_PASS).
     • Il récupère les données requises (par exemple, les alertes de sécurité).
     • La logique de transformation du serveur(src/mcp/transform.rs) traite chaque alerte, en faisant correspondre les champs Wazuh aux champs MCP.
   • Si la commande est interne (par exemple, une vérification d'état spécifique au serveur MCP), elle la traite directement.
5. Le serveur envoie une réponse JSON formatée MCP (par exemple, des alertes transformées, des confirmations de commande ou des messages d'erreur) à l'application via sa sortie standard.
6. L'application lit et traite la réponse MCP à partir de la sortie standard du serveur.

Cette interaction stdio permet une intégration étroite avec les outils de développement locaux ou d'autres applications qui peuvent gérer des processus enfants. Un point d'accès HTTP optionnel(/mcp) peut également être disponible pour les clients qui préfèrent l'interrogation.

Le serveur communique via stdin et stdout en utilisant des messages JSON-RPC 2.0, conformément au protocole Model Context Protocol (MCP).

Exemple de flux d'interaction :

1. L'application cliente (par exemple, une extension IDE) démarre le processus mcp-server-wazuh.

2. Le client envoie une demande d'initialisation à l'adresse stdin du serveur :

   {"jsonrpc" : "2.0", "id" : 0, "method" : "initialize", "params" : { "protocolVersion" : "2024-11-05", "capabilities" : {"sampling" : {}, "roots" : { "listChanged" : true } }, "clientInfo" : { "name" : "mcp-inspector", "version" : "0.11.0" } } }

3. Le serveur envoie la réponse d'initialisation au client via stdout:

   { "jsonrpc" : "2.0", "id" : 1, "result" : { "protocolVersion" : "2024-11-05", "capabilities" : {"prompts" : {}, "resources" : {}, "tools" : {} }, "serverInfo" : { "name" : "rmcp", "version" : "0.1.5" }, "instructions" : "Ce serveur fournit des outils permettant d'interagir avec une instance SIEM Wazuh à des fins de surveillance et d'analyse de la sécurité.\NOutils disponibles:\N- 'get_wazuh_alert_summary' : Récupère un résumé des alertes de sécurité de Wazuh. Le paramètre 'limit' est facultatif et permet de contrôler le nombre d'alertes renvoyées (100 par défaut)." } }

4. Le client envoie des notifications/initialisations au stdin du serveur :(Il s'agit d'une notification, l'identifiant est donc omis par le client)

   { "jsonrpc" : "2.0", "method" : "notifications/initialized" }

5. Le client demande les outils disponibles en envoyant tools/list à la ligne stdin du serveur :

   { "jsonrpc" : "2.0", "id" : 1, "method" : "tools/list", "params" : {} }

6. Le serveur répond en envoyant la liste des outils au client via stdout:

   {"jsonrpc" : "2.0", "id" : 2, "result" : {"tools" : [ { "name" : "get_wazuh_alert_summary", "description" : "Récupère un résumé des alertes de sécurité de Wazuh. Renvoie des informations formatées sur l'alerte, notamment l'ID, l'horodatage et la description.", "inputSchema" : { "$schema" : "http://json-schema.org/draft-07/schema#", "properties" : { "limit" : { "description" : "Nombre maximal d'alertes à récupérer (par défaut : 100)", "format" : "uint32", "minimum" : 0.0, "type" : ["integer", "null"] } }, "title" : "GetAlertSummaryParams", "type" : "object" } } ] }

7. Le client appelle l'outil get_wazuh_alert_summary en envoyant tools/call à la ligne stdin du serveur :

   { "jsonrpc" : "2.0", "id" : 3, "method" : "tools/call", "params" : { "name" : "get_wazuh_alert_summary", "arguments" : { "limit" : 5 } } }

8. Le serveur reçoit sur stdin, traite l'appel get_wazuh_alert_summary (ce qui implique d'interroger l'API de l'indexeur Wazuh et de transformer les données).

9. Le serveur envoie la réponse de l'outil/appel avec les alertes formatées au client via stdout:

   {"jsonrpc" : "2.0", "id" : 3, "result" : {"content" : [ { "type" : "text", "text" : "Alert ID : 1747091815.1212763\nTime : 2024-01-15T10:30:45.123Z\nAgent : web-server-01\nLevel : 7\nDescription : Stockage USB connecté" }, { "type" : "text", "text" : "Alert ID : 1747066333.1207112\nTime : 2024-01-15T10:25:12.456Z\nAgent : database-server\nLevel : 5\nDescription : Nouveau dpkg (paquet Debian) installé." } ], "isError" : false } }

   Ou, si aucune alerte n'est trouvée :

   { "jsonrpc" : "2.0", "id" : 3, "result" : { "content" : [ { "type" : "text", "text" : "No Wazuh alerts found." } ], "isError" : false } }

   Ou, en cas d'erreur de connexion à Wazuh :

   { "jsonrpc" : "2.0", "id" : 3, "result" : { "content" : [ { "type" : "text", "text" : "Error retrieving alerts from Wazuh : HTTP request error : connection refused" } ], "isError" : true } }

Développement et test

• Style du code : Utilise le formatage standard de Rust(cargo fmt).
• Linting : Utilise Clippy(cargo clippy).
• Tests : Contient des tests unitaires pour la logique de transformation et des tests d'intégration. Pour stdio, les tests peuvent impliquer le piping d'entrée/sortie vers un harnais de test. Pour HTTP, les tests utilisent un serveur API Wazuh fictif(httpmock) et un client MCP de test.

  # Exécuter tous les tests cargo test # Exécuter un test d'intégration spécifique (exemple pour les tests HTTP) # cargo test --test integration_test # Exécuter les tests avec une journalisation détaillée RUST_LOG=debug cargo test

• Voir tests/README.md pour plus de détails sur l'exécution des tests et l'utilisation de la CLI du client de test.

Licence

Ce projet est placé sous licence MIT.