Introduction

Cet article présente de façon pratique la mise en place d'un pare-feu (en anglais, firewall) ou
d'un proxy sur une machine GNU/Linux tournant au minimum avec un noyau 2.4.

Pour des informations plus théoriques sur les pare-feux et les proxys, vous pouvez lire l'article
pare-feu.

Présentation d'iptables

iptables est une solution complète de pare-feu pour le système GNU/Linux depuis le noyau
2.4, remplaçant ipchains, le pare-feu du noyau 2.2. iptables permet de faire du firewalling à
états (stateful), de la translation de port et d'adresse, du filtrage au niveau 2 et beaucoup
d'autres choses que nous n'allons pas aborder comme le « mangle » ou modification des
paquets à la volée (atchoum).

iptables est fiable et dispose de très nombreuses options qui permettent de faire du filtrage très
fin.

Précisons dès maintenant que le module qui fournit au noyau Linux les fonctions de pare-feu,
de partage de connexions internet (NAT) et d'historisation du trafic réseau s'appelle Netfilter.
iptables est en fait juste l'outil qui permet à un administrateur de configurer Netfilter en mode
utilisateur.

Licence d'iptables

iptables et le framework NetFilter sont sous licence libre GPL.

1/ Installation
1.1/ Prérequis

iptables est installé en standard sur de nombreuses distributions GNU/Linux récentes (kernel
2.4.x. ou supérieur).

iptables a besoin au minimum d'un noyau 2.4 compilé avec des options spéciales. Ceci ne
pose pas de problèmes avec les noyaux génériques des principales distributions : tout a déjà
été fait pour vous.

Bref, sur une distribution récente et standard, passez à la partie 2/.

1.2/ Options de compilation du kernel

Si vous désirez re-compiler votre kernel, il faut spécifier les options nécessaires au
fonctionnement d'iptables.

Les options suivantes doivent êtres activées en module (M) ou dans le kernel (Y) :
CONFIG_PACKET
CONFIG_NETFILTER

CONFIG_IP_NF_CONNTRACK
CONFIG_IP_NF_FTP
CONFIG_IP_NF_IRC
CONFIG_IP_NF_IPTABLES
CONFIG_IP_NF_FILTER
CONFIG_IP_NF_NAT
CONFIG_IP_NF_MATCH_STATE
CONFIG_IP_NF_TARGET_LOG
CONFIG_IP_NF_MATCH_LIMIT
CONFIG_IP_NF_TARGET_MASQUERADE

et éventuellement :

CONFIG_IP_NF_COMPAT_IPCHAINS pour garder la compatibilité avec ipchains.

CONFIG_IP_NF_COMPAT_IPFWADM pour garder la compatibilité avec ipfwadm.
CONFIG_IP_NF_TARGET_REDIRECT indispensable, pour les proxies transparents par exemple.
CONFIG_IP_NF_MATCH_MAC permet de matcher avec les adresses MAC.

Ne pas oublier le support réseau et TCP/IP et compiler le kernel comme d'habitude :

make dep && make clean && make bzImage && make modules && make
modules_install

1.3/ Installation

Récupérer le package netfilter et l'installer comme d'habitude avec apt-get, urpmi,

emerge...

Notons que sur les versions inférieures a Red Hat 7.1, il faut compiler un noyau 2.4 car
iptables ne supporte pas les noyaux 2.2.x. La compilation de iptables est complexe. Le mieux
est de lire le fichier INSTALL du package des sources.

1.4/ Chargement des modules

Dans le cas ou les options iptables du noyau ont été compilées en modules, il est nécessaire de
charger ces modules avant de pouvoir utiliser iptables :

# modprobe ip_tables

selon les besoins, on peut éventuellement charger les modules suivants :

# modprobe ip_nat_ftp
# modprobe ip_nat_irc
# modprobe iptable_filter
# modprobe iptable_mangle
# modprobe iptable_nat

Si on a besoin de pouvoir rediriger (forward) les paquets IP arrivant sur un interface réseau
(connectée par exemple à Internet) vers une autre interface réseau (connectée par exemple au
réseau local), il sera nécessaire, dans la plupart des cas, d'exécuter cette commande :
# echo 1 > /proc/sys/net/ipv4/ip_forward

afin de l'indiquer au noyau.

Nota bene : tous les modprobe semblent inutiles car le kernel les charge automatiquement si
l'on se sert de l'une des fonctionnalités d'iptables.

2/ Présentation
2.1/ Les tables

 Table NAT (Network Address Translation) : Table utilisée pour la translation

d'adresse ou la translation de port.
Il a 2 types de chaînes# : PREROUTING qui permet de spécifier « à l'arrivée du pare-
feu » et la chaîne POSTROUTING qui permet de spécifier « à la sortie du pare-feu ».
Il existe 3 targets (ou cibles) : DNAT*, SNAT* et MASQUERADE*.
 Table FILTER : C'est la table par défaut lorsque l'on en spécifie pas.
Cette table contient toutes les règles de filtrage, il existe 3 types de chaînes :
FORWARD pour les paquets passant par le pare-feu, INPUT pour les paquets entrant
et OUTPUT pour les paquets sortants. Les cibles disponibles sont : ACCEPT, DENY,
DROP, REJECT °.
 Table Mangle : C'est la table qui contient les règles pour la modification de paquets.
Elle est peu utilisée et ne sera pas décrite dans cet article.

A noter : Les règles sont évaluées dans l'ordre, par défaut la table FILTER est vide et donc
accepte tout. Aucune règle de translation d'adresse n'est présente par défaut.
#
chaîne
une chaîne est une suite de règles, qui sont prises dans l'ordre ; dès qu'une règle
s'applique à un paquet, elle est déclenchée, et la suite de la chaîne est ignorée.
* SNAT
Permet de modifier l'adresse source du paquet.
* DNAT
Permet de modifier l'adresse destination du paquet.
* MASQUERADE
Une passerelle (gateway) transforme les paquets sortants passant par elle pour donner
l'illusion qu'ils sortent de la passerelle elle-même par un port alloué dynamiquement ;
lorsque la passerelle recoit une réponse sur ce port, elle utilise une table de
correspondance entre le port et les machines du réseau privé qu'elle gère pour lui faire
suivre le paquet.
° policy ACCEPT
Permet d'accepter un paquet grâce à la règle vérifiée.
° policy DROP
Rejet d'un paquet sans message d'erreur si la règle est vérifiée ("non ! j'en veux pas
mais je dis rien à l'expediteur").
° policy REJECT
Rejet avec un retour de paquet d'erreur à l'expediteur si la règle est verifiée ("un
paquet recommandé de La Poste refusé par son destinataire").
° policy LOG
Affiche le résultat vers la sortie standard.
 Peut être associé a un préfixe pour une meilleure lisibilité (un préfixe pour les paquets
rejetes,un autre pour les paquets forwardés etc...).
Exemple : -j LOG --log-prefix '[IPTABLES DROP] : '

2.2/ Les commandes

iptables n'est pas livré avec une interface graphique par défaut ; les commandes et les règles
sont généralement passées en ligne de commande. Le mieux est d'écrire des scripts (à rajouter
dans /etc/rc.d/init.d) qui permettent d'appliquer toutes les règles d'un seul coup, dès le
démarrage de GNU/Linux.

La plupart des distributions proposent cependant des outils graphiques ou semi-graphiques

pour configurer le pare-feu. Ainsi, Red Hat et Fedora proposent system-config-firewall-
tui et system-config-firewall , Mageia utilise Shorewall, Ubuntu UFW.

2.2.1/ Commandes principales

-A --append : Ajoute la règle à la fin de la chaîne spécifiée

Exemple :
# iptables -A INPUT ...

-D --delete : Permet de supprimer une chaîne. On peut l'utiliser de 2 manières, soit en

spécifiant le numéro de la chaîne a supprimer, soit en spécifiant la règle à retirer.
Exemples :
# iptables -D INPUT --dport 80 -j DROP
# iptables -D INPUT 1

-R --replace : Permet de remplacer la chaîne spécifiée.

Exemple :
# iptables -R INPUT 1 -s [Link] -j DROP

-I --insert : Permet d'ajouter une chaîne dans un endroit spécifié de la chaîne.

Exemple :
# iptables -I INPUT 1 --dport 80 -j ACCEPT
Si aucun chiffre n'est spécifié à la suite (#iptables -I INPUT --dport 80 -j ACCEPT), la règle
est ajoutée au début de la chaîne spécifiée

-L --list : Permet d'afficher les règles.

Exemples :
# iptables -L # Affiche toutes les règles des chaînes de FILTER
# iptables -L INPUT # Affiche toutes les règles de INPUT (FILTER)

-F --flush : Permet de vider toutes les règles d'une chaîne.

Exemple :
# iptables -F INPUT

-N --new-chain : Permet de créer une nouvelle chaîne.

Exemple :
# iptables -N LOG_DROP
-X --delete-chain : Permet d'effacer une chaîne.
Exemple :
# iptables -X LOG_DROP

-P --policy
: Permet de spécifier au noyau la politique par défaut d'une chaîne DENY,
ACCEPT, REJECT, DROP ...
Exemple :
# iptables -P INPUT DROP

2.2.2/ Commandes pour matcher

Remarques :

Le "!" peut être utilisé pour certaines commandes afin de spécifier le contraire (on peut le
traduire par "sauf"). Par exemple une commande qui doit refuser tout trafic TCP sauf ce qui
provient de l'adresse IP [Link] sera traduite par la commande suivante :
Exemple :
# iptables -A INPUT -p tcp --source ! [Link] -j DROP

Les adresses IP peuvent optionnellement être spécifiées avec le masque associé sous la forme
[adresse ip]/[masque].

-j (jump) : Défini l'action à prendre si un paquet répond aux critères de cette règle: ACCEPT,
LOG, DROP...
Exemple :
# iptables -A INPUT -p icmp -j DROP

-p --protocol : Spécifier un protocole : tcp, udp, icmp, all (tous)

Exemple :
# iptables -A INPUT -p icmp -j DROP

-s --source : Spécifier une adresse source à matcher

Exemple :
# iptables -A INPUT -p tcp -s [Link] -j ACCEPT

-d --destination : Spécifier une adresse destination

Exemple :
# iptables -A FORWARD -p tcp -d [Link] -j ACCEPT

-i --in-interface : Spécifier une interface d'entrée

Exemple :
# iptables -A INPUT -p icmp -i eth0 -j DROP

-o --out-interface : Spécifier une interface de sortie

Exemple :
# iptables -A OUTPUT -p icmp -o eth0 -j DROP

-f --fragment : Paquet fragmenté

Exemple :
# iptables -A INPUT -p icmp -f -j DROP
--sport --source-port : Spécifier le port source ou une plage de ports, fonctionne aussi en
udp, -m multiport permet de
spécifier plusieurs ports à matcher.
Exemples :
# iptables -A INPUT -p tcp --sport 80 -j ACCEPT
# iptables -A INPUT -p udp --sport 80 -j DROP
# iptables -A OUTPUT -p tcp -m multiport --sport 3128,21,1000 -j DROP
# iptables -A OUTPUT -p tcp --sport 1024:2042 -j ACCEPT

--dport --destination-port : Spécifier le port destination ou une plage de ports,

fonctionne aussi en udp, -m multiport
permet de spécifier plusieurs ports a matcher.
Exemples :
# iptables -A INPUT -p tcp --dport 110 -j DROP
# iptables -A INPUT -p udp --dport 110 -j DROP
# iptables -A INPUT -p tcp -m multiport --dport 110,4242,119 -j DROP
# iptables -A INPUT -p tcp --sport 4925:4633 -j ACCEPT

--tcp-flags : Spécifier un flag tcp à matcher : SYN ACK FIN RST URG PSH ALL NONE
Exemple :
# iptables -A INPUT -p tcp --dport 42 --tcp-flags SYN,ACK -j ACCEPT

--icmp-type : Spécifier un type de paquet icmp à matcher

Exemple :
# iptables -A INPUT -p icmp --icmp-type 8 -j DROP

--mac-source : Spécifier l'adresse MAC à matcher

Exemple :
# iptables -A INPUT --mac-source [Link] -j DROP
En cas d'erreur, il peut-être nécessaire de spécifier le module mac, exemple :
# iptables -A INPUT -m mac --mac-source [Link] -j DROP

--state : Permet de spécifier l'état du paquet à matcher parmi les états suivants :
ESTABLISHED : paquet associé à une connexion déjà établie
NEW : paquet demandant une nouvelle connexion
INVALID : paquet associé à une connexion inconnue
RELATED : Nouvelle connexion mais liée, idéal pour les connexions FTP
Exemples :
# iptables -A INPUT -i eth0 -p tcp --dport 80 -m state --state
NEW,ESTABLISHED -j ACCEPT
# iptables -A OUTPUT -o eth0 -p tcp --sport 80 -m state --state ESTABLISHED
-j ACCEPT

Spécificités NAT :

--to-destination : Utilisé en target pour le DNAT, permet de spécifier l'adresse de

destination de la translation, on peut également spécifier un port s'il est différent du port
source.
Exemples :
# iptables -t nat -A PREROUTING -d [Link] -p tcp --dport 110 -j DNAT -
-to-destination [Link]:6110
# iptables -t nat -A PREROUTING -d ! [Link] -p tcp --dport 80 -j DNAT
--to-destination [Link]:3128
--to-source : Utilisé pour en target pour le SNAT, permet de spécifier l'adresse source de la
translation.

Spécificités pour les LOGS :

--log-level : Level, niveau de log

Exemple : Cf. chapitre 3

--log-prefix : Permet de spécifier un préfixe pour les logs.

Exemple : Cf. chapitre 3

2.2.3/ Quelques exemples :

Les exemples qui suivent supposent que vous êtes reliés à internet par modem via l'interface
ppp0 (mais en remplaçant ppp0 par eth0 - par exemple, on peut adapter les exemples pour
d'autres type de liaisons) et que votre réseau local est [Link]/24 (classe C).

 Pour fixer les politiques par défaut (cad: ce qui se passe quand aucune règle ne
correspond - ne matche pas), ici, on refuse tout (normal, on fait un pare-feu, oui ou
non ?) :

iptables -P INPUT DROP

iptables -P OUTPUT DROP
iptables -P FORWARD DROP

 Pour logguer tout ce qu'on jette :

iptables -N LOG_DROP
iptables -A LOG_DROP -j LOG --log-prefix '[IPTABLES DROP] : '
iptables -A LOG_DROP -j DROP

Les trois dernières règles doivent être :

iptables -A FORWARD -j LOG_DROP
iptables -A INPUT -j LOG_DROP
iptables -A OUTPUT -j LOG_DROP

Enfin (pour loguer le trafic autorisé), recommencer en remplaçant -j DROP, par -j ACCEPT et
a la place de -j LOG_DROP il faut mettre -j LOG_ACCEPT

 Pour accepter tout ce qui se passe sur l'interface lo (sinon ce n'est pas la peine
d'activer le réseau !) :

iptables -A INPUT -i lo -j ACCEPT

iptables -A OUTPUT -o lo -j ACCEPT

 Pour accepter tout ce qui se passe sur le réseau local [Link] :

iptables -A INPUT -s [Link]/24 -j ACCEPT

iptables -A OUTPUT -d [Link]/24 -j ACCEPT
iptables -A FORWARD -s [Link]/24 -j ACCEPT

 Pour accepter les résolutions de nom (ie: le dns) :

 iptables -A INPUT -i ppp0 --protocol udp --source-port 53 -j ACCEPT
iptables -A OUTPUT -o ppp0 --protocol udp --destination-port 53 -j
ACCEPT
iptables -A INPUT -i ppp0 --protocol tcp --source-port 53 -j ACCEPT
iptables -A OUTPUT -o ppp0 --protocol tcp --destination-port 53 -j
ACCEPT

 Pour accepter le traffic web (on veut surfer!) :

iptables -A INPUT -i ppp0 --protocol tcp --source-port 80 -m state --

state ESTABLISHED -j LOG_ACCEPT
iptables -A OUTPUT -o ppp0 --protocol tcp --destination-port 80 -m
state --state NEW,ESTABLISHED -j LOG_ACCEPT

La première ligne pour accepter ce qui entre sur notre interface ppp0 sur le port 80 (le
port http) si c'est une connexion déjà établie, la seconde pour accepter ce qui sort sur
ppp0 sur le port 80 si c'est une nouvelle connexion ou si c'est une connexion déjà
établie.

Pour autoriser le ssh, il faut préciser le port 22; pour autoriser l'irc, le port 6667 (ou celui que
vous utilisez pour vous connecter à votre serveur); pour le smtp (envoi d'emails), le port 25;
pour le pop3 (réception d'emails), le port 110; pour le imap (réception d'emails), les ports 143
et 220 (imap3) ; pour le cvs, le port 2401 ; pour le https, le port 443. De manière générale, le
numéros de port se trouvent dans /etc/services.

 Pour le ftp c'est un peu plus complexe. D'abord, il faut charger le module :
ip_conntrack_ftp (c'est lui qui suit - track en anglais - les connexions ftp) et, si vous
natez (en utilisant le masquerading par exemple) vos connexions ftp vers d'autres
postes le module : ip_nat_ftp :

modprobe ip_conntrack_ftp
# éventuellement : modprobe ip_nat_ftp

Ensuite, il faut taper les commandes suivantes :

iptables -A INPUT -i ppp0 -p tcp --sport 21 -m state --state

ESTABLISHED -j ACCEPT
iptables -A OUTPUT -o ppp0 -p tcp --dport 21 -m state --state
NEW,ESTABLISHED -j ACCEPT

Cela pour que la connexion puisse s'établir. Ensuite (et c'est la qu'on a besoin de
ip_conntrack_ftp) :

iptables -A INPUT -i ppp0 -p tcp --sport 20 -m state --state

ESTABLISHED,RELATED -j ACCEPT
iptables -A OUTPUT -o ppp0 -p tcp --dport 20 -m state --state
ESTABLISHED -j ACCEPT

Pour que serveur puisse établir la connexion pour les données (en mode actif). Et
enfin :

iptables -A INPUT -i ppp0 -p tcp --sport 1024:65535 --dport

1024:65535 -m state --state ESTABLISHED -j ACCEPT
 iptables -A OUTPUT -o ppp0 -p tcp --sport 1024:65535 --dport
1024:65535 -m state --state ESTABLISHED,RELATED -j ACCEPT

Pour que le serveur puisse établir la connexion pour les données (en mode passif). Ici
aussi ip_conntrack_ftp est nécessaire.

 Pour partager une connexion, il faut que le forwarding soit activé dans le noyau
(echo 1 > /proc/sys/net/ipv4/ip_forward), puis il faut autoriser iptable à faire
le forwarding :

iptables -F FORWARD
iptables -A FORWARD -j ACCEPT

et enfin, cacher les machines forwardées par le pare-feu :

iptables -A POSTROUTING -t nat -o ppp0 -j MASQUERADE

Sur chaque machine devant être cachée par le pare-feu (ou devant partager la
connexion avec la machine qui est connectée à internet), il faut ajouter une route par
defaut :

route add default gw [Link]

Si la machine connectée à internet a comme ip : [Link]. Par exemple, il suffit

avec une Red Hat ou Mageia d'éditer :

/etc/sysconfig/network

et d'ajouter dedans :

GATEWAY=[Link]

puis de redémarer le réseau :

service network restart

3/ Application par l'exemple

Nous allons mettre en place un pare-feu / proxy.

Pour cet exemple, le pare-feu aura la connexion à Internet (interface eth2) et disposera de 2
pattes sur des réseaux privés (eth0 et eth1) :

 il fait office de proxy sur le port 3128 pour un réseau qui aura ainsi un accès internet
 et une DMZ* ("zone démilitarisée") sur laquelle il y a un ensemble de serveurs
disponibles de l'extérieur dont un serveur web qui a pour adresse [Link] écoutant
sur le port 80 en TCP.

_____ eth1 .-> ---+------+------+---

 _/ \_ ____ / [PC1] [PC2] [PC3]
( ) eth2 | |<--' réseau local [Link]
( INTERNET )<---->|Fire|
(_ _) ppp0 |wall|
\______/ |____|<--. DMZ serveurs [Link]
eth0\ [WEB] [NEWS] [FTP]
'-> ---+------+------+---
ASCIIArt (c) Jice

La classe d'adresse IP [Link] correspond au réseau interne sur l'interface eth1.

La classe d'adresse IP [Link] correspond a la DMZ sur l'interface eth0.
L'interface de la connexion Internet est ppp0 sur l'interface eth2.
*
DMZ, ou zone démilitarisée
Sous-réseau dans lequel des serveurs accessibles depuis internet sont en adressage
privé (classe d'adresse IP réservée comme 192.168.x.x) derrière un pare-feu.

3.1/ Le script init.d

Nous allons écrire un script qui permettra de charger automatiquement au démarrage de la

machine ou sur demande les règles du pare-feu qui seront stockées dans le fichier
/etc/[Link].
Le script de démarrage sera nommé /etc/init.d/firewall. Bien sûr, on n'oubliera pas
d'exécuter un chmod +x sur les 2 scripts que nous allons créer au long de ce chapitre.

À noter que dans de nombreuses distributions, ce script existe déjà. Ainsi, sous Red Hat et
Fedora, il s'appelle /etc/init.d/iptables. Le service associé s'appelle iptables et
lorsqu'il est actif, il utilise les règles définies dans le fichier /etc/sysconfig/iptables.

Go !
Fichier de chargement /etc/init.d/firewall :

#!/bin/bash
#
# Lancement du script de pare-feu
# Arnaud de Bermingham

. /etc/init.d/functions

RETVAL=0

# Fonction pour le lancement du pare-feu

start() {
echo -n "Application des règles IpTables: "
/etc/[Link]
RETVAL=0
[ $RETVAL -eq 0 ] && touch /var/lock/subsys/firewall
echo
}

# Fonction pour arrêter le pare-feu (on flush)

stop() {
echo -n "Flush des règles IpTables: "
/etc/flush_iptables.sh
 RETVAL=0
[ $RETVAL -eq 0 ] && rm -f /var/lock/subsys/firewall
echo
}

case $1 in
start)
start
;;
stop)
stop
;;
restart)
stop
start
;;
status)
/sbin/iptables -L
/sbin/iptables -t nat -L
RETVAL=0
;;
*)
echo "Usage: firewall {start|stop|restart|status}"
RETVAL=1
esac

exit

C'est tout simple non ?

3.2/ Le script pour vider (flusher) les règles

Et maintenant : /etc/flush_iptables.sh.

#!/bin/sh
#
# Script pour vider les règles iptables
# Arnaud de Bermingham
# duracell@[Link]

#
# On remet la police par défaut à ACCEPT
#
iptables -P INPUT ACCEPT
iptables -P FORWARD ACCEPT
iptables -P OUTPUT ACCEPT

#
# On remet les polices par défaut pour la table NAT
#
iptables -t nat -P PREROUTING ACCEPT
iptables -t nat -P POSTROUTING ACCEPT
iptables -t nat -P OUTPUT ACCEPT

#
# On vide (flush) toutes les règles existantes
#
iptables -F
 iptables -t nat -F

#
# Et enfin, on efface toutes les chaînes qui ne
# sont pas à defaut dans la table filter et nat

iptables -X
iptables -t nat -X

# Message de fin
echo " [termine]"

Bon, on va enfin commencer les choses sérieuses : le script du pare-feu :)

3.3/ Les prérequis pour le script du pare-feu et création des tables pour les logs

Le script sera commenté au fur et à mesure, afin de décrire chaque étape.

#!/bin/sh

# script /etc/[Link]

# Pare-feu d'exemple a but pédagogique

# Arnaud de Bermingham
# duracell@[Link]

# Activation du forwarding
# C'est pas pour faire joli, on aura des règles
# de forward et il faut bien que les paquets
# traversent la machine, donc on met ce fichier à 1

echo 1 > /proc/sys/net/ipv4/ip_forward

# Alors la, on va appliquer quelques astuces

# pour empêcher les attaques de type spoofing
# et bloquer les réponses ICMP du pare-feu,
# comme ça c'est très propre. Attention, le
# fait de bloquer le trafic ICMP sur
# le pare-feu bloque les pings.

# Je veux pas de 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 > $filtre
done
fi

# pas de icmp

echo 1 > /proc/sys/net/ipv4/icmp_echo_ignore_all

echo 1 > /proc/sys/net/ipv4/icmp_echo_ignore_broadcasts

# On va utiliser iptables. Si on l'a compilé en module

# dans le kernel, il faut charger le module ip_tables.

modprobe ip_tables

# on va charger quelques modules supplémentaires pour

# gérer la translation d'adresse, l'IRC et le FTP
# Tu me fait 4 pompes. Chef oui chef !

modprobe ip_nat_ftp
modprobe ip_nat_irc
modprobe iptable_filter
modprobe iptable_nat

# Pour faire bien, on va vider toutes les règles

# avant d'appliquer les nouvelles règles de pare-feu

iptables -F
iptables -X

# On va rajouter 2 nouvelles chaînes.

# Ceci permettra d'ajouter des nouvelles cibles qui
# auront la possibilité de loguer ce qui se passe.

# La on logue et on refuse le paquet,

# on rajoute un préfixe pour pouvoir
# s'y retrouver dans les logs
iptables -N LOG_DROP
iptables -A LOG_DROP -j LOG \
--log-prefix '[IPTABLES DROP] : '
iptables -A LOG_DROP -j DROP

# ici, on logue et on accepte le paquet,

# on rajoute un préfixe pour pouvoir
# s'y retrouver dans les logs
iptables -N LOG_ACCEPT
iptables -A LOG_ACCEPT -j LOG \
--log-prefix '[IPTABLES ACCEPT] : '
iptables -A LOG_ACCEPT -j ACCEPT

# On veut faire un pare-feu efficace,

# donc la politique a appliquer est de tout
# refuser par défaut et rajouter une a une
# les règles que l'on autorise.
# Bien sur, on a RTFM un peu et on a vu que
# l'option -P permet de définir
# la cible par défaut

iptables -P INPUT DROP

iptables -P OUTPUT DROP
iptables -P FORWARD DROP

# Pour éviter les problèmes, on va tout accepter sur

# la machine en local (interface lo).
# Je déconseille de retirer cette règle car
# ça pose pas mal de problèmes et ça peut
# faire perdre la main sur la machine

iptables -A INPUT -i lo -j ACCEPT

iptables -A OUTPUT -o lo -j ACCEPT

# Bon, la partie initialisation et préparation est

# terminée, passons aux choses sérieuses

# Comme on l'a dit dans la présentation de

# l'architecture réseau, le pare-feu fait
# également office de proxy grâce par exemple
# à un squid installé dessus. On va donc
# accepter que le proxy ait une connexion
# internet directe. Tant qu'à faire, on va
# mettre des états pour que ça soit bien sécurisé

iptables -A OUTPUT -o ppp0 -m state \

--state NEW,ESTABLISHED -p tcp --dport 80 -j ACCEPT
iptables -A INPUT -i ppp0 -m state \
--state ESTABLISHED -p tcp --sport 80 -j ACCEPT

# Maintenant, on va faire en sorte que le

# proxy soit totalement transparent pour le LAN
# bénéficiant de la connexion internet.
# L'astuce consiste a rediriger toutes les
# requêtes ayant un port de destination 80
# vers le port 3128 du proxy, ici c'est le
# pare-feu (qui est sur le pare-feu et qui
# a l'adresse IP [Link] ).
# Une règle de NAT suffira largement pour faire ça.

iptables -t nat -A PREROUTING -i eth1 -p tcp \

--dport 80 -j DNAT --to-destination [Link]:3128

# Bon, c'est pas trop compliqué ! Maintenant

# on sait que l'on a un serveur web sur la DMZ
# (la machine d'adresse IP [Link]) sur
# le port 80. On souhaite que toutes les requêtes
# provenant d'internet arrivant sur l'adresse IP
# publique du serveur ( ici [Link] ) soit
# redirigées sur le serveur web de la DMZ.
# Rien de bien compliqué. Dans l'exemple,
# on peut retirer le :80 de la target
# --to-destination

iptables -t nat -A PREROUTING -d [Link] \

-p tcp --dport 80 -j DNAT --to-destination [Link]:80

# C'est bien tout ça ! mais le problème c'est

# que les chaînes de la table FILTER sont toutes
# à DENY, donc tout ceci ne fait rien du tout.
# On va donc passer a la configuration du
# pare-feu proprement dit.

# On va quand même accepter les connexions ssh

# (port 22) provenant d'une machine (la votre en
# l'occurrence, on va dire [Link]) vers le
# pare-feu pour pouvoir modifier les règles
# facilement pour bien surveiller, on va quand
# même loguer les connexions provenant de mon IP
# et à destination du ssh du pare-feu
iptables -A INPUT -i eth1 -s [Link] -m state \
--state NEW,ESTABLISHED -p tcp --dport 22 -j LOG_ACCEPT
iptables -A OUTPUT -o eth1 -d [Link] -m state \
--state ESTABLISHED -p tcp --sport 22 -j LOG_ACCEPT

# On veut que le LAN connecté à l'interface

# eth1 ait un accès complet à internet.
# La règle de NAT qui permettait d'avoir
# un proxy transparent sera automatiquement
# appliqué. L'interface correspondant
# à la connexion internet est ici ppp0

iptables -A FORWARD -i eth1 -o ppp0 -j ACCEPT

iptables -A FORWARD -o eth1 -i ppp0 -j ACCEPT

# Maintenant on donne le droit au LAN de

# consulter les pages web du serveur de la DMZ

iptables -A FORWARD -i eth1 -o eth0 -p tcp \

--dport 80 -m state --state NEW,ESTABLISHED -j ACCEPT
iptables -A FORWARD -i eth0 -o eth1 -p tcp \
--sport 80 -m state --state ESTABLISHED -j ACCEPT

# Maintenant il n'y a plus qu'à dire au pare-feu

# d'autoriser à transmettre des paquets TCP à
# destination du port 80 provenant de l'adresse
# IP publique (i.e. d'internet) vers le serveur
# web de la DMZ que nous avons naté précédemment.

iptables -A FORWARD -i ppp0 -o eth0 -p tcp \

--destination-port 80 -m state --state NEW,ESTABLISHED -j ACCEPT
iptables -A FORWARD -o ppp0 -i eth0 -p tcp \
--source-port 80 -m state --state ESTABLISHED -j ACCEPT

# Maintenant il ne reste plus grand chose à faire !

# Il faut permettre à l'ensemble du LAN de dialoguer

# sur internet avec la même adresse IP sinon, bien
# évidemment ça ne marchera pas (à moins que vous
# ayez 30 adresses ip !).
# Une petite règle de NAT avec un -j MASQUERADE
# suffira (masquerade = dialoguer avec l'adresse
# IP publique sur pare-feu)

iptables -t nat -A POSTROUTING \

-s [Link]/24 -j MASQUERADE

# Il faut également que le serveur web de la DMZ

# soit masqueradé sinon, le serveur
# dialoguera sur internet avec son IP privée

iptables -t nat -A POSTROUTING \

-s [Link]/24 -j MASQUERADE

# Toutes les règles qui n'ont pas passé les

# règles du pare-feu seront refusées et loguées...
# facile :
 iptables -A FORWARD -j LOG_DROP
iptables -A INPUT -j LOG_DROP
iptables -A OUTPUT -j LOG_DROP

# Pour faire zoli

echo " [Termine]"

# c'est enfin fini

Et voilà ! le pare-feu de compét' est prêt et fonctionnel.

Ceci était bien évidemment un exemple, vous pouvez dès à présent préparer votre propre
pare-feu personnalisé !
Vous pouvez l'adapter à vos besoins, votre connexion vers internet (par ADSL par exemple),
etc.

Sauvegarder, restaurer et rendre permanente la

configuration
Pour voir si iptables est activé comme service au démarrage, tapez (pour systemd) :

# systemctl list-unit-files |grep iptables

[Link] disabled

Si vous voyez enable, c'est que votre pare-feu est bien activé.

Sinon, pour l'activer :

# systemctl start iptables

Si votre distribution n'utilise pas systemd, tapez :

# chkconfig --list iptables|grep iptables

iptables 0:off 1:off 2:on 3:on 4:on 5:on 6:off

Et pour l'activer :

# chkconfig iptables on

iptables-restore et iptables-save sont deux commandes associées qui permettent de

sauvegarder/restaurer la configuration Netfilter, dans un fichier spécifié, par exemple
/etc/sysconfig/iptables sous Red Hat et Fedora. Généralement, ces commandes peuvent
être appelées par le service, typiquement :

# service iptables save

Sous Ubuntu et Debian, c'est la commande iptables-persistent qui gère les règles iptables
au démarrage, avec comme argument save pour sauvegarder les règles, flush pour les vider
et reload pour les recharger, tout cela en se basant sur le fichier /etc/iptables/rules.v4
(resp. v6 pour IPv6).

Autres ressources
Le partage de connexion facile.

Tester votre pare-feu là.

Cliquez sur 'ShieldsUP!', puis sur l'un des boutons : 'Test My Shields !" et "Probe My Ports !".
Ça vaut pas un bon nmap fait par un ami, mais ça permet de voir ou on en est.

Évidemment, si vous êtes derrière une box internet (Freebox, Livebox etc.), ce sera son pare-
feu à elle - il s'agit d'ailleurs probablement d'iptables également - qui sera testé et non pas
celui de votre distribution.

Setting DMZ with iptables

DMZ (Demilitarised Zone)

What is DMZ : we are segmenting our network in such a way that all the users coming through public
network (internet) should be able to access our Web, Mail, DNS servers without a danger of
compromising our internal network i.e we have divided our resources into two zones, one highly
secured (internal) and one semi-secured (DMZ). Also we want that if any how our DMZ gets
compromised, no should be able to access our internal network from DMZ zone, but at the same
time we want that internal network should be able to access DMZ servers)

Lab set up : Take a system with 3 lan cards & configure it as a router
eth0 ([Link]/24) connected to internal network
eth1 ([Link]/24 (assume)) connected to internet (public network)
eth2 ([Link]/24) connected to DMZ network (web server [Link]/24, mail server
[Link]/24, dns server at [Link])

# set the default policy to DROP

iptables -P INPUT DROP
iptables -P OUTPUT DROP
iptables -P FORWARD DROP

# to configure the system as a router, enable ip forwarding by

sysctl -w net.ipv4.ip_forward=1

# allow traffic from internal (eth0) to DMZ (eth2)

iptables -t filter -A FORWARD -i eth0 -o eth2 -m state –state NEW,ESTABLISHED,RELATED -j ACCEPT

iptables -t filter -A FORWARD -i eth2 -o eth0 -m state –state ESTABLISHED,RELATED -j ACCEPT

# allow traffic from internet (eth1) to DMZ (eth2)

iptables -t filter -A FORWARD -i eth1 -o eth2 -m state –state NEW,ESTABLISHED,RELATED -j ACCEPT

iptables -t filter -A FORWARD -i eth2 -o eth1 -m state –state ESTABLISHED,RELATED -j ACCEPT

#redirect incoming web requests at eth1 ([Link]) of FIREWALL to web server at [Link]
iptables -t nat -A PREROUTING -p tcp -i eth1 -d [Link] –dport 80 -j DNAT –to-dest [Link]
iptables -t nat -A PREROUTING -p tcp -i eth1 -d [Link] –dport 443 -j DNAT –to-dest [Link]

#redirect incoming mail (SMTP) requests at eth1 ([Link]) of FIREWALL to Mail server at
[Link]
iptables -t nat -A PREROUTING -p tcp -i eth1 -d [Link] –dport 25 -j DNAT –to-dest [Link]

#redirect incoming DNS requests at eth1 ([Link]) of FIREWALL to DNS server at [Link]
iptables -t nat -A PREROUTING -p udp -i eth1 -d [Link] –dport 53 -j DNAT –to-dest [Link]
iptables -t nat -A PREROUTING -p tcp -i eth1 -d [Link] –dport 53 -j DNAT –to-dest [Link]

Gateway IpTables – WAN / LAN / DMZ

Introduction:
Ce document vous présente la mise en place d’une passerelle afin de segmenter votre réseau
entre une zone démilitarisé (DMZ), une zone client (LAN), et votre connexion internet

(WAN). Mais avant la pratique, un peut de théorie

IpTables est un outil qui permet de configurer en ligne de commande le pare-feu Netfilter
présent dans le noyau linux à partir de la version 2.4.

omme vous pouvez le constater, il y a de nombreuses étapes à franchir. Un paquet peut être
arrêté dans n’importe quelle chaîne d’iptables, et même ailleurs s’il est malformé. Pourtant, il
est intéressant de se pencher sur le sort du paquet vu par iptables.

La chaîne INPUT est systématiquement parcourue par les paquets souhaitant atteindre les
processus locaux de la passerelle.

La chaîne OUTPUT est parcourue par les paquets sortant de la passerelle.

La chaîne FORWARD est systématiquement parcourue par les paquets qui sont redirigés, ils
n’atteindront jamais la couche applicative de la passerelle.

Pour être plus clair. Si un paquet atteignant la première décision de routage n’est pas destiné à
la machine locale, il sera orienté vers la chaîne FORWARD. En revanche, s’il est destiné à
une adresse IP que la machine écoute, ce paquet sera envoyé vers la chaîne INPUT, et donc à
la machine locale.

Il est important de remarquer que même si des paquets sont destinés à la machine locale, leur
adresse de destination peut être modifiée à l’intérieur de la chaîne PREROUTING par une
opération de NAT. En effet, puisque ceci a lieu avant la première décision de routage, le paquet
ne sera examiné qu’après un éventuel changement. A cause de cette particularité, le routage
peut être altéré avant que la décision de routage ne soit prise. Notez bien que tous les paquets
transiteront par l’un ou l’autre des chemins de ce dessin. Si vous réalisez du DNAT sur un
paquet pour le renvoyer sur le réseau duquel il provient, il continuera malgré tout sa route à
travers les chaînes restantes jusqu’à ce qu’il retourne sur le réseau externe.

Les tables:

La table FILTER : sert principalement à filtrer les paquets c’est la table que vous utiliserez
le plus. On peut établir une correspondance avec des paquets et les filtrer comme on le désire.
C’est l’endroit prévu pour intervenir sur les paquets et analyser leur contenu, c’est-à-dire les
détruire avec la cible DROP ( -j DROP) ou les accepter avec ACCEPT (-j
ACCEPT) suivant leur contenu. Bien entendu, il est possible de réaliser préalablement du
filtrage mais cette table a été spécialement conçue pour ça. Presque toutes les cibles sont
utilisables dans celle-ci. Vous savez maintenant que c’est l’emplacement idéal pour effectuer
votre filtrage principal.

La table NAT : devrait être utilisée seulement pour effectuer de la traduction d’adresse
réseau (NAT) sur différents paquets. Autrement dit, elle ne devrait servir qu’à traduire le
champ de l’adresse source d’un paquet ou celui de l’adresse destination. Précisons à nouveau
que seul le premier paquet d’un flux rencontrera cette chaîne. Ensuite, les autres paquets
subiront automatiquement le même sort que le premier. Voici les cibles actuelles capables
d’accomplir ce genre de choses :

 DNAT
 SNAT
 MASQUERADE
 REDIRECT

La cible DNAT est généralement utile dans le cas où vous détenez une adresse IP publique et
que vous désirez rediriger les accès vers un pare-feu localisé sur un autre hôte (par exemple,
dans une zone démilitarisée ou DMZ). Concrètement, on change l’adresse de destination du
paquet avant de le router à nouveau vers l’hôte désigné.

La cible SNAT est quant à elle employée pour changer l’adresse de source des paquets. La
plupart du temps, vous dissimulerez votre réseau local ou votre DMZ, etc. Un très bon exemple
serait donné par un pare-feu pour lequel l’adresse externe est connue, mais qui nécessite de
substituer les adresses IP du réseau local avec celle du pare-feu. Avec cette cible, le pare-feu
effectuera automatiquement sur les paquets du SNAT dans un sens et du SNAT inverse dans
l’autre, rendant possible les connexions d’un réseau local sur Internet. A titre d’exemple, si
votre réseau utilise la famille d’adresses [Link]/masque_réseau, les paquets envoyés sur
Internet ne reviendront jamais, parce que l’IANA (institut de régulation des adresses) a
considéré ce réseau (avec d’autres) comme privé, et a restreint son usage à des LAN isolés
d’Internet.

La cible MASQUERADE s’utilise exactement de la même façon que la cible SNAT, mais la
cible MASQUERADE demande un peu plus de ressources pour s’exécuter. L’explication
vient du fait que chaque fois qu’un paquet atteint la cible MASQUERADE, il vérifie
automatiquement l’adresse IP à utiliser, au lieu de se comporter comme la cible SNAT qui se
réfère simplement à l’unique adresse IP configurée. Par conséquent, la
cible MASQUERADE permet de faire fonctionner un système d’adressage IP dynamique
sous DHCP, que votre FAI devrait vous procurer pour des connexions à Internet de
type PPP, PPPoE ou SLIP.

La table MANGLE:

La table Mangle permet de découper, nos paquets avant qu’ils entrent dans la couche réseau,
afin que d’autres programmes de la couche Kernel puissent en faire quelque chose. Cette
technique va permettre de différencier les paquets, on va donc pouvoir privilégier certains
flux afin de garantir une optimisation de la bande passante, entendez bien là qu’on parle de
QoS.

Seul les cibles suivante sont valide dans la table Mangle :

 TOS
 TTL
 MARK
 SECMARK
 CONNSECMARK
La cible TOS permet de définir et/ou modifier le champ de Type de Service d’un paquet.
C’est utile pour définir des stratégies réseau concernant le choix de routage des paquets.
Sachez que, d’une part ceci n’a pas été perfectionné, d’autre part ce n’est pas vraiment
implémenté sur Internet car la majorité des routeurs ne se préoccupent pas de ce champ, et
quelquefois même, ils adoptent un comportement erroné. Bref, ne configurez pas ce champ
sur les paquets qui naviguent sur Internet, sauf si vous souhaitez leur appliquer des décisions
de routage, avec iproute2.

La cible TTL permet de modifier le champ durée de vie ou TTL (Time To Live) d’un paquet.
Il est possible par exemple de spécifier aux paquets d’avoir un champ TTL spécifique. Ceci
peut se justifier lorsque vous ne souhaitez pas être rejeté par certains Fournisseurs d’Accès à
Internet (FAI) trop indiscrets. En effet, il existe des FAI qui désapprouvent les utilisateurs
branchant plusieurs ordinateurs sur une même connexion, et de fait, quelques-uns de ces FAI
sont connus pour vérifier si un même hôte génère différentes valeurs TTL, supposant ainsi que
plusieurs machines sont branchées sur la même connexion.

La cible MARK permet d’associer des valeurs de marquage particulières aux paquets. Elles
peuvent ensuite être identifiées par les programmes iproute2 pour appliquer un routage
différent en fonction de l’existence ou de l’absence de telle ou telle marque. On peut ainsi
réaliser de la restriction de bande passante et de la gestion de priorité (Class Based Queuing).

La cible SECMARK peut être utilisée pour placer des marques dans un contexte de sécurité
sur des paquets dans SELinux ou tout autre système de sécurité capable de gérer ces marques.

Et enfin la cible CONNSECMARK sert à copier un contexte de sécurité vers ou depuis un

simple paquet ou vers une connexion complète. Elle est utilisée par SELinux ou autre système
de sécurité pour affiner cette sécurité au niveau connexion.

La machine d’état ou le Traçage de connexion:

Iptables permet de garder en mémoire les paquets qui lui passe sous le nez, afin de savoir si la
connexion à déjà était établie ou non. Les paquets peuvent êtres attribués à quatres états
différents :

 NEW :
 ESTABLISHED
 RELATED
 INVALID

L’intégralité du traçage de connexion est effectué par une structure particulière à l’intérieur du
noyau appelée conntrack. La structure conntrack peut soit être chargée comme un module,
soit être interne au noyau. Il faut donc bien vérifier si conntrack est disponible, et dans le cas
contraire le charger au début du script.

Le traçage de connexion est entièrement pris en charge dans la chaîne PREROUTING, sauf pour
les paquets générés en local, qui sont pris en charge dans la chaîne OUTPUT. Ceci signifie
qu’iptable effectue tous les calculs d’état dans la chaîne PREROUTING. Si on envoie le premier
paquet d’un flux, l’état est défini comme NEW dans la chaîne OUTPUT, et quand on reçoit un
paquet de réponse, l’état passe à ESTABLISHED, et ainsi de suite. Si le premier paquet n’est
pas envoyé par nous-mêmes, l’état NEW est naturellement défini dans la chaîne PREROUTING.
Ainsi, tous les changements d’état et calculs sont réalisés dans les
chaînes PREROUTING et OUTPUT de la table nat.

La syntaxe :
Avant d’attaquer le script, il faut comprendre comment écrire une règle iptables.

Syntaxe: iptables -t <table> -A <regles> -i <eth_entrée> -o <eth_sortie> -s <ip_source> -d

<ip_destination> -p <protocole> –dport <port> -j <cible>

Un exemple de règle:

iptables -t filter -A INPUT -i eth0 -s [Link]/24 -p icmp -j ACCEPT

On peut donc le traduire par : Dans la table Filter

Bon c’est l’heure de la pause café la non ?

Passons aux choses sérieuses place à la Pratique !

Commençons par nous mettre dans le contexte, le rôle de la passerelle sera de faire le lien
entre toutes les interfaces du réseau. Elle va redistribuer internet au deux sous-réseaux, et
filtrer les connexions.

On pourrait commencer par ce demander quel filtre appliquer ? Voici un exemple de ce qu’on
peut rechercher

 Renvoi d’internet dans le LAN et la DMZ

 Possibilité de ping la passerelle du LAN et de la DMZ mais pas d’internet
 Autoriser que quelques ports bien précis du Lan vers la DMZ
 Renvois du port 80 vers la DMZ pour les nouvelles connexions venant d’internet (en
cas d’hébergement Web)
 Autoriser le SSH à partir d’une ip / interface bien précise.
Passons au script :

#!/bin/sh
# Script "[Link]"
# Fichier contenant les règles de filtrage "iptables"

DMZ=eth0
WAN=eth3
LAN=eth1

_stop(){
# REMISE à ZERO des règles de filtrage
iptables -F
iptables -X
iptables -t nat -F
iptables -t nat -X
iptables -P INPUT ACCEPT
 iptables -P FORWARD ACCEPT
iptables -P OUTPUT ACCEPT

echo "0" &gt; /proc/sys/net/ipv4/ip_forward

echo "--------- Firewall désactivé ----------"

#exit
}

_start(){
###################################### INITIALISATION
#################################
#Chargement des modules
echo " + Initialisation des modules"
modprobe ip_conntrack_ftp
modprobe ip_nat_ftp
modprobe ip_conntrack_irc
modprobe ip_conntrack
modprobe iptable_nat
modprobe iptable_filter

# Initialise la table Filter (par defaut tout les echanges sont refuses)
echo " + Initialisation de la table Filter"
iptables -t filter -F
iptables -t filter -X
iptables -t filter -P INPUT DROP
iptables -t filter -P FORWARD DROP
iptables -t filter -P OUTPUT DROP

# Initialise la table NAT (par defaut tout les echanges sont actives)
echo " + Initialisation de la table NAT"
iptables -t nat -F
iptables -t nat -X
iptables -t nat -P PREROUTING ACCEPT
iptables -t nat -P OUTPUT ACCEPT
iptables -t nat -P POSTROUTING ACCEPT

# Initialise la table Mangle (par defaut tout les echanges sont actives)
echo " + Initialisation de la table MANGLE"
iptables -t mangle -F
iptables -t mangle -X
iptables -t mangle -P PREROUTING ACCEPT
iptables -t mangle -P INPUT ACCEPT
iptables -t mangle -P FORWARD ACCEPT
iptables -t mangle -P OUTPUT ACCEPT
iptables -t mangle -P POSTROUTING ACCEPT

###################################### LoopBack
#######################################

iptables -t filter -A OUTPUT -o lo -s [Link]/8 -d [Link]/8 -j

ACCEPT
iptables -t filter -A INPUT -i lo -s [Link]/8 -d [Link]/8 -j
ACCEPT

###################################### ICMP / PING

#####################################
# CLIENT
iptables -t filter -A INPUT -i $LAN -s [Link]/24 -p icmp -j
ACCEPT
 iptables -t filter -A OUTPUT -o $LAN -d [Link]/24 -p icmp -j
ACCEPT
## DMZ
iptables -t filter -A INPUT -i $DMZ -s [Link]/24 -p icmp -j
ACCEPT
iptables -t filter -A OUTPUT -o $DMZ -d [Link]/24 -p icmp -j
ACCEPT

####################################### SSH
##########################################

iptables -t filter -A INPUT -p tcp --dport 22 -j ACCEPT

iptables -t filter -A OUTPUT -p tcp --sport 22 -j ACCEPT

#################################### PARTAGE CONNEXION

###############################

##Activation du routage
echo "1" &gt; /proc/sys/net/ipv4/ip_forward

## Masquerading
iptables -t nat -A POSTROUTING -s [Link]/24 -o $WAN -j
MASQUERADE
iptables -t nat -A POSTROUTING -s [Link]/24 -o $WAN -j
MASQUERADE

## FORWARD du port 80
iptables -A FORWARD -i $WAN -p tcp --dport 80 -j ACCEPT

###########################################################################
###########
# REGLES GENERAL CLIENT
#
###########################################################################
###########

#Garde les connexions actives vers l'exterieur

iptables -A FORWARD -i $WAN -o $LAN -s [Link]/0 -d
[Link]/24 -m state \\
--state RELATED,ESTABLISHED -j ACCEPT
#Autorise la création de nouvelles connexions vers l'exterieur
iptables -A FORWARD -i $LAN -o $WAN -s [Link]/24 -d
[Link]/0 -m state \\
--state NEW,RELATED,ESTABLISHED -j ACCEPT

###########################################################################
###########
# REGLES GENERAL DMZ
#
###########################################################################
###########

###### DMZ EXT ######

#Garde les connexions actives vers l'exterieur depuis la DMZ
iptables -A FORWARD -i $WAN -o $DMZ -s [Link]/0 -d
[Link]/24 -m state \\
--state RELATED,ESTABLISHED -j ACCEPT

#Autorise la création de nouvelles connexions vers l'exterieur depuis DMZ

iptables -A FORWARD -i $DMZ -o $WAN -s [Link]/24 -d
[Link]/0 -m state \\
 --state NEW,RELATED,ESTABLISHED -j ACCEPT

##### DMZ CLIENT #####

#Autorise le transfert entre client &gt; DMZ
iptables -A FORWARD -i $LAN -o $DMZ -s [Link]/24 -d
[Link]/24 -j ACC
EPT
iptables -A FORWARD -i $DMZ -o $LAN -s [Link]/24 -d
[Link]/24 -j ACC
EPT

# iptables -t nat -A INPUT -i $DMZ -s [Link]/24 -d

[Link]/24 -p tcp --
dport 80 -j ACCEPT
# iptables -t nat -A OUTPUT -o $LAN -s [Link]/24 -d
[Link]/24 -p tcp -
-sport 80 -j ACCEPT

echo "--------- Firewall activé ----------"

exit
}

case "$1" in
start)
_start
;;
stop)
_stop
;;
restart)
_stop
_start
;;
*)
echo "Usage: {start|stop|restart}"
exit 1
esac

Voila qui est fait j’espère qu’il ne vous a pas fait trop peur, vous allez voir c’est assez
simple. Commençons par le décortiquer :

#!/bin/sh
# Script "[Link]"
# Fichier contenant les règles de filtrage "iptables"

DMZ=eth0
WAN=eth3
LAN=eth1

_stop(){
# REMISE à ZERO des règles de filtrage
iptables -F
iptables -X
iptables -t nat -F
iptables -t nat -X
iptables -P INPUT ACCEPT
iptables -P FORWARD ACCEPT
iptables -P OUTPUT ACCEPT
 echo "0" &gt; /proc/sys/net/ipv4/ip_forward

echo "--------- Firewall désactivé ----------"

#exit
}

Nous commençons par déclarer les variables, je ne peux que vous inviter à rentrer un
maximum de variable afin de ne pas devoir refaire votre script à chaque modification
d’interface ou de plage-IP.
Dans la section _stop() nous déclarons les commandes de réinitialisation d’Iptables, elles
vident les règles et remette les règles par défaut sur ACCEPT, on désactive par la même
occasion le routage.

_start(){
###################################### INITIALISATION
#################################
#Chargement des modules
echo " + Initialisation des modules"
modprobe ip_conntrack_ftp
modprobe ip_nat_ftp
modprobe ip_conntrack_irc
modprobe ip_conntrack
modprobe iptable_nat
modprobe iptable_filter

# Initialise la table Filter (par defaut tout les echanges sont refuses)
echo " + Initialisation de la table Filter"
iptables -t filter -F
iptables -t filter -X
iptables -t filter -P INPUT DROP
iptables -t filter -P FORWARD DROP
iptables -t filter -P OUTPUT DROP

# Initialise la table NAT (par defaut tout les echanges sont actives)
echo " + Initialisation de la table NAT"
iptables -t nat -F
iptables -t nat -X
iptables -t nat -P PREROUTING ACCEPT
iptables -t nat -P OUTPUT ACCEPT
iptables -t nat -P POSTROUTING ACCEPT

# Initialise la table Mangle (par defaut tout les echanges sont actives)
echo " + Initialisation de la table MANGLE"
iptables -t mangle -F
iptables -t mangle -X
iptables -t mangle -P PREROUTING ACCEPT
iptables -t mangle -P INPUT ACCEPT
iptables -t mangle -P FORWARD ACCEPT
iptables -t mangle -P OUTPUT ACCEPT
iptables -t mangle -P POSTROUTING ACCEPT

Les choses intéressante arrivent, le script s’exécute verticalement, c’est a dire qu’Iptables va
appliquer les règles dans le sens de lecture de haut en bas, nous commençons par initialiser les
règles afin d’être sur qu’il n’y ait pas de vielles règles qui traînent dans le cas d’une nouvelle
exécution du script alors que des règles seraient déjà appliqués.
Puis on attribue la règle DROP par défaut sur les tables INPUT, FORWARD, OUTPUT

iptables -t filter -P INPUT DROP

iptables -t filter -P FORWARD DROP
iptables -t filter -P OUTPUT DROP

A ce stade là, pour votre passerelle c’est comme si elle n’a plus aucun câble de branché …
même un ping localhost ne passe plus :p Essayez !!

On va donc commencer par autoriser la passerelle à pouvoir communiquer avec son interface
Loopback (lo):

###################################### LoopBack
#######################################

iptables -t filter -A OUTPUT -o lo -s [Link]/8 -d [Link]/8 -j

ACCEPT
iptables -t filter -A INPUT -i lo -s [Link]/8 -d [Link]/8 -j
ACCEPT

Pour ne pas vous couper la connexion ssh il ne faut pas oublier d’ajouter dès le début une
règle autorisant les flux SSH.

####################################### SSH
##########################################

iptables -t filter -A INPUT -p tcp --dport 22 -j ACCEPT

iptables -t filter -A OUTPUT -p tcp --sport 22 -j ACCEPT

A partir de là, vous devez normalement pouvoir ping votre propre interface, et établir une
connexion SSH vers votre passerelle.

Le partage de la connexion :
Nous allons indiquer au noyau qu’on veut activer le routage de packets :

##Activation du routage
echo "1" &gt; /proc/sys/net/ipv4/ip_forward

Puis le Masquerading afin que la passerelle cache le reste du réseau. Pour l’éxterieur toutes
les requettes proviendrons de la passerelle.

## Masquerading
iptables -t nat -A POSTROUTING -s [Link]/24 -o $WAN -j
MASQUERADE
iptables -t nat -A POSTROUTING -s [Link]/24 -o $WAN -j
MASQUERADE

Il n’y a plus qu’a autoriser le FORWARD du port 80 et votre passerelle sera en mesure de
renvoyer internet vers vos réseaux.

iptables -A FORWARD -i $WAN -p tcp --dport 80 -j ACCEPT

Le réseau CLIENT :
Nous souhaitons que le réseau Client soit joignable de l’extérieur uniquement si la connexion
a déjà été établie, et nous souhaitons que le réseau client puisse établir de nouvelles
connexions vers l’extérieur.

###########################################################################
###########
# REGLES GENERAL CLIENT
#
###########################################################################
###########

#Garde les connexions actives vers l’extérieur

iptables -A FORWARD -i $WAN -o $LAN -s [Link]/0 -d
[Link]/24 -m state \\
--state RELATED,ESTABLISHED -j ACCEPT
#Autorise la création de nouvelles connexions vers l'exterieur
iptables -A FORWARD -i $LAN -o $WAN -s [Link]/24 -d
[Link]/0 -m state \\
--state NEW,RELATED,ESTABLISHED -j ACCEPT

En français :
Pour le FORWARD, ce qui rentre par $WAN, sort par $LAN, provenant de l’adresse ip
[Link]/0 (ALL) à destination du réseau [Link]/24 J’autorise les connexion déjà établie
ou en cour d’établissement.

Pour le FORWARD, ce qui rentre par $LAN, sort par $WAN, provenant de l’adresse ip
[Link]/24 à destination du réseau [Link]/0, j’autorise les nouvelles connexions, les
connexions déjà établies ou en cours d’établissements.

Voila, j'ai un soucis, j'essaie de réaliser un firewall sous Ubuntu avec les iptables. Mon réseau est
constitué d'une DMZ(eth4) et d'un LAN(eth5) le tout fournit par WAN(eth3)
Cependant j'ai un problème que je n'arrive pas à résoudre.

ifconfig (sur ubuntu firewall) :

eth3 ==> [Link]
eth4 ==> [Link]
eth5 ==> [Link]

#!/bin/sh
# script /etc/[Link]

## We put the firewall to inital settings

iptables -F #Flush Vide la chaîne sélectionnée (ou toutes les chaînes de la
table si aucune n'est précisée). Ceci équivaut à effacer toutes les règles
une par une.
iptables -X # Delete Chain /Efface la chaîne désignée définie par
l'utilisateur. Il ne doit plus exister de référence à cette chaîne. S'il en
reste, vous devez effacer ou remplacer les règles concernées avant de
pouvoir effacer cette chaîne. Si aucun argument n'est fourni, une tentative
aura lieu pour effacer dans la table toutes les chaînes non prédéfinies.
iptables -Z # -zero [chaîne] Met à zéro le compteur de paquets et d'octets
dans toutes les chaînes. Il est autorisé d'associer l'option -L, --list
(liste), pour visualiser les compteurs juste avant qu'ils ne soient
initialisés (voir ci-dessus).
iptables -t nat -F # New table connexions

# Put the rules to "DROP" everythings

iptables -P INPUT DROP
iptables -P OUTPUT DROP
iptables -P FORWARD DROP

# we need proxy arp for the dmz network

echo 1 > /proc/sys/net/ipv4/conf/eth3/proxy_arp
echo 1 > /proc/sys/net/ipv4/conf/eth4/proxy_arp

iptables -A FORWARD -m state --state RELATED,ESTABLISHED -j ACCEPT

iptables -A INPUT -i eth3 -p tcp -j ACCEPT
iptables -A OUTPUT -d eth3 -p tcp -j ACCEPT

#limit ICMP packet to 10/sec on the eth0 (WAN)

iptables -A INPUT -i [Link] -p icmp -m limit --limit 10/second -j
ACCEPT
iptables -A INPUT -i [Link] -p icmp -j DROP

# We authorise eth2 to create all new connexion to everywhere

iptables -t nat -A PREROUTING -d [Link] -j ACCEPT

# We authorize the super user to use telnet (port 23)

iptables -A INPUT -s [Link] -p tcp --dport 23 -j ACCEPT
iptables -A OUTPUT -d [Link] -p tcp --sport 23 -j ACCEPT

# For avoid IP Spoofing

# No Lan ip ([Link]/24) or DMZ IP ([Link]/24) can enter from eth0
(WAN)
# Because all the parc of client and all servers can't come from the
internet,
# it will mean that someone have take the same IP than our network
iptables -A INPUT -i [Link] -d [Link]/24 -j DROP
iptables -A INPUT -i [Link] -d [Link]/24 -j DROP

# No Lan ip ([Link]/24) can enter from eth1 (DMZ)

# Every Lan Ip are in [Link]/24 and can not come from the DMZ parc
# It will mean that someone try to stole the identity of our LAN
iptables -A INPUT -s [Link] -d [Link]/24 -j DROP

# LAN-DMZ
# IMPORTANT:
# For the firewall works, it must have the foward actived !!!!!
# So we active this option for the IPv4 :
echo 1 > /proc/sys/net/ipv4/ip_forward

# We authorize the DMZ to go out our network

iptables -t nat -A POSTROUTING -o eth1 -j ACCEPT
# authorization to execute a ping command in our network (DMZ to LAN and
LAN to DMZ)
#iptables -A FORWARD -s [Link]/24 -d [Link]/24 -p icmp -j ACCEPT
iptables -A FORWARD -s [Link]/24 -d [Link]/24 -p icmp -j ACCEPT
# Authorization to realize WWW tranfert with the protocol HTTP between DMZ
and LAN
# For security reason, only the LAN can create new request to the DMZ
iptables -A FORWARD -p tcp -s [Link] -d [Link] -m state --state
NEW,ESTABLISHED,RELATED --dport 80 -j ACCEPT
iptables -A FORWARD -p tcp -s [Link] -d [Link] -m state --state
ESTABLISHED,RELATED --sport 80 -j ACCEPT
# Authorization to realize WWW tranfert with the protocol HTTPS between DMZ
and LAN
# For security reason, only the LAN can create new request to the DMZ
iptables -A FORWARD -p tcp -s [Link] -d [Link] -m state --state
NEW,ESTABLISHED,RELATED --dport 443 -j ACCEPT
iptables -A FORWARD -p tcp -s [Link] -d [Link] -m state --state
ESTABLISHED,RELATED --sport 443 -j ACCEPT
# Authorization to realize MAIL tranfert with the protocol IMAP between DMZ
and LAN
# For security reason, only the LAN can create new request to the DMZ
iptables -A FORWARD -p tcp -s [Link] -d [Link] -m state --state
NEW,ESTABLISHED,RELATED --dport 220 -j ACCEPT
iptables -A FORWARD -p tcp -s [Link] -d [Link] -m state --state
ESTABLISHED,RELATED --sport 220 -j ACCEPT
# Authorization to realize MAIL tranfert with the protocol POP3 between DMZ
and LAN
# For security reason, only the LAN can create new request to the DMZ
iptables -A FORWARD -p tcp -s [Link] -d [Link] -m state --state
NEW,ESTABLISHED,RELATED --dport 110 -j ACCEPT
iptables -A FORWARD -p tcp -s [Link] -d [Link] -m state --state
ESTABLISHED,RELATED --sport 110 -j ACCEPT
# Authorization to realize MAIL tranfert with the protocol SMTP between DMZ
and LAN
# For security reason, only the LAN can create new request to the DMZ
iptables -A FORWARD -p tcp -s [Link] -d [Link] -m state --state
NEW,ESTABLISHED,RELATED --dport 25 -j ACCEPT
iptables -A FORWARD -p tcp -s [Link] -d [Link] -m state --state
ESTABLISHED,RELATED --sport 25 -j ACCEPT
# Permitir al equipo del administrador acceso total a la DMZ.
# Total authorization for the administrator between the DMZ and HIM
# For security reason, only the administrator can create new request to the
DMZ
iptables -A FORWARD -s [Link] -d [Link]/24 -j ACCEPT
iptables -A FORWARD -s [Link]/24 -d [Link] -m state --state
ESTABLISHED,RELATED -j ACCEPT

## 3. Conexiones WAN-DMZ
# Every WAN connextion which try to entre in the networks without the
server address but with special port (80; 443; 25) are routing to the DMZ
# 3 possibility, for the port 80 and 443 the request are routing to the web
server
# and if the port is 25 the request are routing to the MAIL sever
iptables -t NAT -A PREROUTING -i eth0 -p tcp –dport 80 -j DNAT –to-
destination [Link]:80
iptables -t NAT -A PREROUTING -i eth0 -p tcp –dport 443 -j DNAT –to-
destination [Link]:443
iptables -t NAT -A PREROUTING -i eth0 -p udp –dport 25 -j DNAT –to-
destination [Link]:25

# Authorize the WAN connexion with the DMZ

# For WWW request (HTTP)
iptables -A FORWARD -p tcp --dport 80 -i [Link] -d [Link] -j
ACCEPT
iptables -A FORWARD -p tcp --sport 80 -s [Link] -o [Link] -j
ACCEPT
# For WWW request (HTTPS)
iptables -A FORWARD -p tcp --dport 443 -i [Link] -d [Link] -j
ACCEPT
iptables -A FORWARD -p tcp --sport 443 -s [Link] -o [Link] -j
ACCEPT

# For WWW request (HTTPS)

iptables -A FORWARD -p tcp --dport 25 -i [Link] -d [Link] -j
ACCEPT
iptables -A FORWARD -p tcp --sport 25 -s [Link] -o [Link] -j
ACCEPT

## 4. Conexiones WAN-LAN
# For security reason, we need to hide LAN IP from the world
# When the LAN when go to the WAN, the firewall will change the LAN ip to
eth 0
# Like that, if on hacker want try to look the LAN IP. He will see only the
public Firewall IP
#toutes les adresses du lan son changées par celle de ETH0 du FW (sécurité)
iptables -t nat -A POSTROUTING -s [Link]/24 -o eth0 -j MASQUERADE

# Authorize the LAN to go to WAN and the WAN to reply

# For security reason, only the LAN can create new request, the WAN can
only reply
iptables -A FORWARD -p tcp -s [Link]/24 -d [Link] -m state --
state NEW,ESTABLISHED,RELATED --dport 80 -j ACCEPT
iptables -A FORWARD -p tcp -s [Link] -d [Link]/24 -m state --
state ESTABLISHED,RELATED --sport 80 -j ACCEPT
iptables -A FORWARD -p tcp -s [Link]/24 -d [Link] -m state --
state NEW,ESTABLISHED,RELATED --dport 443 -j ACCEPT
iptables -A FORWARD -p tcp -s [Link] -d [Link]/24 -m state --
state ESTABLISHED,RELATED --sport 443 -j ACCEPT

# Authorization for the administrator to do all what he want !!!!! He is

the boss !!!!!
# For security reason, the Wan can only reply.
iptables -A FORWARD -s [Link] -o [Link] -j ACCEPT
iptables -A FORWARD -i [Link] -d [Link] -m state --state
ESTABLISHED,RELATED -j ACCEPT

I – Contexte :
II – Configuration IP des postes :

Serveur WEB Serveur 2012 Client Windows 7

IP : [Link]
IP : [Link] IP : 192.168.1.X (DHCP)
Passerelle : [Link]
Passerelle : [Link] Passerelle : [Link]
DNS : [Link]
DNS : [Link] DNS : [Link]
Nom DNS : [Link]

III – Objectifs :

On va tout d’abord paramétrer la DMZ pour filtrer les trames qui entre et qui sortent dans les
différents réseaux (WEB et LAN)

On va donc dresser un tableau de filtrage qui représente les autorisations de la DMZ :

(Les chiffres représentés sont ceux du contexte) ; « » signifie « parle à »

Dialogue autorisé Dialogue interdit

12

13

14 21

23 31

32 24

41 34

42

43

IV – Pourquoi effectuer un filtrage sur la zone DMZ ?

Le filtrage va nous servir à protéger le serveur Web des intrusions tout en le rendant
accessible pour ses fonctions principales (Visionner le contenu de la page HTML du serveur,
accès à la base de données).

V – Configuration du filtrage:

Tout d’abord il faut vérifier la situation initiale, pour ce faire il faut réalise un ping vers
l’extérieur et dans le réseau local. Si les deux répondent c’est que la configuration est
correcte.

Les commandes à réaliser dans le terminal :

1. ping [Link]
2. ping [Link]

Etape 1 – Supprimer tout filtrage existant sur notre routeur Debian :

Pourquoi ? Pour partir sur une base saine ou l’on pourra tout choisir a notre guise.

1. iptables -F

Test : pour tester les modifications il va falloir afficher le contenu de la table, si cette dernière
est vide, la commande a réussi.

1. iptables -L

Etape 2 – Mettre en place la politique par défaut qui consiste à tout bloquer sauf sorties
du routeur URANUS.

On bloque toutes trames traversant le routeur:

 1. iptables -P FORWARD DROP

On bloque toutes trames entrant dans le routeur:

1. iptables -P INPUT DROP

On accepte les trames sortant du routeur:

1. iptables -P OUTPUT ACCEPT

Test : réaliser un ping vers l’extérieur et dans le réseau local. Si les deux ne répondent pas
c’est que la politique par défaut a bien été appliquée.

1. ping [Link]
2. ping [Link]

Etape 3 – Autoriser le Trafic établi

Le trafic établi est la réponse aux trames déjà existantes, il est important de l’autoriser.

Accepter les trames établies pour toutes trames traversant, entrant ou sortant du routeur :

1. iptables -A FORWARD -m state --state ESTABLISHED -j ACCEPT

2. iptables -A INPUT -m state --state ESTABLISHED -j ACCEPT
3. iptables -A OUTPUT -m state --state ESTABLISHED -j ACCEPT

Etape 4 – Nouvelle règle : le LAN parle vers la DMZ et le LAN parle vers le WAN

L’objectif est d’autoriser toutes les trames sortant du LAN afin qu’elles puissent
communiquer avec toutes les zones de notre situation initiale.

Accepter les trames traversant le routeur en provenance d’eth0 (LAN) :

1. iptables -A FORWARD -i eth0 -j ACCEPT

Test :

Réaliser un ping sur le poste client Windows 7 en direction d’internet et de la DMZ, ceux-là
doivent fonctionner.

1. ping [Link]
2. ping [Link]

Etape 5 – Règle : le LAN parle au routeur

Le but est d’autoriser le dialogue avec le routeur. (ex : administration du routeur)

Accepter les trames en entrée du LAN vers le routeur :

1. iptables -A INPUT -i eth0 -j ACCEPT

Test: réaliser un un ping vers le routeur URANUS depuis le poste client Windows 7, ce
dernier doit répondre à votre ping.

1. ping [Link]

Etape 6 – Règle : la DMZ parle vers le WAN

Quand le serveur web aura besoin d’aller sur internet il pourra envoyer des paquets sur ce
dernier, ce qui n’était pas possible auparavant.

Accepter les trames en sortie du DMZ en direction du WAN (internet) :

1. iptables -A FORWARD -i eth2 -o eth1 -j ACCEPT

Test : Réaliser un ping vers internet depuis le serveur web dans la DMZ.

1. ping [Link]

Etape 7 – Règle : Autoriser les trames du WAN vers le Serveur WEB

Quand le serveur web envoie des paquets il faut que le destinataire lui réponde, c’est pour cela
qu’il est important que ce paramètre soit ajouté au script.

Autoriser les trames traversant du WAN vers la DMZ ayant comme port 80 pour aller en
direction du serveur web :

1. iptables -A FORWARD -i eth1 -o eth2 -d [Link] -p tcp --dport 80 -j ACCEPT

Etape 8 – Règle : Autoriser l’accès au serveur DNS depuis le serveur WEB

Cela permettra au serveur web de pouvoir bénéficier de la résolution de noms proposée par le
serveur 2012.

Filtrer et accepter toutes les trames traversant de la DMZ vers le LAN ayant comme port 53
via le protocole UDP ayant pour destination le serveur 2012 pour une résolution de nom
(DNS) :

1. iptables -t filter -A FORWARD -i eth2 -o eth0 -d [Link] -p udp --dport 53 -j ACCEPT

Ensuite il faut bien sûr ajouter le serveur DNS dans la configuration IP de votre poste Debian
(Voir documentation : configuration IP d’un poste Debian)

Une fois que tout cela est fait il faut savoir si le serveur DNS a bien accroché à votre serveur
web.

1. nslookup
2.
3. # écran va afficher via quel serveur Debian passe. Dans mon cas il s’agit d’[Link] (nom
du serveur 2012)
Etape 9 – Règle : Autoriser l’accès en consultation au serveur web depuis l’extérieur

Cela consiste à rediriger les trames adressées à l’IP publique du réseau vers le serveur web.
Cela permettra à l’avenir d’avoir accès à la page web du serveur web depuis l’extérieur.

Accorder l’adresse IP publique du routeur Uranus pour un accès externe à la page publique du
serveur WEB. L’accès se fera comme cela ([Link] :

1. iptables –t nat –A PREROUTING –i eth1 –p tcp --dport 80 –j DNAT --to-destination

[Link]

Test : se rendre sur une machine à l’extérieur du groupement de réseau et entrer dans la barre
d’adresse l’adresse IP de la broche eth1 (comprendre adresse IP publique). Et vous devriez
voir la page par défaut de votre serveur web (apache /var/www/[Link]).

It works!

This is the default web page for this server.

The web server software is running but no content has been added, yet.

VI – Sauvegarder la configuration d’iptables :

Toutes les lignes que nous avons rentré dans la partie V sont éphémères, c’est-à-dire qu’après
un redémarrage de votre routeur Debian elles ne prennent plus effet, il est donc préférable de
sauvegarder la configuration d’iptables grâce au paquet iptables-persistent

1. apt install iptables-persistent

Il suffit d’enregistrer les règles IPv4 dynamique :

BONUS – Création du fichier script de filtrage

Etape 1 – Création du fichier et du dossier

Créer un dossier « scripts » :

1. mkdir /root/scripts

Création du fichier « script_filtrage » :

1. nano /root/scripts/scripts_filtrage

Etape 2 – rendre le fichier note en un script

Sur Windows la création d’un script se passe par le biais de la surcouche « bloc-notes » et
après on le sauvegarde au format « .bat ». Sur linux c’est formellement la même chose sauf
que bloc-notes se surnomme « nano » nous sommes à l’intérieur à présent, il suffit d’y ajouter
une première ligne qui définira le type de fichier, dans notre cas nous voulons un script (donc
il s’agit d’un « .sh »).

A insérer au début du script :

1. # !/bin/sh

Etape 3 – insertion de lignes présentées dans la partie V

(PS : les « # » représentent les lignes de commentaires, elles ne sont pas obligatoires mais
vous aide à comprendre votre script)

1. # !/bin/sh
2. # supprimer le filtrage
3. iptables -F
4. # politique par defaut: on bloque tout sauf output
5. iptables -P FORWARD DROP
6. iptables -P INPUT DROP
7. iptables -P OUTPUT ACCEPT
8. # trafic etabli autorise
9. iptables -A FORWARD -m state --state ESTABLISHED -j ACCEPT
10. iptables -A INPUT -m state --state ESTABLISHED -j ACCEPT
11. iptables -A OUTPUT -m state --state ESTABLISHED -j ACCEPT
12. # le LAN parle vers la DMZ et le LAN parle vers le WAN
13. iptables -A FORWARD -i eth0 -j ACCEPT
14. # le LAN parle au routeur
15. iptables -A INPUT -i eth0 -j ACCEPT
16. # la DMZ parle vers le WAN
17. iptables -A FORWARD -i eth2 -o eth1 -j ACCEPT
18. # redirection ip-pub/serveur web
19. iptables -t nat -A PREROUTING -i eth1 -p tcp --dport 80 -j DNAT --to-destination
[Link]
20. # autorise les trames rediriges du WAN vers le serveur web
21. iptables -A FORWARD -i eth1 -o eth2 -d [Link] -p tcp --dport 80 -j ACCEPT
22. # Acces au DNS depuis le serveur WEB
23. iptables –t filter –A FORWARD –i eth2 –o eth0 –d [Link] –p udp --dport 53 –j ACCEPT

Il est entièrement possible d’appeler ce script au démarrage du poste par exemple.

Linux Firewall – DMZ example
Here is the example of advanced iptables firewall, which you can use for DMZ network
structure. They use usualy DMZ, cause it’s necessary to isolate some external servers like
mail, web, dns and prevent them from being compromised. In this example I have Ubuntu
Server 10.04 installed on server with three network interfaces. This server is in a gateway role
and also has squid proxy server installed and being used as the proxy for internal network
clients. One mail server is connected directly to the DMZ interface with crossover patchcord,
however you can connect a switch there and, as a result, you can connect more servers to this
DMZ network.

Let’s start text editor and write our firewall script:

# nano /etc/network/if-up.d/[Link]

Then write the next:

#!/bin/sh

lan_ip="[Link]"
lan_if="eth0"
wan_ip="[Link]"
wan_if="eth1"
dmz_ip="[Link]"
dmz_if="eth2"
lo_if="lo"
lo_ip="[Link]"

dc="[Link]"
db="[Link]"
itchief="[Link]"
mail="[Link]"

IPTABLES="/sbin/iptables"

# Module loading

/sbin/depmod -a
/sbin/modprobe ip_tables
/sbin/modprobe ip_conntrack
/sbin/modprobe iptable_filter
/sbin/modprobe iptable_mangle
/sbin/modprobe iptable_nat
/sbin/modprobe ipt_LOG
/sbin/modprobe ipt_limit
/sbin/modprobe ipt_state

# Enable Forwarding

echo "1" &gt; /proc/sys/net/ipv4/ip_forward

# Syn Flood Protection

echo "1" &gt; /proc/sys/net/ipv4/tcp_syncookies

# Flush it before start

$IPTABLES -F
$IPTABLES -X
$IPTABLES -t nat -F

# Set policies

$IPTABLES -P INPUT DROP

$IPTABLES -P OUTPUT ACCEPT
$IPTABLES -P FORWARD DROP

############## INPUT chain ################

# Bad TCP packets we don't want

$IPTABLES -A INPUT -p tcp --tcp-flags SYN,ACK SYN,ACK -m state --state NEW

-j REJECT --reject-with tcp-reset
$IPTABLES -A INPUT -p tcp ! --syn -m state --state NEW -j DROP

# Loopback

$IPTABLES -A INPUT -p ALL -i $lo_if -s $lo_ip -j ACCEPT

$IPTABLES -A INPUT -p ALL -i $lo_if -s $lan_ip -j ACCEPT
$IPTABLES -A INPUT -p ALL -i $lo_if -s $wan_ip -j ACCEPT
$IPTABLES -A INPUT -p ALL -i $lo_if -s $dmz_ip -j ACCEPT

# Rules for LAN

$IPTABLES -A INPUT -p TCP -i $lan_if --dport 80 -j ACCEPT

$IPTABLES -A INPUT -p TCP -i $lan_if --dport 22 -j ACCEPT
$IPTABLES -A INPUT -p TCP -i $lan_if --dport 3128 -j ACCEPT
$IPTABLES -A INPUT -p ICMP -i $lan_if -j ACCEPT

# Rules for DMZ

$IPTABLES -A INPUT -p TCP -i $dmz_if --dport 53 -j ACCEPT

$IPTABLES -A INPUT -p UDP -i $dmz_if --dport 53 -j ACCEPT
$IPTABLES -A INPUT -p TCP -i $dmz_if --sport 53 -j ACCEPT
$IPTABLES -A INPUT -p UDP -i $dmz_if --sport 53 -j ACCEPT
$IPTABLES -A INPUT -p UDP -i $dmz_if --dport 123 -j ACCEPT
$IPTABLES -A INPUT -p ICMP -i $dmz_if --icmp-type echo-request -j ACCEPT
$IPTABLES -A INPUT -p ALL -d $dmz_ip -m state --state ESTABLISHED,RELATED -
j ACCEPT

# Rules for WAN

$IPTABLES -A INPUT -p ICMP -i $wan_if --icmp-type echo-request -j ACCEPT

$IPTABLES -A INPUT -p ALL -d $wan_ip -m state --state ESTABLISHED,RELATED -
j ACCEPT
$IPTABLES -A INPUT -p TCP -i $wan_if -s $itchief_home --dport 22 -j ACCEPT

# Log weird packets that don't match the above.

$IPTABLES -A INPUT -m limit --limit 3/minute --limit-burst 3 -j LOG --log-

level info --log-prefix "IPTABLES INPUT blocked: "

############### FORWARD chain ################

# Bad TCP packets we don't want

$IPTABLES -A FORWARD -p tcp --tcp-flags SYN,ACK SYN,ACK -m state --state

NEW -j REJECT --reject-with tcp-reset
$IPTABLES -A FORWARD -p tcp ! --syn -m state --state NEW -j DROP

# Rules for LAN

$IPTABLES -A FORWARD -p ICMP -i $lan_if -j ACCEPT

$IPTABLES -A FORWARD -p ALL -i $lan_if -o $lan_if -j ACCEPT
$IPTABLES -A FORWARD -p TCP -i $lan_if -o $dmz_if --dport 110 -j ACCEPT
$IPTABLES -A FORWARD -p TCP -i $lan_if -o $dmz_if --dport 143 -j ACCEPT
$IPTABLES -A FORWARD -p TCP -i $lan_if -o $dmz_if --dport 25 -j ACCEPT
$IPTABLES -A FORWARD -p TCP -i $lan_if -o $dmz_if --dport 80 -j ACCEPT
$IPTABLES -A FORWARD -p TCP -i $lan_if -o $dmz_if --dport 22 -j ACCEPT
$IPTABLES -A FORWARD -p TCP -i $lan_if -o $dmz_if --dport 53 -j ACCEPT
$IPTABLES -A FORWARD -p UDP -i $lan_if -o $dmz_if --dport 53 -j ACCEPT
$IPTABLES -A FORWARD -p ICMP -i $lan_if -o $dmz_if -j ACCEPT
$IPTABLES -A FORWARD -m state --state ESTABLISHED,RELATED -j ACCEPT
$IPTABLES -A FORWARD -p TCP -i $lan_if --dport 5190 -j ACCEPT
$IPTABLES -A FORWARD -p ALL -s $itchief -i $lan_if -j ACCEPT
$IPTABLES -A FORWARD -p UDP -s $dc -i $lan_if --dport 123 -j ACCEPT

# Rules for DMZ

$IPTABLES -A FORWARD -p ALL -i $dmz_if -o $wan_if -j ACCEPT

$IPTABLES -A FORWARD -p UDP -i $dmz_if -o $lan_if -s $mail --dport 123 -j
ACCEPT
$IPTABLES -A FORWARD -p TCP -i $dmz_if -o $lan_if -s $mail --dport 53 -j
ACCEPT
$IPTABLES -A FORWARD -p UDP -i $dmz_if -o $lan_if -s $mail --dport 53 -j
ACCEPT
$IPTABLES -A FORWARD -p TCP -i $dmz_if -o $lan_if -s $mail --sport 53 -j
ACCEPT
$IPTABLES -A FORWARD -p UDP -i $dmz_if -o $lan_if -s $mail --sport 53 -j
ACCEPT

# Rules for WAN

$IPTABLES -A FORWARD -p TCP -i $wan_if -d $db --dport 3389 -j ACCEPT

$IPTABLES -A FORWARD -p TCP -i $wan_if -d $dc --dport 3389 -j ACCEPT
$IPTABLES -A FORWARD -p TCP -i $wan_if -d $mail --dport 25 -j ACCEPT
$IPTABLES -A FORWARD -p TCP -i $wan_if -d $mail --dport 53 -j ACCEPT
$IPTABLES -A FORWARD -p UDP -i $wan_if -d $mail --dport 53 -j ACCEPT
$IPTABLES -A FORWARD -p TCP -i $wan_if -d $mail --dport 80 -j ACCEPT

# Log weird packets that don't match the above.

$IPTABLES -A FORWARD -m limit --limit 3/minute --limit-burst 3 -j LOG --log-

level info --log-prefix "IPTABLES FORWARD blocked: "

############### NAT table ################

$IPTABLES -t nat -A POSTROUTING -o $wan_if -j MASQUERADE

$IPTABLES -t nat -A PREROUTING -p TCP -i $wan_if --dport 3666 -j DNAT --to-
destination $db:3389
$IPTABLES -t nat -A PREROUTING -p TCP -i $wan_if --dport 3777 -j DNAT --to-
destination $dc:3389
$IPTABLES -t nat -A PREROUTING -p TCP -i $wan_if --dport 25 -j DNAT --to-
destination $mail
$IPTABLES -t nat -A PREROUTING -p TCP -i $wan_if --dport 53 -j DNAT --to-
destination $mail
$IPTABLES -t nat -A PREROUTING -p UDP -i $wan_if --dport 53 -j DNAT --to-
destination $mail
$IPTABLES -t nat -A PREROUTING -p TCP -i $wan_if --dport 80 -j DNAT --to-
destination $mail
$IPTABLES -t nat -A PREROUTING -p TCP -i $lan_if -d $wan_ip -j DNAT --to-
destination $mail
$IPTABLES -t nat -A OUTPUT -p TCP -d $wan_ip -j DNAT --to-destination $mail

echo "Iptables rules have been reloaded!"

This script was created in special link up state Ubuntu directory and will be executed when
init process starts network scripts. Save the file and make it executable:

# chmod +x /etc/network/if-up.d/[Link]