Iptables de base - Debian/RedHat

Résumé

Vous pouvez trouver une version plus facile à lire ici : 5dollarwhitebox.org

Beaucoup de gens sont effrayés par IPTables et trouvent cela difficile à comprendre. Cependant, une fois que vous en comprenez les bases, c’est facile. Ce document servira de guide de base sur l’utilisation d’iptables. Je ne suis en aucun cas un expert en iptables, mais je l’utilise de cette manière depuis un certain temps. Si j’ai fait des erreurs, n’hésitez pas à m’envoyer un e-mail.

Le Système

Debian Sarge 3.1 Noyau vanilla 2.6.12.4 de mirrors.kernel.org Utilitaire d’administration iptables version 1.2.11-10

Préparation

Ce How-To est réalisé sur une machine Debian Sarge 3.1, bien que les commandes et la syntaxe devraient fonctionner pour toute distribution Linux. Avant de pouvoir configurer iptables, vous devez d’abord vous assurer qu’il a été compilé dans le noyau et que vous avez les utilitaires userland appropriés installés.

Vous devriez avoir un fichier de configuration datant de la compilation du noyau. En le greppant pour “CONFIG_IP_NF”, vous devriez obtenir ‘=y’ ou ‘=m’ pour la plupart des lignes/options. Ici, vous voyez que “CONFIG_IP_NF_IPTABLES” a été compilé en tant que module du noyau.

# cat /boot/config-2.4.30 | grep -i “CONFIG_IP_NF”

• CONFIG_IP_NF_CONNTRACK=m
  CONFIG_IP_NF_FTP=m
  CONFIG_IP_NF_AMANDA=m
  CONFIG_IP_NF_TFTP=m
  CONFIG_IP_NF_IRC=m
  CONFIG_IP_NF_QUEUE=m
  CONFIG_IP_NF_IPTABLES=m
  CONFIG_IP_NF_MATCH_LIMIT=m
  CONFIG_IP_NF_MATCH_MAC=m
  CONFIG_IP_NF_MATCH_PKTTYPE=m
  CONFIG_IP_NF_MATCH_MARK=m
  CONFIG_IP_NF_MATCH_MULTIPORT=m
  CONFIG_IP_NF_MATCH_TOS=m
  CONFIG_IP_NF_MATCH_RECENT=m
  CONFIG_IP_NF_MATCH_ECN=m
  CONFIG_IP_NF_MATCH_DSCP=m
  CONFIG_IP_NF_MATCH_AH_ESP=m
  CONFIG_IP_NF_MATCH_LENGTH=m
  CONFIG_IP_NF_MATCH_TTL=m
  CONFIG_IP_NF_MATCH_TCPMSS=m
  CONFIG_IP_NF_MATCH_HELPER=m
  CONFIG_IP_NF_MATCH_STATE=m
  CONFIG_IP_NF_MATCH_CONNTRACK=m
  CONFIG_IP_NF_MATCH_UNCLEAN=m
  CONFIG_IP_NF_MATCH_OWNER=m
  CONFIG_IP_NF_FILTER=m
  CONFIG_IP_NF_TARGET_REJECT=m
  CONFIG_IP_NF_TARGET_MIRROR=m
  CONFIG_IP_NF_NAT=m
  CONFIG_IP_NF_NAT_NEEDED=y
  CONFIG_IP_NF_TARGET_MASQUERADE=m
  CONFIG_IP_NF_TARGET_REDIRECT=m
  CONFIG_IP_NF_NAT_AMANDA=m
  CONFIG_IP_NF_NAT_SNMP_BASIC=m
  CONFIG_IP_NF_NAT_IRC=m
  CONFIG_IP_NF_NAT_FTP=m
  CONFIG_IP_NF_NAT_TFTP=m
  CONFIG_IP_NF_MANGLE=m
  CONFIG_IP_NF_TARGET_TOS=m
  CONFIG_IP_NF_TARGET_ECN=m
  CONFIG_IP_NF_TARGET_DSCP=m
  CONFIG_IP_NF_TARGET_MARK=m
  CONFIG_IP_NF_TARGET_LOG=m
  CONFIG_IP_NF_TARGET_ULOG=m
  CONFIG_IP_NF_TARGET_TCPMSS=m
  CONFIG_IP_NF_ARPTABLES=m
  CONFIG_IP_NF_ARPFILTER=m
  CONFIG_IP_NF_ARP_MANGLE=m
  CONFIG_IP_NF_COMPAT_IPCHAINS=m
  CONFIG_IP_NF_NAT_NEEDED=y
  CONFIG_IP_NF_COMPAT_IPFWADM=m
  CONFIG_IP_NF_NAT_NEEDED=y*

Ce n’est pas vraiment nécessaire, car vous découvrirez rapidement si iptables fonctionne ou non une fois que nous essaierons d’ajouter des règles.

Vous pouvez vérifier si vous avez l’utilitaire d’administration iptables installé en exécutant :

# dpkg -l iptables

• iptables 1.2.11-10 Administration iptables pour le noyau Linux 2.4+

…ou pour une distribution basée sur rpm :

# rpm -qa | grep iptables

iptables-xxxxx

…ou vous pouvez simplement vérifier si le binaire est là !

# which iptables

/sbin/iptables

Si l’utilitaire est manquant, vous pouvez l’installer comme suit :

APT

# apt-get update && apt-get install iptables

RPM

# rpm -Uvh iptables-xxxx.rpm

Préparation ################################# [100%]

Les Fichiers Principaux

Debian

• /etc/init.d/iptables – Script INIT pour démarrer|arrêter|redémarrer le service (et sauvegarder les règles). Ce fichier n’est plus par défaut depuis Sarge, mais vous pouvez toujours l’obtenir (je vais vous montrer).

• /var/lib/iptables – Dossier de Debian pour les fichiers de compteurs ‘actifs’ et ‘inactifs’ iptables-save (c’est-à-dire les règles sauvegardées). Sur RedHat, vous trouverez les règles sauvegardées dans ‘/etc/sysconfig/iptables’.

• /var/lib/iptables/active – Compteurs Actifs (plus à ce sujet plus tard)

• /var/lib/iptables/inactive – Compteurs Inactifs

• /sbin/iptables – L’utilitaire/binaire d’administration.

RedHat

• /etc/init.d/iptables – Script INIT pour démarrer|arrêter|redémarrer le service (et sauvegarder les règles).

• /etc/sysconfig/iptables – Fichier de RedHat pour les fichiers de compteurs iptables-save (c’est-à-dire les règles sauvegardées).

• /sbin/iptables – L’utilitaire/binaire d’administration.

Un Peu Sur IPTables

Pour voir quelles règles nous avons actuellement en place, exécutez :

# iptables –list

*Chaîne INPUT (politique ACCEPT)
target prot opt source destination

Chaîne FORWARD (politique ACCEPT)
target prot opt source destination

Chaîne OUTPUT (politique ACCEPT)
target prot opt source destination*

Voici ce que vous verrez lorsqu’il n’y a pas de règles en place. En regardant cela, nous voyons 3 ‘Chaînes’.

• INPUT - Contient des règles pour le trafic dirigé vers ce serveur.

• FORWARD – Contient des règles pour le trafic qui sera transféré vers une IP derrière ce serveur (c’est-à-dire si cette machine sert de pare-feu pour d’autres serveurs).

• OUTPUT – Contient des règles pour le trafic provenant de ce serveur vers Internet.

Principalement, nous allons traiter le trafic dirigé vers ce serveur et émettre des règles pour la Chaîne INPUT. Lorsque le trafic passe par le noyau, il détermine un “TARGET” en fonction de si le paquet correspond à une règle ou non. Les cibles générales sont :

• ACCEPT – Le trafic est accepté pour la livraison.

• REJECT – Le trafic est rejeté, renvoyant un paquet à l’hôte émetteur.

• DROP - Le trafic est abandonné. Rien n’est renvoyé à l’hôte émetteur.

Configuration des Règles

Alors, allons-y. Il est important de noter que l’ordre dans lequel les règles sont ajoutées est très important. Par exemple, si votre première règle est de tout refuser… alors peu importe ce que vous autorisez spécifiquement, cela sera refusé.

Il est également à noter que rien de ce que vous faites n’est sauvegardé sur le disque tant que vous n’exécutez pas ‘iptables-save’ (ou utilisez le script init pour sauvegarder). Tous les compteurs/règles sont en mémoire. Une fois que le serveur redémarre, ou que vous exécutez ‘iptables –flush’, tout ce sur quoi vous avez travaillé est perdu. Personnellement, je travaille à partir d’un fichier de script bash appelé ‘iptables-rules.sh’, ce qui me permet de garder tout organisé et commenté. Si je fais une erreur, je n’ai pas de soucis si je veux juste vider toutes les règles, je retourne simplement à mon script bash et commence à éditer à nouveau, je le sauvegarde et exécute le script (cependant, cela ne s’exécutera pas au démarrage… cela sera couvert dans la section suivante).

Il est très important que si vous travaillez sur ce serveur à distance via ssh, que vous fassiez tout votre possible pour ne pas vous verrouiller dehors. Par conséquent, notre première règle sera de s’assurer que peu importe ce qui se passe, je peux toujours accéder à ssh depuis mon adresse IP.

# iptables -A INPUT -s 192.168.1.10 -d 10.1.15.1 -p tcp –dport 22 -j ACCEPT

Décomposons cela :

• -A => Indique à iptables d’”ajouter” cette règle à la Chaîne INPUT

• -s => Adresse Source. Cette règle ne concerne que le trafic provenant de cette IP. Remplacez par l’adresse IP depuis laquelle vous vous connectez en SSH.

• -d => Adresse de Destination. Cette règle ne concerne que le trafic allant vers cette IP. Remplacez par l’adresse IP de ce serveur.

• -p => Protocole. Spécifiant le trafic qui est TCP.

• –dport => Port de Destination. Spécifiant le trafic qui est pour le Port TCP 22 (SSH)

• -j => Jump. Si tout dans cette règle correspond, alors “jump” vers ACCEPT

Ensuite, nous voudrons utiliser quelques règles standard pour le trafic réseau général. Cela va un peu au-delà des choses de base, cependant iptables peut déterminer l’état dans lequel se trouve un paquet. Cela a à voir avec la communication TCP standard. Par exemple, le handshake à 3 voies entre deux hôtes lors de la transmission de données.

• NEW => Serveur1 se connecte à Serveur2 en émettant un paquet SYN (Synchroniser).

• RELATED => Serveur 2 reçoit le paquet SYN, puis répond avec un paquet SYN-ACK (Accusé de réception de synchronisation).

• ESTABLISHED => Serveur 1 reçoit le paquet SYN-ACK puis répond avec le dernier paquet ACK (Accusé de réception).

Après que ce handshake à 3 voies soit complet, le trafic est maintenant ÉTABLI. Pour ce type de communication TCP, quelque chose de similaire à ces trois règles est nécessaire :

# iptables -A INPUT -m state –state RELATED,ESTABLISHED -j ACCEPT

La dernière règle permet évidemment tout trafic quittant le serveur.

Maintenant que nous avons nos bases en place, voyons ce qu’iptables liste pour nos règles :

# iptables –list

*Chaîne INPUT (politique ACCEPT)
target prot opt source destination

ACCEPT tcp – 192.168.1.10 10.1.15.1 tcp dpt:ssh
ACCEPT all – anywhere anywhere state RELATED,ESTABLISHED

Chaîne FORWARD (politique ACCEPT)
target prot opt source destination
ACCEPT all – anywhere anywhere state RELATED,ESTABLISHED

Chaîne OUTPUT (politique ACCEPT)
target prot opt source destination
ACCEPT all – anywhere anywhere state NEW,RELATED,ESTABLISHED*

À partir de là, vous pouvez ajouter les règles que vous souhaitez. Si vous exécutez un serveur web de base, vous aurez probablement besoin de quelque chose de similaire à :

REJETS INDIVIDUELS EN PREMIER :

MAUVAIS GARS (Bloquer l’adresse IP source) :

# iptables -A INPUT -s 172.34.5.8 -j DROP

AUCUN SPAMMEUR (remarquez l’utilisation de FQDN) :

# iptables -A INPUT -s mail.spammer.org -d 10.1.15.1 -p tcp –dport 25 -j REJECT

ENSUITE OUVREZ-LE : ———————————————————————–
MYSQL (Autoriser l’accès à distance à une IP particulière) :

SSH :

# iptables -A INPUT -d 10.1.15.1 -p tcp –dport 22 -j ACCEPT

Envoyer mail/Postfix :

# iptables -A INPUT -d 10.1.15.1 -p tcp –dport 25 -j ACCEPT

FTP : (Remarquez comment vous pouvez spécifier une plage de ports 20-21)

# iptables -A INPUT -d 10.1.15.1 -p tcp –dport 20:21 -j ACCEPT

Ports FTP passifs peut-être : (Encore une fois, spécifiant les ports 50000 à 50050 dans une règle)

# iptables -A INPUT -d 10.1.15.1 -p tcp –dport 50000:50050 -j ACCEPT

HTTP/Apache

# iptables -A INPUT -d 10.1.15.1 -p tcp –dport 80 -j ACCEPT

SSL/Apache

# iptables -A INPUT -d 10.1.15.1 -p tcp –dport 443 -j ACCEPT

IMAP

# iptables -A INPUT -d 10.1.15.1 -p tcp –dport 143 -j ACCEPT

IMAPS

# iptables -A INPUT -d 10.1.15.1 -p tcp –dport 993 -j ACCEPT

POP3

# iptables -A INPUT -d 10.1.15.1 -p tcp –dport 110 -j ACCEPT

POP3S

# iptables -A INPUT -d 10.1.15.1 -p tcp –dport 995 -j ACCEPT

Tout le trafic provenant de localhost :

# iptables -A INPUT -d 10.1.15.1 -s 127.0.0.1 -j ACCEPT

ICMP/Ping :

# iptables -A INPUT -d 10.1.15.1 -p icmp -j ACCEPT

REJETS GLOBAUX DERNIERS :

Rejeter tout le reste vers cette IP :

# iptables -A INPUT -d 10.1.15.1 -j REJECT

Ou, rejeter tout le reste venant vers n’importe quelle IP :

# iptables -A INPUT -j REJECT

Remarquez que nous faisons les lignes de REJET global en dernier ! Celles-ci doivent être dernières.

Sauvegarde des Règles

Avec les scripts init, la sauvegarde des règles est assez facile. Une fois que vous êtes satisfait de votre configuration, faites simplement l’une des choses suivantes :

La Méthode Debian

Le vieux script init n’est plus par défaut dans Sarge, mais il est toujours là pour un usage hérité. Je crois que la nouvelle méthode consiste à utiliser ‘/etc/network/if-up.d’ et ‘/etc/network/if-down.d’ pour les scripts iptables (mais je n’aime pas ça).

Vous pouvez récupérer le script INIT hérité de cette manière :

# gunzip /usr/share/doc/iptables/examples/oldinitdscript.gz -c > /etc/init.d/iptables

Maintenant que vous avez le script en place, vous pouvez faire ce qu’il faut.

Règles Actives

Les règles actives sont celles chargées lors du démarrage d’iptables :

# /etc/init.d/iptables save active

Sauvegarde du jeu de règles iptables : sauvegarder “actif” avec des compteurs.

Ceci sauvegarde vos règles dans /var/lib/iptables/active

Règles Inactives

Vous pouvez également configurer un deuxième ensemble de règles pour lorsque vous arrêtez iptables appelé ‘inactif’. Iptables ne “s’arrête” pas réellement, il vide simplement les jeux de règles en place puis charge les règles ‘inactives’.

# /etc/init.d/iptables stop

Chargement du jeu de règles iptables : charger “inactif”

Par conséquent, vous pouvez définir vos règles ‘inactives’, puis les sauvegarder avec :

# /etc/init.d/iptables save inactive

Sauvegarde du jeu de règles iptables : sauvegarder “inactif” avec des compteurs.

La Méthode RedHat

Le script INIT de RedHat est très similaire. Vous pouvez l’utiliser pour démarrer et arrêter iptables, ainsi que pour sauvegarder des jeux de règles.

Pour sauvegarder vos règles actives, exécutez ce qui suit :

# /etc/init.d/iptables save

Cela sauvegardera vos règles dans ‘/etc/sysconfig/iptables’.

Lorsque vous démarrez iptables, les règles sont lues à partir de ‘/etc/sysconfig/iptables’ :

# /etc/init.d/iptables start

Démarrage d’iptables [OK]

Et lorsque vous arrêtez iptables, toutes les règles sont vidées :

# /etc/init.d/iptables stop

Arrêt d’iptables [OK]

Sauvegarde et Restauration Manuelles

Vous pouvez également utiliser manuellement les utilitaires iptables-save et iptables-restore comme suit :

Sauvegarder les règles dans un fichier

# iptables-save > /root/iptables-save.out

Restaurer les règles

# iptables-restore -c /root/iptables-save.out

Le -c indique à iptables-restore que ce fichier a été créé en utilisant iptables-save, qui sort les règles en tant que “compteurs”.

Conclusion

Et voilà, iptables à son niveau le plus basique. Les utilisations d’iptables sont trop nombreuses pour même commencer à vraiment faire un howto à leur sujet. Cependant, pour la sécurité de base et la compréhension d’IPTables, j’espère que cela vous aura aidé. Si je peux ajouter quelque chose, n’hésitez pas à m’envoyer un e-mail.

—
BJ Dierkes, RHCE4-LPIC1
wdierkes [at] 5dollarwhitebox [dot] org
Texas, USA

Ressources

• Netfilter/Iptables : http://www.netfilter.org/
• Protocole de Contrôle de Transmission : http://www.rhyshaden.com/tcp.htm