====== 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 :

<code>apt-get install iptables</code>

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.

<code># touch /etc/init.d/firewall</code>

Le rendre exécutable :

<code>chmod +x /etc/init.d/firewall</code>

====== 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 ====

<code>#!/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</code>


==== Dans des fichiers séparés ====

<code>#!/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</code>

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 :
<code># mkdir -p /etc/iptables
# cd /etc/iptables
# touch active
# touch inactive</code>

Nous pouvons donc lancer une première fois la sauvegarde des règles courantes (s’il y en a) :
<code>#/etc/init.d/firewall save</code>
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)

<code>*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</code>

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

<code>*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</code>


====== Démarrage automatique du firewall ======


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

<code># cd /etc/init.d/ && update-rc.d firewall defaults 30</code>