FPLinux.com

Reprenez le contrôle de votre liberté

Mise en place d'un pare-feu basique

Dès que vous avez booté sur votre système pour la première fois, la première chose à faire est de mettre en place un pare-feu basique. En effet, bien que pour l'instant, vous n'ayez aucun service qui soit susceptible d'être utilisé par un hacker pour pénétrer sur votre machine, cela ne va pas durer car nous allons petit à petit installer des logiciels sur la machine.

Sous GNU/Linux, le pare-feu est en fait fourni avec le noyau Linux et s'appelle "Netfilter". Il nous faut paramétrer ce dernier. Cela s'effectue avec l'utilitaire "iptables". Sous DEBIAN, cet utilitaire est installé d'office avec le système de base. Ce n'est pas le cas de toutes les distributions.

Etablissement d'un script de paramétrage du parefeu:

Pour paramétrer "Netfilter", il existe plusieurs méthodes. La plus courante consiste à utiliser un script. C'est cette méthode que nous allons utiliser ici. Créons ce script que nous appellerons "firewall" dans un répertoire prévu à cet usage, dans le dossier de l'utilisateur principal. Pour cela, nous allons utiliser l'éditeur de texte "Nano", également installé d'office sous DEBIAN:

$ cd ~
$ mkdir system
$ cd system
$ nano firewall

La première ligne que nous plaçons dans ce script permet d'indiquer au "shell" que le présent fichier est un script de ligne de commande. Il est indispensable de commencer le script avec elle:

#!/bin/bash

Commençons tout d'abord par initialiser notre pare-feu en effaçant toutes règles qui pourraient être présentes afin de partir sur une bonne base. Placez immédiatement en dessous de la ligne précédente celles-ci:

# Initialisation du parefeu:
###########################
# On efface toutes les règles précédentes
iptables -t filter -F
iptables -t filter -x
iptables -t nat -F
iptables -t nat -X

La commande "iptables" permet de gérer plusieurs tables pour le pare-feu. Pour un pare-feu de base, seule la table "filter" est sollicitée. celle-ci permet de gérer  trois flux de données:

  • flux INPUT: les paquets de données qui rentrent dans la machine,
  • flux OUTPUT: les paquets de données qui sortent de la machine,
  • flux FORWARD: les paquets de données qui traversent la machine.

Nous allons maintenant établir la politique par défaut du pare-feu. Il existe deux écoles pour établir les règles qui vont la définir:

  • l'école parano: on empêche les trois flux de passer
  • l'école rationnelle: compte tenu que pour qu'il y ait une sortie de données vers l'extérieur, il a fallu que l'utilisateur donne un ordre à la machine, on ne ferme que le flux INPUT et le flux FORWARD et on ouvre OUTPUT

Si apparemment la méthode "parano" semble être la méthode la plus sécurisante, elle en est pas moins un faux ami. En effet, elle oblige par la suite à ouvrir les flux OUTPUT  et INPUT port par port en fonction des besoins. Très vite, si vous optez pour cette méthode, vous allez constater que votre machine sera bloquée pour un oui ou pour un non avec de très sérieux ralentissement dans les opérations de téléchargements. Il se peut même qu'à la longue, à force d'ouvrir des ports pour que vous puissiez utiliser votre machine, vous finissiez par créer de sacrées failles.

En fait, la bonne méthode est bien la méthode "rationnelle": en effet, à partir du moment ou on ferme le flux INPUT, il ne peut pas avoir une sortie sur le flux OUTPUT sans que celle-ci ne soit initialisé que par l'utilisateur et uniquement celui-ci. Aussi a-t-on tout autant de sécurité sans pour autant bloquer la machine. C'est donc cette école que nous appliquerons ici.

Voila le texte du script à placer immédiatement derrière les lignes précédentes:

# Politique par défaut du parefeu:
#################################
# On vire tout ce qui essaye de rentrer et on laisse passer ce qui sort
iptables -t filter -P INPUT DROP
iptables -t filter -P FORWARD DROP
iptables -t filter -P OUTPUT ACCEPT

Si vous lanciez le script maintenant, vous constateriez très vite que votre machine est innacessible depuis l'extérieur et  ne peut accéder à Internet. On a donc bien le même effet qu'avec la méthode "parano".

Néanmoins, la situation n'est certainement pas satisfaisante pour vous n'est-ce-pas? Aussi allons-nous maintenant établir les règles qui permettent une utilisation sans risques.

Tout d'abord, il nous faut nous préoccuper d'un détail extrêmement important: en effet, la machine doit pouvoir se causer à elle-même car elle est un brin autiste. Cette communication de la machine avec elle-même se fait à travers une interface qui lui est réservée, l'interface "loopback" (abréviation "lo"). Il suffit donc d'ouvrir INPUT sur cette interface. Inutile de se préoccuper de OUTPUT puisque par défaut ce flux est déjà ouvert:

# Ouverture interface "loopback":
################################
# Pour que la machine puisse se parler à elle-même
iptables -A INPUT -i lo -j ACCEPT

Pour certains, il serait utile d'ouvrir le pare-feu au protocole ICMP afin d'interroger la présence de la machine (commande "ping") sur le réseau. Sur un ordinateur portable cela ne sert pas à grand chose, en revanche sur  un poste fixe, particulièrement sur un serveur, cela peut effectivement servir. Pour ceux qui tiennent à cette spécificité voila la règle à rajouter:

# Ouverture protocole ICMP:
##########################
# Pour pouvoir "pinger" la machine
iptables -A INPUT -p icmp -j ACCEPT

 Enfin, il nous faut maintenant pouvoir accéder au réseau. Là, c'est un peu plus complexe car en fait il nous faut ouvrir le pare-feu uniquement lorsque la connexion est initialisée depuis la machine. Pour cela, on fait intervenir le module "conntrack"qui permet de trier les paquets selon leurs états. Deux de ces états nous intéressent tout particulièrement:

  • état ESTABLISHED: les paquets possédant cet état sont issu d'une connexion établie et non pas d'une nouvelle connexion
  • état RELATED: les paquets possédant cet état sont issu d'une connexion établie sur un autre port

En acceptant au niveau de la chaîne INPUT que seulement ces deux états, on est sûr que n'arrivera sur la machine que ce qui a été demandé. En effet, les connexions établies depuis l'extérieur possèdent un état NEW et ceux-ci sont "dropés" au niveau de la politique par défaut. Voila donc la partie à rajouter au script, juste en dessous de ce qui précède:

# Accés au réseau:
#################
# On n'accepte les paquets que seulement si on les a demandés
iptables -A INPUT -m conntrack --ctstate RELATED,ESTABLISHED -j ACCEPT

Et voila!... Il ne reste plus qu'à conclure notre script en rajoutant une dernière règle pour confirmer la politique par défaut. A la fin du script on rajoute donc:

# Finalisation du pare-feu:
##########################
# CETTE REGLE DOIT TOUJOURS ETRE EN DERNIER
iptables -A INPUT -j DROP

Notre pare-feu est maintenant complet pour l'instant. Au fur et à mesure que l'on rajoute des logiciels à notre système on placera AU DESSUS de la règle précédente celles qui seront rajoutés au script. Donc, pour terminer, on peaufine en préparant l'espace. Insérez au-dessus de la partie précédente le texte suivant:

# Règles particulières
######################
# ...
# ...

 

Voila le script intégral pour les afficionados du copier-coller:

#!/bin/bash
# Initialisation du parefeu:
###########################
# On efface toutes les règles précédentes
iptables -t filter -F
iptables -t filter -x
iptables -t nat -F
iptables -t nat -X
 
# Politique par défaut du parefeu:
#################################
# On vire tout ce qui essaye de rentrer et on laisse passer ce qui sort
iptables -t filter -P INPUT DROP
iptables -t filter -P FORWARD DROP
iptables -t filter -P OUTPUT ACCEPT
 
# Ouverture interface "loopback":
################################
# Pour que la machine puisse se parler à elle-même
iptables -A INPUT -i lo -j ACCEPT
 
# Ouverture protocole ICMP:
##########################
# Pour pouvoir "pinger" la machine
iptables -A INPUT -p icmp -j ACCEPT
 
# Accés au réseau:
#################
# On n'accepte les paquets que seulement si on les a demandés
iptables -A INPUT -m conntrack --ctstate RELATED,ESTABLISHED -j ACCEPT
 
# Règles particulières
######################
# ...
# ...
 
# Finalisation du pare-feu:
##########################
# CETTE REGLE DOIT TOUJOURS ETRE EN DERNIER
iptables -A INPUT -j DROP

Reste plus maintenant qu'à sauvegarder notre script (sous "nano" cela s'effectue à l'aide de la combinaison de touches <Ctrl>+<X>), à le rendre exécutable, à le lancer en tant qu'utilisateur "root" (d'ou la commande "su") et à contrôler:

$ su
# chmod +x firewall
# ./firewall
# iptables -L
Chain INPUT (policy DROP)
target prot opt source destination
ACCEPT all -- anywhere anywhere
ACCEPT icmp -- anywhere anywhere
ACCEPT all -- anywhere anywhere ctstate RELATED,ESTABLISHED
DROP all -- anywhere anywhere
 
Chain FORWARD (policy DROP)
target prot opt source destination
 
Chain OUTPUT (policy ACCEPT)
target prot opt source destination

La sortie de la commande "iptables -L" montre bien que le pare-feu est en place.

Automatisation du pare-feu

Pour l'instant, ce pare-feu n'est pas mise en place automatiquement au lancement de la machine. Il existe plusieurs solutions pour cela. Nous allons en indiquer deux:

la première consiste tout simplement à placer le script dans un dossier spécifique du répertoire "/etc" (le dossier "/etc/network/if-pre-up.d/"). En effet, tous les scripts contenus dans ce dossier sont lancés automatiquement avant la connexion sur le réseau. Si vous n'avez pas de connexion actuellement (c'est certainement le cas si vous avez fait l'installation sur un portable non relié de manière filaire au réseau), il vous faudra obligatoirement utiliser cette méthode puisque l'autre suppose que vous ayez déjà l'accés au réseau. En tant que "root" tapez la commande suivante:

# cp ~/systeme/firewall /etc/network/if-pre-up.d/

 

la deuxième est celle que je préfère car elle permet de garder le script dans le répertoire personnel afin d'y revenir pour le corriger au fur et à mesure de la construction. Elle consiste tout simplement à utiliser le paquet "iptables-persistent".
Vous pouvez d'ores et déjà l'utiliser si vous êtes en connexion filaire:
Tout d'abord effectuez une mise-à-jour:

# apt-get update
# apt-get upgrade

Installez maintenant le paquet:

# apt-get install iptables-persistent

Enfin sauvegardez les règles après avoir lancer le script:

# ~/systeme/firewall
# netfilter-persistent save

Et voila!... La machine est maintenant protégée sur le réseau. On va donc pouvoir commencer à la "customiser" quelque peu. A partir de maintenant, deux voies s'ouvrent à vous:

  • Serveur: votre machine est déjà connectée au réseau par voie filaire. Il vous faut maintenant continuer le tuto vers "Primo-sécurisation du serveur"
  • Poste de travail: la machine n'est pas connectée s vous êtes en réseau WIFI (cas d'un portable). Il vous faut alors vous occuper de ce détail avant de continuer   

 

 

Fanch33

 

Précédent: Fin de l'installation du système de base

Suivant serveur: Primo-sécurisation du serveur

Suivant poste: Connexion au réseau

« »

Laissez un commentaire