---
# System prepended metadata

title: Wazhu configuration

---

# Wazuh SIEM — Guide de configuration complet

> **Guide pas à pas** — Installation et configuration de Wazuh Manager, Agent et Dashboard sur Ubuntu Server avec hardening de base, SSH sécurisé, pare-feu UFW et Fail2Ban.

---

## Table des matières

1. [Configuration réseau (Netplan)](#1--configuration-réseau-netplan)
2. [Hardening de base du serveur](#2--hardening-de-base-du-serveur)
3. [Sécurisation SSH + UFW + Fail2Ban](#3--sécurisation-ssh--ufw--fail2ban)
4. [Installation Wazuh Manager](#4--installation-wazuh-manager)
5. [Installation Wazuh Agent](#5--installation-wazuh-agent)
6. [Compatibilité des versions Agent/Manager/Dashboard](#6--compatibilité-des-versions-agentmanagerdashboard)
7. [Script d'automatisation de reconnexion](#7--script-dautomatisation-de-reconnexion)

---

## Prérequis

- **Ubuntu Server** 20.04 ou 22.04 LTS installé
- Deux VMs : une pour le **Manager Wazuh** (`192.168.10.20`) et une pour le **serveur durci + Agent** (`192.168.10.10`)
- Accès root ou sudo sur les deux machines

### Architecture cible

```
┌──────────────────────┐          ┌──────────────────────┐
│  Ubuntu Hardened     │          │  Wazuh Manager       │
│  (Agent)             │──1514──▶│  (Server + Dashboard)│
│  IP: 192.168.10.10   │          │  IP: 192.168.10.20   │
└──────────────────────┘          └──────────────────────┘
```

---

## 1 — Configuration réseau (Netplan)

### 1.1 — Éditer la configuration Netplan

```bash
sudo nano /etc/netplan/00-installer-config.yaml
```

Exemple de configuration avec IP statique :

```yaml
network:
  version: 2
  ethernets:
    ens33:
      dhcp4: true
    ens37:
      addresses: [192.168.10.10/24]
      gateway4: 192.168.10.1
      nameservers:
        addresses: [8.8.8.8]
```

![Configuration Netplan — IP statique](https://hackmd.io/_uploads/HJp9Qr6Xxg.png)

> Le fichier Netplan définit les interfaces réseau. Ici, `ens33` est en DHCP (accès Internet via NAT) et `ens37` a une IP statique sur le réseau interne (`192.168.10.10/24`).

### 1.2 — Tester et appliquer

```bash
sudo netplan try       # Teste sans appliquer (rollback automatique si erreur)
sudo netplan apply     # Applique définitivement
ip a                   # Vérifie les IP attribuées
```

![Vérification des interfaces réseau avec ip a](https://hackmd.io/_uploads/B1HRXSpQeg.png)

> ✅ La commande `ip a` confirme que l'IP `192.168.10.10` est bien attribuée à l'interface `ens37`.

> **💡 En cas de problème :** `sudo systemctl restart systemd-networkd` ou en dernier recours `sudo reboot`.

---

## 2 — Hardening de base du serveur

### 2.1 — Mise à jour et outils de sécurité

```bash
sudo apt update && sudo apt upgrade -y
sudo apt install apparmor apparmor-profiles apparmor-utils auditd
sudo systemctl enable --now apparmor
```

![Installation d'AppArmor et auditd](https://hackmd.io/_uploads/SkS-rZd7el.png)

> On installe **AppArmor** (contrôle d'accès obligatoire) et **auditd** (journalisation des événements système). Ces outils renforcent la sécurité du noyau Linux.

### 2.2 — Mises à jour automatiques

```bash
sudo apt install unattended-upgrades
sudo dpkg-reconfigure --priority=low unattended-upgrades
```

![Configuration des mises à jour automatiques](https://hackmd.io/_uploads/ByDeU-_Xll.png)

> Les mises à jour de sécurité s'installeront automatiquement. C'est une bonne pratique pour limiter les vulnérabilités connues.

### 2.3 — Durcissement du noyau via sysctl

```bash
sudo mkdir -p /etc/sysctl.d
sudo nano /etc/sysctl.d/99-hardening.conf
```

Ajoutez les paramètres suivants :

```
net.ipv4.ip_forward = 0
net.ipv4.conf.all.send_redirects = 0
net.ipv4.conf.all.accept_source_route = 0
net.ipv4.conf.all.accept_redirects = 0
net.ipv4.conf.all.rp_filter = 1
```

![Paramètres sysctl de durcissement réseau](https://hackmd.io/_uploads/By7jP-OXxl.png)

> Ces paramètres désactivent le routage IP, les redirections ICMP et le source routing — des vecteurs d'attaque réseau courants.

Appliquer les changements :

```bash
sudo sysctl --system
```

![Application des paramètres sysctl](https://hackmd.io/_uploads/BkyY1zumxg.png)

> ✅ Les paramètres sont appliqués immédiatement sans redémarrage.

### 2.4 — Vérifier les mises à jour automatiques

```bash
cat /etc/apt/apt.conf.d/20auto-upgrades
```

![Vérification de la configuration auto-upgrades](https://hackmd.io/_uploads/HkrSaB6meg.png)

> ✅ Les deux lignes `APT::Periodic::Update-Package-Lists` et `APT::Periodic::Unattended-Upgrade` doivent être à `"1"`.

---

## 3 — Sécurisation SSH + UFW + Fail2Ban

### 3.1 — Vérifier que SSH est installé et actif

```bash
which sshd
```

![Vérification de la présence de sshd](https://hackmd.io/_uploads/rymmy2K7gg.png)

> La commande confirme que le binaire `sshd` est bien installé sur le système.

```bash
sudo systemctl start ssh
sudo systemctl enable ssh
sudo systemctl status ssh
```

![Service SSH actif et enabled](https://hackmd.io/_uploads/rk9pk2FXxl.png)

> ✅ Le service SSH est démarré et configuré pour se lancer automatiquement au boot.

### 3.2 — Durcir la configuration SSH

```bash
sudo nano /etc/ssh/sshd_config
```

Modifiez ces lignes :

```
PermitRootLogin no
PasswordAuthentication no
Port 22
```

![Configuration SSH durcie](https://hackmd.io/_uploads/HkW6_MuQxx.png)

> On interdit la connexion root et l'authentification par mot de passe. Seules les clés SSH seront acceptées.

### 3.3 — Générer et configurer les clés SSH

#### Vérifier si une clé existe

```bash
ls ~/.ssh/id_rsa.pub
```

![Clé publique SSH existante](https://hackmd.io/_uploads/ryXQx2F7eg.png)

> Si le fichier existe, vous avez déjà une paire de clés.

#### Sinon, en créer une

```bash
ssh-keygen -t rsa -b 4096
```

![Génération de la paire de clés RSA 4096 bits](https://hackmd.io/_uploads/HksUnMuQxl.png)

> La clé privée est stockée dans `/home/abder/.ssh/id_rsa`. Ne la partagez jamais.

![Clé SSH générée avec succès](https://hackmd.io/_uploads/By-tD9Fmgl.png)

> ✅ La paire de clés (privée + publique) est créée.

#### Ajouter la clé publique sur la VM

```bash
mkdir -p ~/.ssh
chmod 700 ~/.ssh
nano ~/.ssh/authorized_keys
```

Collez votre clé publique (format `ssh-rsa AAAAB3Nza...`), puis :

```bash
chmod 600 ~/.ssh/authorized_keys
```

![Clé publique ajoutée dans authorized_keys](https://hackmd.io/_uploads/rJsLehKQxe.png)

> La clé publique est enregistrée. La VM acceptera maintenant les connexions SSH avec cette clé.

#### Tester la connexion AVANT de redémarrer SSH

```bash
ssh -i ~/.ssh/id_rsa -p 22 abder@192.168.10.10
```

![Connexion SSH par clé réussie](https://hackmd.io/_uploads/H1V9xnY7gx.png)

> ✅ La connexion SSH par clé fonctionne sans mot de passe. On peut maintenant redémarrer le service SSH en toute sécurité.

```bash
sudo systemctl restart ssh
```

### 3.4 — Configurer UFW (pare-feu)

```bash
sudo apt install ufw
sudo ufw default deny incoming
sudo ufw default allow outgoing
sudo ufw allow 22/tcp
sudo ufw enable
sudo ufw status verbose
```

![UFW activé avec règle SSH](https://hackmd.io/_uploads/r1ylznK7el.png)

> ✅ Le pare-feu est actif. Seul le port 22 (SSH) est autorisé en entrée. Tout le reste est bloqué.

### 3.5 — Installer Fail2Ban

```bash
sudo apt install fail2ban
sudo systemctl enable --now fail2ban
sudo systemctl status fail2ban
```

![Fail2Ban actif et en fonctionnement](https://hackmd.io/_uploads/BJMV-ntQxe.png)

> ✅ Fail2Ban surveille les tentatives de connexion SSH échouées et bannit automatiquement les IP suspectes.

---

## 4 — Installation Wazuh Manager

### 4.1 — Préparer la VM Manager

#### Mettre à jour le système

```bash
sudo apt update && sudo apt upgrade -y
```

#### Configurer le réseau (IP statique)

```bash
sudo nano /etc/netplan/00-installer-config.yaml
```

```yaml
network:
  version: 2
  ethernets:
    ens33:
      dhcp4: true          # NAT avec Internet
    ens37:
      dhcp4: false
      addresses: [192.168.10.20/24]
      nameservers:
        addresses: [8.8.8.8]
```

```bash
sudo netplan try
sudo netplan apply
ip a
```

![IP 192.168.10.20 configurée sur le Manager](https://hackmd.io/_uploads/H1qdOo0meg.png)

> ✅ L'IP `192.168.10.20` est attribuée à la VM qui hébergera Wazuh Manager.

### 4.2 — Télécharger et installer Wazuh

```bash
curl -sO https://packages.wazuh.com/4.7/wazuh-install.sh
ls -l wazuh-install.sh
```

![Script d'installation Wazuh téléchargé](https://hackmd.io/_uploads/ByRhOjA7gx.png)

> Le script officiel Wazuh est téléchargé. Il installe automatiquement le Manager, l'Indexer et le Dashboard.

```bash
sudo bash ./wazuh-install.sh -a -i
```

> ⏱️ L'installation prend **5 à 15 minutes**. À la fin, le script affiche les identifiants de connexion au dashboard.

![Installation Wazuh terminée — identifiants affichés](https://hackmd.io/_uploads/r1DFniA7lx.png)

> **⚠️ Important :** Copiez et conservez le **nom d'utilisateur** et le **mot de passe** affichés à la fin de l'installation. Ils sont nécessaires pour se connecter au dashboard.

### 4.3 — Vérifier le service

```bash
sudo systemctl status wazuh-manager
```

![Wazuh Manager actif et en fonctionnement](https://hackmd.io/_uploads/Hk_jnjA7lx.png)

> ✅ Le service Wazuh Manager est `active (running)`.

### 4.4 — Accéder au dashboard web

Ouvrez dans votre navigateur :

```
https://192.168.10.20:443
```

> ⚠️ Un avertissement de certificat auto-signé apparaîtra. C'est normal en installation locale — cliquez sur **"Avancé" → "Accepter le risque"**.

![Avertissement de certificat auto-signé](https://hackmd.io/_uploads/rk_FCiAmeg.png)

> Le certificat SSL est auto-signé car nous n'utilisons pas de domaine avec un certificat validé par une autorité.

#### Se connecter avec les identifiants générés

![Page de connexion Wazuh Dashboard](https://hackmd.io/_uploads/B10fk2C7le.png)

> Utilisez les identifiants copiés lors de l'installation. Par exemple : `admin` / `28cI1.+5+Zb6XSd34NAKmrB94Kxkm.YC`

![Dashboard Wazuh — page d'accueil](https://hackmd.io/_uploads/Bk74720Xgg.png)

> ✅ **Wazuh Manager est opérationnel.** Le dashboard affiche l'état du cluster et attend la connexion d'agents.

### 4.5 — (Optionnel) Sécuriser avec UFW

```bash
sudo apt install ufw
sudo ufw default deny incoming
sudo ufw default allow outgoing
sudo ufw allow 22/tcp
sudo ufw enable
```

![UFW configuré sur le Manager](https://hackmd.io/_uploads/B1qUVhR7xe.png)

> ✅ Le pare-feu est actif sur le Manager. Pensez à ouvrir le port **1514** (communication agent) et **443** (dashboard) si nécessaire.

---

## 5 — Installation Wazuh Agent

### Contexte

| Élément | Valeur |
|---|---|
| Manager Wazuh (serveur) | `192.168.10.20` |
| Agent (client) | `192.168.10.10` (Ubuntu Hardened) |
| Nom de l'agent | `agent-abder` |
| Port de communication | `1514` (TCP) |

### 5.1 — Installer l'agent sur la VM durcie

```bash
wget https://packages.wazuh.com/4.x/apt/pool/main/w/wazuh-agent/wazuh-agent_4.7.5-1_amd64.deb
```

Installer avec les variables d'environnement (adaptez le nom et l'IP) :

```bash
sudo WAZUH_MANAGER='192.168.10.20' WAZUH_AGENT_NAME='agent-abder' dpkg -i ./wazuh-agent_4.7.5-1_amd64.deb
```

### 5.2 — Enregistrer l'agent côté Manager

Sur la VM Manager (`192.168.10.20`) :

```bash
sudo /var/ossec/bin/manage_agents
```

Dans le menu interactif :

1. Tapez **A** → Add an agent
2. Nom : `agent-abder`
3. IP : `192.168.10.10`
4. Tapez **E** → Extract key → copiez la clé générée
5. Tapez **L** → vérifiez que l'agent est listé

![Agent enregistré sur le Manager — liste des agents](https://hackmd.io/_uploads/rJwzJZlNlx.png)

> ✅ L'agent `agent-abder` est enregistré avec son ID, son nom et son IP.

### 5.3 — Importer la clé sur l'agent

Sur la VM Agent (`192.168.10.10`) :

```bash
sudo /var/ossec/bin/manage_agents
```

Tapez **I** → collez la clé copiée depuis le Manager.

![Clé importée sur l'agent — confirmation](https://hackmd.io/_uploads/S1gM_blVle.png)

> ✅ La clé est importée. L'agent affiche les informations de confirmation (ID, nom, IP du Manager).

### 5.4 — Vérifier la configuration de l'agent

```bash
sudo nano /var/ossec/etc/ossec.conf
```

Vérifiez la section `<client>` et assurez-vous que l'IP pointe vers le Manager :

![Configuration ossec.conf — adresse du Manager](https://hackmd.io/_uploads/SJHC1-lVee.png)

> L'adresse `192.168.10.20` doit figurer dans la balise `<server><address>`. Corrigez si nécessaire.

### 5.5 — Enregistrement automatique (alternative)

```bash
sudo /var/ossec/bin/agent-auth -m 192.168.10.20 -A agent-abder
```

> 💡 Si un agent avec ce nom existe déjà, supprimez-le côté Manager avec `manage_agents` → **R** (remove).

### 5.6 — Démarrer et vérifier l'agent

```bash
sudo systemctl daemon-reload
sudo systemctl restart wazuh-agent
sudo systemctl status wazuh-agent
```

![Agent Wazuh actif et en fonctionnement](https://hackmd.io/_uploads/SJkz7-eEex.png)

> ✅ L'agent est `active (running)`.

### 5.7 — Vérifier depuis le Manager

```bash
sudo /var/ossec/bin/agent_control -l
```

> Résultat attendu : `ID: 001, Name: agent-abder, IP: 192.168.10.10, Active`

![Agent confirmé actif depuis le Manager](https://hackmd.io/_uploads/S1CkZZeEex.png)

> ✅ Le Manager confirme que l'agent est connecté et actif.

### 5.8 — Tests de connectivité (optionnel)

```bash
telnet 192.168.10.20 1514
nc -vz 192.168.10.20 1514
```

![Tests de connectivité réseau réussis](https://hackmd.io/_uploads/HklWjWWlExe.png)

> ✅ Le port 1514 du Manager est accessible depuis l'agent.

### 5.9 — Vérification sur le Dashboard

![Agent visible et actif dans le Dashboard Wazuh](https://hackmd.io/_uploads/HJkAW-gNgg.png)

> ✅ L'agent apparaît comme **"Active"** dans l'interface web du Dashboard. La configuration est terminée.

> **⚠️ Si l'agent affiche "Never connected" :** recommencez depuis l'étape 5.2 (enregistrement sur le Manager). Ce problème survient souvent si la clé n'a pas été correctement importée.

### 5.10 — Tableau récapitulatif des commandes de diagnostic

| Étape | Commande | VM | Objectif |
|---|---|---|---|
| Lister les agents | `sudo /var/ossec/bin/agent_control -l` | Manager | Vérifier si l'agent est inscrit et actif |
| Logs de l'agent | `sudo tail -f /var/ossec/logs/ossec.log` | Agent | Suivre les logs en temps réel |
| Log de connexion | `sudo grep "Connected to the server" /var/ossec/logs/ossec.log` | Agent | Confirmer la connexion au Manager |
| Test port TCP | `nc -vz 192.168.10.20 1514` | Agent | Vérifier l'accès au port 1514 |
| Test Telnet | `telnet 192.168.10.20 1514` | Agent | Autre test de connectivité |
| Redémarrer l'agent | `sudo systemctl restart wazuh-agent` | Agent | Appliquer les modifications |
| Recharger les services | `sudo systemctl daemon-reload` | Agent | Recharger les fichiers systemd |
| Vérifier la config | `sudo cat /var/ossec/etc/ossec.conf` | Agent | Vérifier l'IP et le port du Manager |

### Captures des commandes de diagnostic

![agent_control -l — liste des agents](https://hackmd.io/_uploads/rkIhV-x4el.png)

> Commande `agent_control -l` exécutée sur le Manager — l'agent est listé avec son statut.

![Logs ossec.log — suivi en temps réel](https://hackmd.io/_uploads/r1IZrZg4lg.png)

> Les logs de l'agent montrent les événements de connexion et de communication avec le Manager.

![Grep "Connected to the server"](https://hackmd.io/_uploads/rkKMrblVgg.png)

> La ligne de connexion réussie est présente dans les logs.

![Test nc -vz — port 1514 accessible](https://hackmd.io/_uploads/r1-BHWxEgg.png)

> Le port 1514 du Manager est joignable depuis l'agent.

![Test telnet — connectivité confirmée](https://hackmd.io/_uploads/rk5HBZeEee.png)

> Telnet confirme également que la connexion TCP est établie.

![Vérification de ossec.conf](https://hackmd.io/_uploads/Sy7dr-lNlg.png)

> Le fichier de configuration de l'agent pointe bien vers `192.168.10.20` sur le port `1514`.

---

## 6 — Compatibilité des versions Agent/Manager/Dashboard

L'agent et le Manager doivent être à la **même version**. Le Dashboard doit aussi être compatible.

### 6.1 — Vérifier les versions

#### Côté Agent

```bash
sudo /var/ossec/bin/wazuh-control info
```

![Version de l'Agent — v4.12.0](https://hackmd.io/_uploads/HyiUn4bNeg.png)

> L'agent est en version `v4.12.0`.

#### Côté Manager

```bash
sudo /var/ossec/bin/wazuh-control info
```

![Version du Manager — v4.12.0](https://hackmd.io/_uploads/SyF9-HW4xx.png)

> ✅ Le Manager est aussi en `v4.12.0`. Les versions sont compatibles.

#### Côté Dashboard

```bash
dpkg -l | grep wazuh-dashboard
```

![Version du Dashboard — 4.7.5 (incompatible)](https://hackmd.io/_uploads/r1ZfqB-4lx.png)

> ❌ Le Dashboard est en version `4.7.5-1`, ce qui est **incompatible** avec le Manager/Agent en `4.12.0`.

### 6.2 — Mettre à jour le Dashboard

```bash
# Sauvegarder la configuration
sudo cp -r /etc/wazuh-dashboard /etc/wazuh-dashboard.bak

# Installer la version compatible
sudo apt update
sudo apt install wazuh-dashboard=4.12.0-1
```

![Installation du Dashboard 4.12.0](https://hackmd.io/_uploads/S14d5SZ4ee.png)

> Le Dashboard est mis à jour vers la version `4.12.0-1` pour correspondre au Manager et à l'Agent.

```bash
# Finaliser l'installation
sudo dpkg --configure -a

# Vérifier la version
dpkg -l | grep wazuh-dashboard

# Redémarrer et vérifier
sudo systemctl restart wazuh-dashboard
sudo systemctl status wazuh-dashboard
```

![Dashboard 4.12.0 actif et fonctionnel](https://hackmd.io/_uploads/rJ3T5B-Vxx.png)

> ✅ Le Dashboard est maintenant en version `4.12.0` et fonctionne correctement. Toutes les versions sont alignées.

---

## 7 — Script d'automatisation de reconnexion

Ce script vérifie et relance automatiquement l'agent Wazuh à chaque démarrage de la VM.

### 7.1 — Créer le script

```bash
sudo nano /home/abder/reconnect_wazuh_agent.sh
```

```bash
#!/bin/bash

echo "[$(date)] Script reconnect_wazuh_agent lancé automatiquement." >> /var/log/wazuh_reconnect.log 2>&1

echo "==> Vérification du statut du service Wazuh Agent..."
sudo systemctl status wazuh-agent

echo "==> Redémarrage de l'agent Wazuh..."
sudo systemctl restart wazuh-agent

echo "==> Vérification de la connectivité avec le Wazuh Manager (192.168.10.20:1514)..."
ping -c 3 192.168.10.20
nc -zv 192.168.10.20 1514 || echo "⚠️ Le port 1514 n'est pas accessible"
telnet 192.168.10.20 1514 || echo "⚠️ Telnet échoué (peut ne pas être installé)"

echo "==> Relance finale de l'agent..."
sudo systemctl restart wazuh-agent

echo "==> Vérification des 20 dernières lignes de logs Wazuh..."
sudo tail -n 20 /var/ossec/logs/ossec.log

echo "[$(date)] Wazuh Agent redémarré." >> /var/log/wazuh_reconnect.log 2>&1
echo "✅ Script terminé. Vérifie maintenant dans le Dashboard si l'agent est 'Active'."
```

![Contenu du script de reconnexion](https://hackmd.io/_uploads/SJBvR9fVlx.png)

> Le script effectue dans l'ordre : vérification du statut, redémarrage, test de connectivité, relance finale et lecture des logs.

Rendre le script exécutable :

```bash
chmod +x /home/abder/reconnect_wazuh_agent.sh
```

### 7.2 — Planifier l'exécution automatique au démarrage

#### Choisir nano comme éditeur par défaut

```bash
sudo update-alternatives --config editor
```

![Sélection de nano comme éditeur par défaut](https://hackmd.io/_uploads/BklqA5z4gl.png)

> Tapez le numéro correspondant à **nano** (ou Entrée pour le défaut).

#### Ajouter le script au crontab root

```bash
sudo crontab -e
```

Ajoutez cette ligne à la fin du fichier :

```
@reboot /home/abder/reconnect_wazuh_agent.sh
```

![Ligne @reboot ajoutée dans le crontab](https://hackmd.io/_uploads/rJH1kofExg.png)

> Le script sera exécuté automatiquement à chaque démarrage de la VM.

Sauvegardez avec **Ctrl+O** puis quittez avec **Ctrl+X**.

### 7.3 — Tester le script

#### Test après reboot

```bash
sudo reboot
```

Après reconnexion, vérifiez le log :

```bash
cat /var/log/wazuh_reconnect.log
```

![Log de reconnexion après reboot](https://hackmd.io/_uploads/HJs4JofNlg.png)

> ✅ Le log confirme que le script s'est bien exécuté automatiquement au démarrage.

#### Exécution manuelle (pour diagnostic)

```bash
sudo /home/abder/reconnect_wazuh_agent.sh
```

![Exécution manuelle du script — partie 1](https://hackmd.io/_uploads/HyjayoGNex.png)

> Le script affiche chaque étape : statut, redémarrage, ping, test de port...

![Exécution manuelle du script — partie 2](https://hackmd.io/_uploads/BydCkjGExl.png)

> ✅ Toutes les vérifications passent. L'agent est connecté et fonctionnel.

### 7.4 — Vérification finale sur le Dashboard

![Agent actif dans le Dashboard Wazuh après script](https://hackmd.io/_uploads/rkJblizEgg.png)

> ✅ L'agent est **"Active"** dans le Dashboard. Le script de reconnexion automatique fonctionne parfaitement.

---

## Récapitulatif de l'architecture

```
┌─────────────────────────────────┐
│     VM Ubuntu Hardened          │
│     IP: 192.168.10.10           │
│                                 │
│  ┌─ AppArmor + auditd          │
│  ├─ SSH (clé uniquement)        │
│  ├─ UFW (port 22)              │
│  ├─ Fail2Ban                    │
│  ├─ sysctl hardening           │
│  ├─ Mises à jour auto          │
│  └─ Wazuh Agent ──────────┐    │
└────────────────────────────┼────┘
                             │ TCP 1514
┌────────────────────────────▼────┐
│     VM Wazuh Manager            │
│     IP: 192.168.10.20           │
│                                 │
│  ┌─ Wazuh Manager (v4.12.0)    │
│  ├─ Wazuh Indexer               │
│  ├─ Wazuh Dashboard (:443)     │
│  └─ UFW (ports 22, 443, 1514)  │
└─────────────────────────────────┘
```

### Résumé des mesures de sécurité

| Couche | Mesure | Détail |
|---|---|---|
| Réseau | UFW | Pare-feu avec politique deny par défaut |
| Réseau | sysctl hardening | Désactivation du routage et des redirections |
| Authentification | SSH par clé | Mot de passe désactivé, root interdit |
| Protection brute-force | Fail2Ban | Bannissement automatique des IP suspectes |
| Noyau | AppArmor | Contrôle d'accès obligatoire (MAC) |
| Audit | auditd | Journalisation des événements système |
| Mises à jour | unattended-upgrades | Patchs de sécurité automatiques |
| Monitoring | Wazuh SIEM | Détection d'intrusion et centralisation des logs |

---

> **Guide réalisé par Abder** — Configuration Wazuh SIEM avec hardening Ubuntu Server