2026-05-06T08:27:27+00:00 https://blog.folf.fr Tristan BRINGUIER blog@folf.fr 2026-04-27T08:19:13+00:00 2026-04-22T14:16:25+00:00 https://blog.folf.fr/snippets/2026/03/16/naim-uniti/ > [!NOTE] > Il n'existe **aucune documentation officielle** de Naim Audio pour cette API. Tout a été reverse-engineered depuis le trafic réseau de l'app Naim et confirmé par des intégrations open-source (Home Assistant, Homebridge, Unfolded Circle, etc.). ## Connexion - **Port HTTP** : `15081` - **Port TCP streaming** : `4545` (push JSON temps réel, pas HTTP) - **Pas d'authentification** (réseau local uniquement) - **URL de base** : `http://<IP>:15081` - **Hostname mDNS** : `<modèle>-<serial>.local` ``` http://192.168.1.42:15081 ``` ## Informations système - ```shell curl http://<IP>:15081/ ``` - Retourne la version de l'API, le changestamp, la classe (`object.api.support`), la charge CPU. - ```shell curl http://<IP>:15081/system ``` - Infos complètes : `model`, `hostname`, `hardwareSerial`, `hardwareType`, `appVer` (firmware), `ipAddress`, `kernel`, `machine`, `udid`, `displayType`, `firstTimeSetupComplete`. ## Alimentation - ```shell curl http://<IP>:15081/power ``` - État actuel : `system` (`on` / `lona`), `state` (`on` / `standby`), `powerMode`, `serverMode`, `standbyTimeout`. - ```shell curl -X PUT "http://<IP>:15081/power?system=on" ``` - Allumer l'appareil. - ```shell curl -X PUT "http://<IP>:15081/power?system=lona" ``` - Mettre en veille. La valeur est bien `lona`, pas `off` ni `standby`. ## Volume / Audio - ```shell curl http://<IP>:15081/levels/room ``` - Retourne `volume` (0-100), `mute` (0/1), `balance` (-50 à 50), `headphoneDetect` (0/1). - ```shell curl http://<IP>:15081/levels ``` - Vue d'ensemble des niveaux audio (idem + `mode`). - ```shell curl -X PUT "http://<IP>:15081/levels/room?volume=45" ``` - Régler le volume (entier, 0 à 100). - ```shell curl -X PUT "http://<IP>:15081/levels/room?mute=1" ``` - Couper le son. - ```shell curl -X PUT "http://<IP>:15081/levels/room?mute=0" ``` - Rétablir le son. - ```shell curl -X PUT "http://<IP>:15081/levels/room?balance=-20" ``` - Régler la balance (-50 = tout à gauche, 50 = tout à droite). ## Lecture / Transport - ```shell curl http://<IP>:15081/nowplaying ``` - Métadonnées complètes : `transportState`, `title`, `artist`, `album`, `artwork`, `codec`, `bitDepth`, `bitRate`, `sampleRate`, `channels`, `duration`, `transportPosition`, `repeat`, `shuffle`, `source`, `station`, `genre`, `live`. - **transportState** : `0` = arrêté, `1` = en pause, `2` = en lecture, `3` = buffering. - ```shell curl "http://<IP>:15081/nowplaying?cmd=play" ``` - Lecture. - ```shell curl "http://<IP>:15081/nowplaying?cmd=pause" ``` - Pause. - ```shell curl "http://<IP>:15081/nowplaying?cmd=playpause" ``` - Basculer lecture/pause. - ```shell curl "http://<IP>:15081/nowplaying?cmd=stop" ``` - Arrêt. - ```shell curl "http://<IP>:15081/nowplaying?cmd=next" ``` - Piste suivante. - ```shell curl "http://<IP>:15081/nowplaying?cmd=prev" ``` - Piste précédente. - ```shell curl "http://<IP>:15081/nowplaying?cmd=seek&position=120000" ``` - Seek à la position donnée (en millisecondes, ici 2 min). - ```shell curl -X PUT "http://<IP>:15081/nowplaying?repeat=0" ``` - Répétition désactivée. - ```shell curl -X PUT "http://<IP>:15081/nowplaying?repeat=1" ``` - Répéter la piste en cours. - ```shell curl -X PUT "http://<IP>:15081/nowplaying?repeat=2" ``` - Répéter toute la file. - ```shell curl -X PUT "http://<IP>:15081/nowplaying?shuffle=1" ``` - Activer la lecture aléatoire. - ```shell curl -X PUT "http://<IP>:15081/nowplaying?shuffle=0" ``` - Désactiver la lecture aléatoire. ## Sources / Entrées - ```shell curl http://<IP>:15081/inputs ``` - Liste toutes les sources disponibles. Chaque entrée contient `name`, `ussi`, `class`, `alias`, `disabled`, `selectable`, `multiroomMaster`. - ```shell curl http://<IP>:15081/inputs/spotify ``` - Infos sur une source spécifique. - ```shell curl "http://<IP>:15081/inputs/spotify?cmd=select" ``` - Basculer sur cette source. - ```shell curl "http://<IP>:15081/inputs/radio?cmd=play" ``` - Sélectionner et lancer la lecture d'une source streaming. ### Identifiants de source connus | ID | Nom | Classe | |---|---|---| | `ana1` – `ana4` | Analogique 1–4 | `object.input.analogue` | | `dig1` – `dig5` | Numérique 1–5 | `object.input.digital` | | `hdmi` | HDMI (ARC) | `object.input.hdmi` | | `bluetooth` | Bluetooth | `object.input.bluetooth` | | `radio` | Radio Internet | `object.input.radio.internet` | | `spotify` | Spotify Connect | `object.input.spotify` | | `tidal` | TIDAL | `object.input.tidal` | | `qobuz` | Qobuz | `object.input.qobuz` | | `usb` | USB | `object.input.usb` | | `airplay` | AirPlay | `object.input.airplay` | | `gcast` | Chromecast built-in | `object.input.googlecast` | | `upnp` | Serveurs UPnP | `object.input.upnp` | | `playqueue` | File de lecture | `object.input.playqueue` | | `files` | Fichiers locaux / Démo | `object.input.files` | | `roon` | Roon Ready | — | | `multiroom` | Multiroom | — | > [!TIP] > Toutes les sources ne sont pas présentes sur tous les modèles. L'endpoint `/inputs` retourne uniquement celles disponibles sur votre appareil. ## Favoris / Presets - ```shell curl http://<IP>:15081/favourites ``` - Liste tous les favoris. Chaque favori contient `name`, `ussi`, `available`. - ```shell curl "http://<IP>:15081/favourites/3754de0b49624983ab2179ed8524e9a2?cmd=play" ``` - Lancer un favori par son UUID (portion après `favourites/` dans le champ `ussi`). ## File de lecture - ```shell curl http://<IP>:15081/inputs/playqueue ``` - Infos sur la file de lecture. Le champ `current` contient le chemin vers la piste en cours (utilisable comme endpoint GET pour les métadonnées détaillées). ## Réseau - ```shell curl http://<IP>:15081/network ``` - Configuration réseau : `connectionState`, `current` (`network/wired` ou `network/wifi`), `dhcp`, `dns1`, `dns2`, `dnsName`, `gateway`, `hostname`, `ipAddress`, `macAddress`, `netmask`, `workgroup`. ## Découverte SSDP/UPnP Les appareils Naim s'annoncent comme **MediaRenderer UPnP**. Pour les trouver sur le réseau : - ```shell gssdp-discover -t urn:schemas-upnp-org:device:MediaRenderer:2 --timeout=5 ``` - Recherche SSDP des MediaRenderers. L'en-tête `LOCATION` pointe vers le XML de description contenant `manufacturer`, `friendlyName`, `modelName`, `serialNumber`, `UDN`. ## Socket TCP temps réel (port 4545) > [!IMPORTANT] > Ce n'est **pas du HTTP**. C'est une connexion TCP brute qui pousse du JSON en continu. - ```shell nc <IP> 4545 ``` - Se connecter et recevoir les mises à jour en temps réel (état de lecture, métadonnées, position). - Valeurs de `state` : `playing`, `paused`, `stopped`. Structure JSON poussée : ```json { "data": { "state": "playing", "trackRoles": { "title": "Nom de la piste", "icon": "https://url-artwork...", "mediaData": { "metaData": { "artist": "Artiste", "album": "Album" }, "activeResource": { "bitsPerSample": "24", "sampleFrequency": "96000" } } }, "mediaRoles": { "title": "Nom de la source", "mediaData": { "metaData": { "serviceID": "spotify" } } }, "status": { "duration": 355000 } }, "playTime": { "i64_": 45000 } } ``` 2026-04-27T08:19:13+00:00 2026-04-22T14:16:25+00:00 https://blog.folf.fr/snippets/2026/03/01/pipewire/ ## Identifier les propriétés de son DAC - ```shell wpctl status ``` - Identifier le périphérique de sortie actuellement utilisé par PipeWire - ```shell cat /proc/asound/cards ``` - Identifier le numéro de la carte ALSA correspondant au DAC - ```shell cat /proc/asound/cardX/stream0 ``` - Identifier les capacités de décodage du DAC ## Créer la configuration adéquate - ```shell mkdir -p ~/.config/pipewire/pipewire.conf.d/ ``` - Créer un dossier de configuration PipeWire propre à notre compte utilisateur - ```shell ~/.config/pipewire/pipewire.conf.d/10-hires-dac.conf context.properties = { # Fréquence par défaut default.clock.rate = 384000 # Autoriser PipeWire à basculer automatiquement sur ces fréquences sans rééchantillonner default.clock.allowed-rates = [ 44100 48000 88200 96000 176400 192000 352800 384000 ] # Profondeur de bits maximale pour exploiter le DAC default.audio.format = "S32_LE" # Amélioration de la latence et réduction des craquements default.clock.quantum = 1024 default.clock.min-quantum = 32 default.clock.max-quantum = 8192 } ``` - Adapter la configuration avec les paramètres spécifique au modèle du DAC, récupérés avec les commandes précédentes. - ```shell systemctl --user restart pipewire pipewire-pulse wireplumber ``` - Redémarrer PipeWire pour appliquer la nouvelle configuration. ## Tester et Vérifier la qualité de lecture - ```shell grep -i "Momentary freq" /proc/asound/card*/stream0 ``` - Après avoir lancé la lecture d'un fichier Hi-Res, permet de voir en quelle qualité est lue le fichier en temps réel. - ```shell pw-top ``` - Petit outil GUI/CLI permettant de voir quel processus décode actuellement du contenu audio et à quelle qualité. Il est important de ne pas modifier le volume et de laisser tout à 100% pour ne pas forcer Linux à re-encoder le flux audio ! 2026-04-27T08:19:13+00:00 2026-04-22T14:16:25+00:00 https://blog.folf.fr/snippets/2026/03/01/linux-debian-proxmox/ ## APT - ```shell apt-cache policy (package) ``` - Permet de déterminer à partir de quel dépôt est installé / téléchargé un paquet. Ainsi, si jamais plusieurs dépôts proposent le même paquet, il est possible de savoir celui qui aura la plus haute priorité. - ```shell apt-cache show (package) ``` - Permet d'obtenir les métadonnées d'un paquet. ## GRUB - ```shell /etc/default/grub GRUB_CMDLINE_LINUX="net.ifnames=0 biosdevname=0" ``` - Permet de forcer le nommage des interfaces réseau en ethX plûtot que enpXsX. Les interfaces en enpXsX sont succeptibles de changer aléatoirement en cas de modification matérielle ou montée de version logicielle. - ```shell /etc/default/grub GRUB_CMDLINE_LINUX="console=tty0 console=ttyS0,115200n8" GRUB_TERMINAL="console serial" GRUB_SERIAL_COMMAND="serial --speed=115200 --unit=0 --word=8 --parity=no --stop=1" update-grub update-initramfs -u -k all sudo systemctl enable serial-getty@ttyS0.service ``` - Permet d'activer GRUB / un shell sur le port console. ## LVM - ```shell lvmconfig --validate ``` - Permet de vérifier la syntaxe de configuration du fichier `/etc/lvm/lvm.conf` ## BASH - ```shell ~/.bashrc export HISTSIZE=-1 export HISTFILESIZE=-1 export HISTTIMEFORMAT="%F %T " export PROMPT_COMMAND="history -a; $PROMPT_COMMAND" shopt -s histappend ``` - Permet de sauvegarder de manière illimitée l'historique bash. - ```shell grep -rnw '/path/où/chercher/' -e "string" ``` - Permet de chercher une string de manière récursive dans un dossier voulu. ## Proxmox - ```shell bash -c "$(curl -fsSL https://raw.githubusercontent.com/community-scripts/ProxmoxVE/main/tools/pve/kernel-clean.sh)" ``` - Permet de désinstaller les anciennes versions du noyau Linux qui subsistent en cas de mise à jour Proxmox. ## Git - ```shell git rebase -i sha256commit(^) ``` - Permet de lancer un rebase interactif à partir du commit indiqué (^ indique son parent) - ```shell git fetch --all git reset --hard origin/main ``` - Permet de forcer git à revenir à la version sur le serveur (pour annuler les modifications locales) ## Qemu - ```shell qemu-img convert -f vmdk -O qcow2 source.vmdk destination.qcow2 ``` - Permet de convertir une image de disque virtuelle VMDK en QCOW2. ## VirtualBox - ```shell VBoxManage modifymedium disk "/chemin/vers/image/disque" --compact ``` - Permet de compacter un fichier d'image disque - ```shell zerofree -v /dev/sdaX ``` - Permet de remplir de zéros les emplacements vides d'un disque dur Linux formaté en ext4. ## systemd - ```shell systemctl list-jobs systemctl list-units --type=service --state=activating ``` - Identifier les services qui sont en cours de démarrage, pouvant bloquer le démarrage complet de l'hôt.e ```shell systemctl status mon-service.service journalctl -u mon-service.service -f ``` - Permet d'approfondir pourquoi un service ne démarre pas en regardant l'intégralité de ses logs. ## openssh - ```shell ~/.ssh/config Host monserveur HostName mon.serveur.fr User utilisateur ForwardAgent yes ``` - Permet de pré-définir / enregistrer des paramètres de session SSH pour voir se connecter en une seule commande rapidement. - `ForwardAgent yes` permet de passer l'agent SSH du client vers l'hôte pour transférer les clés SSH entre les deux. 2026-04-27T08:19:13+00:00 2026-04-22T14:16:25+00:00 https://blog.folf.fr/snippets/2026/03/01/dell/ ## M1000e - ```shell racadm getfaninfo -d -p glacier -w 50 ``` - Écrase la vitesse des ventilateurs par 50%. - ``` racadm getfanreqinfo ``` - Récupère la vitesse des ventilateurs effective et demandée par les blades. 2026-04-27T08:19:13+00:00 2026-04-22T14:16:25+00:00 https://blog.folf.fr/bunkerweb/ ## Introduction **Depuis que je peux héberger toutes sortes d’applications**, **[accessibles via des adresses IPv4 publiques](https://blog.folf.fr/wireguardl)**, **la question de leur sécurité m’est devenue centrale**. **Beaucoup se tournent vers** **[NGINX](https://nginx.org/)** — parfois accompagné d’**interfaces conviviales** **comme** **[NGINX Proxy Manager](https://github.com/NginxProxyManager/nginx-proxy-manager)** — ou vers d’**autres reverse proxies** tels que **[Caddy](https://github.com/caddyserver/caddy)** ou **[HAProxy](https://github.com/haproxy/haproxy)**. Pourtant, **ces solutions restent *[peu sécurisées](https://www.reddit.com/r/selfhosted/comments/176znvu/security_of_sites_behind_reverse_proxy/) par défaut***. **Un certificat** **TLS/SSL** **assure** certes **le chiffrement des échanges**, **empêchant l’interception des données** sensibles (***sauf en cas d’attaque [MITM](https://fr.wikipedia.org/wiki/Attaque_de_l%27homme_du_milieu)***), **mais la sécurité ne s’arrête pas là** : **de nombreux** autres **aspects** **doivent être pris en compte** ! Il faut notamment **se prémunir contre les exploits applicatifs**, par exemple (*liste non exhaustive*) : - les injections **SQL** ; - le **cross-site scripting** ; - l’**élévation de privilèges**. **Un reverse-proxy se contente de relayer le trafic** ; **s’il n’intègre pas de protections**, **il transmettra l’exploit** sans sourciller. La **généralisation de l’hébergement** via des **conteneurs** **Docker** **offre** un **certain niveau d’isolation** au niveau du **noyau Linux**, **mais une application compromise** **reste une porte d’entrée** potentielle **pour la fuite de données**. **Il existe aussi des WAF grand public** et **professionnels**, comme **Cloudflare**, **qui proposent gratuitement** de **nombreuses fonctionnalités**. ***Malheureusement**, **ces solutions sont souvent mal déployées** (par ex. : non-restriction des IP à [**celles de Cloudflare**](https://www.cloudflare.com/ips/)) et **soulèvent des** [**questions éthiques**](https://0xacab.org/dCF/deCloudflare/-/blob/master/readme/fr.md) : confier son trafic à une société américaine, c’est accepter un intermédiaire puissant, ce qui, dans le contexte politique actuel, peut prêter à débat.* **Toutes ces réflexions m’ont conduit à chercher un WAF** **simple d’utilisation et souverain 🇫🇷**, **c’est ainsi que j’ai découvert** **[BunkerWeb](https://bunkerweb.io)** ! ## Présentation de BunkerWeb **[BunkerWeb](https://bunkerweb.io)** est un **pare-feu d’applications Web** (**[Web Application Firewall](https://fr.wikipedia.org/wiki/Web_application_firewall)**) **open-source** de **nouvelle génération** qui fonctionne comme un [**reverse-proxy**](https://fr.wikipedia.org/wiki/Proxy_inverse) **complet** **basé** **sur** **NGINX**. Il est **développé** et **maintenu** par **Bunkerity**, **entreprise française** spécialisée en cybersécurité, ce qui inscrit la solution dans une **démarche** de **souveraineté numérique**. Publié **sous licence** **AGPL v3**, son **code** reste **entièrement** **auditable** et **modifiable**, **garantissant** à chacun la maîtrise de ses briques de **sécurité** et de leur évolution. **Conçu pour la souveraineté** jusqu’au bout, BunkerWeb est totalement **auto-hébergeable** : il se déploie **[on-premises](https://en.wikipedia.org/wiki/On-premises_software)** sur un **Linux** ou via **Docker**. **Sans aucune dépendance** **à** un **SaaS externe**, toutes les règles, journaux et certificats TLS **demeurent sous votre contrôle**, répondant aux **exigences** **les plus strictes** en matière de **résidence** et de **conformité des données.** **Par défaut**, BunkerWeb **protège** vos **services** avec une approche secure by default : **intégration** **de** **[ModSecurity](https://github.com/owasp-modsecurity/ModSecurity)** **et** **de** l’[**OWASP CRS**](https://github.com/coreruleset/coreruleset), **durcissement TLS**, **bannissement automatique** des **comportements anormaux**, **défis pour les robots**, **rate limiting**, **blacklists IP** **et bien plus**. Un système de **plugins** **permet** d’**étendre** **les capacités** (PHP, notifications, etc.), tandis que l’**interface Web** **simplifie** **la gestion** depuis n’importe où. **Après avoir examiné l’ensemble des critères évoqués plus haut** et **échangé** **avec plusieurs développeurs** du projet lors du [**FIC**](https://europe.forum-incyber.com/), j’ai **décidé de déployer** **BunkerWeb au sein de mon** **homelab**. Quelques mois plus tard, **le bilan est sans appel** : **j’en suis pleinement satisfait**. **Dans cet article**, **nous verrons pas à pas comment installer et configurer BunkerWeb**. ## Pré-requis > [!NOTE] > **BunkerWeb peut s'exécuter sur n'importe quel environnement Docker.** > **Prévoyez** au **minimum** **2 vCPU** et **4 Go de RAM** pour un **usage standard** ; dans des **contextes plus exigeants**, **préférez** plutôt **4 vCPU** et **16 Go de RAM**. #### Pourquoi autant de ressources ? - **La mémoire est mise à contribution** parce qu’un **processus ModSecurity dédié** est **lancé pour chaque sous-domaine** — une option que l’**on peut désactiver** sur les **machines disposant de peu de RAM**, comme nous le verrons plus loin. - **La charge CPU, quant à elle**, provient surtout du **chiffrement avancé** et des **optimisations à la volée** (compression **[GZip](https://fr.wikipedia.org/wiki/Gzip)** ou **[Brotli](https://fr.wikipedia.org/wiki/Brotli)**), qui **allègent le poids des fichiers** **transmis aux clients** au détriment d’un surcroît de calcul. #### Ports réseau à autoriser | Port | Protocole | Rôle | |------|-----------|------| | **80** | TCP | HTTP | | **443** | TCP | HTTPS | | **443** | UDP | HTTP/3 🚀 | > [!NOTE] > **Pour le trafic réseau**, **pensez à autoriser les ports** **80/TCP**, **443/TCP** et **443/UDP**. > Le port **443 en UDP est indispensable pour la prise en charge de HTTP/3 : le futur 🚀 est à nos portes !** #### Règles DNS **Assurez-vous également** de **créer un enregistrement** **DNS** **pour l’interface d’administration Web** ; disposer de cette entrée **dès le départ** permet d’**effectuer la configuration initiale** de BunkerWeb **directement depuis l’URL** correspondante. De même, **chaque sous-domaine que vous protégerez avec BunkerWeb devra auparavant avoir son enregistrement DNS approprié** !! **Une fois ces prérequis validés, passons au déploiement de notre WAF !** ## Déploiement de BunkerWeb avec Docker Compose **Commencez par créer un fichier** **`compose.yaml`**, **puis** **copiez-y** **le bloc de configuration ci-dessous** : ```yaml ################################################################################ ## BunkerWeb – Docker Compose # ## Ce fichier déploie BunkerWeb (reverse-proxy + WAF), son ordonnanceur, # ## l’interface Web d’administration et une base PostgreSQL pour le stockage. # ## # ## → AVANT DE PASSER EN PROD : # ## - Changez le mot de passe « motdepasseachanger » # ## # ## → POUR LE RÉSEAU EXTERNE 'bw-apps' : # ## - Créez-le avec : docker network create bw-apps # ################################################################################ ################################ Variables globales ############################ ## Regroupées sous une ancre YAML (&bw-env) pour pouvoir être ré-utilisées ## (« merge key » <<) dans les différents services. x-bw-env: &bw-env ## Liste d’IP autorisées à appeler l’API interne de BunkerWeb. ## Indiquer le même subnet que celui du réseau « bunker » ## Format : réseaux CIDR séparés par des espaces. API_WHITELIST_IP: "127.0.0.0/8 10.20.30.0/24" ## Chaîne de connexion à la base PostgreSQL (SQLAlchemy). ## ➜ Changez le mot de passe. DATABASE_URI: "postgresql://bunkerweb:motdepasseachanger@bw-db:5432/db" ############################################################################### ## Services ## ############################################################################### services: ########################################################################### ## 1. Reverse-proxy / WAF ## ########################################################################### bunkerweb: image: bunkerity/bunkerweb:latest ## Utilise la dernière image stable ## ── Ports exposés ────────────────────────────────────────────────────── ports: - "80:8080/tcp" ## HTTP vers port interne 8080 - "443:8443/tcp" ## HTTPS vers port interne 8443 - "443:8443/udp" ## HTTP/3 (QUIC) sur le même port 8443 en UDP ## ── Variables d’environnement ───────────────────────────────────────── environment: <<: *bw-env ## Fusionne les variables communes ## ── Redémarrage automatique ─────────────────────────────────────────── restart: unless-stopped ## Relance sauf si vous l’arrêtez manuellement ## ── Réseau ──────────────────────────────────────────────────────────── networks: - bunker # Place le conteneur sur le réseau « bunker » - bw-apps # Place le conteneur sur le réseau externe « bw-apps » ## ── Logs ────────────────────────────────────────────────────────────── logging: driver: json-file options: max-size: "10m" ## Rotation : 10 Mo par fichier max-file: "10" ## Garde 10 fichiers ########################################################################### ## 2. Ordonnanceur (scheduler) ## ########################################################################### bw-scheduler: image: bunkerity/bunkerweb-scheduler:latest environment: <<: *bw-env BUNKERWEB_INSTANCES: "bunkerweb" SERVER_NAME: "" MULTISITE: "yes" UI_HOST: "http://bw-ui:7000" volumes: - bw-data:/data ## Monte les données persistantes (policies, etc.) restart: unless-stopped networks: - bunker ## Même réseau que bunkerweb - bunker-db ## Accès direct à la base ########################################################################### ## 3. Interface Web d’administration ## ########################################################################### bw-ui: image: bunkerity/bunkerweb-ui:latest environment: <<: *bw-env restart: unless-stopped networks: - bunker ## Doit voir le proxy - bunker-db ## Doit voir PostgreSQL ########################################################################### ## 4. Base de données PostgreSQL ## ########################################################################### bw-db: image: postgres:17 environment: POSTGRES_DB: "db" POSTGRES_USER: "bunkerweb" ## ☠️ À CHANGER ABSOLUMENT AVANT PROD ! ## ➜ Pensez aussi à mettre à jour DATABASE_URI plus haut. POSTGRES_PASSWORD: "motdepasseachanger" volumes: - bw-dbdata:/var/lib/postgresql/data ## Persistance des données SQL restart: unless-stopped networks: - bunker-db ## Isolé du reste pour sécurité ############################################################################### ## Réseaux ## ############################################################################### networks: ## Réseau frontal (reverse-proxy, scheduler, UI, etc.) bunker: name: bunker ipam: driver: default config: - subnet: 10.20.30.0/24 ## Réseau identique à celui autorisé dans BunkerWeb ## Réseau backend (UI & scheduler ↔ PostgreSQL). Non exposé au proxy. bunker-db: name: bunker-db ## Réseau pour connecter vos applications backend à BunkerWeb. ## Doit être créé manuellement sur l'hôte Docker avant de lancer ce compose : ## → docker network create bw-apps bw-apps: name: bw-apps external: true ############################################################################### ## Volumes ## ############################################################################### volumes: ## Policies, certificats, listes IP, etc. bw-data: ## Données SQL de PostgreSQL bw-dbdata: ``` **N’oubliez pas de changer le mot de passe** `"motdepasseachanger"` **par un autre aléatoire** 🔐 ! **Vous pouvez également le faire avec la commande suivante** (qui génère un mot de passe aléatoire de 32 caractères et remplace compose.yaml à votre place) : ```shell sed -i -e "s|motdepasseachanger|$(openssl rand -base64 32 | tr -dc 'A-Za-z0-9' | head -c32)|g" -e '/^\s*#/d' -e 's/\s*#.*$//' compose.yaml ``` ```shell docker network create bw-apps ``` **Une fois le fichier compose.yaml prêt**, il vous suffit de **`docker compose up -d`** **puis passez à la première configuration via l’interface web** ! **Le premier démarrage peut prendre un certain temps** ⏰, vous pouvez **observer l’avancement** via les **logs** avec la commande suivante : **`docker compose logs --follow`** ## Premier démarrage via l’interface web 1. **Rendez vous sur `https://url-de-votre-bunker.web/setup` afin de retrouver la page de démarrage suivante :**  **Dans un premier temps**, vous devez **renseigner** les **propriétés** du **compte administrateur**. 2. **Ensuite, vous devez renseigner le hostname public de votre instance BunkerWeb.**  > [!WARNING] > Il ne faut **surtout pas toucher** à **UI Host** et **UI URL** !! **En ce qui en est de la gestion des certificats TLS/SSL**, **l’implémentation de Let’s Encrypt** est **très simple d’utilisation** ! Il vous **suffit de cocher** **« Auto Let’s Encrypt »** pour que cela soit **géré de manière automatique**, et de **mentionner un mail** pour **recevoir les informations Let’s Encrypt**. **Vous avez aussi la possibilité de demander des certificats TLS/SSL via** **DNS**, **permettant** ainsi donc **l’usage de** **Wildcards** (`*.votredomaine.tld`). Pour cela : - **Sélectionnez** comme **Challenge Type** : `dns` - **Choisissez** votre **DNS Provider** - **Renseignez** la **clé d’API** adéquate 3. **Une fois toutes les informations renseignées, BunkerWeb propose un récapitulatif des paramètres renseignés précédemment.** Vous pouvez **valider** et **lancer l’installation**.  **Après avoir patienté** le temps de **la** **mise en place** de BunkerWeb, vous devriez être **redirigé sur la page de** **login**. **Vous pouvez vous y connecter**.  ## Présentation de l’interface web et paramétrage rapide **Bienvenue sur l’interface web de** **BunkerWeb** !  **Sur la page d’accueil**, vous **retrouverez** quelques **statistiques** **essentielles** liées à **votre** **instance**. **Dans la barre latérale**, à gauche, se trouvent les **menus suivants** : - **Home** : ***Page d’accueil*** - **Instances** : ***Uniquement utile pour un cluster**, c’est dans cette rubrique que sont renseignées les **différentes instances composant le cluster*** - **Global Config** : ***Gérer la configuration générale** **et commune à tous les services*** - **Services** : ***Gérer la configuration de chaque VirtualHost** / **service*** - **Configs** : ***Gérer les configurations NGINX avancées*** - **Plugins** : ***Gérer les modules supplémentaires*** - **Cache** : ***Gérer les fichiers mis en cache*** - **Reports** : ***Consulter les alertes et blocages*** - **Bans** : ***Consulter les bannissements*** - **Jobs** : ***Gérer les tâches planifiées*** - **Logs** : ***Consulter les fichiers de journalisation*** **Les catégories principales** **que j’utilise régulièrement** sont **Global Config**, **Services** et **Bans** / **Report**. **Nous allons maintenant passer en revue** **quelques paramètres** **pratiques**, pour ce faire, **rendez-vous dans la rubrique** « **Global Config** »  **En haut à gauche**, le **menu déroulant** vous **permet de choisir la configuration de chaque plug-in** ; **en haut à droite**, le **bouton** **Save** enregistre vos changements. **Ci-dessous**, vous trouverez **les principaux réglages** sur mon **instance personnelle** : #### ⚙️ Général * `LISTEN_STREAM` : **false** – *désactive la fonctionnalité Stream de NGINX (permettant de forward les ports).* * `USE_TCP` : **false** * `USE_UDP` : **false** #### 🗜️ Brotli * `USE_BROTLI` : **true** – *active la compression Brotli pour des transferts encore plus légers (vous pouvez ensuite affiner niveau et types MIME).* #### 📦 Cache client * `USE_CLIENT_CACHE` : **true** – *autorise le cache côté navigateur, soulageant ainsi votre serveur.* #### 🗜️ Gzip * `USE_GZIP` : **true** – *démarre la compression Gzip, largement reconnue ; ajustez ensuite les paramètres selon vos besoins.* #### 🔐 Let’s Encrypt * `AUTO_LETS_ENCRYPT` : **true** – *préremplit les champs Let’s Encrypt lors de la création d’un service.* * `EMAIL_LETS_ENCRYPT` : **mail@votredomaine.tld** #### 🛡️ ModSecurity * `USE_MODSECURITY_GLOBAL_CRS` : **true** – *⚠️⚠️ à envisager seulement si votre machine dispose de peu de RAM⚠️⚠️.* #### 🔄 Reverse Proxy * `REVERSE_PROXY_INTERCEPT_ERRORS` : **false** – *permet d’afficher l’erreur native du service (utile, par exemple, avec Guacamole).* #### 🔒 SSL * `REDIRECT_HTTP_TO_HTTPS` : **true** – *force la redirection vers HTTPS.* * `SSL_PROTOCOLS` : **TLSv1.3** – *limite les échanges au protocole le plus récent.* **Passons à présent au déploiement d’un service.** ## Déployer un service pas à pas > [!NOTE] > **Prérequis :** **assurez-vous d’avoir créé au préalable l’enregistrement DNS du service** ; il servira à l’**émission automatique du certificat** **Let’s Encrypt**. Ouvrez la section **Services** puis cliquez sur **Create new service**. Suivez ensuite les étapes décrites ci-après. ### 1 | Web service – *Front service*  * **`SERVER_NAME`** : nom(s) de domaine à protéger. * **Let’s Encrypt** : si **`AUTO_LETS_ENCRYPT`** n’est *pas* à `true`, renseignez les champs manuellement. * **Template** : choisissez un profil de sécurité (*low*, *medium*, *high*) adapté à la criticité de l’application. Ces réglages concernent la *face publique* du reverse-proxy exposée sur Internet. ### 2 | Web service – *Upstream server*  * **`REVERSE_PROXY_HOST`** : URL interne du service (incluant le schéma `http://` ou `https://`). * **`REVERSE_PROXY_WS`** : activez-le pour la prise en charge des WebSockets. ### 3 | HTTP – *General*  | Variable | Rôle | Suggestion | | --------------------- | ------------------------------- | ---------------------------------------------------------------- | | **`ALLOWED_METHODS`** | Méthodes HTTP autorisées | Conservez les valeurs du template, sauf besoin spécifique. | | **`MAX_CLIENT_SIZE`** | Taille max. du corps de requête | Ex. `1024m` pour autoriser des uploads massifs. | | **`SSL_PROTOCOLS`** | Versions TLS admises | Restreignez à `TLSv1.3` si vous exigez le niveau le plus strict. | ### 4 | HTTP – *Headers*  Vous pouvez ici : * ajouter ou supprimer des en-têtes personnalisés ; * activer **`USE_CORS`** pour contrôler le partage de ressources entre sites (pratique pour limiter le vol de cookies). > [!TIP] > Les valeurs par défaut conviennent à la plupart des cas. ### 5 | Security – *Bad behavior*  Le module **Bad behavior** bannit les clients générant trop d’erreurs. | Variable | Par défaut | Fonction | | ------------------------------- | ----------------------------- | ------------------------------------ | | **`BAD_BEHAVIOR_STATUS_CODES`** | `400 401 403 404 405 429 444` | Codes suivis. | | **`BAD_BEHAVIOR_THRESHOLD`** | `10` | Nombre d’erreurs déclenchant le ban. | | **`BAD_BEHAVIOR_COUNT_TIME`** | `60 s` | Fenêtre de comptage. | | **`BAD_BEHAVIOR_BAN_TIME`** | `86400 s` (24 h) | Durée du ban. | Les valeurs par défaut sont généralement suffisantes. ### 6 | Security – *Blacklisting*  Activez **`USE_BLACKLIST`** pour bloquer immédiatement les IP ou user-agents référencés dans les listes internes ou personnelles. Par défaut, la configuration protège déjà contre les robots les plus agressifs. ### 7 | Security – *Limiting*  * **`USE_LIMIT_CONN`** : limite le nombre de connexions simultanées. * **`USE_LIMIT_REQ`** : plafonne le débit de requêtes (HTTP 429 en cas d’excès). > Ajustez les quotas uniquement si un service légitime se voit bloqué. ### 8 | Security – *Antibot*  * **`USE_ANTIBOT`** : active la protection. * **`ANTIBOT_MODE`** : `captcha` (résolution manuelle) ou `javascript` (tests invisibles). * **`ANTIBOT_PROVIDER`** : *reCAPTCHA*, *hCaptcha*, *Turnstile*, etc. (clé site & secret requis). Si jamais vous avez besoin de rajouter un captcha, choisissez `javascript` tant que possible pour préserver l’ergonomie. Si besoin de sécurité supplémentaire. puis passez en `captcha` sur les pages les plus sensibles. ### 9 | Security – *Auth basic*  Placez un verrou HTTP Basic en activant **`USE_AUTH_BASIC`** puis : * renseignez `login:password` (ou hashés) dans **`AUTH_BASIC_LIST`**, * ou référencez un fichier `.htpasswd` avec **`AUTH_BASIC_FILE`**. ### 10 | Security – *Country*  * **`BLACKLIST_COUNTRY`** : bloque la liste de pays indiqués (`RU KP` par ex.). * **`WHITELIST_COUNTRY`** : autorise *uniquement* les pays listés (`FR BE`, etc.). Toute requête provenant d’un pays exclu reçoit un **403 Forbidden**. ### 11 | Security – *ModSecurity*  ModSecurity analyse chaque requête / réponse à l’aide du Core Rule Set (OWASP). Conservez les réglages par défaut, puis excluez au besoin des règles via la rubrique **Custom configuration**. ### 12 | Finaliser le déploiement Cliquez sur **Save** : BunkerWeb lance immédiatement le déploiement en arrière-plan (**patientez ≈ 1 min**). **Votre service est maintenant protégé et accessible à l’extérieur !** ## Conclusion **Et voilà**, **vous avez maintenant un reverse-proxy sécurisé pour toutes vos applications !** J’améliorerai cette documentation au fil du temps en fonction des situations et problèmes que je rencontrerais à l’avenir. ###### [Mettre en place un reverse-proxy sécurisé grâce au WAF BunkerWeb]({{ site.url }}/bunkerweb) by [{{ site.author.name }}]({{ site.url }}) is licensed under [CC BY-NC-SA 4.0](https://creativecommons.org/licenses/by-nc-sa/4.0/) #### Implémentations futures : - Ajout d’exceptions ModSecurity - Ajout de cas par cas applications Authentik 2026-05-06T08:26:45+00:00 2026-04-22T14:16:25+00:00 https://blog.folf.fr/wireguard/ # Introduction J'ai chez moi un **serveur** sur lequel tourne [**Proxmox**](https://www.proxmox.com/), un **hyperviseur** qui me permet de créer des **machines virtuelles** et des [**conteneurs Linux**](https://linuxcontainers.org/) afin d'héberger **différents services** pour mes diverses activités d'**auto-hébergement**. Seulement, ne possédant qu'un seul abonnement internet de particulier, et par conséquent **une seule IP résidentielle**, je suis vite limité par le **nombre de ports disponibles** et je ne peux pas faire tourner tous les services que je souhaite dans les meilleures conditions. Encore heureux, je peux **ouvrir mes ports**, mais certains opérateurs en France **retirent cette** option au fil du temps, ou bien les **box 4G/5G** ne proposent pas cette option à cause du **[CG-NAT](https://fr.wikipedia.org/wiki/Carrier-grade_NAT)**. Ces **limitations** m'ont amené à **mettre en place une solution pour avoir plusieurs adresses IP** **chez soi**, **dédiées**, **protégées** par un **Anti-DDOS** et **peu chères**. N'ayant trouvé aucune solution existante, j'ai bidouillé et mis en place la mienne. # Principe de fonctionnement  # Le choix de l'hébergeur J'ai choisi [**HostMyServers**](https://www.hostmyservers.fr/), un **hébergeur français** 🇫🇷 avec **plusieurs années d'existence**, car ils proposent des **tarifs très intéressant**s au niveau du **réseau** et la **qualité de service est correcte**. Le premier **[VPS SSD](https://www.hostmyservers.fr/vps-ssd)** suffit amplement pour un **traffic raisonnable (~250Mbps)** dans le **tunnel** et inclus une **protection Anti-DDOS basique** **contre les attaques simples**. Leur **support** via le site est relativement **réactif**, mais je n'ai **pas rencontré de problèmes** après plus de deux ans chez eux.  Ce qui nous concerne le plus, c'est le **tarif des adresses IP supplémentaires**. Chez HMS, elles **coûtent 2€ à vie**. D'**autres hébergeurs** comme [**RoyaleHosting**](https://royalehosting.net/store/vps) ou [**OVH**](https://www.ovhcloud.com/fr/vps/) peuvent proposer un **réseau de meilleure qualité** mais à un **prix bien plus important**. Ce tutoriel se concentrera sur HMS. # Achat d'adresses IP supplémentaire **Pour faire marcher cette documentation, il est nécessaire d'avoir plusieurs adresses IPv4 sur le VPS.** Depuis la rubrique "**Configuration**" sur votre VPS vous pouvez cliquer sur "**Commander IP Supplémentaires**" afin d'en acheter. Voici les tarifs proposés par **HostMyServers** :  Je vous **recommande** de **prendre des adresses IPv4 Supplémentaires à l'unité**. (les blocs ne sont pas assez intuitifs à mon goût dans l'espace client pour le moment) Une fois l'**adresse IP achetée**, votre panel devrait **ressembler à ceci** :   **Notez bien** pour la suite du tutoriel que : - **L'adresse IP principale du VPS** est celle qui **possède** un **reverse DNS associée**. - **L'adresse IP supplémentaire** est celle qui ne **possède** **pas** de **reverse DNS**. **Notez sur un bloc note** quelle IP est laquelle **afin de ne pas vous emmêler les pinceaux dans la suite** du tuto. > [!WARNING] > Commandez raisonnablement des adresses IPv4, il n'y en a plus beaucoup, et il est inutile d'en claim si elles restent inutilisées. # Préparation du VPS **Cette partie de la documentation s'applique uniquement aux clients HMS / RoyaleHosting. Si vous avez un VPS avec Debian 12 et systemd-networking, vous pouvez ignorer cette étape.** **Une fois votre VPS livré**, rendez-vous dans votre **espace client** pour **choisir sa distribution**. Nous installons **Debian 12**.  **Une fois le VPS installé**, vous **recevrez** les **identifiants** pour s'y connecter sur votre **adresse email** client.  **Connectez-vous** y avec un **client SSH** comme [**PuTTY**](https://www.putty.org/) ou [**Termius**](https://termius.com/). Nous allons d'abord **préparer** **le VPS** en désinstallant **netplan** et réinstallant **systemd-networking**. J'ai déjà préparé un **script** qui fais tout cela **automatiquement**, il vous suffit d'**effectuer la commande ci-dessous** : ```bash curl -sSL https://raw.githubusercontent.com/tbringuier/wireguard/refs/heads/master/preparevps.sh | bash ``` Le VPS **redémarrera automatiquement** une fois la **préparation effectuée**. # Installation de Wireguard **Une fois votre VPS préparé**, nous pouvons nous y **connecter en SSH** grâce à un **client SSH** comme [**PuTTY**](https://www.putty.org/) ou [**Termius**](https://termius.com/) **Commençons** par **mettre à jour** et **installer** les **paquets principaux** sur le **VPS** : ```bash apt update apt full-upgrade -y apt install wireguard-tools resolvconf iptables arping sudo bash curl arping wget -y apt autoremove -y reboot ``` Une fois notre VPS **redémarré**, nous pouvons **déployer le serveur Wireguard** : ```bash curl -O https://raw.githubusercontent.com/angristan/wireguard-install/master/wireguard-install.sh chmod +x wireguard-install.sh bash wireguard-install.sh ``` Un long **setup va démarrer**, nous pouvons **laisser les paramètres par défaut**. ```plaintext Welcome to the wireguard installer! The git repository is available at: https://github.com/angristan/wireguard-install I need to ask you a few questions before starting the setup. You can keep the default options and just press enter if you are ok with them. IPv4 or IPv6 public address: 146.19.168.213 Public interface: eth0 wireguard interface name: wg0 Server wireguard IPv4: 10.66.66.1 Server wireguard IPv6: fd42:42:42::1 Server wireguard port [1-65535]: 62052 First DNS resolver to use for the clients: 1.1.1.1 Second DNS resolver to use for the clients (optional): 1.0.0.1 wireguard uses a parameter called AllowedIPs to determine what is routed over the VPN. Allowed IPs list for generated clients (leave default to route everything): 0.0.0.0/0,::/0 Okay, that was all I needed. We are ready to setup your wireguard server now. You will be able to generate a client at the end of the installation. Press any key to continue... ``` Une fois ceci-fait, il nous demandera **le nom de notre profil wireguard**. Dans mon cas je l'appelle MaVM : ```plaintext The client name must consist of alphanumeric character(s). It may also include underscores or dashes and can't exceed 15 chars. Client name: MaVM ``` **On laisse** les adresses IP proposées **par défaut** : ```plaintext Client wireguard IPv4: 10.66.66.2 Client wireguard IPv6: fd42:42:42::2 ``` Une fois le **client créé**, **un QR-Code vous sera affiché** et un **fichier aura été créé** dans le **répertoire actuel**. **Préparons** notre **serveur wireguard**. **Vous n'avez qu'à faire cette étape une seule fois**. ```bash nano /etc/wireguard/wg0.conf ``` Voici à quoi ressemble notre **fichier** wg0.conf **initial** : ```ini [Interface] Address = 10.66.66.1/24,fd42:42:42::1/64 ListenPort = 62052 PrivateKey = qA0nlMcMHLUGLgbsQ7zsVlvg2NartzikMUMJRNwdeVs= PostUp = iptables -I INPUT -p udp --dport 62052 -j ACCEPT PostUp = iptables -I FORWARD -i eth0 -o wg0 -j ACCEPT PostUp = iptables -I FORWARD -i wg0 -j ACCEPT PostUp = iptables -t nat -A POSTROUTING -o eth0 -j MASQUERADE PostUp = ip6tables -I FORWARD -i wg0 -j ACCEPT PostUp = ip6tables -t nat -A POSTROUTING -o eth0 -j MASQUERADE PostDown = iptables -D INPUT -p udp --dport 62052 -j ACCEPT PostDown = iptables -D FORWARD -i eth0 -o wg0 -j ACCEPT PostDown = iptables -D FORWARD -i wg0 -j ACCEPT PostDown = iptables -t nat -D POSTROUTING -o eth0 -s 10.66.66.0/24 -j MASQUERADE PostDown = ip6tables -D FORWARD -i wg0 -j ACCEPT PostDown = ip6tables -t nat -D POSTROUTING -o eth0 -j MASQUERADE ### Client MaVM [Peer] PublicKey = VApiknwvlZmUewjbwZGFYp/77M3XUOSVde8AGcAdgzg= PresharedKey = t+rgwqN3j8LccHtgi7GULlwBrf8ghY8HAbZN6cagP8s= AllowedIPs = 10.66.66.2/32,fd42:42:42::2/128 ``` Nous devons simplement **remplacer** **les lignes PostUp et PostDown** **par celles ci-dessous** : ```ini PostUp = iptables -I FORWARD -i eth0 -o wg0 -s 10.66.66.0/24 -j ACCEPT; iptables -I FORWARD -i wg0 -d 10.66.66.0/24 -j ACCEPT; iptables -t nat -A POSTROUTING -o eth0 -s 10.66.66.0/24 -j MASQUERADE; iptables -I INPUT -p udp -s 10.66.66.0/24 -j ACCEPT; ip6tables -I FORWARD -i wg0 -j ACCEPT; ip6tables -t nat -A POSTROUTING -o eth0 -j MASQUERADE PostDown = iptables -D FORWARD -i eth0 -o wg0 -s 10.66.66.0/24 -j ACCEPT; iptables -D FORWARD -i wg0 -d 10.66.66.0/24 -j ACCEPT; iptables -t nat -D POSTROUTING -o eth0 -s 10.66.66.0/24 -j MASQUERADE; iptables -D INPUT -p udp -s 10.66.66.0/24 -j ACCEPT; ip6tables -D FORWARD -i wg0 -j ACCEPT; ip6tables -t nat -D POSTROUTING -o eth0 -j MASQUERADE ``` > [!WARNING] > N'oubliez pas de remplacer `eth0` par le vrai nom de votre interface (cela peut changer en fonction de l'OS / provider) ! Voici à quoi ressemble notre **fichier** de configuration **after modification** : ```ini [Interface] Address = 10.66.66.1/24,fd42:42:42::1/64 ListenPort = 62052 PrivateKey = qA0nlMcMHLUGLgbsQ7zsVlvg2NartzikMUMJRNwdeVs= PostUp = iptables -I FORWARD -i eth0 -o wg0 -s 10.66.66.0/24 -j ACCEPT; iptables -I FORWARD -i wg0 -d 10.66.66.0/24 -j ACCEPT; iptables -t nat -A POSTROUTING -o eth0 -s 10.66.66.0/24 -j MASQUERADE; iptables -I INPUT -p udp -s 10.66.66.0/24 -j ACCEPT PostDown = iptables -D FORWARD -i eth0 -o wg0 -s 10.66.66.0/24 -j ACCEPT; iptables -D FORWARD -i wg0 -d 10.66.66.0/24 -j ACCEPT; iptables -t nat -D POSTROUTING -o eth0 -s 10.66.66.0/24 -j MASQUERADE; iptables -D INPUT -p udp -s 10.66.66.0/24 -j ACCEPT ### Client MaVM [Peer] PublicKey = VApiknwvlZmUewjbwZGFYp/77M3XUOSVde8AGcAdgzg= PresharedKey = t+rgwqN3j8LccHtgi7GULlwBrf8ghY8HAbZN6cagP8s= AllowedIPs = 10.66.66.2/32,fd42:42:42::2/128 ``` Après avoir **sauvegardé** le fichier, nous pouvons **activer l'ip forwarding** : ```bash echo 'net.ipv4.ip_forward=1 net.ipv4.conf.all.proxy_arp=1 net.ipv6.conf.all.forwarding=1' | tee -a /etc/sysctl.conf ``` On peut ensuite **redémarrer** notre **VPS** **HMS** : ```bash reboot ``` Nous pouvons maintenant **modifier la configuration serveur et client** pour **associer** l'**ip supplémentaire**. ```bash nano /etc/wireguard/wg0.conf ``` ```ini [Interface] Address = 10.66.66.1/24,fd42:42:42::1/64 ListenPort = 62052 PrivateKey = qA0nlMcMHLUGLgbsQ7zsVlvg2NartzikMUMJRNwdeVs= PostUp = iptables -I FORWARD -i eth0 -o wg0 -s 10.66.66.0/24 -j ACCEPT; iptables -I FORWARD -i wg0 -d 10.66.66.0/24 -j ACCEPT; iptables -t nat -A POSTROUTING -o eth0 -s 10.66.66.0/24 -j MASQUERADE; iptables -I INPUT -p udp -s 10.66.66.0/24 -j ACCEPT PostDown = iptables -D FORWARD -i eth0 -o wg0 -s 10.66.66.0/24 -j ACCEPT; iptables -D FORWARD -i wg0 -d 10.66.66.0/24 -j ACCEPT; iptables -t nat -D POSTROUTING -o eth0 -s 10.66.66.0/24 -j MASQUERADE; iptables -D INPUT -p udp -s 10.66.66.0/24 -j ACCEPT ### Client MaVM [Peer] PublicKey = VApiknwvlZmUewjbwZGFYp/77M3XUOSVde8AGcAdgzg= PresharedKey = t+rgwqN3j8LccHtgi7GULlwBrf8ghY8HAbZN6cagP8s= AllowedIPs = 10.66.66.2/32,fd42:42:42::2/128 ``` Nous avons **créé** le **client** MaVM précédemment, il faut maintenant **ajouter** dans les **AllowedIPs** l'**adresse ip supplémentaire**. ```ini AllowedIPs = 10.66.66.2/32,fd42:42:42::2/128,163.5.121.254/32 ``` Voici à quoi ressemble le **fichier modifié** : ```ini [Interface] Address = 10.66.66.1/24,fd42:42:42::1/64 ListenPort = 62052 PrivateKey = qA0nlMcMHLUGLgbsQ7zsVlvg2NartzikMUMJRNwdeVs= PostUp = iptables -I FORWARD -i eth0 -o wg0 -s 10.66.66.0/24 -j ACCEPT; iptables -I FORWARD -i wg0 -d 10.66.66.0/24 -j ACCEPT; iptables -t nat -A POSTROUTING -o eth0 -s 10.66.66.0/24 -j MASQUERADE; iptables -I INPUT -p udp -s 10.66.66.0/24 -j ACCEPT PostDown = iptables -D FORWARD -i eth0 -o wg0 -s 10.66.66.0/24 -j ACCEPT; iptables -D FORWARD -i wg0 -d 10.66.66.0/24 -j ACCEPT; iptables -t nat -D POSTROUTING -o eth0 -s 10.66.66.0/24 -j MASQUERADE; iptables -D INPUT -p udp -s 10.66.66.0/24 -j ACCEPT ### Client MaVM [Peer] PublicKey = VApiknwvlZmUewjbwZGFYp/77M3XUOSVde8AGcAdgzg= PresharedKey = t+rgwqN3j8LccHtgi7GULlwBrf8ghY8HAbZN6cagP8s= AllowedIPs = 10.66.66.2/32,fd42:42:42::2/128,163.5.121.254/32 ``` Une fois le fichier **sauvegardé**, nous pouvons modifier la **configuration côté client** : ```bash nano wg0-client-MaVM.conf ``` ```ini [Interface] PrivateKey = MM2OFVfYrJFtdAgebfPJL2hDtjaslufqoJ1yzvdN+X8= Address = 10.66.66.2/32,fd42:42:42::2/128 DNS = 1.1.1.1,1.0.0.1 [Peer] PublicKey = udEYVLpHnWb4o7kgjZ4pCnfUaVjqd9inXAUmak9mXxM= PresharedKey = t+rgwqN3j8LccHtgi7GULlwBrf8ghY8HAbZN6cagP8s= Endpoint = 146.19.168.213:62052 AllowedIPs = 0.0.0.0/0,::/0 ``` Il faut **remplacer l'adresse IP** **10.66.66.2** **par l'adresse ip supplémentaire** et également **rajouter la ligne** ci-dessous **en dessous de DNS** : ```ini PostUp = iptables -t mangle -A POSTROUTING -p tcp --tcp-flags SYN,RST SYN -o wg0 -j TCPMSS --clamp-mss-to-pmtu ``` Voici à quoi ressemble le **fichier modifié** : ```ini [Interface] PrivateKey = MM2OFVfYrJFtdAgebfPJL2hDtjaslufqoJ1yzvdN+X8= Address = 163.5.121.254/32,fd42:42:42::2/128 DNS = 1.1.1.1,1.0.0.1 PostUp = iptables -t mangle -A POSTROUTING -p tcp --tcp-flags SYN,RST SYN -o wg0 -j TCPMSS --clamp-mss-to-pmtu [Peer] PublicKey = udEYVLpHnWb4o7kgjZ4pCnfUaVjqd9inXAUmak9mXxM= PresharedKey = t+rgwqN3j8LccHtgi7GULlwBrf8ghY8HAbZN6cagP8s= Endpoint = 146.19.168.213:62052 AllowedIPs = 0.0.0.0/0,::/0 ``` Une fois les **modifications apportées**, nous pouvons **relancer le serveur wireguard** pour **appliquer la configuration des clients** : ```bash systemctl restart wg-quick@wg0 ``` Vous pouvez **vérifier l'état du serveur** avec les commandes ```bash systemctl status wg-quick@wg0 wg show ``` **Notre client est maintenant prêt à être déployé!** # Déploiement du profil wireguard : Notre **profil** est maintenant **prêt** à être **déployé** sur **n'importe quelle plateforme** (Windows, Linux, Android, macOS, IOS et plein d'autres!) Voici les **commandes** **pour** **déployer le profil** **sur un linux** en base Debian : ```bash # Installer wireguard, Resolvconf et IPTables apt install wireguard-tools resolvconf iptables # Installer le profil Wireguard : nano /etc/wireguard/wg0.conf (puis coller le profil wireguard (wg0-client-) modifié à l'intérieur) # Activer et lancer notre profil wireguard au démarrage : systemctl enable wg-quick@wg0 --now # Et voilà ! Votre IP est maintenant montée sur cet appareil ! # Vous pouvez vérifier en faisant un ip a # ou un curl ifconfig.me ``` # Diagnostics **Si jamais le profil ne fonctionne pas**, **vérifiez que vous n'avez pas mélangé les adresses IPs** et **relisez la documentation**. Il peut arriver qu'il y ai des soucis de routage sur le VPS HMS. Dans ce cas **Voici les commande à exécuter SUR LE VPS HMS** pour **résoudre le problème** : ## Étape 1 : Créer le fichier `ips` 1. **Créer le fichier `ips`** dans le répertoire `/root` : ```bash sudo nano /root/ips ``` 2. **Ajouter les adresses IP** que vous utilisez avec Wireguard, une par ligne. Par exemple : ``` <ip-additionnelle1> <ip-additionnelle2> ``` 3. **Enregistrer et quitter** l'éditeur (`CTRL + X`, puis `Y`, puis `Entrée`). ## Étape 2 : Configurer le script 1. **Créer le script** ``arping-loop.sh`` dans ``/usr/local/bin`` et coller dedans : ```bash #!/bin/bash while true; do for arg in $(< /root/ips); do arping -q -c1 -P $arg -S $arg -i eth0 & done sleep 1 wait done ``` > [!WARNING] > N'oubliez pas de remplacer `eth0` par le vrai nom de votre interface (cela peut changer en fonction de l'OS / provider) ! 2. **Enregistrer et quitter** l'éditeur (`CTRL + X`, puis `Y`, puis `Entrée`). 3. **Donner la permission** au script de s'exécuter ```bash chmod +x /usr/local/bin/arping-loop.sh ``` 4. **Créer le service systemd** ``arping-loop.service`` dans ``/etc/systemd/system/`` ```ini [Unit] Description=ARP Loop for keep connection on additional IPs After=network.target [Service] Type=simple ExecStart=/usr/local/bin/arping-loop.sh Restart=always [Install] WantedBy=multi-user.target ``` 5. **Enregistrer et quitter** l'éditeur (`CTRL + X`, puis `Y`, puis `Entrée`). 6. **Activer le service** ```bash systemctl daemon-reload systemctl enable arping-loop systemctl start arping-loop ``` ## Étape 4 : Vérifier la configuration 1. **Vérifier que la tâche cron a été ajoutée correctement** : ```bash systemctl status arping-loop ``` 2. **Vérifier que le script fonctionne** en l'exécutant manuellement une première fois : ```bash bash /usr/local/bin/arping-loop.sh ``` Tout devrait être opérationnel si aucune erreur ne survient ! # Conclusion & Remerciements **Et voilà**, **vous avez maintenant des IP Failovers disponibles chez vous**, **protégées par Anti-DDOS**, **sur n'importe quel appareil !** Cette **astuce** m'a permis de franchir un **grand pas dans l'auto-hébergement**, que ce soit pour des **services pour moi** ou **pour les autres**, car elle m'offre la puissance d'avoir des **VPS** avec des **IP dédiées à prix réduit** et avec un **service de qualité similaire**. **Ce tutoriel existe initialement depuis juillet 2020**, mais a été remasterisé **récemment** en **septembre 2024** avec beaucoup d'**améliorations** et de **mises à jour**. ## Je tiens à remercier : - [@Aven678](https://github.com/Aven678/) : Pour avoir simplifié énormément la gestion des IPs et la création de profils. - [@DrKnaw](https://github.com/DrKnaw) : Pour avoir patché des bugs liés à mon système qui n'était pas tout à fait fini à l'époque. - [@MaelMagnien](https://web.archive.org/web/20240108141946/https://github.com/maelmagnien) : Qui a entièrement testé le tutoriel pour voir que tout fonctionne. - [@Gogow_](https://github.com/Gogowwww) : Qui m'a également fait débugger plusieurs fois ma doc. - [@Diggyworld](https://github.com/Diggyworld) : Qui a remarqué et passé toute une soirée à trouver une solution pour ces fichus soucis de MTU - [@titin](https://git.feelb.io/Titin) : Pour avoir trouvé la commande arping pour régler certains soucis de routage - [@Hecate](https://github.com/TheHecateII) : Pour la commande iptables pour les soucis de MTU - [@TheOrion-OVH](https://github.com/TheOrion-OVH) : Pour le correctif ARP qui fonctionnais une fois sur 2 et quelques erreurs de typo dans la documentation. Et plein d'autres personnes qui m'ont envoyé un message sur Discord pour m'aider à améliorer cette documentation ou me remercier. ## Si vous souhaitez approfondir Il est possible d'**implémenter différemment** ces **tunnels** **wireguard**, avec un **routeur** **centralisé** qui **distribue** ensuite **les IPs** **aux VMs**. Cela permet d'**éviter** de **déployer** un **profil** **wireguard** **par** **client**. Un **ami** a moi a **rédigé** une **super documentation** pour monter les addresses sur un **routeur** **VyOS** : [Router un subnet IPv4 chez soi avec WireGuard + VyOS](https://blog.azernet.xyz/router-un-subnet-ipv4-chez-soi-avec-wireguard-vyos-2/) Si d'autres personnes souhaitent faire figurer leurs « forks » de cette documentation, n'hésitez pas à me DM Discord ou Telegram ! ## [Avoir des adresses IPv4/IPv6 chez soi avec un tunnel Wireguard]({{ site.url }}/wireguard) by [{{ site.author.name }}]({{ site.url }}) is licensed under [CC BY-NC-SA 4.0](https://creativecommons.org/licenses/by-nc-sa/4.0/) ### Implémentations futures (quand j'aurais le temps de les écrire) : - Firewalling avec UFW - Routage bloc IPv6