Pare-feu

Introduction

Le noyau Linux intègre le sous-système Netfilter, qui est utilisé pour manipuler ou décider du destin du trafic réseau arrivant, sortant ou passant par votre serveur. Tous les pare-feu modernes pour Linux utilisent ce système pour le filtrage des paquets.

Le système du noyau de filtrage de paquets serait bien peu utile aux administrateurs sans une interface utilisateur pour le gérer. C'est le but d'iptables. Quand un paquet atteint votre serveur, Netfilter décidera s'il est accepté, manipulé, ou rejeté en suivant les règles fournies grâce à iptables. Si vous le maîtrisez, iptables suffit donc à gérer votre pare-feu, mais de nombreuses interfaces existent pour vous simplifier la tâche.

ufw - pare-feu simplifié

L'outil de configuration de pare-feu par défaut sous Ubuntu est ufw. Développé pour faciliter la configuration d'iptables, ufw propose une manière ergonomique de créer une machine servant de pare-feu IPv4 ou IPv6.

ufw est désactivé par défaut. D'après la page manuel de ufw :

« ufw n'est pas conçu pour fournir une solution pare-feu complète via son interfaces de commandes, mais il propose d'ajouter ou de supprimer facilement des règles simples. Il est actuellement principalement utilisé pour des machines servant de pare-feu. »

Voici quelques exemples d'utilisation de ufw :

D'abord, ufw doit être activé. Depuis un terminal saisissez :
```
sudo ufw enable
```
Pour ouvrir un port (ssh dans cet exemple) :
```
sudo ufw allow 22
```
Les règles peuvent également être ajoutées en utilisant un format numéroté :
```
sudo ufw insert 1 allow 80
```
De même, pour fermer un port ouvert :
```
sudo ufw deny 22
```
Pour supprimer une règle, utilisez « delete » suivi de la règle :
```
sudo ufw delete deny 22
```
Il est également possible d'autoriser les accès pour des hôtes ou des ports spécifiques. L'exemple suivant autorise les accès SSH depuis l'hôte 192.1687.0.2 vers n'importe quelle adresse IP :
```
sudo ufw allow proto tcp from 192.168.0.2 to any port 22
```
Remplacez 192.168.0.2 par 192.168.0.0/24 pour permettre un accès ssh depuis l'ensemble du sous-réseau.

L'ajout de l'option --dry-run à la commande ufw affichera les règles sans les appliquer. Par exemple, voici ce qu'il faudrait faire pour ouvrir le port HTTP :

sudo ufw --dry-run allow http

*filter
:ufw-user-input - [0:0]
:ufw-user-output - [0:0]
:ufw-user-forward - [0:0]
:ufw-user-limit - [0:0]
:ufw-user-limit-accept - [0:0]
### RULES ###

### tuple ### allow tcp 80 0.0.0.0/0 any 0.0.0.0/0
-A ufw-user-input -p tcp --dport 80 -j ACCEPT

### END RULES ###
-A ufw-user-input -j RETURN
-A ufw-user-output -j RETURN
-A ufw-user-forward -j RETURN
-A ufw-user-limit -m limit --limit 3/minute -j LOG --log-prefix "[UFW LIMIT]: "
-A ufw-user-limit -j REJECT
-A ufw-user-limit-accept -j ACCEPT
COMMIT
Rules updated

ufw peut être désactivé par :
```
sudo ufw disable
```
Pour voir le statut du pare-feu, saisissez:
```
sudo ufw status
```
Et pour des informations plus détaillées sur son statut, utilisez:
```
sudo ufw status verbose
```
Pour voir le format numéroté :
```
sudo ufw status numbered
```

Si le port que vous voulez ouvrir ou fermer est défini dans /etc/services, vous pouvez utiliser le nom du port au lieu de son numéro. Dans les exemples ci-dessus, remplacez 22 par ssh.

Ceci est une introduction rapide à l'utilisation de ufw. Veuillez vous référer à la page de manuel de ufw pour plus d'informations.

Intégration du programme ufw

Les programmes ouvrant des ports peuvent inclure un profil pour ufw qui renseigne les ports utilisés par ce programme pour fonctionner correctement. Les profils se conservés dans /etc/ufw/applications.d et peuvent être modifiés si les ports par défaut ont été changés.

Pour voir quelles applications ont installé un profil, saisissez la commande suivante dans un terminal :
```
sudo ufw app list
```
De même que pour autoriser l'utilisation d'un port, on peut utiliser un profil pour un programme en écrivant :
```
sudo ufw allow Samba
```
Une syntaxe étendue est également disponible:
```
ufw allow from 192.168.0.0/24 to any app Samba
```
Remplacez Samba et 192.168.0.0/24 par le profil d'application que vous utilisez et la plage d'adresses IP de votre réseau.

Il n'est pas utile de spécifier le protocole car cette information est renseignée dans le profil. Notez également que le nom app remplace le numéro de port.
Pour afficher les renseignements sur les ports, protocoles, etc. définis pour un programme, saisissez :
```
sudo ufw app info Samba
```

Not all applications that require opening a network port come with ufw profiles, but if you have profiled an application and want the file to be included with the package, please file a bug against the package in Launchpad.

ubuntu-bug nomdupaquet

Masquage IP

Le but du masquage IP (forme de translation d'adresses) est de permettre à des machines d'un réseau doté d'adresses IP privées non routables d'accéder à l'Internet en passant par une autre machine effectuant la translation. Le trafic sortant du réseau privé pour aller vers Internet doit être manipulé pour que les réponses puissent être acheminées vers la machine qui a fait la requête correspondante. Pour cela, le noyau doit modifier l'adresse IP source de chaque paquet pour que les réponses lui soient renvoyées à lui plutôt qu'à l'adresse privée qui a fait la requête, ce qui est impossible sur l'Internet. Linux utilise Connection Tracking (conntrack) pour savoir à chaque instant quelle connexion appartient à quelle machine, et re-router ensuite les paquets vers la bonne machine. Le trafic sortant du réseau privé apparaît donc « masqué », comme s'il provenait de la passerelle Ubuntu. Ce procédé est appelé « Partage de connexion Internet » dans la documentation de Microsoft.

Masquage IP avec ufw

Le masquage IP peut être accompli en utilisant des règles ufw spécifiques. Ceci est possible car ufw se base actuellement sur iptables-restore avec des fichiers de règles situés dans /etc/ufw/*.rules. Ces fichiers sont le meilleur endroit pour ajouter des anciennes règles iptables sans passer par ufw, ainsi que des règles qui touchent au routage et aux ponts réseau.

Les règles sont scindées en deux fichiers différents, celles qui doivent être exécutées avant les règles en ligne de commande de ufw et celles qui doivent être exécutées après les règles en ligne de commande de ufw.

Tout d'abord, la retransmission (forwarding) des paquets doit être activée dans ufw. Deux fichiers de configuration doivent être modifiés. Dans /etc/default/ufw ajustez la valeur de DEFAULT_FORWARD_POLICY à « ACCEPT » :
```
DEFAULT_FORWARD_POLICY="ACCEPT"
```
Modifiez ensuite /etc/ufw/sysctl.conf et décommentez :
```
net/ipv4/ip_forward=1
```
De manière similaire, pour IPV6 décommentez :
```
net/ipv6/conf/default/forwarding=1
```
Nous allons maintenant ajouter des règles au fichier /etc/ufw/before.rules. Les règles par défaut ne configurent que la table filter, pour activer le masquage IP la table nat devra être configurée. Ajoutez ce qui suit au début du fichier, juste après les commentaires de l'en-tête :
```
# règles pour le NAT
*nat
:POSTROUTING ACCEPT [0:0]

# Retransmet le trafic de eth1 vers eth0.
-A POSTROUTING -s 192.168.0.0/24 -o eth0 -j MASQUERADE

# ne pas effacer « COMMIT » sinon les nouvelles règles ne seront pas prises en compte
COMMIT
```
Les commentaires ne sont pas strictement nécessaires, mais c'est une bonne habitude à prendre de documenter votre configuration. Vérifiez bien également, que lorsque vous modifiez l'un des fichiers rules dans /etc/ufw, ces lignes soient bien présentes à la fin de chaque table modifiée :
```
# n'effacez pas « COMMIT » sinon ces règles ne seront pas traitées
COMMIT
```
Pour chaque table il est nécessaire de faire correspondre une déclaration COMMIT. Dans ces exemples seules les tables nat et filter sont décrites mais vous pouvez aussi ajouter des règles aux tables raw et mangle.

Remplacez dans l'exemple ci-dessus eth0, eth1 et 192.168.0.0/24 par vos propres interfaces et la plage d'IP pour votre réseau.
Enfin, désactivez et réactivez ufw pour appliquer les modifications :
```
sudo ufw disable && sudo ufw enable
```

Le masquage IP doit maintenant être activé. Vous pouvez également ajouter des règles FORWARD supplémentaires au fichier /etc/ufw/before.rules. Il est recommandé d'ajouter ces règles supplémentaires à la chaîne ufw-before-forward.

Masquage IP avec iptables

iptables peut aussi être utilisé pour activer le masquage.

Tout comme pour ufw-before-forward, la première étape est d'activer la retransmission de paquets IPv4 en modifiant le fichier /etc/sysctl.conf. Il faut décommenter la ligne suivante :
```
net.ipv4.ip_forward=1
```
Si vous souhaitez activer la retransmission IPv6, décommentez également :
```
net.ipv6.conf.default.forwarding=1
```
Ensuite, exécutez la commande sysctl pour activer les nouveaux paramètres dans le fichier de configuration :
```
sudo sysctl -p
```
Le masquage IP peut maintenant être effectué avec une seule règle iptable, pouvant être légèrement différente suivant la configuration de votre réseau :
```
sudo iptables -t nat -A POSTROUTING -s 192.168.0.0/16 -o ppp0 -j MASQUERADE
```
Les commandes ci-dessus supposent que votre plage d'adresses privées 192.168.0.0/16 et que votre interface de connexion à l'Internet est ppp0. La syntaxe se décompose ainsi :
- -t nat -- la règle ira dans la table NAT
- -A POSTROUTING -- la règle sera ajoutée (-A) à la chaîne POSTROUTING
- -s 192.168.0.0/16 -- la règle s'applique au trafic provenant de plage d'adresse spécifiée
- -o ppp0 -- la règle s'applique au trafic devant être routé à travers l'interface réseau spécifiée
- -j MASQUERADE -- le trafic correspondant à cette règle est « rejeté » (-j) vers la cible MASQUERADE pour être manipulé comme décrit ci-dessus
Chaque chaîne de la table « filter » (la table par défaut où le filtrage des paquets a principalement lieu) a pour règle par défaut ACCEPT (accepter), mais si vous créez une machine pare-feu et routeur, vous avez peut-être défini les règles sur DROP (ignorer) ou REJECT (rejeter), dans ce cas le trafic masqué doit être autorisé avec la chaîne FORWARD pour que la règle ci-dessus fonctionne :
```
sudo iptables -A FORWARD -s 192.168.0.0/16 -o ppp0 -j ACCEPT
sudo iptables -A FORWARD -d 192.168.0.0/16 -m state \
--state ESTABLISHED,RELATED -i ppp0 -j ACCEPT
```
Les commandes ci-dessus autoriseront toutes les connexions depuis votre réseau local vers l'Internet et tout le trafic lié à ces connexions sera redirigé vers la machine qui l'a initié.
Si vous souhaitez que le masquage IP soit activé au démarrage du serveur, modifiez /etc/rc.local et ajoutez les commandes utilisez ci-dessus. Par exemple, ajoutez la première commande sans filtrage :
```
iptables -t nat -A POSTROUTING -s 192.168.0.0/16 -o ppp0 -j MASQUERADE
```

Journaux

Les journaux du pare-feu sont essentiels pour identifier les attaques, résoudre les problèmes des règles du pare-feu, et remarquer une activité inhabituelle sur votre réseau. Vous devez inclure des règles d'écriture des journaux dans votre pare-feu pour qu'ils soient générés. Ces règles doivent être placées avant toute règle applicable de terminaison (une règle qui décide du sort des paquets, comme ACCEPT, DROP ou REJECT).

Si vous utilisez ufw, vous pouvez activer la journalisation en saisissant ce qui suit dans un terminal :

sudo ufw logging on

Pour désactiver la journalisation de ufw, remplacez simplement on par off dans la commande ci-dessus.

Si vous utilisez iptables au lieu de ufw, saisissez :

sudo iptables -A INPUT -m state --state NEW -p tcp --dport 80 \
-j LOG --log-prefix "NEW_HTTP_CONN: "

Une requête sur le port 80 de la machine locale, à ce moment là, générera un journal dans dmesg qui ressemble à ceci (une ligne unique divisée en 3 pour s'adapter à ce document) :

[4304885.870000] NEW_HTTP_CONN: IN=lo OUT= MAC=00:00:00:00:00:00:00:00:00:00:00:00:08:00
SRC=127.0.0.1 DST=127.0.0.1 LEN=60 TOS=0x00 PREC=0x00 TTL=64 ID=58288 DF PROTO=TCP
SPT=53981 DPT=80 WINDOW=32767 RES=0x00 SYN URGP=0

The above log will also appear in /var/log/messages, /var/log/syslog, and /var/log/kern.log. This behavior can be modified by editing /etc/syslog.conf appropriately or by installing and configuring ulogd and using the ULOG target instead of LOG. The ulogd daemon is a userspace server that listens for logging instructions from the kernel specifically for firewalls, and can log to any file you like, or even to a PostgreSQL or MySQL database. Making sense of your firewall logs can be simplified by using a log analyzing tool such as logwatch, fwanalog, fwlogwatch, or lire.

Autres outils

Il existe de nombreux outils pour vous aider à constituer un pare-feu complet sans connaissances particulières de iptables. Les outils en mode graphique :

fwbuilder est très puissant et semblera familier à un administrateur ayant déjà utilisé un pare-feu commercial comme Checkpoint FireWall-1.

Si vous préférez un outil en ligne de commande avec des fichiers de configuration en mode texte :

Shorewall est une solution très puissante pour vous aider à configurer un pare-feu avancé pour n'importe quel réseau.

Références

La page de wiki Pare-feu Ubuntu contient des informations sur le développement de ufw.
La page de manuel ufw contient des informations très utiles : man ufw.
Voir IPtables HOWTO en français pour plus d'informations sur l'utilisation de iptables.
Le guide pratique du NAT contient plus de renseignements sur le masquage IP.
La page du Wiki Ubuntu (en anglais) IPTables HowTo est également une très bonne source d'informations.

Précédent Suivant

Guides Ubuntu