Port Knocking SSH

Objectif

Mettre en place un système de Port Knocking pour protéger l'accès SSH. Le port SSH restera fermé par défaut et ne s'ouvrira qu'après avoir frappé une séquence spécifique de ports dans le bon ordre.

Cette technique de sécurité par l'obscurité ajoute une couche de protection contre les scans de ports et les tentatives de brute force SSH.

Prérequis

• Serveur Debian 11 / Ubuntu
• SSH fonctionnel et configuré
• Accès root ou sudo
• iptables installé (généralement présent par défaut)
• Connexion physique ou console de secours (en cas de blocage SSH)

Procédure Complète

Étape 1 : Installation de knockd

Mettre à jour les dépôts et installer knockd :

apt update
apt install knockd -y

Vérifier l'installation :

knockd --version

Étape 2 : Configuration de knockd

Éditer le fichier de configuration principal :

nano /etc/knockd.conf

Remplacer le contenu par la configuration suivante :

[options]
 UseSyslog

[openSSH]
 sequence = 7000,8000,9000
 seq_timeout = 15
 command = /sbin/iptables -A INPUT -s %IP% -p tcp --dport 22 -j ACCEPT
 tcpflags = syn

[closeSSH]
 sequence = 9000,8000,7000
 seq_timeout = 15
 command = /sbin/iptables -D INPUT -s %IP% -p tcp --dport 22 -j ACCEPT
 tcpflags = syn

Sauvegarder et quitter (Ctrl+O, Entrée, Ctrl+X)

Étape 3 : Configuration de l'interface réseau

Éditer le fichier de configuration pour spécifier l'interface réseau :

nano /etc/default/knockd

Modifier les lignes suivantes :

START_KNOCKD=1
KNOCKD_OPTS="-i eth0"

ip a

Interfaces courantes : eth0, ens33, enp0s3, ens18

Étape 4 : Configuration du firewall (iptables)

Bloquer le port SSH par défaut :

iptables -A INPUT -p tcp --dport 22 -j DROP

Autoriser les connexions SSH établies (important pour ne pas couper les sessions actives) :

iptables -I INPUT -m state --state ESTABLISHED,RELATED -j ACCEPT

Sauvegarder les règles iptables :

apt install iptables-persistent -y
netfilter-persistent save

Étape 5 : Démarrage de knockd

Activer knockd au démarrage du système :

systemctl enable knockd

Démarrer le service :

systemctl start knockd

Vérifier le statut :

systemctl status knockd

Utilisation côté client

Installation du client knock (Linux)

Sur la machine cliente (Debian/Ubuntu) :

apt install knockd -y

Ouvrir le port SSH

Frapper la séquence pour ouvrir le port :

knock ADRESSE_IP_SERVEUR 7000 8000 9000

Exemple :

knock 192.168.1.100 7000 8000 9000

Connexion SSH immédiatement après :

ssh [email protected]

Fermer le port SSH

Frapper la séquence inverse pour fermer :

knock 192.168.1.100 9000 8000 7000

Alternative : nmap (si knock n'est pas disponible)

for PORT in 7000 8000 9000; do nmap -Pn --max-retries 0 -p $PORT 192.168.1.100; done

Alternative : telnet (Windows/Linux)

telnet 192.168.1.100 7000
(Ctrl+C pour quitter)
telnet 192.168.1.100 8000
(Ctrl+C)
telnet 192.168.1.100 9000
(Ctrl+C)
ssh [email protected]

Script bash automatisé

Créer un script pour simplifier l'usage :

nano ~/knock-ssh.sh

Contenu du script :

#!/bin/bash
SERVER="192.168.1.100"
knock $SERVER 7000 8000 9000
sleep 1
ssh utilisateur@$SERVER

Rendre le script exécutable :

chmod +x ~/knock-ssh.sh

Utilisation :

~/knock-ssh.sh

Vérifications

Vérification du service knockd

systemctl status knockd

Doit afficher "active (running)"

Vérification des logs

tail -f /var/log/syslog | grep knockd

Doit afficher les tentatives de knock en temps réel

Vérification des règles iptables

iptables -L INPUT -v -n

Doit montrer les règles dynamiques ajoutées par knockd après un knock réussi

Test depuis une machine distante

1. Tenter une connexion SSH directe (doit échouer) :

   ssh [email protected]
   # Doit rester bloqué ou afficher "Connection refused"

2. Frapper la séquence :

   knock 192.168.1.100 7000 8000 9000

3. Connexion SSH immédiate (doit réussir) :

   ssh [email protected]

Test de la séquence de fermeture

Depuis une autre session SSH (ne pas fermer la session active) :

knock 192.168.1.100 9000 8000 7000

Tenter une nouvelle connexion SSH depuis un autre terminal : elle doit échouer

Sécurité et Limites

Avantages du Port Knocking

• Masque le service SSH des scans de ports automatisés
• Réduit les tentatives de brute force SSH
• Ajoute une couche de sécurité supplémentaire
• Ne nécessite pas de modification du client SSH standard
• Logs précis des tentatives de knock

Limites et inconvénients

Recommandations de sécurité complémentaires

Configuration SSH renforcée

Éditer /etc/ssh/sshd_config :

nano /etc/ssh/sshd_config

Paramètres recommandés :

PermitRootLogin no
PasswordAuthentication no
PubkeyAuthentication yes
AllowUsers utilisateur1 utilisateur2
MaxAuthTries 3
ClientAliveInterval 300
ClientAliveCountMax 2

Redémarrer SSH :

systemctl restart sshd

Surveillance des logs

# Logs SSH
tail -f /var/log/auth.log

# Logs knockd
tail -f /var/log/syslog | grep knockd

# Logs iptables (si activé)
tail -f /var/log/kern.log

Variante : Port Knocking avec authentification OTP

Pour aller plus loin (hors périmètre BTS standard), il existe des solutions combinant port knocking et OTP (One-Time Password) comme fwknop (Firewall Knock Operator) utilisant SPA (Single Packet Authorization).

Alternatives plus robustes

• VPN (WireGuard, OpenVPN) : accès SSH via tunnel chiffré
• Bastion SSH (Jump Host) : serveur intermédiaire pour rebondir
• SSH via Tor : anonymisation du trafic
• 2FA/MFA : authentification à deux facteurs (Google Authenticator, Yubikey)

Dépannage

Problème : knockd ne démarre pas

journalctl -xe -u knockd

Vérifier :

• La syntaxe du fichier /etc/knockd.conf
• Le nom de l'interface réseau dans /etc/default/knockd
• Les permissions du fichier de configuration

Problème : La séquence ne fonctionne pas

• Vérifier que l'interface réseau est bien spécifiée
• Vérifier les logs en temps réel : tail -f /var/log/syslog
• Tester avec tcpdump pour voir si les paquets arrivent :

  tcpdump -i eth0 port 7000 or port 8000 or port 9000

Problème : Bloqué après configuration

Accéder via console physique ou hyperviseur et :

systemctl stop knockd
iptables -F
iptables -P INPUT ACCEPT
systemctl restart sshd

Points Clés pour l'Oral BTS

• Port Knocking : technique de sécurité par l'obscurité
• Principe : frapper une séquence de ports pour débloquer un service
• knockd : daemon Linux qui écoute les séquences et exécute des règles iptables
• Limites : vulnérable au sniffing, ne remplace pas l'authentification forte
• Complémentarité : doit être combiné avec clés SSH, fail2ban, firewall
• Usage : protection contre scans automatisés et brute force SSH
• Alternatives : VPN, bastion SSH, 2FA sont plus robustes