WireGuard + port knocking : VPN furtif sur Contabo 2026

Disclosure affiliée — Cet article contient des liens d'affiliation Contabo. Si tu prends un VPS via nos liens, on touche une commission sans surcoût pour toi. Toutes les commandes sont testées sur nos propres VPS de prod.

Tu as un WireGuard auto-hébergé sur Contabo. Tout marche. Sauf que ton port UDP 51820 est dans Shodan depuis 3 jours, ton VPS reçoit des milliers de paquets de scan par heure, et tu vois dans journalctl des handshakes WireGuard rejetés depuis des botnets. Si ton WireGuard est bien configuré (clé publique forte, pas de PSK partagée), tu n'as rien à craindre cryptographiquement — mais ce bruit pollue tes logs, gaspille du CPU, et un jour quelqu'un trouvera peut-être une vulnérabilité.

Port knocking est une technique vieille mais efficace pour résoudre ça : ton endpoint WireGuard reste fermé par défaut (UFW drop), et s'ouvre uniquement après une "séquence de knock" (suite de tentatives de connexion TCP sur des ports précis dans un ordre précis). Le client tape la séquence, le firewall ouvre temporairement le port WireGuard, la session s'établit, le port se referme. Pour Shodan, ton VPS n'expose aucun port UDP/51820 — tu es invisible.

Ce guide couvre l'installation knockd sur VPS Contabo, la séquence sécurisée, l'intégration fail2ban, et un script de déploiement automatisé pour reproduire le setup sur plusieurs VPS.

Le principe : trois portes, une combinaison

Port knocking fonctionne comme une sonnette codée. Tu définis une séquence de ports (par exemple 7001 → 8002 → 9003) et un ordre. Le client envoie une simple tentative TCP/SYN vers chaque port dans l'ordre. Aucun service n'écoute sur ces ports — le firewall LOG les paquets et passe.

Quand le démon knockd voit la séquence valide depuis une même IP en < 30 secondes, il exécute une commande : typiquement iptables -A INPUT -s <ip> -p udp --dport 51820 -j ACCEPT. L'IP du client est temporairement autorisée. Quelques secondes plus tard, knockd ferme : iptables -D INPUT ....

Avantage : pour un scanner externe (Shodan, Censys, masscan), ton port 51820 ne répond JAMAIS. Il n'est pas listé. Limite : ce n'est pas de la cryptographie. Quelqu'un qui sniff ton trafic peut voir les knocks et les rejouer. C'est pour ça qu'on combine avec WireGuard (qui reste l'auth cryptographique forte).

Installation sur Contabo VPS

VPS Contabo VPS S (4,99 €/mois, voir l'offre) sous Ubuntu 24.04 LTS, WireGuard déjà installé et fonctionnel (si pas encore : voir notre guide self-host WireGuard).

Étape 1 — Installer knockd

apt update && apt install -y knockd

Étape 2 — Fermer WireGuard par défaut

D'abord, vérifie ton firewall actuel :

ufw status verbose

Si UFW autorise 51820/udp en grand, on va remplacer ça par "fermé par défaut + ouvert par knockd". Édite /etc/default/ufw ou directement iptables :

ufw delete allow 51820/udp
# WireGuard est maintenant DROP par défaut

Vérifie : depuis l'extérieur, nmap -sU -p 51820 ton-ip doit donner filtered ou closed.

Étape 3 — Configurer knockd

/etc/knockd.conf :

[options]
    UseSyslog
    Interface = eth0

[openWireGuard]
    sequence    = 7203,4581,6217
    seq_timeout = 15
    command     = /usr/sbin/iptables -I INPUT -s %IP% -p udp --dport 51820 -j ACCEPT
    tcpflags    = syn

[closeWireGuard]
    sequence    = 6217,4581,7203
    seq_timeout = 15
    command     = /usr/sbin/iptables -D INPUT -s %IP% -p udp --dport 51820 -j ACCEPT
    tcpflags    = syn

Champs clés :

• sequence : tes ports knock. Pas séquentiels (pas 1234,1235,1236), choisis-les aléatoires entre 1024 et 65000.
• seq_timeout : 15 secondes pour compléter la séquence depuis la même IP. Si trop court, problème de latence client mobile. Si trop long, fenêtre d'attaque par brute force agrandie.
• command : ce qui est exécuté quand la séquence est valide. %IP% est remplacé par l'IP source du knock.
• tcpflags : syn pour matcher uniquement le paquet de début de connexion (évite les faux positifs).

Pour une auto-fermeture après 60 secondes au lieu d'un knock manuel, utilise cmd_timeout :

[openWireGuard]
    sequence    = 7203,4581,6217
    seq_timeout = 15
    command     = /usr/sbin/iptables -I INPUT -s %IP% -p udp --dport 51820 -j ACCEPT
    tcpflags    = syn
    cmd_timeout = 60
    stop_command = /usr/sbin/iptables -D INPUT -s %IP% -p udp --dport 51820 -j ACCEPT

C'est plus propre : pas besoin que le client fasse un "close knock", knockd ferme tout seul après 60s. WireGuard a établi sa session UDP entre-temps, elle reste active.

Étape 4 — Activer knockd

/etc/default/knockd :

START_KNOCKD=1
KNOCKD_OPTS="-i eth0"

systemctl enable --now knockd
journalctl -u knockd -f

Knocker côté client

Linux / macOS : installe le paquet knockd (il fournit aussi le client knock) :

apt install knockd      # Ubuntu/Debian
brew install knock      # macOS via Homebrew

Usage :

knock ton-ip-vps 7203 4581 6217

Tu attends 1-2 secondes, puis tu montes WireGuard normalement :

wg-quick up wg0

Tu as 60 secondes pour que WireGuard établisse son handshake UDP. Une fois la session active, knockd peut fermer le firewall : la connexion existante n'est pas concernée par les nouvelles règles INPUT.

Windows : pas de port officiel knock.exe maintenu. Solution pragmatique : un script PowerShell qui fait 3 Test-NetConnection rapides :

$ip = "ton-ip-vps"
$ports = 7203, 4581, 6217
foreach ($p in $ports) {
    Test-NetConnection -ComputerName $ip -Port $p -InformationLevel Quiet
    Start-Sleep -Milliseconds 200
}
Start-Sleep -Seconds 1
# Lance l'app WireGuard ici

Android : app KnockOnD sur Play Store (gratuit). Tu configures IP + séquence, tu tappes le bouton, ça envoie les knocks. Combine avec WireGuard Android : après le knock, monte le tunnel manuellement.

iOS : PortKnock sur AppStore (gratuit). Même principe.

Sécurisation : éviter le knock-replay

Le knock simple a une faiblesse : si quelqu'un sniff ton trafic (Wi-Fi public, ISP malveillant, etc.), il peut rejouer la séquence depuis son IP et obtenir l'ouverture du firewall. Trois mitigations :

1. fail2ban sur les knocks invalides

Bannit les IPs qui font 5+ knocks invalides (ne complétant pas la séquence). Crée /etc/fail2ban/filter.d/knockd.conf :

[Definition]
failregex = ^.*knockd.*<HOST>:.*: Stage \d failed.*$
ignoreregex =

Et /etc/fail2ban/jail.d/knockd.conf :

[knockd]
enabled = true
filter = knockd
logpath = /var/log/syslog
maxretry = 5
findtime = 60
bantime = 3600

Reload : systemctl reload fail2ban.

2. knock séquence one-time (knockd 0.8+)

Utilise des séquences à usage unique via one_time_sequences :

[openWireGuard]
    one_time_sequences = /etc/knockd/sequences.list
    seq_timeout = 15
    command = /usr/sbin/iptables -I INPUT -s %IP% -p udp --dport 51820 -j ACCEPT
    tcpflags = syn
    cmd_timeout = 60
    stop_command = /usr/sbin/iptables -D INPUT -s %IP% -p udp --dport 51820 -j ACCEPT

Le fichier /etc/knockd/sequences.list contient une séquence par ligne. Une fois utilisée, elle est supprimée. Tu pré-génères 100 séquences, tu les distribues au client (fichier chiffré), et chaque connexion consomme une.

C'est nettement plus sécurisé contre le replay, au prix d'une gestion plus complexe.

3. Combiner avec un VPN d'amorçage

Approche élégante : ton VPS expose uniquement un Shadowsocks ou un V2Ray sur 443 (en mode camouflage). Les knocks WireGuard sont envoyés à travers ce premier tunnel SS/V2Ray. Le sniff externe ne voit que du TLS vers ton domaine, pas les knocks.

C'est le setup "ceinture+bretelles" pour les déplacements ultra-sensibles.

Script de déploiement automatisé

Pour reproduire ce setup sur plusieurs VPS Contabo, on a un script qu'on partage. Place-le dans /usr/local/bin/setup-knock-wg.sh :

#!/bin/bash
set -euo pipefail

if [[ $EUID -ne 0 ]]; then
    echo "Lance ce script en root"
    exit 1
fi

# Génère 3 ports aléatoires entre 5000 et 60000
PORT1=$(( ( RANDOM % 55000 ) + 5000 ))
PORT2=$(( ( RANDOM % 55000 ) + 5000 ))
PORT3=$(( ( RANDOM % 55000 ) + 5000 ))

echo "Séquence générée : $PORT1 -> $PORT2 -> $PORT3"

apt update && apt install -y knockd fail2ban

cat > /etc/knockd.conf <<EOF
[options]
    UseSyslog
    Interface = eth0

[openWireGuard]
    sequence    = ${PORT1},${PORT2},${PORT3}
    seq_timeout = 15
    command     = /usr/sbin/iptables -I INPUT -s %IP% -p udp --dport 51820 -j ACCEPT
    tcpflags    = syn
    cmd_timeout = 60
    stop_command = /usr/sbin/iptables -D INPUT -s %IP% -p udp --dport 51820 -j ACCEPT
EOF

sed -i 's/START_KNOCKD=0/START_KNOCKD=1/' /etc/default/knockd

# Ferme WireGuard par défaut
ufw delete allow 51820/udp 2>/dev/null || true

# Configure fail2ban
cat > /etc/fail2ban/filter.d/knockd.conf <<EOF
[Definition]
failregex = ^.*knockd.*<HOST>:.*: Stage \d failed.*\$
ignoreregex =
EOF

cat > /etc/fail2ban/jail.d/knockd.conf <<EOF
[knockd]
enabled = true
filter = knockd
logpath = /var/log/syslog
maxretry = 5
findtime = 60
bantime = 3600
EOF

systemctl enable --now knockd
systemctl reload fail2ban

echo ""
echo "Setup terminé !"
echo "Client : knock $(curl -s ifconfig.me) ${PORT1} ${PORT2} ${PORT3}"
echo "Garde cette séquence en sécurité — gestionnaire de mots de passe recommandé."

Rends exécutable et lance :

chmod +x /usr/local/bin/setup-knock-wg.sh
/usr/local/bin/setup-knock-wg.sh

Tu obtiens en sortie la séquence à utiliser côté client. Conserve-la dans Bitwarden / 1Password / KeePass — c'est un secret au même titre que ta clé SSH.

Validation : tester que ça marche

1. Depuis l'extérieur (ton laptop, pas le VPS) — vérifier que 51820 est fermé :

nmap -sU -p 51820 ton-ip-vps
# PORT      STATE    SERVICE
# 51820/udp filtered (ou closed) — pas de réponse

2. Toujours depuis l'extérieur — knock + tentative WireGuard :

knock ton-ip-vps 7203 4581 6217
sleep 2
wg-quick up wg0
wg show wg0   # doit montrer un handshake

3. Côté serveur — vérifier le log :

journalctl -u knockd | tail -20
# Doit afficher : openWireGuard: Stage 3 OK
#                 openWireGuard: OPEN SESAME
#                 openWireGuard: running command

4. Vérifier qu'après le cmd_timeout, le firewall se referme :

# Sur le serveur, attendre 60s puis :
iptables -L INPUT -n | grep 51820
# Plus de règle pour ton IP. WireGuard session reste active grâce au conntrack.

Cas d'usage typiques

1. Self-host pour soi-même, agacé par le bruit Shodan. Setup parfait : 5 minutes de config, tu n'as plus rien dans Shodan, tes logs sont propres. Aucun changement côté client WireGuard mobile (juste un knock avant chaque connexion).

2. Self-host pour quelques utilisateurs avancés. Distribue à chaque user une séquence one-time. Chacun a sa séquence individuelle. Si une fuite, tu révoques cette séquence sans impact sur les autres.

3. Setup multi-VPS résilients. Chaque VPS Contabo a sa propre séquence aléatoire. Le client a une liste de fallback : si VPS1 ne répond pas (knock raté ou IP down), il knock VPS2, etc.

4. Honeypot inversé. Couplé avec psad ou crowdsec, les IPs qui scan tes ports knock invalides finissent dans une blacklist communautaire. Tu deviens un capteur de threat intel.

Limites et alternatives

Port knocking n'est pas magique :

• Si quelqu'un a un accès passif à ton trafic LAN (proxy d'entreprise qui MITM TLS), il peut voir les knocks et rejouer.
• Si ton client mobile est sur un réseau cell où l'opérateur log tout, idem.
• Si ton VPS est un peu lent, le seq_timeout = 15s peut être trop court sur de la 3G en bordure de couverture.

Alternatives à considérer :

Port knocking est complémentaire, pas substitut. Tu peux empiler : port knocking + Cloak + WireGuard, et tu as un setup quasi-invisible. Au prix d'une complexité opérationnelle accrue.

Quand un VPN commercial est plus simple

Si tu ne veux pas gérer knockd + fail2ban + UFW + WireGuard, un VPN commercial t'épargne ça. NordVPN ne te donne pas le contrôle bas-niveau, mais ses serveurs sont mutualisés (donc dilution naturelle des scans). Tu n'es pas la cible identifiable.

Beaucoup de nos lecteurs combinent : self-host avec port knocking pour usage quotidien (perf max, IP fixe), VPN commercial en backup déplacement (no maintenance).

Pour aller plus loin

• Self-host VPN sur Contabo : guide WireGuard complet 2026
• Cloak : obfuscation TLS pour VPN self-host
• V2Ray VMess/VLess : configuration complète 2026
• VPN killswitch Linux : iptables + systemd

Sources techniques :

• knockd documentation officielle
• Original Port Knocking paper — M. Krzywinski, 2003
• fail2ban GitHub
• WireGuard whitepaper — Jason A. Donenfeld

Article publié le 2026-06-03. Setup testé sur VPS Contabo VPS S Nuremberg + clients résidentiels Europe, mars-avril 2026. Port knocking est une couche défensive complémentaire, pas une solution miracle — combine toujours avec auth WireGuard forte et fail2ban.

Rappel légal : port knocking et WireGuard self-host sont parfaitement légaux dans l'UE, US, Canada. Vérifier les régulations locales avant déploiement dans des juridictions sensibles. VPNSmith publie ce guide à titre éducatif.