Recherche de site Web

Comment configurer un pare-feu Iptables pour activer l'accès à distance aux services sous Linux - Partie 8


Présentation du programme de certification Linux Foundation

Vous vous souviendrez de la première partie – À propos d'Iptables de cette série LFCE (Linux Foundation Certified Engineer) que nous avons donné une description de base de ce qu'est un pare-feu : un mécanisme pour gérer paquets entrant et sortant du réseau. Par « gérer », nous entendons en réalité :

  1. Pour autoriser ou empêcher certains paquets d’entrer ou de sortir de notre réseau.
  2. Pour transférer d'autres paquets d'un point du réseau à un autre.

sur la base de critères prédéterminés.

Dans cet article, nous verrons comment implémenter le filtrage de paquets de base et comment configurer le pare-feu avec iptables, une interface pour netfilter, qui est un module natif du noyau utilisé pour le pare-feu.

Veuillez noter que le pare-feu est un vaste sujet et cet article n'est pas destiné à être un guide complet pour comprendre tout ce qu'il y a à savoir à ce sujet, mais plutôt comme un point de départ pour une étude plus approfondie de ce sujet. Cependant, nous reviendrons sur le sujet dans la Partie 10 de cette série lorsque nous explorerons quelques cas d'utilisation spécifiques d'un pare-feu sous Linux.

Vous pouvez imaginer un pare-feu comme un aéroport international où les avions de passagers vont et viennent presque 24 heures sur 24, 7 jours sur 7. En fonction d’un certain nombre de conditions, telles que la validité du passeport d’une personne ou son pays d’origine (pour ne citer que quelques exemples), elle peut ou non être autorisée à entrer ou à sortir d’un certain pays.

Dans le même temps, les agents de l'aéroport peuvent demander aux personnes de se déplacer d'un endroit à un autre de l'aéroport si nécessaire, par exemple lorsqu'elles doivent passer par les services douaniers.

L’analogie avec l’aéroport pourrait nous être utile dans la suite de ce didacticiel. Gardez simplement à l’esprit les relations suivantes au fur et à mesure que nous procédons :

  1. Personnes=Paquets
  2. Pare-feu=Aéroport
  3. Pays n°1=Réseau n°1
  4. Pays n°2=Réseau n°2
  5. Réglementations aéroportuaires appliquées par les agents=règles de pare-feu

Iptables – Les bases

Au bas niveau, c'est le noyau lui-même qui « décide » quoi faire des paquets en fonction de règles regroupées en chaînes, ou phrases. Ces chaînes définissent les actions à entreprendre lorsqu'un package correspond aux critères spécifiés par elles.

La première action entreprise par iptables consistera à décider quoi faire avec un paquet :

  1. L'accepter (le laisser passer dans notre réseau) ?
  2. Le rejeter (l'empêcher d'accéder à notre réseau) ?
  3. Le transférer (vers une autre chaîne) ?

Juste au cas où vous vous demanderiez pourquoi cet outil s'appelle iptables, c'est parce que ces chaînes sont organisées en tables, la table de filtrage étant la plus connue et celle qui est la plus connue. utilisé pour implémenter le filtrage de paquets avec ses trois chaînes par défaut :

1. La chaîne INPUT gère les paquets entrant dans le réseau, qui sont destinés aux programmes locaux.

2. La chaîne OUTPUT est utilisée pour analyser les paquets provenant du réseau local, qui doivent être envoyés vers l'extérieur.

3. La chaîne FORWARD traite les paquets qui doivent être transmis vers une autre destination (comme dans le cas d'un routeur).

Pour chacune de ces chaînes, il existe une politique par défaut, qui dicte ce qui doit être fait par défaut lorsque les paquets ne correspondent à aucune des règles de la chaîne. Vous pouvez afficher les règles créées pour chaque chaîne et la stratégie par défaut en exécutant la commande suivante :

iptables -L

Les politiques disponibles sont les suivantes :

  1. ACCEPTER → laisse passer le paquet. Tout paquet qui ne correspond à aucune règle de la chaîne est autorisé à accéder au réseau.
  2. DROP → supprime le paquet tranquillement. Tout paquet qui ne correspond à aucune règle de la chaîne ne peut pas entrer dans le réseau.
  3. REJECT → rejette le paquet et renvoie un message informatif. Celle-ci en particulier ne fonctionne pas comme politique par défaut. Au lieu de cela, il est destiné à compléter les règles de filtrage des paquets.

Lorsqu'il s'agit de décider quelle politique vous mettrez en œuvre, vous devez prendre en compte les avantages et les inconvénients de chaque approche, comme expliqué ci-dessus. Notez qu'il n'existe pas de solution unique. -toutes les solutions.

Ajout de règles

Pour ajouter une règle au pare-feu, appelez la commande iptables comme suit :

iptables -A chain_name criteria -j target

où,

  1. -A signifie Append (ajouter la règle actuelle à la fin de la chaîne).
  2. chain_name est soit INPUT, OUTPUT ou FORWARD.
  3. cible est l'action, ou la politique, à appliquer dans ce cas (ACCEPT, REJECT ou DROP).
  4. Les critères sont l'ensemble des conditions par rapport auxquelles les paquets doivent être examinés. Il est composé d’au moins un (très probablement plusieurs) des drapeaux suivants. Les options entre parenthèses, séparées par une barre verticale, sont équivalentes les unes aux autres. Le reste représente des commutateurs optionnels :
[--protocol | -p] protocol: specifies the protocol involved in a rule.
[--source-port | -sport] port:[port]: defines the port (or range of ports) where the packet originated.
[--destination-port | -dport] port:[port]: defines the port (or range of ports) to which the packet is destined.
[--source | -s] address[/mask]: represents the source address or network/mask.
[--destination | -d] address[/mask]: represents the destination address or network/mask.
[--state] state (preceded by -m state): manage packets depending on whether they are part of a state connection, where state can be NEW, ESTABLISHED, RELATED, or INVALID.
[--in-interface | -i] interface: specifies the input interface of the packet.
[--out-interface | -o] interface: the output interface.
[--jump | -j] target: what to do when the packet matches the rule.

Notre environnement de test

Regroupons tout cela dans 3 exemples classiques en utilisant l'environnement de test suivant pour les deux premiers :

Firewall: Debian Wheezy 7.5 
Hostname: dev2.gabrielcanepa.com
IP Address: 192.168.0.15
Source: CentOS 7 
Hostname: dev1.gabrielcanepa.com
IP Address: 192.168.0.17

Et ceci pour le dernier exemple

NFSv4 server and firewall: Debian Wheezy 7.5 
Hostname: debian
IP Address: 192.168.0.10
Source: Debian Wheezy 7.5 
Hostname: dev2.gabrielcanepa.com
IP Address: 192.168.0.15
EXEMPLE 1 : Analyser la différence entre les politiques DROP et REJECT

Nous allons d'abord définir une politique DROP pour les pings d'entrée sur notre pare-feu. Autrement dit, les paquets ICMP seront supprimés silencieusement.

ping -c 3 192.168.0.15
iptables -A INPUT --protocol icmp --in-interface eth0 -j DROP

Avant de passer à la partie REJECT, nous allons vider toutes les règles de la chaîne INPUT pour nous assurer que nos paquets seront testés par cette nouvelle règle :

iptables -F INPUT
iptables -A INPUT --protocol icmp --in-interface eth0 -j REJECT
ping -c 3 192.168.0.15

EXEMPLE 2 : Désactiver/réactiver les connexions SSH de dev2 à dev1

Nous traiterons de la chaîne OUTPUT car nous gérons le trafic sortant :

iptables -A OUTPUT --protocol tcp --destination-port 22 --out-interface eth0 --jump REJECT

EXEMPLE 3 : Autoriser/empêcher les clients NFS (à partir de 192.168.0.0/24) de monter des partages NFS4

Exécutez les commandes suivantes dans le serveur/pare-feu NFSv4 pour fermer les ports 2049 et 111 pour tout type de trafic :

iptables -F
iptables -A INPUT -i eth0 -s 0/0 -p tcp --dport 2049 -j REJECT
iptables -A INPUT -i eth0 -s 0/0 -p tcp --dport 111 -j REJECT

Ouvrons maintenant ces ports et voyons ce qui se passe.

iptables -A INPUT -i eth0 -s 0/0 -p tcp --dport 111 -j ACCEPT
iptables -A INPUT -i eth0 -s 0/0 -p tcp --dport 2049 -j ACCEPT

Comme vous pouvez le constater, nous avons pu monter le partage NFSv4 après avoir ouvert le trafic.

Insertion, ajout et suppression de règles

Dans les exemples précédents, nous avons montré comment ajouter des règles aux chaînes INPUT et OUTPUT. Si nous souhaitons les insérer à une position prédéfinie, nous devrions plutôt utiliser le commutateur -I (i majuscule).

Vous devez vous rappeler que les règles seront évaluées les unes après les autres et que l'évaluation s'arrête (ou saute) lorsqu'une stratégie DROP ou ACCEPT correspond. Pour cette raison, vous devrez peut-être déplacer les règles vers le haut ou vers le bas dans la liste des chaînes, selon vos besoins.

Nous utiliserons un exemple trivial pour démontrer cela :

Plaçons la règle suivante,

iptables -I INPUT 2 -p tcp --dport 80 -j ACCEPT

à la position 2) dans la chaîne INPUT (déplaçant ainsi le numéro 2 précédent comme le numéro 3)

À l'aide de la configuration ci-dessus, le trafic sera vérifié pour voir s'il est dirigé vers le port 80 avant de vérifier le port 2049.

Vous pouvez également supprimer une règle et modifier la cible des règles restantes sur REJECT (à l'aide du commutateur -R) :

iptables -D INPUT 1
iptables -nL -v --line-numbers
iptables -R INPUT 2 -i eth0 -s 0/0 -p tcp --dport 2049 -j REJECT
iptables -R INPUT 1 -p tcp --dport 80 -j REJECT

Enfin et surtout, vous devrez vous rappeler que pour que les règles de pare-feu soient persistantes, vous devrez les enregistrer dans un fichier puis les restaurer automatiquement au démarrage (en utilisant la méthode préférée de votre choix ou celle qui est disponible pour votre distribution).

Sauvegarde des règles de pare-feu :

iptables-save > /etc/iptables/rules.v4		[On Ubuntu]
iptables-save > /etc/sysconfig/iptables		[On CentOS / OpenSUSE]

Règles de restauration :

iptables-restore < /etc/iptables/rules.v4		[On Ubuntu]
iptables-restore < /etc/sysconfig/iptables		[On CentOS / OpenSUSE]

Ici, nous pouvons voir une procédure similaire (enregistrement et restauration manuelle des règles de pare-feu) en utilisant un fichier factice appelé iptables.dump au lieu de celui par défaut, comme indiqué ci-dessus.

iptables-save > iptables.dump

Pour rendre ces modifications persistantes lors des démarrages :

Ubuntu : installez le package iptables-persistent, qui chargera les règles enregistrées dans le fichier /etc/iptables/rules.v4.

apt-get install iptables-persistent

CentOS : ajoutez les 2 lignes suivantes au fichier /etc/sysconfig/iptables-config.

IPTABLES_SAVE_ON_STOP="yes"
IPTABLES_SAVE_ON_RESTART="yes"

OpenSUSE : répertorie les ports, protocoles, adresses autorisés, etc. (séparés par des virgules) dans /etc/sysconfig/SuSEfirewall2.

Pour plus d'informations, reportez-vous au dossier lui-même, qui est abondamment commenté.

Conclusion

Les exemples fournis dans cet article, bien qu'ils ne couvrent pas toutes les fonctionnalités d'iptables, ont pour but d'illustrer comment activer et désactiver le trafic entrant ou sortant.

Pour ceux d'entre vous qui sont fans de pare-feu, gardez à l'esprit que nous reviendrons sur ce sujet avec des applications plus spécifiques dans la Partie 10 de cette série LFCE.

N'hésitez pas à me faire savoir si vous avez des questions ou des commentaires.