Configurer manuellement un pare-feu peut être compliqué pour un administrateur débutant (et même parfois pour un expert). Cependant, la communauté des logiciels libres a créé un certain nombre d'outils pouvant être utilisés pour configurer facilement un pare-feu local. Soyez prévenu que certains de ces outils sont plus orientés vers de la protection locale seulement (également connu sous le nom de pare-feu personnel) et d'autres sont plus versatiles et peuvent être utilisés pour configurer des règles complexes pour protéger des réseaux entiers.

Plusieurs logiciels peuvent être utilisés pour configurer des règles de pare-feu dans un système Debian.

De nombreuses autres interfaces à iptables sont disponibles dans Debian ; une liste exhaustive de comparaison des différents paquets dans Debian est tenue à jour sur la http://wiki.debian.org/Firewalls.

Remarquez que certains des paquets cités ci-dessus introduiront probablement des scripts de pare-feu à exécuter lors de l'amorçage du système. Testez-les de manière exhaustive avant de redémarrer le système ou vous pourriez vous retrouver bloqué en dehors de la machine. Si vous mélangez différents paquets de pare-feu, vous pouvez obtenir des effets indésirables. Habituellement, le script de pare-feu qui s'exécute en dernier sera celui qui configurera le système (qui peut ne pas être ce que vous voulez). Consultez la documentation du paquet et utilisez l'un d'entre eux pour ces configurations.

Comme mentionné précédemment, certains programmes comme firestarter, guarddog ou knetfilter sont des interfaces graphiques pour l'administration qui utilisent soit GNOME, soit KDE (les deux derniers). Ces applications sont plus orientées utilisateur (c'est-à-dire utilisation « familiale ») tandis que certains des autres paquets de la liste sont plus orientés administrateur. Certains des programmes mentionnés auparavant (comme bastille) sont ciblés sur la mise en place de règles de pare-feu qui protègent l'hôte sur lequel ils fonctionnent, mais ils ne sont pas nécessairement conçus pour mettre en place des règles de pare-feu pour des hôtes de pare-feu qui protègent un réseau (comme shorewall ou fwbuilder).

Il existe encore un autre type d'application de pare-feu: les serveurs mandataires (proxy) applicatifs. Si vous cherchez à mettre en place un tel pare-feu de niveau d'entreprise qui effectue du filtrage de paquets et fournit un certain nombre de serveurs mandataires transparents qui peuvent faire une analyse fine du trafic, vous devriez considérer l'utilisation de zorp, qui fournit cela dans un seul programme. Vous pouvez également mettre en place ce type de pare-feu manuellement en utilisant les serveurs mandataires disponibles dans Debian pour différents services comme pour le DNS en utilisant bind (correctement configuré), dnsmasq, pdnsd ou totd pour le FTP en utilisant frox ou ftp-proxy, pour X11 en utilisant xfwp, pour IMAP en utilisant imapproxy, pour le courrier en utilisant smtpd, ou pour POP3 en utilisant p3scan. Pour d'autres protocoles, vous devriez soit utiliser un serveur mandataire TCP générique comme simpleproxy, soit un serveur mandataire SOCKS comme dante-server, tsocks ou socks4-server. Vous devrez également typiquement utiliser un système de cache web (comme squid) et un système de filtrage web (comme squidguard ou dansguardian).

Une autre possibilité est de configurer manuellement vos règles de pare-feu par un script init.d qui exécutera toutes les commandes iptables. Suivez les étapes ci-dessous.

Voici l'exemple de script de pare-feu :

#!/bin/sh
# Exemple de configuration de pare-feu.
#
# Mises en garde
# - Cette configuration s'applique à toutes les interfaces réseau.
#   Si vous voulez ne restreindre cela qu'à une interface donnée,
#   utilisez « -i INTERFACE » dans les appels iptables ;
# - L'accès à distance pour les services TCP/UDP est accordé à tout
#   hôte, vous voudrez probablement restreindre cela en utilisant
#   « --source ».
#
# chkconfig : 2345 9 91
# description : activer ou désactiver le pare-feu au démarrage
#
# Vous pouvez tester ce script avant de l'appliquer avec l'extrait
# de script shell suivant, si vous ne tapez rien pendant
# 20 secondes, les règles de pare-feu seront effacées.
#---------------------------------------------------------------
#  while true; do test=""; read  -t 20 -p "OK ? " test ; \
#  [ -z "$test" ] && /etc/init.d/parefeu clear ; done
#---------------------------------------------------------------

PATH=/bin:/sbin:/usr/bin:/usr/sbin

# Services que le système offrira au réseau
TCP_SERVICES="22" # seulement SSH
UDP_SERVICES=""
# Services que le système utilisera du réseau
REMOTE_TCP_SERVICES="80" # navigation web
REMOTE_UDP_SERVICES="53" # DNS
# Réseau qui sera utilisé pour la gestion à distance
# (si non défini, aucune règle ne sera mise en place)
# NETWORK_MGMT=192.168.0.0/24
# Port utilisé pour le service SSH, à définir si vous avez configuré
# une gestion de réseau mais l'avez enlevé de TCP_SERVICES
# SSH_PORT="22"

if ! [ -x /sbin/iptables ]; then  
    exit 0
fi

fw_start () {

  # Trafic d'entrée :
  /sbin/iptables -A INPUT -m state --state ESTABLISHED,RELATED -j ACCEPT
  # Services
  if [ -n "$TCP_SERVICES" ] ; then
  for PORT in $TCP_SERVICES; do
    /sbin/iptables -A INPUT -p tcp --dport ${PORT} -j ACCEPT
  done
  fi
  if [ -n "$UDP_SERVICES" ] ; then
  for PORT in $UDP_SERVICES; do
    /sbin/iptables -A INPUT -p udp --dport ${PORT} -j ACCEPT
  done
  fi
  # Gestion à distance
  if [ -n "$NETWORK_MGMT" ] ; then
    /sbin/iptables -A INPUT -p tcp --src ${NETWORK_MGMT} --dport ${SSH_PORT} -j ACCEPT
  else 
    /sbin/iptables -A INPUT -p tcp --dport ${SSH_PORT}  -j ACCEPT
  fi
  # Test à distance
  /sbin/iptables -A INPUT -p icmp -j ACCEPT
  /sbin/iptables -A INPUT -i lo -j ACCEPT
  /sbin/iptables -P INPUT DROP
  /sbin/iptables -A INPUT -j LOG

  # Sortie :
  /sbin/iptables -A OUTPUT -j ACCEPT -o lo 
  /sbin/iptables -A OUTPUT -m state --state ESTABLISHED,RELATED -j ACCEPT
  # ICMP est permis :
  /sbin/iptables -A OUTPUT -p icmp -j ACCEPT
  # Ainsi que les mises à jour de sécurité :
  # Remarque : vous pouvez indiquer en dur l'adresse IP ici afin de prévenir une
  # usurpation DNS et configurer les règles même si le DNS ne fonctionne pas mais
  # dans ce cas vous ne « verrez » pas les modifications d'IP pour ce service :
  /sbin/iptables -A OUTPUT -p tcp -d security.debian.org --dport 80 -j ACCEPT 
  # Ainsi que pour tous les services définis :
  if [ -n "$REMOTE_TCP_SERVICES" ] ; then
  for PORT in $REMOTE_TCP_SERVICES; do
    /sbin/iptables -A OUTPUT -p tcp --dport ${PORT} -j ACCEPT
  done
  fi
  if [ -n "$REMOTE_UDP_SERVICES" ] ; then
  for PORT in $REMOTE_UDP_SERVICES; do
    /sbin/iptables -A OUTPUT -p udp --dport ${PORT} -j ACCEPT
  done
  fi
  # Toutes les autres connexions sont enregistrées dans syslog
  /sbin/iptables -A OUTPUT -j LOG
  /sbin/iptables -A OUTPUT -j REJECT 
  /sbin/iptables -P OUTPUT DROP
  # Autres protections réseau
  # (certaines ne fonctionneront que pour certaines versions de noyau)
  echo 1 > /proc/sys/net/ipv4/tcp_syncookies
  echo 0 > /proc/sys/net/ipv4/ip_forward 
  echo 1 > /proc/sys/net/ipv4/icmp_echo_ignore_broadcasts 
  echo 1 > /proc/sys/net/ipv4/conf/all/log_martians 
  echo 1 > /proc/sys/net/ipv4/ip_always_defrag
  echo 1 > /proc/sys/net/ipv4/icmp_ignore_bogus_error_responses
  echo 1 > /proc/sys/net/ipv4/conf/all/rp_filter
  echo 0 > /proc/sys/net/ipv4/conf/all/send_redirects
  echo 0 > /proc/sys/net/ipv4/conf/all/accept_source_route

}

fw_stop () {
  /sbin/iptables -F
  /sbin/iptables -t nat -F
  /sbin/iptables -t mangle -F
  /sbin/iptables -P INPUT DROP
  /sbin/iptables -P FORWARD DROP
  /sbin/iptables -P OUTPUT ACCEPT
}

fw_clear () {
  /sbin/iptables -F
  /sbin/iptables -t nat -F
  /sbin/iptables -t mangle -F
  /sbin/iptables -P INPUT ACCEPT
  /sbin/iptables -P FORWARD ACCEPT
  /sbin/iptables -P OUTPUT ACCEPT
}


case "$1" in
  start|restart)
    echo -n "Démarrage du pare-feu…"
    fw_stop 
    fw_start
    echo "done."
    ;;
  stop)
    echo -n "Arrêt du pare-feu…"
    fw_stop
    echo "done."
    ;;
  clear)
    echo -n "Effacement des règles de pare-feu…"
    fw_clear
    echo "done."
    ;;
  *)
    echo "Utilisation : $0 {start|stop|restart|clear}"
    exit 1
    ;;
  esac
exit 0

Au lieu d'intégrer toutes les règles iptables dans un script init.d, vous pouvez utiliser le programme iptables-restore pour restaurer les règles sauvées avec iptables-save. Pour faire cela, vous devez configurer les règles et sauver le jeu de règles dans un endroit statique (comme /etc/default/firewall).

Vous pouvez également utiliser la configuration du réseau dans /etc/network/interfaces pour mettre en place les règles de pare-feu. Pour cela, vous devez :

Optionnellement, vous pouvez mettre en place un jeu de règles à appliquer quand l'interface est inactivée en créant un jeu de règles, en le sauvant dans /etc/iptables.down.rules et en ajoutant la directive suivante à la configuration de l'interface :

    post-down iptables-restore < /etc/iptables.down.rules

Pour des scripts de configuration de pare-feu plus avancés avec ifupdown, vous pouvez utiliser les accroches (hooks) disponibles pour chaque interface dans les répertoires *.d/ appelés avec run-parts (consultez run-parts(8)).

Tester la configuration de pare-feu est aussi facile et aussi dangereux que d'exécuter simplement le script de pare-feu (ou d'activer la configuration que vous avez définie dans l'application de configuration de pare-feu). Cependant, si vous n'êtes pas assez prudent et que vous configurez le pare-feu à distance (comme à travers une connexion SSH), vous pourriez vous enfermer dehors.

Plusieurs moyens permettent d'empêcher cela. L'un est d'exécuter un script dans un terminal séparé qui va enlever la configuration de pare-feu si vous ne faites pas d'entrée clavier. Un exemple de cela est :

$  while true; do test=""; read  -t 20 -p "OK? " test ; \
  [ -z "$test" ] && /etc/init.d/firewall clear ; done

Un autre moyen est d'introduire une porte dérobée dans le système par un mécanisme alternatif qui vous permet soit d'enlever le système de pare-feu, soit de percer un trou dedans si quelque chose déraille. Pour cela, vous pouvez utiliser knockd et le configurer pour qu'une tentative de connexion sur un certain port enlève le pare-feu (ou ajoute une règle temporaire). Bien que les paquets soient rejetés par le pare-feu, comme knockd se lie à l'interface et les voit, vous pourrez contourner le problème.

Tester un pare-feu qui protège un réseau interne est un problème différent, vous voudrez étudier certains des outils utilisés pour le test de failles à distance (consultez Section 8.1, « Outils d'évaluation des vulnérabilités à distance ») pour sonder le réseau depuis l'extérieur (ou dans toute autre direction) pour tester l'efficacité de la configuration du pare-feu.