Comment utiliser le port knocking pour cacher votre démon SSH des attaquants sur Ubuntu

Introduction

Les serveurs, par définition, sont mis en œuvre comme un moyen de fournir des services et de rendre des applications et des ressources accessibles aux utilisateurs. Cependant, tout ordinateur connecté à Internet est inévitablement ciblé par des utilisateurs malveillants et des scripts espérant tirer parti des vulnérabilités de sécurité.

Les pare-feu existent et doivent être utilisés pour bloquer l'accès sur les ports non utilisés par un service, mais il reste la question de ce qu'il faut faire concernant les services auxquels vous souhaitez accéder, mais que vous ne souhaitez pas exposer à tout le monde. Vous voulez un accès quand vous en avez besoin, mais vous voulez qu'il soit bloqué autrement.

Le port knocking est une méthode pour dissimuler les services que vous avez en cours d'exécution sur votre machine. Cela permet à votre pare-feu de protéger vos services jusqu'à ce que vous demandiez l'ouverture d'un port à travers une séquence spécifique de trafic réseau.

Dans ce guide, nous allons discuter de la façon de mettre en œuvre le port knocking comme méthode d'obscurcissement de votre démon SSH sur un VPS Ubuntu 12.04 en utilisant le package knockd.

Remarque : Ce tutoriel couvre la sécurité IPv4. Dans Linux, la sécurité IPv6 est gérée séparément de l'IPv4. Par exemple, “iptables” ne gère que les règles de pare-feu pour les adresses IPv4, mais il a un équivalent IPv6 appelé “ip6tables”, qui peut être utilisé pour maintenir les règles de pare-feu pour les adresses réseau IPv6.

Si votre VPS est configuré pour IPv6, n'oubliez pas de sécuriser à la fois vos interfaces réseau IPv4 et IPv6 avec les outils appropriés. Pour plus d'informations sur les outils IPv6, consultez ce guide : Comment configurer des outils pour utiliser IPv6 sur un VPS Linux

Comment fonctionne le Port Knocking ?

Le port knocking fonctionne en configurant un service pour surveiller les journaux de pare-feu ou les interfaces de capture de paquets pour des tentatives de connexion. Si une séquence spécifique de tentatives de connexion prédéfinies (ou "coups") est effectuée, le service modifiera les règles du pare-feu pour ouvrir des connexions sur un certain port.

Cela vous permet de garder vos services cachés jusqu'à ce que vous prévoyiez réellement de les utiliser. Cela ne serait pas pratique pour quelque chose comme un serveur HTTP, car vous voudriez des connexions disponibles à tout moment. Mais cela serait utile pour des services destinés à être utilisés uniquement par des utilisateurs connus et légitimes, comme SSH.

Bien qu'une séquence de frappes puisse être arbitrairement complexe, elle n'est généralement pas, en elle-même, le seul ensemble de mesures de sécurité. En général, les méthodes de sécurité et d'authentification du service sont ensuite accessibles à un utilisateur qui émet la séquence correcte. De cette manière, le port knocking ajoute une couche supplémentaire que l'utilisateur doit traverser pour parvenir à l'authentification régulière.

Encore plus utile, c'est qu'aucun retour d'information n'est donné sur les tentatives de knocking. Un intrus scannant verrait tous les ports habituels fermés et s'il tentait une séquence de knocking, il devrait vérifier entre chaque tentative pour voir si un port s'est ouvert. Cela suffit souvent à dissuader ou à interdire les attaquants.

Pour nos besoins, nous utiliserons le pare-feu iptables qui vient avec Ubuntu 12.04, et nous installerons un démon appelé knockd pour fournir la fonctionnalité de knocking de port.

Configurer IPTables pour bloquer la plupart du trafic

Avant d'en arriver au véritable port knocking, nous devons configurer un pare-feu de base. Nous voulons verrouiller la plupart des choses.

Par défaut, Ubuntu est livré avec iptables installé. Cependant, il n'y a pas de règles par défaut en place, donc tout le trafic est autorisé. Pour concevoir votre propre ensemble de règles, vous pouvez apprendre à configurer un pare-feu avec iptables ici.

Pour nos besoins, nous utiliserons la plupart des règles de ce guide.

Commencez par autoriser le trafic sur la machine locale. Cela signifie accepter le trafic que le serveur génère et envoie à lui-même. Cela permet aux services de communiquer entre eux sans être bloqués :

sudo iptables -A INPUT -i lo -j ACCEPT

Cela ajoute une règle à la chaîne "INPUT". Cette chaîne gère toutes les connexions entrant dans le serveur. Cette règle indique à iptables d'accepter tout le trafic sur l'interface réseau "lo", qui est l'interface de bouclage local utilisée pour la communication interne.

Ensuite, nous voulons nous assurer que nous autorisons toutes les connexions établies et le trafic lié aux connexions établies en tapant :

sudo iptables -A INPUT -m conntrack --ctstate ESTABLISHED,RELATED -j ACCEPT

Cette règle indique à iptables d'accepter le trafic associé à une connexion déjà établie. C'est une règle importante, car une fois que nous commençons à bloquer des connexions, nous ne voulons pas que notre session SSH actuelle soit interrompue.

Ensuite, vous voudrez autoriser des services persistants, consommables dans le monde entier. Ce que je veux dire par là, c'est qu'il faut ajouter des règles pour les services qui doivent être toujours en cours d'exécution et visibles. Par exemple, si vous avez un site Web servi sur le port standard 80, vous voudrez autoriser ce trafic tout le temps.

Ne pas ajouter de règles à iptables pour les services pour lesquels nous utiliserons le port knocker pour ouvrir. Nous utiliserons plutôt le démon de knocking pour modifier dynamiquement notre ensemble de règles. Pour notre tutoriel, nous n'ajouterons pas notre serveur SSH dans notre configuration iptables initiale.

Utilisez cette syntaxe pour établir vos propres règles :

 sudo iptables -A INPUT -p tcp --dport 80 -j ACCEPT 

À ce stade, nous avons seulement ajouté des règles pour accepter les connexions, pas pour les rejeter. Nous continuons à tout accepter, nous avons juste été explicites sur certains types de trafic.

Maintenant, nous allons abandonner tout ce que nous n'avons pas spécifiquement autorisé. Ajoutez cette règle :

sudo iptables -A INPUT -j DROP

Tout trafic qui n'a pas été traité par les règles ci-dessus sera rejeté. Vous pouvez voir vos règles en tapant :

sudo iptables -S

-P INPUT ACCEPT
-P FORWARD ACCEPT
-P OUTPUT ACCEPT
-A INPUT -i lo -j ACCEPT
-A INPUT -m conntrack --ctstate RELATED,ESTABLISHED -j ACCEPT
-A INPUT -p tcp -m tcp --dport 80 -j ACCEPT
-A INPUT -j DROP

Comme vous pouvez le voir, nous n'avons toujours pas de règles pour accepter de nouvelles connexions SSH.

Si votre connexion est interrompue à ce stade, vous devrez accéder à votre serveur via le panneau de contrôle en cliquant sur le bouton « accès à la console » dans le coin supérieur droit :

Cela agit comme une connexion directe et n'utilise pas SSH, donc cela ne sera pas affecté par vos règles.

Une fois que vous avez établi vos règles iptables, rendez-les persistantes avec iptables-persistent. Installez-le en tapant :

sudo apt-get install iptables-persistent

Ensuite, démarrez le service en tapant :

sudo service iptables-persistent start

Installez le service Knockd

Le service de port knocking que nous allons utiliser s'appelle knockd. Nous pouvons l'installer en tapant simplement :

sudo apt-get install knockd

Cela installera l'utilitaire, mais ne démarrera pas le service par défaut.

C'est une mesure de sécurité afin d'empêcher le démon de bloquer immédiatement le trafic important. Vous devez configurer et activer explicitement ce service.

Configurer Knockd pour utiliser le port knocking

Pour configurer le service, nous devrons modifier le fichier de configuration. Ouvrez ce fichier avec des privilèges root :

sudo nano /etc/knockd.conf

Vous devriez voir un fichier qui ressemble à ceci :

[options]
        UseSyslog

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

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

Immédiatement, vous devriez pouvoir voir certaines informations importantes sur le fonctionnement de knockd. Vous devriez également commencer à réaliser que la configuration n'est pas trop complexe.

Dans la section « options », nous voyons une directive appelée UseSyslog. Cela indique à knockd qu'il doit enregistrer ses informations en utilisant les méthodes syslog normales. Cela insérera des journaux dans /var/log/messages.

Si vous souhaitez spécifier un fichier journal différent, vous pouvez le faire en utilisant cette option à la place :

 FichierJournal=/chemin/vers/le/fichier/de/journal 

En dessous, nous avons deux sections. Les noms de ces sections peuvent être n'importe quoi. Ils sont utilisés pour regrouper un ensemble de règles qui correspondront à un seul événement chacune.

Par exemple, dans notre fichier, nous avons une section qui ouvrira notre port SSH, et une autre qui le refermera.

Le paramètre qui définit le schéma de cliquetis est ici :

 séquence   =7000,8000,9000 

Cela signifie que cet ensemble de règles correspondra si la même IP demande une connexion sur le port 7000, suivie directement du port 8000, puis enfin du port 9000.

Deux autres paramètres dans cet ensemble contrôlent également si l'activité correspond :

seq_timeout = 5
tcpflags = syn

La première option spécifie une durée dans laquelle la séquence doit être complétée.

Le second spécifie un drapeau qui doit être présent dans les paquets tcp pour qu'ils soient considérés comme valides. La valeur de syn que nous voyons ici est couramment utilisée pour distinguer les paquets que nous voulons de ceux créés en arrière-plan par des programmes comme SSH.

Enfin, nous voyons la commande :

command = /sbin/iptables -A INPUT -s %IP% -p tcp --dport 22 -j ACCEPT

Vous devriez reconnaître cela comme une règle iptables. Comme l'indique l'étiquette de section « openSSH », cette section ouvrira un port pour les connexions SSH lorsque la bonne séquence sera atteinte.

Cependant, si vous avez prêté attention lors de la configuration d'iptables, vous verrez que cette nouvelle règle utilise l'option -A pour ajouter cette règle à la fin de la chaîne INPUT. Cela placera cette règle après la règle pour supprimer toutes les connexions restantes.

Pour résoudre cette situation, nous devons modifier cette commande. Remplacez la commande par une règle pour insérer la nouvelle règle en haut de la liste. Nous faisons cela en utilisant l'option -I et en référant l'emplacement comme règle 1 :

command = /sbin/iptables -I INPUT 1 -s %IP% -p tcp --dport 22 -j ACCEPT

Avec ce changement, une nouvelle règle sera ajoutée en haut de la chaîne INPUT pour accepter les connexions SSH de l'utilisateur qui a frappé. La portion %IP% de la règle sera remplacée par l'adresse IP qui a effectué le coup acceptable.

La deuxième section SSH fait presque la même chose, mais elle utilise une séquence différente et supprime la règle d'iptables qui ouvrait des connexions SSH. Nous pouvons frapper cette séquence pour fermer l'écart que nous avons ouvert.

En pratique, vous devriez toujours changer les séquences pour ces deux sections en quelque chose qui est essentiellement aléatoire. Conserver la séquence par défaut équivaut à éliminer toute sécurité que l'astuce de port knocking établit.

Avant de configurer quoi que ce soit d'autre, testons notre configuration actuelle. Enregistrez et fermez le fichier.

Mettre en œuvre le service Knockd

Maintenant que nous avons configuré knockd pour avoir un ensemble de règles valide, nous pouvons le tester en mettant en œuvre notre démon. N'oubliez pas que, bien que la configuration soit valide, à ce stade, elle n'est pas sécurisée à moins que vous n'ayez changé les séquences de port pour chaque section de frappage.

Nous devons activer le service en modifiant un autre fichier. Ouvrez ce fichier avec des privilèges root :

sudo nano /etc/default/knockd

Nous devons changer l'option START_KNOCKD pour qu'elle soit “1” afin de démarrer le service :

 DÉBUT_KNOCKD=1 

Enregistrez et fermez le fichier.

Maintenant, nous pouvons commencer le service en tapant :

sudo service knockd start

Cela va démarrer le démon et vous permettre de modifier les ensembles de règles iptables en frappant sur les séquences de ports.

Test de Tapotement de Port

Nous devrions maintenant tester notre capacité à modifier les règles iptables en utilisant la séquence de port knocking que nous avons configurée.

Dans une nouvelle fenêtre de terminal, nous pouvons utiliser des outils pour demander ces ports. Il est préférable de garder votre autre session ouverte en cas de problème. Encore une fois, si vous vous verrouillez accidentellement, utilisez le bouton « accès à la console » dans le coin supérieur droit de la page du droplet dans le panneau de contrôle.

Nous pouvons utiliser une variété d'outils différents pour frapper. Certains choix populaires sont netcat, nmap et un client spécialement conçu qui s'appelle, de manière appropriée, knock.

Nous allons utiliser nmap dans cet exemple, car il est installé par défaut sur la plupart des distributions Linux et OS X.

Avant de frapper, confirmons que notre port SSH est effectivement fermé actuellement. Tapez la commande que vous utilisez habituellement pour vous connecter au serveur :

 ssh root@adresse_ip_du_serveur 

 sh: connexion au hôte adresse_ip_du_serveur port 22 : Temps d'opération dépassé 

Vous ne devriez recevoir aucune réponse du serveur et le client SSH devrait expirer. Cela est dû au fait que notre démon SSH est actuellement bloqué par iptables. Tapez ctrl-C pour terminer la tentative SSH si elle ne se termine pas automatiquement.

En raison du paramètre de délai d'attente de séquence qui est défini, nous avons en fait un temps très limité pour atteindre la séquence correcte. Nous utiliserons un petit script bash en ligne pour vérifier rapidement ces ports.

Depuis votre ordinateur local, tapez une commande comme celle-ci :

pour x dans 7000 8000 9000 ; faire nmap -Pn --host_timeout 201 --max-retries 0 -p $x server_ip_address ; terminé

Dans la commande, ajustez les trois numéros aux numéros que vous avez sélectionnés pour votre séquence afin d'ouvrir le port SSH. Changez l'adresse_ip_serveur pour refléter l'adresse de votre serveur.

Cela appellera nmap séquentiellement sur tous les ports que vous avez listés.

Une fois cela terminé, vous devriez pouvoir vous connecter à SSH régulièrement :

ssh root@server_ip_address

Nous pouvons refermer le port en frappant sur l'autre séquence que nous avons configurée :

pour x dans 9000 8000 7000; faire nmap -Pn --host_timeout 201 --max-retries 0 -p $x server_ip_address; terminé

Port Knocking avec l'outil Knock

Une manière plus simple de frapper est d'utiliser l'utilitaire knock fourni par les créateurs de knockd. Cela est inclus dans le package knockd, donc vous pouvez l'installer sur notre machine client tout comme nous l'avons fait avec le serveur :

sudo apt-get install knockd

Vous pouvez également obtenir des clients knock sur le site web du projet dans la section "téléchargement". Il existe des clients natifs pour OS X et Windows (et même des clients iOS et Android).

Une fois que vous avez installé le client knock, vous pouvez facilement effectuer une séquence en utilisant simplement cette syntaxe :

 frapper adresse_ip_serveur séquence 

Donc, pour notre exemple, vous pourriez ouvrir votre port SSH en tapant :

 frapper adresse_ip_serveur 7000 8000 9000 

C'est beaucoup plus rapide que l'autre méthode mentionnée.

Nous pouvons fermer le port en tapant :

frappé l'adresse_ip_serveur 9000 8000 7000

Configurer Knockd pour fermer les connexions automatiquement

Maintenant que nous avons établi que notre démon de frappe de port fonctionne correctement, changeons quelques détails de configuration pour le rendre plus robuste.

Ouvrez à nouveau le fichier de configuration :

sudo nano /etc/knockd.conf

Nous allons tirer parti de la capacité de knockd à établir un délai d'attente pour les commandes afin de condenser notre correspondance SSH en une seule règle. Cela signifie que nous n'aurons pas à nous souvenir de frapper pour fermer le port SSH après avoir terminé.

Nous pouvons commenter ou supprimer les sections « openSSH » et « closeSSH ». Nous les remplacerons par une seule section que nous appellerons simplement « SSH » :

[options]
    UseSyslog

[SSH]

Dans cette nouvelle section, nous établirons une séquence, les tcpflags, et le délai d'attente de la séquence tout comme nous l'avons fait dans les autres sections. Nous inclurons également la commande que nous avons utilisée pour ouvrir le port SSH :

 [options] UtiliserSyslog
[SSH] séquence=<span class="highlight « >5438,3428,3280,4479</span> tcpflags=syn seq_timeout=15 start_command=/sbin/iptables -I INPUT 1 -s %IP % -p tcp --dport 22 -j ACCEPT </pre>
Choisissez une séquence de ports unique. Comme vous pouvez le voir, dans cet exemple, nous utilisons quatre ports. Nous pouvons augmenter le nombre de ports tant qu'ils peuvent tous être frappés dans le délai spécifié dans le paramètre seq_timeout.
Le paramètre start_command est le même que le paramètre command utilisé dans l'autre exemple. Nous avons choisi d'utiliser cette variante simplement pour être plus explicites sur ce que nous faisons.
Après cela, nous ajouterons de nouveaux paramètres qui nous aideront à fermer le port :
 [options] UtiliserSyslog
[SSH] séquence=5438,3428,3280,4479 tcpflags=syn seq_timeout=15 start_command=/sbin/iptables -I INPUT 1 -s %IP% -p tcp --dport 22 -j ACCEPT cmd_timeout=10 stop_command=/sbin/iptables -D INPUT -s %IP% -p tcp --dport 22 -j ACCEPT 
Le cmd_timeout est le nombre de secondes que knockd attendra avant d'exécuter la commande contenue dans la variable stop_command.
Le résultat est que lorsque la séquence correcte est utilisée, le daemon ouvrira le port SSH. Il attendra ensuite 10 secondes avant de fermer à nouveau le port.
Enregistrez et fermez le fichier.
Mettez en œuvre votre nouvelle règle en redémarrant le démon :
sudo service knockd restart
Nous pouvons utiliser cette règle de port knocking pour nous connecter facilement dans le délai spécifié. Par exemple, nous pourrions utiliser cette commande pour nous connecter facilement à notre serveur :
 frapper adresse_ip_serveur 5438 3428 3280 4479 && ssh root@adresse_ip_serveur 
Le trou que nous créons dans notre pare-feu se fermera après nous dans 10 secondes.
Conclusion
Bien que le port knocking soit parfois évoqué de manière désinvolte comme une sécurité par l'obscurité (cacher un service au lieu de réellement le sécuriser), c'est un excellent moyen d'ajouter une couche de protection supplémentaire contre les attaques aléatoires.
Vous devez toujours sécuriser vos services en utilisant les outils natifs disponibles pour obtenir les meilleurs résultats. Cependant, ajouter quelque chose comme un schéma de port knocking devant ces méthodes peut réduire considérablement le nombre d'attaques par force brute ou de tentatives d'intrusion que vos services subissent.
Par Justin Ellingwood