Tutoriel pour la configuration d'un script iptables
I./ Qu'est-ce qu'Iptables?
Vous ne le savez peut-être pas, mais iptables n'est pas le/un parfeux des systèmes GNU/Linux!
En effet, le parfeux sous GNU/Linux, c'est netfilter.
Iptables n'est en fait qu'un langage de script, une "interface" en quelque sorte, pour configurer netfilter correctement.
Il en existe d'autres. Nous pouvons citer par exemple Shorewall qui était par defaut sur les mandrake 9.2, 10.1; après je ne sais pas, j'ai utilisé iptables!
Il existe également des interfaces graphiques qui permettent de configurer netfilter.
Netfilter est integré au noyau linux, ce qui implique parfois de le recompiler pour obtenir quelques options spécifiques.
Il également interessant d'aller voir dans les nouveaux noyaux quelles sont les nouvelles options, ou celles qui peuvent nous interesser.
N'oubliez pas que si vous avez besoin d'aide, le man iptables est assez complet, et très compréhensible une fois qu'on a compris le fonctionnement d'iptables.
II./ Historique.
Iptables a été integré au noyau linux à partir de la version 2.4. Il est issu de la réecriture d'ipchains qui fonctionnait sur les noyaux de la serie 2.2.
Ainsi, les commandes, tout du moins au début d'iptables, sont peu différentes.
III./ Fonctionnement général.
Pour bien configuer netfilter et créer un script performant, il faut comprendre le cheminement d'un paquet au coeur de netfilter.
Introduisons d'abord le concept de tables.
1./ Les tables.
Netfilter fonctionne sous forme de tables. Chaque paquet va circuler dans ces tables qui contiennent des chaines de filtres. Ce sont ces chaines que nous nous efforcerons d'expliquer.
Par defaut, il existe 3 tables : la table filter, la table nat, et la table mangle.
a./ La table filter.
Cette table sert à filtrer les paquets. L'utilisation principale de cette tables va donc être d'accepter (ACCEPT), de rejeter (REJECT), ou de détruire (DROP) les paquets que nous choisirons de filtrer. Remarquons au passage que nous commençons à introduire le vocabulaire des scripts iptables, et que l'emploie des majuscules pour ACCEPT, REJECT et DROP n'est pas une coquetterie!
Retenez que c'est l'endroit privilégié pour filtrer.
b./ La tables nat.
Cette table sert à faire de la traduction d'adresse réseau (Network Adress Translating). La tables NAT ne sert généralement pas à filtrer les paquets, bien que nous verrons que cela est possible. En effet, elle sert à faire passer un paquet par un autre chemin que le chemin normal. Des exemples d'utilisation sont le partage de connexion, la redirection de port, la redirection vers un serveur (par exemple si l'un de vos serveur web est en maintenance, vous pouvez envoyer tout ce qui est à destination du 80 vers un autre serveur....).
Les cibles de la tables NAT sont : DNAT, SNAT, MASQUERADE, REDIRECT.
La cibles DNAT sert à changer l'adresse de destination, SNAT pour changer l'adresse source, MASQUERADE s'utilise de la même façon que SNAT, et REDIRECT sert à changer le port de destination.
c./ La tables mangle.
Le rôle principal de cette tables est de modifier les paquets.
Les cibles de cette table sont par exemple : TOS, TTL, MARK...
Comme pour toutes les options, il est bien evidemment conseillé de lire les pages du man. Et pour les plus accrocs d'entre vous, un petit coup d'oeil dans les sources du kernel peu vous renseigner rapidement sur les nouveautées apportées.
2./ Parcours des tables.
Afin de pouvoir construire un firewall efficace, il est primordial de bien comprendre quel est le chemin des paquets dans les tables Iptables.
a./ Paquet à destination de la machine locale.
La première table qu'il traverse est la tables mangle, et la chaine utilisée est alors PREROUTING afin d'effectuer un changement des paquets des maintenant.
Ensuite, le paquet traverse la table nat avec la chaine PREROUTING. C'est ici qu'il vous appartient de faire du FORWARD, sans filtrage préalable.
Si le paquet n'est pas forwardé, il traverse la chaine INPUT de la tables mangle. Cela permet de modifier le paquet après décision de routage, mais avant le processus sur la machine.
La paquet passe ensuite dans la chaine INPUT de la tables filter. C'est ici que vous filtrez les paquets qui arrivent sur votre machine.
Enfin, le processus local qui a besoin du paquet le reçoit.
b./ Paquet issu de la machine locale.
Le paquet passe d'abord par la chaine OUTPUT de la table mangle.
Ensuite, la tables nat est parcourue par le biais de la chaine OUTPUT. On peut ici faire du NAT sur des paquets sortant du parfeux.
La décision de routage a lieu. Le paquet n'est pas forwardé, il va dans la tables filter, par la chaine OUTPUT. Ici, la paquet est filtré.
Notre paquet passe alors dans les tables mangle puis nat par la chaine POSTROUTING.
Il sort enfin de la machine sur le cable.
c./ Paquet destiné à être redirigé.
Cela correspond à ce que nous n'avons pas dit lorsque qu'il est écrit "si le paquet n'est pas forwardé...". Vous vous étiez bien sur demandé "mais que fait-il notre paquet forwardé?".
Ainsi, lorsque le paquet est redirigé avec nat, PREROUTING, celui ci va traverser mangle FORWARD, puis filter FORWARD (notez que j'écris le nom de la table en minusucle et celui de la chaine en majuscule. Cela parce que ce sera cette convention qui sera utilisée dans le script iptables.)
IV./ Construction d'un parfeux avec iptables.
Il serait maintenant tout à fait possible de vous dresser une liste des cibles et autres options pour chaque tables et chaines.
Je pense néamoins qu'il est plus ludique de construire avec vous un exemple de parfeux fonctionnel avec un maximum d'options raisonnable pour la sécurité de votre installation informatique.
Le premier parfeux qui sera construit sera orienté desktop : ce qui est important à filter est ce qui vient d'internet. Ce qui sort de votre ordinateur sera jugé à priori relativement fiable (quoique...). Il n'y aura donc pas de partage de connexion, pas de redirection de ports, et autres astuces. Il n'y a qu'un interface reseau qui est connectée.
Le deuxième exemple de parfeux sera orienté passerelle/serveur.
Nous présenterons à cette occasion le partage de connexion, et toutes les redirections les plus utilisées (ports, adresse source, adresse cible).
1./ Un parfeux de desktop.
Parfeux de desktop (Cliquez pour faire apparaitre le fichier)
#! /bin/bash
# Comme tout scipt, le fichier doit commencer par cela. Cela se nomme le shebang.
# Afin de simplifier, nous aimerons déclarer des variables :
neteth = "eth1" # interface connectée au net
# Ensuite, nous devons vider toutes les règles dans les tables qui existent peut être déja :
iptables -F
iptables -X
iptables -F -t nat
iptables -X -t nat
iptables -F -t mangle
iptables -X -t mangle
# Nous mettons en place des politiques par defaut : tout paquet est par defaut mauvais!
# Nous bloquons tout par defaut, et nous ouvrons ensuite au cas par cas.
iptables -P INPUT DROP # On pourrait aussi remettre REJECT au lieu de DROP. DROP est plus "silencieux" que REJECT.
iptables -P OUTPUT DROP
iptables -P FORWARD DROP
# Afin que les processus locaux puissent communiquer librement, il est préférable d'autoriser tout sur l'interface lo :
iptables -A INPUT -i lo -j ACCEPT
iptables -A OUTPUT -o lo -j ACCEPT
# Ceci est le premier exemple de syntaxe iptables. Expliquons là!
# L'argument "-A" permet d'Ajouter la règle qui suit. On pourrait aussi inserer avec "-I", ou supprimer avec "-D".
# Ceci est suivi de la chaine concernée par la règle.
# Il faut ensuite préciser ou nous travaillons.
# Par défaut, on utilisise la tables filter, elle n'est donc pas précisiée ici. Sinon, il faudrait mettre :
# iptables -t filter -A INPUT ...
# Les autres arguments "-i", et "-o" concernent les interfaces d'entrée et de sortie (-i:input, et -o:output).
# Enfin, "-j" permet de spécifier ce qu'on fait des paquets. On fait suivre cet arguement par la chaine concernée.
# Les cibles peuvent être, suivant la table : ACCEPT, REJECT, DROP, MASQUERADE, ULOG...
# Nous allons maintenant procéder au filtrage de ce que entre et sort par l'interface "neteth".
# Les règles étant identiques pour tous les ports, nous utiliserons une boucle.
# Les ports choisis ici sont arbitraires et à titre indicatif. A vous ensuite de personnaliser.
for port_tcp in 22 80 443 8080
do
iptables -A INPUT -i -p tcp --sport -j ACCEPT
iptables -A OUTPUT -o -p tcp --dport -j ACCEPT
done
for port_udp in 53
do
iptables -A INPUT -i -p udp --sport -j ACCEPT
iptables -A OUTPUT -o -p udp --dport -j ACCEPT
done
# Une rapide explication s'impose.
# Vous avez deja compris les arguements "-A", "-i", "-o", "-j".
# "-p" signifie protocol. Nous utilisons la syntaxe simplifiée, mais sachez qu'une syntaxe longue existe..
# "--sport" signifie source port, et "--dport" signifie destination port.
# Il est aussi possible de faire du traçage de connexion. A quoi cela sert-il?
# Lors de l'etablissement d'une connexion, il y a échange d'un certain nombre d'informations contenues dans les entêtes des paquets tcp.
# Il y a notemment l'ordre d'arrivée des paquets, et l'état de la connexion.
# Ainsi, si une connexion entrante n'est pas liée à une connexion que vous avez déja établie, celle ci peut être rejettée.
# Cela peut servir par exemple lors de connexion pour transferts de fichiers par msn.
# Voici ce qu'il va y avoir dans le script, par exemple :
# iptables -A INPUT -i -p tcp --sport -m state --state RELATED,ESTABLISHED -j ACCEPT
# iptables -A OUTPUT -o -p tcp --dport -m state --state NEW,RELATED,ESTABLISHED -j ACCEPT
# Explications :
# -m state : charge le module state nécessaire à la lecture de l'entête en ce qui concerne le suivi de connexion.
# --state : on déclare l'instruction
# NEW : nouveaux paquets
# RELATED : paquets liés à une connexion préexistante.
# ESTABLISHED : paquets entrant dans le cadre d'une connexion existante.
Nous venons de faire une rapide présentation d'iptables et de quelques unes des principales règles.
Ce qui vient d'être présenté peut paraitre suffisant pour un ordinateur personnel connecté à internet. Les règles sont simples, et vous pourrez rapidement mettre en place votre parfeux.
Dans tous les cas, n'oubliez pas qu'il s'agit d'un script, et donc, n'hésitez pas à en utiliser la souplesse!
Nous allons maintenant présenter un parfeux comprenant plus d'instruction. Il sera plus à destination de passerelle, ou de serveur. Mais naturellement, un grand nombre de règles peuvent être utilisées pour votre ordinateur personnel.
2./ Parfeux de passerelle/serveur. (ou utilisateur avancé/paranoïaque!)
Afin que vous puissiez lire agréablement ce paragraphe, il est nécessaire que vous ayez lu et compris les précédents.
En effet, la structure d'iptables n'est pas compliquée, il suffit de l'avoir bien comprise. Ensuite, il faut avoir les idées nettes sur ce qu'on souhaite faire.
Et enfin, il faut connaitre les fonctions d'iptables qui peuvent être utiles.
Nous aborderons ici la création de nouvelle chaine de vérifications, certaines redirection : partage de connexion, redirection de port en interne, redirection de port vers un serveur du lan.
De plus, certaines règles serons données pour des limitations divers (nombre de paquets par minute, adresse source/cible, adresse mac source, spoofing, synflood...).
Parfeux de passerelle/serveur (Cliquez pour faire apparaitre le fichier)
# !/bin/bash
# Script pour la mise en place d'un firewall.
#######################################################################################
firewall_var () {
# Déclaration des variables
# Les interfaces
neteth="eth1" # Interface connectée à internet
localeth="eth2" # Interface connectée au reseau local (pour une passerelle par exemple)
vpneth="tun" # Interface virtuelle d'un vpn
# Les reseaux
local="192.168.0.0/255.255.0.0" # Adresses du reseau local (exemple : 192.168.0.0/24)
vpn="10.1.0.0/255.255.255.0" # Adresses du vpn
# Pour les adresses, on a definit ici une categorie d'ip, une plage en quelque sorte.
# Il bien sur possible de ne donner qu'une adresse particulière si vous la connaissez...
}
#######################################################################################
# PREPARATION DES REGLES DE BASE
#######################################################################################
firewall_stop () {
echo "# [ Mise à zero de toutes les tables ]"
# On vide tout
iptables -F
iptables -X
iptables -F -t nat
# On met la politique sur ACCEPT partout!
iptables -P INPUT ACCEPT
iptables -P OUTPUT ACCEPT
iptables -P FORWARD ACCEPT
echo -e "#[32m OK[00m"
}
firewall_stop2 () {
echo "####################################################################"
echo "####################################################################"
echo "###################### #####################"
echo -e "######################[31m [ Aucun filtrage !!! ][00m #####################"
echo "###################### #####################"
echo "####################################################################"
echo "####################################################################"
}
#######################################################################################
firewall_preparation () {
echo "# [ Configuration des politiques par defaut ]"
# Politique par defaut : DROP
iptables -P INPUT DROP
iptables -P OUTPUT DROP
iptables -P FORWARD DROP
# Tout passe dans la boucle locale
iptables -A INPUT -i lo -j ACCEPT
iptables -A OUTPUT -o lo -j ACCEPT
echo -e "#[32m OK[00m"
}
#######################################################################################
firewall_chaines () {
echo "# [ Declaration des nouvelles chaines de filtrage ]"
iptables -N verification
iptables -F verification
# C'est ici que vous pouvez déclarer vos nouvelles chaines. "-N" permet de créer, et "-F" permet de la vider (flush en anglais).
echo -e "#[32m OK[00m"
}
#######################################################################################
firewall_verification () {
echo "# [ Configuration des chaines ]"
# Filtrage des drapeux dans l'entête des paquets.
# Afin de bien comprendre quels drapeaux sont filtrés, il peut être utile de lire la rfc sur les connexions tcp.
iptables -A verification -p tcp --tcp-flags ALL ALL -j DROP
iptables -A verification -p tcp --tcp-flags ALL NONE -j DROP
iptables -A verification -p tcp --tcp-flags SYN,ACK ACK,SYN -m state --state NEW -j DROP
iptables -A verification -p tcp ! --syn -m state --state NEW -j DROP
# On DROP les paquets dont l'état de connection est INVALID.
iptables -A verification -m state --state INVALID -j DROP
# Filtrage icmp : on ne laisse passer que le ping et le pong. Et on met une limite pour eviter le DOS avec le ping.
# Attention, cette limitation de ping dans le temps peut être assez génante en phase de test de reseau!
iptables -A verification -p icmp --icmp-type echo-request -m limit --limit 12/minute -j ACCEPT
iptables -A verification -p icmp --icmp-type echo-reply -m limit --limit 12/minute -j ACCEPT
# Synflood
if [ -e /proc/sys/net/ipv4/tcp_syncookies ] ; then
echo 1 > /proc/sys/net/ipv4/tcp_syncookies
fi
# Spoofing
if [ -e /proc/sys/net/ipv4/conf/all/rp_filter ] ; then
for filtre in /proc/sys/net/ipv4/conf/*/rp_filter
do
echo 1 >
done
fi
# Liste des ports acceptés => à vous de choisir !!
for port_tcp in 22 53 80 443 1863 6667 6668 8080
do
iptables -A verification -p tcp --dport -j ACCEPT
iptables -A verification -p tcp --sport -j ACCEPT
done
for port_udp in 53 26000
do
iptables -A verification -p udp --dport -j ACCEPT
iptables -A verification -p udp --sport -j ACCEPT
done
echo -e "#[32m OK[00m"
}
#######################################################################################
# Cette partie sert eessentiellement pour les passerelles.
firewall_nat () {
echo "# [ Mise en place du NAT ]"
# Ip forwarding au niveau du noyau.
echo 1 > /proc/sys/net/ipv4/ip_forward
# Postrouting
for adresse_source in # L'adresse source correspond aux adresses auxquelles vous voulez donner le net.
do
iptables -A POSTROUTING -t nat -o -s -j MASQUERADE
done
echo -e "#[32m OK[00m"
}
#######################################################################################
# Dans cette partie, vous mettez les règles que vous voulez!
# Nous allone changer un peu cette partie afin d'y présenter un maximum de règles.
# Imaginons 3 classes d'utilisateurs :
# - des admin qui ont acces "total" au net
# - des users qui ont acces à certains sites internets définit dans un squid qui tourne sur la passerelle
# - des admins passerelles qui ont acces "total" au net, et qui ont acces à la passerelle par ssh.
# L'acces "total" signifie naturellement "total dans la limite de la chaine vérification"!
# Ensuite, nous imaginons un service quelconque tournant sur un serveur présent dans notre lan.
# Le port visible de l'exterieur sera la 1234, mais son ports d'écoute en interne sera le 4321.
firewall_preparation2 () {
# La preparation précédente des variables étant incomplète, nous allons la reprendre ici.
# Attention, toutes ces variables doivent avoir été définies avant afin d'être utilisées dans la partie nat...
echo "# [ Preparation du filtrage ]"
# Nouvelles variables
AdminPasserelle="192.168.1.0"
Admin="192.168.2.0"
User="192.168.10.0"
iface_lan="eth2"
iface_net="eth1"
echo -e "#[32m OK[00m"
}
firewall_admin () {
# Nous allons mettre en place ici les règles pour les admin.
# Nous rappelons qu'ils ont un accès au net, suivant les règles données dans la chaine verification.
# En aucun cas ils ne peuvent acceder à la passerelle.
# Nous mettons en outre un traçage de l'état de connexion afin d'éviter qu'un admin fasse tourner un serveur sur sa machine personnelle.
echo "# [ Mise en place du filtrage pour les admin ]"
iptables -A FORWARD -s -i -o -m state --state NEW,RELATED,ESTABLISHED -j verification
iptables -A FORWARD -d -o -i -m state --state RELATED,ESTABLISHED -j verification
echo -e "#[32m OK[00m"
}
firewall_admin_passerlle () {
# Nous allons mettre en place les règles pour les admin passerelle.
# Ceux-ci peuvent avoir un accès total au net.
# Ils peuvent faire tourner un serveur joignable de l'exterieur sur leur machine personnelle.
# Ils peuvent acceder à la passerelle par n'importe quel port!
echo "# [ Mise en place du filtrage pour les admin passerelle ]"
# acces à la passerelle
iptables -A INPUT -i -s -j ACCEPT
iptables -A OUTPUT -o -d -j ACCEPT
# acces au net
iptables -A FORWARD -s -i -o -j ACCEPT
iptables -A FORWARD -d -o -i -j ACCEPT
# Si vous avez compris le fonctionnement d'iptables en général, et de ce script en particulier,
# vous avez alors compris que les admin passerelle n'ont pas de filtrage au niveau des drapeaux des entêtes...
echo -e "#[32m OK[00m"
}
firewall_user () {
# Nous allons mettre en place une redirection pour les utilisateurs.
# En effet, ceux-ci ne peuvent se connecter que à travers un proxy transparents.
# Nous allons donc rediriger ici le port 80 vers le port du proxy qui tourne sur la passerelle. Nous avons choisi le port 3128.
echo "# [ Mise en place du filtrage pour les utilisateurs ]"
iptables -t nat -A PREROUTING -s -p tcp --dport 80 -j REDIRECT --to-port 3128
echo -e "#[32m OK[00m"
}
firewall_redirection () {
# Dans cette section, nous allons vous montrer un exemple de redirection.
# Nous allons considerer que nous avons un serveur web qui tourne sur un serveur dans notre reseau local.
# Son ip est 192.168.5.5
echo "# [ Mise en place des redirections ]"
# accessibilité du net
iptables -t nat -A PREROUTING -p tcp --dport 80 -j DNAT --to-destination 192.168.5.5
# accessibilité des personnes du reseau local
iptables -t nat -A POSTROUTING -p tcp --dport 80 --dst 192.168.5.5 -j SNAT --to-source 192.168.0.0
echo -e "#[32m OK[00m"
}
firewall_last_rules () {
# Il reste quelques petites choses à faire :
# Donner accès au net à la passerelle,
# Donner accès au net au serveur web!
# acces au net par la passerelle
iptables -A INPUT -i -j verification
iptables -A OUTPUT -o -j verification
# acces au net du serveur web
iptables -A FORWARD -s 192.168.5.5 -i -o -j verification
iptables -A FORWARD -d 192.168.5.5 -o -i -j verification
}
#firewall_filtrons () {
#
# echo "# [ Mise en place du filtrage ]"
#
# echo -e "#[32m OK[00m"
#}
#######################################################################################
# Chaines de log
firewall_log () {
echo "# [ Mise en place des logs ]"
iptables -A INPUT -j ULOG --ulog-prefix="[INPUT]"
iptables -A OUTPUT -j ULOG --ulog-prefix="[OUTPUT]"
iptables -A POSTROUTING -t nat -j ULOG --ulog-prefix="[NAT]"
# Cette partie permet de loger les paquets rejettés par netfilter.
# Il faut bien avoir le module ulog compilé avec votre noyau, et avoir installé ulog.
# Vos logs sont alors dans /var/log/ulog/syslogmenu.log
echo -e "#[32m OK[00m"
}
#######################################################################################
# Le menu
firewall_start () {
echo "####################################################################"
echo "####################################################################"
echo "#"
echo "# [ DEMARRAGE DU FIREWALL ]"
echo "#"
echo "#"
firewall_var
firewall_preparation
firewall_chaines
firewall_verification
firewall_nat
# firewall_filtrons
firewall_preparation2
firewall_admin
firewall_admin_passerlle
firewall_user
firewall_redirection
firewall_last_rules
firewall_log
echo "#"
echo "#"
echo "####################################################################"
echo "####################################################################"
echo "###################### #####################"
echo -e "######################[34;5m [ Filtrage en place ! ][00m #####################"
echo "###################### #####################"
echo "####################################################################"
echo "####################################################################"
echo -e "[35;5m PiFnuX[00m"
}
firewall_stop3 () {
echo "####################################################################"
echo "####################################################################"
echo "#"
echo "# [ ARRET DU FIREWALL ]"
echo "#"
echo "#"
firewall_stop
firewall_stop2
}
firewall_restart () {
echo "####################################################################"
echo "####################################################################"
echo "#"
echo "# [ REDEMARRAGE DU FIREWALL ]"
echo "#"
echo "#"
firewall_stop
firewall_start
}
firewall_test () {
# Vous pouvez ici faire des tests en supprimant certaines fonctions de votre parfeux
echo " # Mode de test du firawall"
echo " # Plus de protection dans 60 secondes"
firewall_stop
firewall_var
firewall_preparation
firewall_chaines
firewall_verification
firewall_nat
firewall_filtrons
firewall_log
sleep 60
firewall_stop
echo " #"
echo " #"
echo " # Test reussi avec succès!"
echo " # Attention, vous n'êtes plus protégé!"
}
case "$1" in
'start')
firewall_start
;;
'stop')
firewall_stop3
;;
'restart')
firewall_restart
;;
'test')
firewall_test
;;
'mode_pf')
# Ceci est un mode de démarrage personnel et adapté à un laptop :
# lorsque je me connecte en wifi, je fais du nat sur mon interface ethernet afin de partager rapidement ma connexion internet!
# Lorsque je suis connecté en ethernet, je ne fais pas de nat.
case "$2" in
'wifi')
# Déclarartion des variables
# Les interfaces
neteth="eth2" # Interface connecté à internet
localeth="eth1" # Interface connecté au reseau local (pour une passerelle par exemple)
vpneth="tun0" # Interface virtuelle dun vpn
# Les reseaux
local="192.168.0.0/24" # Adresse du reseau local (exemple : 192.168.0.0/24)
vpn="10.1.0.0/24" # Adresse du vpn
# On demarre le firewall avec les interface configurées comme il faut....
firwall_stop
firwall_preparation
firewall_chaines
firewall_verification
firewall_nat
firewall_filtrons
firewall_log
;;
'lan')
# Déclarartion des variables
# Les interfaces
neteth="eth1" # Interface connecté à internet
localeth="" # Interface connecté au reseau local (pour une passerelle par exemple)
vpneth="tun0" # Interface virtuelle dun vpn
# Les reseaux
local="192.168.0.0/24" # Adresse du reseau local (exemple : 192.168.0.0/24)
vpn="10.1.0.0/24" # Adresse du vpn
# On demarre le firewall avec les interface configurées comme il faut....
firwall_stop
firwall_preparation
firewall_chaines
firewall_verification
firewall_filtrons
firewall_log
;;
*)
echo " Usage du mode_pf : {wifi|lan}"
esac
;;
*)
echo " Script de firewall pour Iptables ecrit avec Netfilter par Pierre-François Raymond"
echo " Usage: {start|stop|restart|test|mode_pf}"
echo " Usage du mode_pf : {wifi|lan}"
esac
Maintenant que vous avez construit votre script, il peut être interessant de regarder rapidement ce à quoi il peut ressembler.
Pour cela, la commande iptables peut vous permettre d'afficher les différentes tables et chaines avec différents niveau de verbosité :
-L : liste classique
-L -t nat : liste la table nat
-v : affiche le nombre de paquets ayant transité dans chaque règle
-n : ne fait pas la correspondance de nom.