Comment utiliser fwknop pour activer l'authentification par paquet unique sur Ubuntu 12.04

Statut : Obsolète

Cet article couvre une version d'Ubuntu qui n'est plus prise en charge. Si vous utilisez actuellement un serveur exécutant Ubuntu 12.04, nous vous recommandons fortement de mettre à niveau ou de migrer vers une version prise en charge d'Ubuntu :

Raison: Ubuntu 12.04 a atteint sa fin de vie (EOL) le 28 avril 2017 and no longer receives security patches or updates. This guide is no longer maintained.

Voir plutôt : Ce guide peut toujours être utile comme référence, mais peut ne pas fonctionner sur d'autres versions d'Ubuntu. S'il est disponible, nous vous recommandons fortement d'utiliser un guide écrit pour la version d'Ubuntu que vous utilisez. Vous pouvez utiliser la fonctionnalité de recherche en haut de la page pour trouver une version plus récente.

Introduction

L'exposition de services à Internet est toujours un risque, mais c'est souvent la raison principale pour laquelle il y a un serveur en premier lieu. Tout port ouvert ou service exposé peut être soumis à de nombreuses tentatives d'exploration et d'accès par des utilisateurs malveillants ou des scripts automatisés.

Alors que certains services doivent rester accessibles car ils sont destinés à être consommés publiquement (comme un serveur Web hébergeant un site), d'autres services ne sont destinés à être utilisés que par un ou quelques utilisateurs autorisés et personne d'autre (comme SSH). Dans le meilleur des cas, ces services seraient bien sécurisés, mais également accessibles uniquement lorsque nous voulons réellement les utiliser.

L'authentification par paquet unique est une méthode permettant au pare-feu de bloquer l'accès à un service jusqu'à ce qu'un paquet crypté spécialisé soit envoyé à un service d'écoute. Lorsque le service valide ce paquet, il modifie rapidement les règles du pare-feu pour exposer le port nécessaire.

Un outil appelé fwknop, qui signifie Firewall Knock Operator, peut être utilisé pour interpréter ces paquets et modifier les règles du pare-feu. Dans ce guide, nous allons configurer un serveur et un client fwknop sur les systèmes Ubuntu 12.04. Cela nous permettra de protéger notre serveur SSH jusqu'à ce qu'il soit spécifiquement demandé.

Installez le serveur fwknop sur un VPS

Notre configuration supposera que vous avez deux instances VPS Ubuntu 12.04. Nous supposerons également que vous avez un nom de domaine pointé vers le serveur VPS, bien que l'utilisation d'adresses IP devrait également fonctionner. Si vous avez besoin d'aide pour configurer les noms de domaine pour DigitalOcean, cliquez ici.

Sur la machine serveur, installez le composant serveur fwknop via apt-get :

sudo apt-get update
sudo apt-get install fwknop-server

Lors de l'installation, quelques questions vous seront posées pour configurer le service et les composants associés.

Le premier composant sur lequel il pose des questions est le suffixe. Sélectionnez « Site Internet », puis indiquez votre nom de domaine dans la section suivante.

Ensuite, il vous demande si vous voulez que fwknop protège le port SSH par défaut, en utilisant un système de clé moins sécurisé. Sélectionnez "oui" pour que le service configure certains paramètres. Nous passerons aux paramètres plus sécurisés un peu plus tard.

Sélectionnez l'interface que vous souhaitez protéger. Habituellement, ce sera « eth0 ». Enfin, choisissez une clé de chiffrement à utiliser pour le chiffrement. Puisque nous allons changer cela plus tard, peu importe ce que vous mettez. Assurez-vous simplement qu'il s'agit d'un mot, sinon la configuration générera une erreur.

Installez le client fwknop sur l'autre VPS

Sur le VPS que nous utiliserons en tant que client, nous devons installer le composant client. C'est la partie de notre système qui fabriquera notre paquet chiffré à envoyer à l'autre machine :

sudo apt-get update
sudo apt-get install fwknop-client

La partie client ne nécessite aucune configuration à ce stade.

Configurer les clés GPG

Nous utiliserons des clés GPG pour fournir l'authentification pour notre transfert de paquets. Comme il s'agit d'un chiffrement asymétrique, nous devons effectuer ces étapes à la fois sur la machine cliente et sur la machine serveur. GPG devrait être installé par défaut.

Sur chaque machine, générez une clé en tapant :

gpg --gen-key

Cela vous demandera quelques informations. Pour la plupart des questions, vous êtes sûr d'accepter la valeur par défaut.

Fournissez et confirmez une phrase de passe. Après cela, il faudra un certain temps pour générer suffisamment d'informations aléatoires pour créer une clé.

Ensuite, nous devons écrire ou copier les identifiants publics pour chacune des clés que nous avons générées. Vous pouvez les obtenir en tapant :

 gpg --list-keys

  /home/test/.gnupg/pubring.gpg

pub 2048R/ 11111111 2014-01-09 client uid [email protected] sous 2048R/C1C26BA6 2014-01-09

La partie mise en évidence ci-dessus est la partie dont vous avez besoin pour chacune des touches. Copiez-le quelque part et étiquetez-le comme composant serveur ou client.

SERVER: 11111111
CLIENT: 99999999

Maintenant, sur la machine cliente, faites une copie ascii client.asc de la clé en l'exportant dans un fichier. Vous devez référencer l'ID de clé que vous venez de copier pour le client :

gpg -a --export 99999999 > client.asc

Sur la machine serveur, effectuez une procédure similaire en référençant l'ID de la clé du serveur afin de produire un fichier server.asc :

gpg -a --export 11111111 > serveur.asc

Transférer des clés entre ordinateurs

Maintenant, nous devons transférer les clés entre les machines afin que chaque machine ait une copie des deux.

Nous le ferons à l'aide de l'outil scp de la machine cliente.

Sur la machine cliente, copiez le fichier client.asc sur le serveur en utilisant une commande comme celle-ci :

scp client.asc server_domain_or_ip : /path/to/user/home/directory

Cela vous demandera de vous authentifier en utilisant votre mot de passe de compte normal pour le serveur. Modifiez le chemin pour refléter le dossier de départ de votre utilisateur habituel.

Ensuite, nous allons saisir le fichier server.asc en utilisant une commande similaire :

scp server_domain_or_ip : /path/to/user/home/directory /server.asc .

Vous devriez maintenant avoir les deux fichiers sur chaque machine.

Importer et signer des clés

Maintenant que nous avons accès à l'autre clé sur chaque machine, nous pouvons importer la clé opposée (clé serveur sur le client et clé client sur le serveur) dans la base de données GPG locale.

Sur la machine serveur, tapez :

gpg --import client.asc

Sur la machine cliente, tapez :

gpg --import server.asc

Maintenant que chaque ordinateur a la clé opposée dans sa base de données, vous pouvez signer chaque clé pour les valider.

Sur chaque machine, tapez cette commande, en faisant référence aux ID des clés que vous venez d'importer. Dans notre exemple, sur la machine cliente, nous taperions :

gpg --edit-clé 11111111

Et sur la machine serveur, on taperait :

gpg --edit-clé 99999999

Vous recevrez une invite GPG. Nous voulons signer les clés, alors tapez :

sign

On vous demandera si vous êtes sûr :

Après cela, vous pouvez enregistrer et quitter en tapant :

save

À ce stade, chacun de vos ordinateurs possède une copie de la clé GPG de l'autre. Ils sont signés pour signifier que nous faisons confiance à l'authenticité de la clé.

Configurer l'accès sur le serveur fwknop

Sur la machine serveur, nous devons configurer le service fwknop pour utiliser nos clés GPG et permettre à notre client de se connecter et de s'authentifier.

Sur le serveur, ouvrez la configuration d'accès avec les privilèges root :

sudo nano /etc/fwknop/access.conf

Vous devriez voir un fichier qui ne contient qu'environ quatre lignes actives. Ça devrait ressembler a quelque chose comme ca:

 SOURCE : TOUT ;  OPEN_PORTS : tcp/22 ;  ### pour ssh (modifier pour accéder à d'autres services) KEY : throw_away_password ;  FW_ACCESS_TIMEOUT : 30 ;

Ceci est configuré à l'aide du mot de passe que vous avez sélectionné lors de l'installation du service. Nous n'en aurons pas besoin, car nous allons passer à l'authentification GPG. Commentez cette ligne maintenant :

 SOURCE : TOUT ;  OPEN_PORTS : tcp/22 ;  ### pour ssh (modifier pour accéder à d'autres services)
CLÉ : mot_de_passe_jetable ;
FW_ACCESS_TIMEOUT : 30 ;

Ensuite, nous ajouterons quelques paramètres supplémentaires qui indiqueront au service fwknop nos clés. Nous devons ajouter quelques informations supplémentaires :

 SOURCE : TOUT ;  OPEN_PORTS : tcp/22 ;  ### pour ssh (modifier pour accéder à d'autres services)
CLÉ : mot_de_passe_jetable ;
FW_ACCESS_TIMEOUT : 30 ;
REQUIRE_SOURCE_ADDRESS : O ;  DATA_COLLECT_MODE : PCAP ;  GPG_REMOTE_ID : 99999999 ;  ## La clé client va ici GPG_DECRYPT_ID : 11111111 ;  ## La clé du serveur va ici GPG_DECRYPT_PW : your_GPG_passphrase_here ;  ## Placez la phrase de passe GPG ici GPG_HOME_DIR : /home/ test /.gnupg ;  ## Chemin vers le répertoire GPG de votre utilisateur. Habituellement ## ceci se trouve dans le répertoire personnel de votre utilisateur.

Assurez-vous de modifier le GPG_REMOTE_ID pour refléter l'ID de la clé de votre client et le GPG_DECRYPT_ID pour refléter l'ID du serveur.

De plus, vous devrez entrer votre mot de passe GPG et inclure le chemin d'accès au répertoire .gnupg de votre utilisateur.

Enregistrez et fermez le fichier.

Configurer les règles IPTables

Maintenant que nous avons modifié la configuration du serveur fwknop, nous devons créer des règles iptables réelles. Le service les modifiera si nécessaire, mais nous devons d'abord fermer notre port.

Tout d'abord, nous devons autoriser notre connexion actuelle. Cette règle autorisera les connexions déjà établies et les données associées :

sudo iptables -A INPUT -i eth0 -p tcp --dport 22 -m conntrack --ctstate ESTABLISHED,RELATED -j ACCEPT

Ensuite, juste après, nous limiterons tous les autres accès au port en supprimant toutes les tentatives de connexion non établies :

sudo iptables -A INPUT -i eth0 -p tcp --dport 22 -j DROP

Maintenant que nous avons un pare-feu de base limitant l'accès à ce port, nous pouvons implémenter notre configuration. Redémarrez le serveur fwknop en tapant :

sudo service fwknop-server restart

Maintenant, le service fwknop commencera à surveiller notre serveur pour les paquets qui correspondent aux règles que nous avons configurées.

Connexion au serveur depuis le client

Maintenant que notre serveur est configuré et en cours d'exécution, nous pouvons faire un test pour voir si nous pouvons nous connecter à notre serveur SSH à partir de notre client. Cela devrait expirer, car nous n'avons pas encore envoyé le paquet chiffré :

 ssh root@ server_domain_or_ip

  ssh : connexion à l'hôte server_domain_or_ip port 22 : connexion expirée

Vous pouvez appuyer sur "Ctrl-C" si vous n'avez pas envie d'attendre que cela se termine.

Maintenant, nous pouvons envoyer un paquet crypté qui nous authentifiera auprès de notre serveur. Pour ce faire, nous transmettons à la commande client fwknop un certain nombre de paramètres :

-A tcp/22 : Cette option spécifie le protocole et le port que nous demandons d'ouvrir.
–gpg-recip : cette option spécifiera l'ID de clé GPG du serveur.
–gpg-sign : cette option spécifie l'ID de clé GPG du client.
-a : ce paramètre indique à fwknop à quelle adresse IP autoriser l'accès. Cela devrait être votre ordinateur client.
-D : Cela indique à la commande la destination à laquelle nous envoyons notre paquet. Il s'agit du nom de domaine ou de l'adresse IP de notre serveur.

Maintenant que nous connaissons les informations dont nous avons besoin dans notre chaîne, nous pouvons créer et envoyer notre paquet :

fwknop -A tcp/22 --gpg-recip 11111111 --gpg-sign 99999999 -a client_ip_address -D server_domain_or_ip

Votre mot de passe GPG vous sera demandé pour déchiffrer les clés. Ensuite, votre paquet sera envoyé au serveur.

À ce stade, si votre paquet a été accepté, vous aurez 30 secondes pour tenter de vous connecter via SSH :

ssh root@ server_domain_or_ip

Si tout se passe bien, vous devriez pouvoir vous connecter avec succès. Le port ouvert se fermera après 30 secondes, mais votre connexion restera active.

Sur la machine serveur, après avoir envoyé un paquet (et avant que 30 secondes ne soient écoulées), vous devriez pouvoir voir une nouvelle règle ajoutée pour autoriser temporairement l'adresse IP de votre client :

 sudo iptables -S

 -P INPUT ACCEPT -P FORWARD ACCEPT -P OUTPUT ACCEPT -N FWKNOP_INPUT -A INPUT -j FWKNOP_INPUT -A INPUT -i eth0 -p tcp -m tcp --dport 22 -m conntrack --ctstate CONNEXE, ETABLIE -j ACCEPTER -A INPUT -i eth0 -p tcp -m tcp --dport 22 -j DROP -A FWKNOP_INPUT -s client_ip_address/32 -p tcp -m tcp --dport 22 - j ACCEPTER

L'utilitaire ajoute une autre chaîne à iptables et filtre toutes les entrées à travers celle-ci. Il vérifie ensuite si la connexion correspond à la machine qui produit le paquet chiffré et l'accepte si c'est le cas. Sinon, il le laisse tomber comme d'habitude.

Conclusion

En configurant un mécanisme d'authentification par paquet unique, vous pouvez ajouter une couche de sécurité supplémentaire lors de la connexion entre vos serveurs. Cela cachera non seulement votre serveur SSH des attaques aléatoires et des tentatives de force brute, mais cela aidera également dans les situations où un exploit de sécurité est trouvé dans les services protégés. Cela vous permettra de rester en sécurité pendant que vous travaillez pour résoudre le problème.

Bien que l'authentification par paquet unique puisse poser trop de problèmes à certains utilisateurs, c'est une bonne option pour ajouter une couche supplémentaire à votre sécurité. Combiné avec des mesures de sécurité SSH régulières, cela devrait rendre vos services cachés assez sécurisés.

Par Justin Ellingwood