Outils pour utilisateurs

Outils du site


Panneau latéral

Traductions de cette page:

Avez-vous remarqué ?

Il n'y a aucune publicités ou scripts de profilage (tracker) sur ce site.

Ce n'est que grâce à votre aide que l'auteur peut financer l'hébergement et le temps consacré à cet ouvrage.

Si vous voulez l'encourager, vous pouvez faire un don ♥. (même un tout petit ;-))

Sommaire

2-admin:pf

Le pare–feu (pf)

Quoi? Déjà le firewall?

Eh oui, on va commencer par cet élément essentiel à la sécurité du serveur. Avouez que ce serait dommage de travailler sur une machine vulnérable dès le départ :/. Donc avant d'aller plus loin : le pare-feu ! Comme toujours on va simplifier au maximum puis proposer des exemples plus complexes (pas “compliqués” ;)) pour ceux qui veulent aller plus loin.

Sur OpenBSD, le pare-feu s'appelle pf, comme “packet filter”. Sa configuration se déroule dans le fichier /etc/pf.conf, et comme vous le verrez, est nettement plus facile à appréhender que celle d'iptables (l'outil servant à configurer le pare-feu sous Linux…).

Avant toutes choses, il faut se demander ce dont on va avoir besoin sur notre serveur. Un serveur web (http) ? Les mails ? Un serveur ftp ? Selon les réponses à ces questions, nous n'ouvrirons pas les mêmes ports. En effet, pour assurer un maximum de sécurité, on ne va rien laisser passer sauf ce que qui est réellement utile. Redoutable ^^.

Pour trouver les ports sur lesquels écoutent les services dont vous pourriez avoir besoin, regardez le contenu du fichier /etc/services. Ainsi, écrire www ou 80 revient au même pour pf, mais est plus lisible pour les humains.

Les règles que vous allez définir seront appliquées dans l'ordre de lecture du fichier de configuration.

Un premier exemple

Prêts ? C'est parti pour un exemple détaillé. Nous allons configurer le parefeu pour un simple site web avec accès sur les ports 80 (www) et 443 (https).

On commence par tout bloquer, et enregistrer dans le journal les connexions interdites avec le mot log.

block log

Afin de nous simplifier la vie, nous allons mettre les ports à ouvrir dans une variable. Ça sera particulièrement pratique lorsqu'on aura davantage de ports à gérer.

tcp_pass = "{ 80 443 }"

Remarquez que c'est identique à tcp_pass = “{ www https }”

Ensuite, on autorise les visiteurs éventuels à accéder à votre serveur. Ce seront des connexions dites “entrantes”, on utilisera donc le mot clé “in”. Au lieu de chercher le nom de votre interface réseau (qui dépend de votre matériel), nous allons préciser le nom du groupe que portent ces interfaces afin que ça fonctionne sans inquiétudes : egress.

pass in quick on egress proto tcp to port $tcp_pass 
T'es mignon hein, mais c'est du charabia tout ça!

D'accord, nous allons expliquer ce que veut dire cette syntaxe. On peut la traduire la ligne de configuration précédente ainsi : “laisse passer vers l'intérieur (pass in) sans tenir compte des règles qui pourraient suivre (quick) à travers l'interface egress (on egress) pour le protocole tcp (proto tcp) vers les ports dans $tcp_pass (to port $tcp_pass).

Pfouh! :-P

Enfin, on autorise tout le trafic en sortie (mot clé ”out“) :

pass out on egress 

Cela nous donne au final :

tcp_pass = "{ 80 443 }"
block log

pass in quick on egress proto tcp port $tcp_pass 
pass out on egress all

Facile, non ? ^^

Je vous propose de remplacer la dernière ligne par quelque chose d'un peu plus restrictif :

pass out on egress proto { tcp udp icmp ipv6-icmp } modulate state

On précise simplement les protocoles autorisés en sortie avec une précaution pour chaque connexion sortante (modulate state).

Vous l'aurez compris, pf nous permet un contrôle de premier ordre sur notre serveur. Dans un premier temps, vous souhaiterez simplement choisir quels ports doivent être ouverts.

Cela fait de nombreuses nouvelles notions, prenez le temps de relire ce qui a été écrit jusqu'ici si besoin.

Lorsque vous serez plus à l'aise, sachez qu'on pourra filtrer le trafic entrant et sortant, et même rediriger une partie de celui-ci vers des services internes (par exemple un anti-spam). Je vous invite à lire la partie ”aller-plus-loin-avec-pf“. Vous y verrez comment ignorer certaines listes d'IP connues comme nuisibles que l'on enregistrera dans des tables, des règles contre les attaques bruteforce ou encore une proposition d'outil qui ajoute sur liste noire d'éventuels pirates en temps réel. Jetez aussi un œil à la page du wiki openbsd.fr.eu.org consacrée à pf.

Je vous laisse construire votre fichier /etc/pf.conf selon vos besoins. Partez de l'exemple vu au-dessus puis ajoutez les ports à ouvrir pour commencer. N'hésitez pas à consulter l'exemple fourni à la fin du document.

Pour être sûr, on peut avoir un exemple pour ouvrir le port SSH ?

Si le port SSH configuré est le 222, alors vous aurez dans la configuration de pf :

pass in quick on egress proto tcp to port 222

Bien sûr, vous pouvez aussi vous contenter de modifier uniquement la variable tcp_pass :

tcp_pass = "{80 443 222}"
pass in...

Commandes pratiques pour pf

Je vous propose une liste de commandes utiles pour gérer pf :

  • Désactiver le pare-feu : # pfctl -d
  • Activer le pare-feu avec le fichier /etc/pf.conf : # pfctl -ef /etc/pf.conf
  • Relancer le pare-feu : # pfctl -d && pfctl -ef /etc/pf.conf
  • Recharger la configuration du pare-feu : # pfctl -f /etc/pf.conf
  • Vider les règles du pare-feu (Attention!), ça peut être pratique lorsqu'on s'est auto-banni du serveur (si si, ça arrive même aux meilleurs…) : # pfctl -F all
  • Voir en temps réel ce que le pare-feu bloque (à condition que vous ayez mis le mot clé log dans la configuration) : # tcpdump -n -e -ttt -i pflog0
  • Voir à tout instant les logs enregistrés : # tcpdump -n -e -ttt -r /var/log/pflog
  • Afficher la liste des IP bloquées dans une table : # pfctl -t nom_de_la_table -T show
  • Ajouter une IP dans une table : # pfctl -t nom_de_la_table -T add 123.456.678.909
  • Retirer une IP d'une table # pfctl -t nom_de_la_table -T delete 123.456.678.909
  • Lister toutes les règles actives : # pfctl -sr

Aller plus loin avec pf

Blacklist d'IP nuisibles

Certaines adresses IP sont connues pour être les sources d'attaques. Vous pouvez configurer pf pour qu'il rejette automatiquement toutes les requêtes venant de ces IP.

Pour nous faciliter la vie, Stéphane HUC s'est donné la peine d'écrire des outils qui rassemblent des listes d'IP nuisibles de plusieurs sources. Merci qui ?

Merci Stéphane ! :-)

Son projet se trouve à cette adresse.

Il contient des listes que vous pourrez utiliser avec d'autres logiciels que pf si vous avez l'envie d'y jeter un œil.

En attendant, nous allons utiliser directement les listes générées par ses bons soins.

On commence par télécharger les listes, tout en vérifiant leur intégrité. Nous les placerons dans un dossier /var/blockzones.

# mkdir -p /var/blockzones
# cd /var/blockzones
# ftp https://stephane-huc.net/share/BlockZones/lists/badips_ipv4
# ftp https://stephane-huc.net/share/BlockZones/lists/badips_ipv6
# ftp https://stephane-huc.net/share/BlockZones/lists/BlockZones_GenLists.pub
# ftp https://stephane-huc.net/share/BlockZones/lists/BlockZones.sha512.sig

Pour vérifier l'intégrité des données, on lance ensuite :

signify -Cp BlockZones_GenLists.pub -x BlockZones.sha512.sig

Le message suivant doit vous être retourné :

Signature Verified
./badips_ipv4: OK
./badips_ipv6: OK
./bind.zone: FAIL
./hosts: FAIL
./baddomains: FAIL
./bogons_ipv4: FAIL
./local-zone: FAIL
./bogons_ipv6: FAIL
./README: FAIL

Les “FAIL” correspondent aux fichiers que je n'ai pas récupéré pour l'exemple. Pas d'inquiétudes à avoir donc pour ces derniers. :)

Pour utiliser ces listes, on ajoute les lignes suivantes dans le fichier /etc/pf.conf :

set limit table-entries 400000
table <t_badips>  persist file "/var/blockzones/badips_ipv4"
table <t_badips6> persist file "/var/blockzones/badips_ipv6"

block quick from { <t_badips>, <t_badips6> }

Vous pouvez maintenant relancer le parefeu avec pfctl -f /etc/pf.conf. Et voilà, votre serveur sera nettement allégé à l'avenir ^^.

Je vous invite à mettre à jour régulièrement les listes d'IP en mettant les lignes précédentes dans le fichier /etc/weekly.local par exemple.

Pour compléter les listes proposées par Stéphane, vous pouvez consulter celles que je rassemble avec le même projet ainsi que l'outil vilain en suivant ce lien.

Anti-bruteforce

Une méthode qu'utilisent les pirates pour s'en prendre à un serveur s'appelle “bruteforce”. Ces attaques consistent à essayer toutes les combinaisons d'identifiants/mot-de-passe possibles jusqu'à tomber sur la bonne.

Si vous avez choisi des phrases de passe robustes, vous êtes normalement à l'abri. Toutefois, ces attaques utilisent inutilement des ressources sur votre serveur et peuvent potentiellement réussir un jour (avouez que ça serait pas de bol).

Afin de déjouer ces attaques, il faudrait prendre le temps de décortiquer les journaux des services que vous hébergez (dans /var/log et /var/www/logs) à la recherche d'échecs d'identification et repérer d'où viennent ces attaques pour en bannir les auteurs. Mais soyons honnête, c'est à la fois pénible et chronophage.

L'idéal serait un outil qui surveille les journaux à votre place et s'occupe de mettre sur la liste noire de votre parefeu les IP des “attaquants”. Ça tombe bien, vous pouvez utiliser vilain ou sshguard qui sont faits pour ça.

En attendant, pf intègre déjà une protection qui limite le nombre de connexions sur un port pendant un temps donné. C'est très efficace et reste léger.

Anti-Bruteforce intégré à pf

pf dispose d'une fonctionnalité très intéressante : les “tables” (tableaux). Ça va nous permettre de garder en mémoire certaines adresses IP de pirates qui tenteraient de compromettre le serveur. Par exemple, pour protéger le service SSH, on va procéder ainsi :

  1. Création d'une table pour enregistrer les IP abusives avec notre serveur SSH.
  2. Bloquer toutes les IP qui seraient dans la table précédente, et ne pas aller plus loin pour elles.
  3. Ouvrir le port ssh, mais enregistrer dans la table précédente toutes

les IP qui tenteraient de se connecter plus de 3 fois par minute (attaque par bruteforce).

Ça nous donne donc ceci :

ssh_port = "22"
table <ssh_abuse> persist
block in log quick proto tcp from <ssh_abuse> to any port $ssh_port
pass in on egress proto tcp to any port $ssh_port flags S/SA keep state (max-src-conn-rate 3/60, overload <ssh_abuse> flush global)

Notez que nous avons enregistré le numéro du port utilisé pour le serveur SSH. C'est inutile, car on peut mettre à la place de $ssh_port simplement ssh, c'est-à-dire le nom du service. Cependant, on peut vouloir changer le port par défaut du serveur SSH, comme décrit dans le chapitre sur ce service.

Voici un autre exemple pour un site web (ports http et https) :

http_ports = "{ www https }"         # ports http(s)
# Si + de 40 connexions toutes les 5 secondes sur les ports http(s)
# ou si elle essaie de se connecter + de 100 fois
# on ajoute l'ip pour la bloquer.
pass in on egress proto tcp to any port $http_ports flags S/SA keep state (max-src-conn 100, max-src-conn-rate 40/5, overload <http_abuse> flush global)

En temps réel avec vilain

Je me permets de vous proposer un outil que j'ai écrit avec l'aide de Vincent Delft dans le but de mettre sur liste noire d'éventuels pirates lorsque l'attaque a lieu. Vos retours d'utilisation permettront de l'améliorer.

Le script en question s'appelle vilain. Vous pouvez suivre le lien suivant pour consulter le code.

Voici comment l'installer. Tout d'abord, on télécharge l'archive dans le dossier /tmp :

# cd /tmp
# ftp -o vilain.tgz https://framagit.org/prx/vilain/repository/master/archive.tar.gz

On décompresse l'archive :

# tar xvzf vilain.tgz

Ensuite, on procède à l'installation :

# cd vilain-master*
# make install

Afin que vilain puisse fonctionner, ajoutez une table à la configuration de pf afin de retenir les IP des attaquants. Éditez le fichier /etc/pf.conf pour y mettre :

table <vilain_bruteforce> persist
block quick from <vilain_bruteforce>

Rechargez pf avec # pfctl -f /etc/pf.conf puis éditez le fichier de configuration de vilain /etc/vilain.conf. Vous y trouverez quelques exemples de la forme suivante :

[nom du gardien]
logfile = /chemin/du/journal/a/inspecter
regex = expression reguliere qui retourne l'IP de l'attaquant en cas d'echec

D'autres options sont disponibles, comme le nombre d'échecs avant le bannissement, les IP à ignorer s'il y a une erreur…

Afin de lancer vilain, vous avez besoin de python3. Installez le paquet python-3.7.* par exemple.

Vous pouvez maintenant activer et lancer vilain comme n'importe quel service :

# rcctl enable vilain
# rcctl start vilain

Si vous consultez les journaux dans le fichier /var/log/daemon, vous y verrez des messages comme :

Start vilain for ssh
Start vilain for ssh2
Start vilain for http401
Start vilain for smtp
Start vilain for dovecot

vilain est en train de protéger votre serveur.

Vous pouvez si vous le souhaitez lancer régulièrement cette commande pour retirer les IP bannies depuis trop longtemps :

pfctl -t vilain_bruteforce -T expire 86400

Pour voir les IP bannies, saisissez :

pfctl -t vilain_bruteforce -T show

En temps réel avec sshguard

Contrairement à ce que son nom indique, sshguard est en mesure de vérifier les tentatives de connexions sur plusieurs services, pas seulement SSH.

Son installation sous OpenBSD n'est pas très compliquée à mettre en place. Comme pour vilain, vous devrez créer une table dans pf qui contiendra toutes les IP mises sur liste noire. Ainsi, on ajoute dans le fichier /etc/pf.conf une nouvelle table contenant les IP des pirates qui sont aussitôt bloquées :

table <sshguard> persist
block in from <sshguard>

Rechargez le parefeu avec pfctl -f /etc/pf.conf.

Maintenant, on installe sshguard comme on a l'habitude de le faire :

# pkg_add sshguard

Copiez le fichier de configuration donné en exemple :

# cp /usr/local/share/examples/sshguard/sshguard.conf.sample /etc/sshguard.conf

Éditez ce fichier si vous le souhaitez pour le rendre plus ou moins sévère. Les options par défaut sont plutôt raisonnables.

Nous pouvons maintenant activer et lancer sshguard :

# rcctl enable sshguard
# rcctl start sshguard

Et voilà, votre serveur est désormais sous bonne garde.

Vous voudrez peut-être mettre sur liste blanche quelques adresses IP avec l'option ”-w“. Procédez ainsi (cette option peut être employée plusieurs fois).

rcctl set sshguard flags -w 192.168.1.0/24 -w 123.123.123.123

Contribu(trices|teurs) :

prx
2-admin/pf.txt · Dernière modification: 2020/01/10 13:06 par prx