LinuxPedia

Wiki libre et indépendant dédié à GNU-Linux et BSD.

Outils pour utilisateurs

Outils du site


iptables

Définition by Wikipedia

Netfilter est le module qui fournit à Linux les fonctions de pare-feu, de traduction d'adresse et d'historisation du trafic réseau. Netfilter fonctionne en mode noyau. Il intercepte et manipule les paquets IP avant et après le routage.

iptables est la commande qui permet à un administrateur réseaux de configurer Netfilter en espace utilisateur.

Installation

En principe, le paquet 'iptables' est installé d'origine sous Debian mais si ce n'était pas le cas, rien de plus simple à faire :

apt-get install iptables

Sous Debian, c’est NetFilter qui est installé par défaut, et il n’y a pas de règles actives. Il y a la commande “iptables” qui permet de gérer les règles directement en ligne de commande, mais elles ne sont pas mémorisées et rechargées au prochain redémarrage. Il faut alors les écrire dans un fichier qui sera utilisé à chaque boot.

Pour cela il y a 2 options :

  • 1. utiliser un script de démarrage, par exemple /etc/init.d/firewall
  • 2. utiliser un script lié aux interfaces réseaux

Un script lié aux interfaces réseaux

La seconde méthode correspond aux nouvelles recommandations de Debian depuis Sarge. Elle consiste à ré-initialiser les règles du firewall à chaque rechargement de l’interface réseau. Cependant, elle est un peu moins connue et pratiquée que la première.

Un script de démarrage

La première méthode est la plus classique. Elle consiste à créer un script shell dans le dossier /etc/init.d/, à le rendre exécutable et à régler la séquence d’initialisation pour qu’elle en prenne compte.

# touch /etc/init.d/firewall

Le rendre exécutable :

chmod +x /etc/init.d/firewall

Configuration

Ensuite nous avons encore 2 choix :

  • 1. placer directement les règles iptables dans le fichier /etc/init.d/firewall
  • 2. placer les règles dans des fichiers séparés qui seront utilisés par le script /etc/init.d/firewall

Directement dans le fichier firewall

#!/bin/sh
#
# Regles netfilter
#
## Variables
ipt="/sbin/iptables"
net="eth0"
lan="eth1"

## Script
# Vidage table FILTER
iptables -F
iptables -X 

# Vidage table NAT
iptables -t nat -F
iptables -t nat -X

# Vidage table MANGLE
iptables -t mangle -F
iptables -t mangle -X

## Activation du mode "routeur"
echo 1> /proc/sys/net/ipv4/ip_forward

# Interdire tout par defaut
$ipt -P INPUT DROP
$ipt -P OUTPUT DROP
$ipt -P FORWARD DROP

# Autoriser la boucle locale
$ipt -A INPUT -i lo -j ACCEPT
$ipt -A OUTPUT -o lo -j ACCEPT

# Autoriser tout traffic depuis internet mais filtre en entree
$ipt -A INPUT -i $net -m state --state ESTABLISHED,RELATED -j ACCEPT
$ipt -A OUTPUT -o $net -m state --state NEW,ESTABLISHED,RELATED -j ACCEPT

# Autoriser tout traffic sur intranet
$ipt -A INPUT -i $lan -j ACCEPT
$ipt -A OUTPUT -o $lan -j ACCEPT
# Autorisation traffic entre internet et intranet
$ipt -A FORWARD -i $lan -o $net -j ACCEPT
$ipt -A FORWARD -i $net -o $lan -j ACCEPT
# Activation du NAT
$ipt -t nat -A POSTROUTING -o $net -j MASQUERADE

# Autoriser le multiposte Free
$ipt -t nat -A PREROUTING -i $net -p udp --dport 31336:31337 -s 212.27.38.253 -j DNAT --to 192.168.20.10
$ipt -A FORWARD -i $net -p udp --dport 31336:31337 -s 212.27.38.253 -d 192.168.20.10 -j ACCEPT

# Autoriser SSH
#$ipt -A INPUT -i $net -p tcp --dport 22 -m state --state NEW,ESTABLISHED -j ACCEPT

# Autoriser client torrent sur port 17478
$ipt -t nat -A PREROUTING -i $net -p tcp --dport 17478 -j DNAT --to-destination 192.168.20.10
$ipt -A FORWARD -i $net -p tcp -d 192.168.20.10 --dport 17478 -j ACCEPT

Dans des fichiers séparés

#!/bin/sh

## Activation du mode "routeur"
echo 1> /proc/sys/net/ipv4/ip_forward

ruleset_dir=/etc/iptables

case "$1" in
start)
        /sbin/iptables-restore < $ruleset_dir/active
        echo -n "Démarrage du service NetFilter:                             [OK]"
;;
stop)
        /sbin/iptables-restore < $ruleset_dir/inactive
        echo -n "Arrêt du service NetFilter:                                 [OK]"
;;
force-reload|restart)
        $0 stop
        sleep 1
        $0 start
;;
save)
        cp $ruleset_dir/active $ruleset_dir/active-$(date +%Y%m%d_%H%M)
        echo -n "Copie de sauvegarde des anciennes règles:                   [OK]"
        /sbin/iptables-save > $ruleset_dir/active
        echo -n "Sauvegarde des modifications des règles:                    [OK]"

;;
*)
        echo "Usage: /etc/init.d/iptables {start|stop|restart|force-reload}"
        exit 1
esac

exit 0

On a donc un script qui permet de charger/décharger les règles avec les options start et stop utilisées automatiquement, mais il peut aussi accepter d’être rechargé avec les options restart ou force-reload. Enfin, il permet de sauvegarder la configuration des règles courantes, avec l’option save, très utile quand on a testé des règles via la ligne de commande et qu’on souhaite les rendre persistantes.

Il reste donc à mettre en place les fichiers de stockage des règles.

Par défaut le dossier /etc/iptables n’existe pas, nous allons le créer, ainsi que les fichiers vierges :

# mkdir -p /etc/iptables
# cd /etc/iptables
# touch active
# touch inactive

Nous pouvons donc lancer une première fois la sauvegarde des règles courantes (s’il y en a) :

#/etc/init.d/firewall save

Le fichier vide /etc/iptables/active est renommé avec la date du jour et un nouveau fichier est créé avec les règles courantes.

<note>Attention, iptables-restore et iptables-save utilisent une syntaxe particulière !</note>

Exemple pour active (équivalent du script manuel cité plus haut)

*nat
:PREROUTING ACCEPT [2514:237945]
:POSTROUTING ACCEPT [2:1448]
:OUTPUT ACCEPT [5:380]
-A PREROUTING -s 212.27.38.253 -i eth0 -p udp -m udp --dport 31336:31337 -j DNAT --to-destination 192.168.20.10
-A PREROUTING -i eth0 -p tcp -m tcp --dport 17478 -j DNAT --to-destination 192.168.20.10
-A POSTROUTING -o eth0 -j MASQUERADE
COMMIT
*filter
:INPUT DROP [636:117431]
:FORWARD DROP [0:0]
:OUTPUT DROP [0:0]
-A INPUT -i lo -j ACCEPT
-A INPUT -i eth0 -m state --state RELATED,ESTABLISHED -j ACCEPT
-A INPUT -i eth1 -j ACCEPT
-A FORWARD -i eth1 -o eth0 -j ACCEPT
-A FORWARD -i eth0 -o eth1 -j ACCEPT
-A FORWARD -s 212.27.38.253 -d 192.168.20.10 -i eth0 -p udp -m udp --dport 31336:31337 -j ACCEPT
-A FORWARD -d 192.168.20.10 -i eth0 -p tcp -m tcp --dport 17478 -j ACCEPT
-A OUTPUT -o lo -j ACCEPT
-A OUTPUT -o eth0 -m state --state NEW,RELATED,ESTABLISHED -j ACCEPT
-A OUTPUT -o eth1 -j ACCEPT
COMMIT

Exemple pour inactive (dans le cas présent, laisse tout ouvert et fait du NAT entre le LAN et INTERNET)

*mangle
:PREROUTING ACCEPT [292:117858]
:INPUT ACCEPT [60:4116]
:FORWARD ACCEPT [232:113742]
:OUTPUT ACCEPT [46:4960]
:POSTROUTING ACCEPT [278:118702]
COMMIT
*nat
:PREROUTING ACCEPT [2539:239336]
:POSTROUTING ACCEPT [2:1448]
:OUTPUT ACCEPT [5:380]
-A POSTROUTING -o eth0 -j MASQUERADE
COMMIT
*filter
:INPUT ACCEPT [60:4116]
:FORWARD ACCEPT [232:113742]
:OUTPUT ACCEPT [46:4960]
COMMIT

Démarrage automatique du firewall

Pour que le firewall soit lancé à chaque démarrage du serveur, il faut utiliser la commande update-rc.d

# cd /etc/init.d/ && update-rc.d firewall defaults 30
iptables.txt · Dernière modification: 2018/11/17 13:53 (modification externe)