iptables : comment configurer le pare-feu Linux pour protéger votre serveur

Principales fonctionnalités d'iptables

iptables est un logiciel chargé d'agir comme pare-feu ou pare-feu sur notre réseau. C'est une partie très importante des systèmes d'exploitation, et il est spécifiquement conçu pour autoriser l'accès autorisé et bloquer l'accès non autorisé. Un pare-feu établit un point de contrôle, à la fois pour les paquets entrants et sortants. De plus, il est très important d'indiquer qu'un pare-feu protège du trafic qui traverse différents réseaux, mais il ne protège pas le réseau local des attaques qui se produisent au sein du même sous-réseau. .

iptables est le pare-feu inclus dans les systèmes Linux depuis la version 2.4, il est donc intégré par défaut dans des systèmes comme Debian, Ubuntu, Linux Mint et bien d'autres, bien qu'actuellement nftables soit utilisé en interne, car iptables est considéré comme ancien, bien qu'aujourd'hui iptables soit encore largement utilisé dans le monde de l'administration système Linux et aussi dans le monde de l'administration réseau.

Ce pare-feu possède plusieurs tables créées par défaut, dans le but de faciliter grandement la possibilité d'ajouter différentes chaînes et règles. Un détail très important est que par défaut, nous avons tout défini sur «accepter», c'est-à-dire que tout le trafic est autorisé, il n'y a pas de règle pour refuser le trafic, donc, au début, ce pare-feu est permissif, mais nous pouvons changer la politique par défaut très facilement et rapidement.

Une fois que nous connaissons les principales caractéristiques, nous allons vous montrer le fonctionnement et l'architecture de ce pare-feu.

Fonctionnement et architecture

Ce pare-feu est basé sur des règles que nous allons introduire les unes après les autres, son fonctionnement est basé sur l'application de règles que le pare-feu lui-même est chargé d'exécuter. Bien qu'iptables puisse sembler simple à utiliser au premier abord, si vous souhaitez le faire de manière avancée, c'est plus compliqué. Ensuite, vous pouvez voir un schéma récapitulatif du fonctionnement d'iptables.

La structure d'iptables est basée sur des tables, dont beaucoup sont déjà créées par défaut. À l'intérieur des tables, nous avons les chaînes, dont certaines sont également créées par défaut. Enfin, à l'intérieur des chaînes, nous avons les différentes règles que nous pouvons configurer. Sur la photo suivante, vous pouvez voir un petit schéma de ce à quoi ressemblerait l'architecture du pare-feu :

Par défaut, nous avons un total de quatre tables :

• tableau de filtrage : c'est la table par défaut, si on ne définit pas de table pour ajouter une règle, elle ira toujours dans la table de filtrage. Dans ce tableau, nous avons au total trois chaînes par défaut, selon ce qui nous intéresse, nous devrons utiliser une chaîne ou une autre : INPUT (ce sont les paquets dans le sens entrant, vers le pare-feu lui-même), OUTPUT (ce sont les les paquets sortants, du serveur vers l'extérieur) et FORWARD (utilisé pour filtrer les paquets allant d'une interface réseau à une autre).
• Nat table : cette table est chargée de faire le NAT, de transformer l'IP privée en publique et vice versa. Au sein de NAT, nous avons trois chaînes : PREROUTING (modifie les paquets avant de les router, ici DNAT ou la redirection de port est effectuée), POSTROUTING (modifie les paquets après les avoir routés, ici SNAT ou MASQUERADE est fait) et OUTPUT (paquets générés par le pare-feu que le NAT traversera).
• essoreuse à rouleaux table : cette table est responsable de la modification des paquets, c'est là que la QoS est configurée pour la qualité de service, la modification des en-têtes TCP, etc. Dans cette table, nous avons les cinq chaînes : PREROUTING, INPUT, FORWARD, OUTPUT, POSTROUTING.
• brut table – Cette table n'est pas souvent utilisée car les paquets voyagent sans état de connexion. Nous avons la chaîne PREROUTING et OUTPUT.

Dans l'image suivante, vous pouvez voir un petit résumé des chaînes que nous avons dans les différents tableaux :

Le fonctionnement lors de l'ajout d'une règle est le suivant :

• Les règles que nous ajoutons aux chaînes ont toujours une cible (-j dans la règle).
• Lorsque le pare-feu reçoit un paquet, il vérifie si le paquet correspond à une règle que nous avons inscrite. Si elle correspond, la commande cible est exécutée, sinon, elle passe à la règle suivante jusqu'à la fin de la chaîne.
• Les règles sont vérifiées dans un ordre séquentiel, de la première règle à la dernière. L'ordre est très important, si nous bloquons tout d'abord puis autorisons quelque chose de plus spécifique, nous bloquerons tout le trafic et la règle la plus spécifique ne sera pas vérifiée.
• Dans le cas où aucune règle ne satisfait le paquet, alors la politique de la chaîne dont nous disposons (règle globale) sera utilisée.

Les objectifs des différentes règles sont les suivants :

• ACCEPTER : accepte le paquet et le transmet au niveau suivant, un serveur Web, SSH, FTP, etc.
• DROP : bloque le paquet et ne le passe pas au niveau suivant.
• QUEUE : est une cible spéciale, qui transmet le paquet dans une file d'attente destinée au traitement de l'espace utilisateur. Cela peut être utilisé pour exécuter d'autres programmes externes.
• RETOUR : a le même effet que si nous avions atteint la fin de la chaîne. Si la règle se trouvait dans l'une des chaînes par défaut, la stratégie de la chaîne est exécutée. Pour une règle qui se trouve dans une chaîne définie par l'utilisateur, elle est quittée, en continuant dans la chaîne avant le saut, juste après la règle avec laquelle elle a été sautée.

Une fois que nous savons comment cela fonctionne et son architecture, nous allons voir différentes commandes pour effectuer différentes actions.

 

Commandes essentielles pour utiliser iptables

La première chose que nous devons prendre en compte lors de la configuration de ce pare-feu est que nous avons besoin des autorisations de superutilisateur pour exécuter les différentes commandes. Il faut absolument qu'ils courent, sinon ça ne marchera pas. Les commandes suivantes n'ont pas "sudo" car nous supposons que vous êtes déjà superutilisateur (sudo su).

Dans les dernières versions de Linux, il n'est pas possible d'arrêter le service iptables, afin d'autoriser tout le trafic réseau et de laisser le pare-feu avec les paramètres par défaut, nous devons exécuter les commandes suivantes :

• sudo iptables -F
• sudo iptables -X
• sudo iptables -t nat -F
• sudo iptables -t nat -X
• sudo iptables -t mangle -F
• sudo iptables -t mangle -X
• sudo iptables -P ENTRÉE ACCEPTÉE
• sudo iptables -P AVANT ACCEPTER
• sudo iptables -P SORTIE ACCEPTER

Une fois que nous aurons fait cela, nous aurons le pare-feu "réinitialisé" et autoriserons tout. Maintenant que nous savons comment le réinitialiser, voyons les différentes commandes.

 

Voir les tableaux actuels

Si vous voulez voir le contenu des différentes chaînes et règles que nous avons dans un certain tableau, vous pouvez voir à quoi elles ressembleraient :

• iptables -t filtre –liste
• iptables -t mangle –liste
• iptables -t nat-list
• iptables -t brut –liste

 

Principaux arguments et à quoi ils servent

• -t, –table table Sélectionnez la table que nous voulons
• -A, –append chain rule-specification Nous ajoutons une nouvelle règle dans une certaine chaîne
• -C, –check chain rule-specification Nous vérifions qu'il existe une certaine règle dans une certaine chaîne
• -D, –delete chain rule-specification Nous supprimons la règle que nous avons mise dans une certaine chaîne
• -D, –delete chain rulenum Nous supprimons le numéro de règle X dans une certaine chaîne
• -I, –insert chain [rulenum] rule-specification Nous insérons une nouvelle chaîne avec un numéro dans une certaine table
• -R, –replace chain rulenum règle-spécification Remplace une chaîne donnée dans une table, utilisée pour déplacer le nombre.
• -L, –list [chaîne] Afficher la liste des règles d'une chaîne
• -F, –flush [chaîne] Vide toutes les règles d'une chaîne donnée.
• -Z, –zero [chain [rulenum]] Met les compteurs d'une règle donnée à 0.
• -N, –new-chain chain Nous créons une nouvelle chaîne dans une certaine table
• -X, –delete-chain [chaîne] Nous supprimons une certaine chaîne (vide) dans une certaine table
• -P, –policy chain target On applique la politique par défaut, elle est remplie lorsqu'aucune règle des chaînes n'est remplie.
• -E, –rename-chain ancienne-chaîne nouvelle-chaîne Renommer une chaîne précédemment ajoutée
• -h, affiche l'aide
• -v, –verbose Sortie utilisée conjointement avec –L, pour afficher plus d'informations que la commande –L n'en fournit.
• -n, –numeric Les adresses IP et les numéros de port apparaîtront sous forme de nombres. Par exemple, si nous filtrons le port 80, avec le typique –L www apparaîtra, et non 80.
• -x, –exact Affiche la valeur exacte du compteur de paquets et d'octets, au lieu d'utiliser K, M ou G pour les valeurs.
• –line-numbers Lors de l'affichage de la liste des règles, il affichera le numéro exact de la règle. Idéal pour utiliser –D et le nombre (supprimer) ou –I à introduire avant ou après ladite règle.

 

Conditions principales

• -p , –protocole protocole. Filtrez le paquet par protocole, le protocole spécifié peut être : tcp, udp, Idplite, icmp, esp, ah, sctp.
• -s , –adresse source[/masque][,…] Adresse IP source du paquet. On peut avoir une IP ou un sous-réseau (indiquant le masque au format CIDR). On peut aussi mettre des noms d'hôtes (domaines, sites web etc), mais c'est une mauvaise idée car ce n'est pas efficace. Plusieurs adresses source peuvent être spécifiées (192.168.1.1,192.168.1.2) mais cela créera différentes règles pour les satisfaire.
• -d , –destination address[/mask][,…] Adresse IP de destination du paquet. Il se comporte exactement comme -s.
• -m , –match match. Spécifie si on veut appeler les modules étendus d'iptables, pour effectuer certaines actions telles que :
  • Mettez plusieurs ports source et destination (module multiport).
  • Connexions de contrôle (module conntrack).
  • Évitez la force brute (module récent, idéal pour SSH).
  • Limitez le nombre de connexions (modulo limit et connlimit).
  • Plage d'adresses IP (iprange).
• -j , – cible de saut. Spécifie l'objectif de la règle, si nous voulons accepter, refuser et même transmettre le paquet à une autre chaîne pour un traitement ultérieur. Toujours dans n'importe quelle règle, nous aurons un -j pour lui dire ce que nous voulons faire. Si nous n'ajoutons pas de –j, la règle sera ajoutée et elle comptera les paquets, mais elle ne fera rien. Si nous utilisons -j pour passer à une autre chaîne, une fois l'autre chaîne terminée, elle reviendra à l'original.
• -g , –chaîne goto. Il est utilisé pour transférer le trafic vers une autre chaîne, mais contrairement au saut, il ne reviendra pas à la chaîne d'origine où il est entré.
• -i , –nom de l'interface. Nom de l'interface par laquelle un paquet est reçu. Cela ne fonctionne que pour les chaînes d'entrée telles que INPUT, FORWARD et PREROUTING. Si nous mettons Cela signifie tout sauf cette interface. Si nous mettons un + à la fin du nom, toute interface avec le début du nom le saisira pour vérification. Imaginons eth0, eth1 et eth2. Si nous voulons mettre les trois, il suffit de mettre eth+.
• -o , –nom de l'interface de sortie. Nom de l'interface par laquelle un paquet sort. Il n'est valide que pour les chaînes de sortie telles que OUTPUT, FORWARD et POSTROUTING.

 

Conditions uniquement si vous utilisez TCP ou UDP

Si vous utilisez le protocole TCP ou UDP, vous souhaiterez peut-être filtrer par numéro de port source et/ou destination, alors vous avez les deux arguments que vous pouvez utiliser :

• –sport –port-source. Sélectionnez les ports source à autoriser ou à refuser. Si nous utilisons ! exclut.
• –dport –port-destination. Sélectionnez les ports de destination à autoriser ou à refuser. Si nous utilisons ! exclut.

Il existe de nombreuses autres conditions pour une configuration avancée du pare-feu, mais nous avons déjà répertorié les conditions élémentaires.

 

Définir la politique par défaut

Les politiques sont utilisées de sorte que lorsqu'une règle n'est pas trouvée dans la chaîne, la politique par défaut est exécutée. La politique par défaut pour toutes les chaînes est ACCEPT, mais il y a deux options : ACCEPT ou DROP

-P, –cible de la chaîne de politiques

Exemples :

• iptables -P BAISSE D'ENTRÉE
• iptables -P DROP FORWARD
• iptables -P DROP DE SORTIE

Avec cela, nous allons manquer d'Internet, alors nous devons ensuite commencer à créer des règles permissives.

Ci-dessous, vous pouvez voir toutes les politiques que nous avons dans les différents tableaux :

• iptables -t filter -P (ENTRÉE | SORTIE | AVANT) (ACCEPTER | ABANDONNER)
• iptables -P (ENTRÉE | SORTIE | AVANT) (ACCEPTER | ABANDONNER)
• iptables -t mangle -P (ENTREE | SORTIE | AVANT | PREROUTING | POSTROUTING) (ACCEPTER | ABANDONNER)

 

Afficher l'état du pare-feu

Le paramètre -L affiche les règles que nous avons configurées. V permet de recevoir plus d'informations sur les connexions et N renvoie les adresses IP et leurs ports correspondants sans passer par un DNS serveur.

• iptables -L -n -v

C'est l'une des commandes les plus importantes pour voir l'état du pare-feu.

 

Modules (correspondance -m) d'iptables

 

multiport

C'est une extension d'iptables qui nous donne la possibilité de regrouper des règles similaires avec différents ports TCP et UDP en un seul. Le multiport vous permet de mettre plusieurs ports ignorés, ainsi que plusieurs ports à la suite, le maximum est de 15 arguments de port. Exemple:

• iptables –A ENTRÉE –p tcp –m multiport –dports 80,81,1000:1200 –j ACCEPTER

Grâce à ce module, nous avons la possibilité d'utiliser plusieurs ports dans la même règle.

 

Plage ip

iprange nous permet de mettre plusieurs adresses IP source ou destination à la fois, sans avoir besoin de mettre des dizaines de règles. Il permet aussi de mettre à la fois l'IP source et l'IP destination, la syntaxe est la suivante :

• [!]–src-range ip-ip
• [!]–IP-IP de la plage d'heure d'été

Le fonctionnement de cette règle est assez simple, on met simplement l'IP de début et l'IP de fin.

 

limite

Le module connlimit se charge de restreindre le nombre de connexions simultanées effectuées par une adresse IP, il est idéal pour limiter le nombre de connexions pour éviter les DoS.

• –connlimit-jusqu'à n . Nous vérifions si le nombre de connexions est égal ou inférieur à N (alors nous pouvons autoriser ou refuser).
• –connlimit-au-dessus de n . Nous vérifions si le nombre de connexions est supérieur à N (alors nous pouvons autoriser ou refuser).
• –connlimit-mask prefix_length . Nous marquons par plage de sous-réseaux (c'est la même chose qu'un hôte effectuant 2 connexions, deux hôtes sur le même sous-réseau effectuant 1 connexion chacun).
• –connlimit-saddr . Appliquez la limitation au groupe source, c'est la valeur par défaut si rien n'est spécifié.
• –connlimit-daddr . Applique la limitation au groupe cible.

Par exemple, disons que nous voulons autoriser seulement deux connexions SSH par client :

• iptables -A ENTRÉE -p tcp –dport 22 -m limite de connexion –limite de connexion-au-dessus de 2 -j DROP

Cependant, nous pouvons faire la règle complémentaire, en mettant un accepter jusqu'à 2 connexions.

 

conntrack

Ce module sert à tracer les connexions, il sert à gérer l'entrée et la sortie des paquets avant et après l'établissement de la connexion. Dans ce module, il existe plusieurs options, mais la plus importante est -ctstate qui nous permet d'accepter ou de refuser différents types de paquets. Au sein de ctstate, nous avons plusieurs états, les suivants se distinguent :

• INVALID : le paquet reçu est invalide et n'appartient à aucune connexion.
• NEW : Nouvelles connexions établies ou associées à une connexion qui n'est pas encore bidirectionnelle.
• ÉTABLI : Connexions établies, ils passent d'abord par NOUVEAU depuis qu'ils ont eu une réponse
• RELATED : un paquet qui est lié à une connexion existante, mais qui n'en fait pas partie, comme un FTP passif.

Imaginons que nous voulions accéder à n'importe quel site, cependant, nous ne voulons absolument pas que personne nous accède.

• iptables –P BAISSE D'ENTRÉE
• iptables -A ENTRÉE -m conntrack –ctstate ÉTABLI, CONNEXE -j ACCEPTER

 

limite

Le module limit nous permet de limiter à la fois le trafic et le nombre de journaux à écrire dans le syslog en tant que tentatives de connexion. Il a deux arguments principaux :

• –limite N . Cet argument spécifie le nombre maximal de correspondances moyennes par seconde (N/s), minute (N/m), heure (N/h) ou jour (N/d) à autoriser. N spécifie le nombre
• –limit-burst N . Indique la rafale la plus longue qui peut se produire avant de vérifier la limite –limit.

La valeur par défaut si rien n'est précisé est de 3 correspondances par heure, par rafales de 5. Imaginez la règle suivante : « iptables -A INPUT -m limit -j LOG », le fonctionnement est le suivant :

• La première fois que cette règle est atteinte, les cinq premiers paquets sont enregistrés.
• Ensuite, il faudra vingt minutes avant qu'un paquet ne soit réenregistré avec cette règle (3 matchs entre 60 minutes égalent 20 minutes, puisque c'est MOYEN).
• De plus, toutes les vingt minutes qui s'écoulent sans qu'un paquet n'atteigne la règle, la rafale récupérera un paquet.
• Si rien ne se passe pendant 100 minutes, la rafale sera entièrement rechargée ; puis retour à la situation initiale.

 

Articles de

Le module récent sert à limiter le nombre de connexions par seconde au niveau IP, c'est idéal pour nous protéger des attaques sur le port SSH car un attaquant va essayer plusieurs mots de passe. Par exemple, si nous voulons protéger notre SSH, nous pourrions exécuter la règle suivante :

• iptables -A INPUT -p tcp –dport 22 -m conntrack –ctstate NEW -m recent –set –name ssh –rsource
• iptables -A INPUT -p tcp –dport 22 -m state –state NEW -m recent –rcheck –seconds 60 –hitcount 4 –name ssh –rsource -j DROP

Cette règle n'autorise que quatre tentatives de connexion en 60 secondes, c'est une fenêtre "glissante".

 

NAT

Ce pare-feu est également responsable du NAT de notre connexion. Pour faire le NAT de notre IP publique (ou interface qui a cette IP publique), il faut mettre :

• SNAT statique : iptables -t nat -A POSTROUTING -s 192.168.1.0/24 –o eth1 -j SNAT –to IP_eth1
• SNAT dynamique : iptables -t nat -A POSTROUTING -s 192.168.1.0/24 -o eth1 -j MASQUERADE

La chose normale est d'utiliser MASQUERADE pour faire du NAT quelle que soit l'adresse IP de l'interface physique ou logique.

Pour ouvrir des ports, nous devons ajouter une règle dans la chaîne PREROUTING de la table NAT.

• iptables -t nat -A PREROUTING -i eth1 -p tcp –dport 22 -j DNAT –vers la destination 192.168.1.1

La table PREROUTING nous permet également de modifier les ports à la volée, de sorte que si nous recevons des paquets sur le port 2121, nous pouvons le transformer en 21.

• iptables -t nat -A PREROUTING -i eth1 -p tcp –dport 2121 -j DNAT –vers la destination 192.168.1.1:21

Une fois que nous connaissons en détail ce pare-feu, nous allons voir les exemples d'utilisation de base et aussi les plus avancés.

 

Exemples d'utilisation de base

Ce pare-feu est très complet et nous avons des centaines de commandes que nous pouvons exécuter pour effectuer différentes actions. Dans cet article, nous allons vous donner quelques exemples faciles à comprendre pour une première approche de ce pare-feu.

Empêchez l'adresse IP 192.168.1.10 d'établir toute communication avec notre serveur :

• iptables -A INPUT –s 192.168.1.10 –j DROP

Empêchez les adresses IP 192.168.1.20, 192.168.1.30, 192.168.1.40, 192.168.1.50 de communiquer avec notre serveur :

• iptables -A INPUT –s 192.168.1.20,192.168.1.30,192.168.1.40,192.168.1.50 –j DROP

Empêchez tout le sous-réseau 192.168.2.0/24 d'établir toute communication avec notre serveur, à l'exception de l'adresse IP 192.168.2.20, qui serait autorisée :

• iptables –A ENTRÉE –s 192.168.2.20 –j ACCEPTER
• iptables –A INPUT –s 192.168.2.0/24 –j DROP

Bloquez l'adresse IP de 192.168.4.50 afin que nous ne puissions établir aucune communication :

• iptables –A SORTIE –d 192.168.4.50 –j DROP

Bloquez les adresses IP 192.168.4.51 et 192.168.4.52 afin que nous ne puissions établir aucune communication :

• iptables –A SORTIE –d 192.168.4.51,192.168.4.52 –j DROP

Bloquez l'accès à www.google.es depuis iptables :

• iptables –A SORTIE –d www.google.es –j DROP

Nous voulons bloquer l'accès à notre serveur depuis le MAC 00:01:02:03:04:05, et le reste autorise tout :

• iptables -A INPUT -m mac –mac-source 00:01:02:03:04:05 -j DROP

Nous voulons autoriser l'accès à notre serveur à l'adresse MAC MAC 00:01:02:03:04:06, et le reste nier tout :

• iptables -A ENTRÉE -m mac –mac-source 00:01:02:03:04:05 -j ACCEPTER
  iptables -A ENTRÉE -j DROP

Bloquez l'adresse IP 192.168.1.10 pour le ping de notre serveur :

• iptables -A INPUT -s 192.168.1.10 -p icmp -j DROP

Bloquer les adresses IP 192.168.1.20, 192.168.1.30, 192.168.1.40, 192.168.1.50 de PINGing notre serveur (en une seule règle) :

• iptables -A INPUT -s 192.168.1.20,192.168.1.30,192.168.1.40,192.168.1.50 -p icmp -j DROP

Bloquez tout le sous-réseau 192.168.2.0/24 afin qu'il n'envoie pas de PING à notre serveur, à l'exception de l'adresse IP 192.168.2.20, qui serait autorisée :

• iptables -A ENTRÉE -s 192.168.2.20 -p icmp -j ACCEPTER
  iptables -A INPUT -s 192.168.2.0/24 -p icmp -j DROP

Bloquez l'adresse IP de 192.168.4.50 afin que nous ne puissions pas la cingler.

• iptables -A SORTIE -d 192.168.4.50 -p icmp -j DROP

Bloquez les adresses IP 192.168.4.51 et 192.168.4.52 afin que nous ne puissions pas les cingler.

• iptables -A SORTIE -d 192.168.4.51,192.168.4.52 -p icmp -j DROP

Bloquer l'accès à www.google.es depuis iptables.

• iptables -A SORTIE -d www.google.es -p icmp -j DROP

Comme vous pouvez le constater, le fonctionnement est assez simple avec les règles basées sur l'IP avec origine et destination. Nous pourrions également utiliser le module iprange pour configurer une plage d'adresses IP :

Empêchez une plage d'adresses IP de 192.168.5.1 à 192.168.5.50 de pouvoir envoyer un ping à partir de notre serveur.

• iptables -A SORTIE -m iprange –dst-range 192.168.5.1-192.168.5.50 -p icmp -j DROP

Nous pouvons également filtrer le protocole ICMP de manière plus avancée. Imaginons que nous ayons un utilisateur qui veut pouvoir envoyer un ping à n'importe quel hôte, mais ne veut pas que PERSONNE puisse lui envoyer un ping. Comment pouvons-nous le faire avec iptables si PING lui-même a une communication bidirectionnelle ?

• iptables -A INPUT -s IP -p icmp –requête d'écho de type icmp -j DROP

Bloquez tout accès entrant via l'interface eth0 (uniquement), permettant ainsi l'accès à eth1.

• iptables -A INPUT -i eth0 -j DROP
• iptables -A INPUT -i eth1 -j ACCEPTER

Bloquer le trafic sortant sur l'interface eth0 (uniquement), permettant ainsi l'accès à eth1.

• iptables -A SORTIE -o eth0 -j DROP
• iptables -A SORTIE -o eth1 -j ACCEPTER

Autorisez tout trafic entrant et sortant sur eth0 et refusez tout trafic entrant ou sortant sur eth1.

• iptables -A INPUT -i eth0 -j ACCEPTER
• iptables -A SORTIE -o eth0 -j ACCEPTER
• iptables -A INPUT -i eth1 -j DROP
• iptables -A SORTIE -o eth1 -j DROP

Si vous voulez commencer à voir comment fonctionnent les protocoles TCP et UDP, voici quelques exemples :

Bloquez l'accès Web à www.google.es et autorisez tout le reste (ping) par exemple.

• iptables -A SORTIE -d www.google.es -p tcp –dport 80 -j DROP

Bloquez l'accès FTP à n'importe quelle adresse IP ou domaine et autorisez tout le reste.

• iptables -A SORTIE -p tcp –dport 21 -j DROP

Bloquez l'accès SSH à l'IP 192.168.1.50 et autorisez tout le reste.

• iptables -A SORTIE -d 192.168.1.50 -p tcp –dport 22 -j DROP

Bloquez l'accès Telnet au sous-réseau 192.168.2.0 et autorisez tout le reste.

• iptables -A SORTIE -d 192.168.2.0/24 -p tcp –dport 23 -j DROP

Bloquez l'accès 192.168.1.50 à notre serveur Web.

• iptables -A INPUT -s 192.168.1.50 -p tcp –dport 80 -j DROP

Bloquez l'accès 192.168.1.150 et 192.168.1.151 à notre serveur SSH.

• iptables -A INPUT -s 192.168.1.150,192.168.1.151 -p tcp –dport 22 -j DROP

Bloquer l'accès de l'ensemble du sous-réseau 192.168.2.0/24 à notre service telnet

• iptables -A INPUT -s 192.168.2.0/24 -p tcp –dport 23 -j DROP

Bloquez l'accès de tout le monde au serveur OpenVPN, à l'exception de l'adresse IP 77.77.77.77 qui est autorisée.

• iptables -A ENTRÉE -s 77.77.77.77 -p tcp –dport 1194 -j ACCEPTER
• iptables -A INPUT -p tcp –dport 1194 -j DROP

Bloquez l'accès DNS à 8.8.8.8 et autorisez tout le reste (ping) par exemple.

• iptables -A SORTIE -d 8.8.8.8 -p tcp –dport 53 -j DROP
• iptables -A SORTIE -d 8.8.8.8 -p udp –dport 53 -j DROP

Bloquez l'accès au port 1194 à n'importe quelle adresse IP ou domaine, et autorisez tout le reste.

• iptables -A INPUT -p udp –dport 1194 -j DROP

Nous avons un serveur DNS sur notre serveur. Nous voulons que seuls les ordinateurs du sous-réseau 192.168.1.0/24 puissent communiquer avec lui et bloquer tous les autres accès.

• iptables -A ENTRÉE -s 192.168.1.0/24 -p tcp –dport 53 -j ACCEPTER
• iptables -A ENTRÉE -s 192.168.1.0/24 -p udp –dport 53 -j ACCEPTER
• iptables -A INPUT -p tcp –dport 53 -j DROP
• iptables -A INPUT -p udp –dport 53 -j DROP

Bloquer l'accès à notre serveur web, depuis la plage IP 192.168.100.0/24, provenant de l'interface eth0.

• iptables -A INPUT -s 192.168.100.0/24 -i eth0 -p tcp –dport 80 -j DROP

Bloquez l'accès à notre serveur ssh, depuis la plage IP 192.168.100.0/24, provenant de l'interface eth1.

• iptables -A INPUT -s 192.168.100.0/24 -i eth1 -p tcp –dport 22 -j DROP

 

Exemples d'utilisation avancée

Si vous souhaitez en savoir plus sur iptables, voici quelques exemples où nous utilisons le module connlimit.

Autorisez seulement 10 connexions Telnet par client.

• iptables -A INPUT -p tcp –dport 23 -m connlimit –connlimit-above 10 –connlimit-mask 32 -j DROP

Refuser jusqu'à la connexion numéro 5 sur le web faite par un client (cela n'a pas beaucoup de sens mais c'est un exemple).

• iptables -A INPUT -p tcp –dport 80 -m connlimit –connlimit-upto 5 –connlimit-mask 32 -j DROP

Autorisez seulement 10 connexions Telnet par client (faites-le différemment que ci-dessus).

• iptables -A INPUT -p tcp –dport 23 -m connlimit –connlimit-upto 10 –connlimit-mask 32 -j ACCEPTER
• iptables -A INPUT -p tcp –dport 23 -j DROP

N'autorisez que 10 connexions Web dans la plage IP 10.0.0.0/8 et refusez si elle dépasse ce nombre.

• iptables -A INPUT -s 10.0.0.0/8 -p tcp –dport 80 -m connlimit –connlimit-above 10 –connlimit-mask 8 -j DROP

N'autorisez que 20 connexions HTTP pour chaque client, dès qu'il est dépassé, nous envoyons une réinitialisation TCP.

• iptables -A INPUT -p tcp –dport 80 -m connlimit –connlimit-above 20 –connlimit-mask 32 -j REJECT –reject-with tcp-reset

Ou de cette façon :

• iptables -A INPUT -p tcp –syn –dport 80 -m connlimit –connlimit-above 20 –connlimit-mask 32 -j REJECT –reject-with tcp-reset

Comme vous pouvez le voir, ce pare-feu est vraiment complet et nous pouvons faire beaucoup de configuration très poussée, pour contrôler en détail toutes les connexions entrantes et sortantes.