7.6 KiB

Raw Blame History

NFTables

Introduction

NFTables est un outil permettant de de gérer une partie de la gestion des paquets réseaux dans une machine Linux. Cet outil supplante ses prédécesseurs xtables (iptables, ip6tables, arptables, ...) et son support ets inclus dans les noyaux Linux modernes. Lorsqu'un paquet traverse, sort de ou entre sur votre machine, il parcourt un certain chemin de prises de décisions afin de décider de son sort (jeté, accepté (= intouché), modifié, ...).

Structure de NFTables

NFTables permet d'organiser les règles définissant le comportement à avoir avec un paquet en fonction de certains critères.

Les règles ne sont pas appliquées par NFTables à n'importe quel moment. En effet, certaines règles ne concernent que les paquets issus de la machine, d'autre les paquets sortant, ... Afin de regrouper les règles agissant au même endroit, les règles de NFTables sont regroupées en chaînes d'actions, lesquelles concernent un crochet de prise de décision du noyau.

Là encore, on peut souhaiter avoir des chaînes différentes pour les paquets IP, IPv6, arp, ... . Pour cette raison, les chaînes sont regroupées dans des tables, chacune ne concernant un ou plusieurs type de protocole (généralement de couche 3).

La structure des règles NFTables ainsi obtenue devient :

+------------------------------------------------------------+
| Table concernant les paquets IP                            |
| ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~                            |
|                                                            |
| +----------------------------------------------------+     |
| | Chaîne concernant le crochet du filtre d'entrée    |     |
| | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~    |     |
| |                                                    |     |
| |           +--------------------------+             |     |
| |           | Règle 1                  |             |     |
| |           | ~~~~~~~                  |             |     |
| |           | paquet TCP ?             |             |     |
| |           | à destination du port 53 |             |     |
| |           | vient-il de a.b.c.d      |             |     |
| |           | action: rejeter          |             |     |
| |           +--------------------------+             |     |
| |                                                    |     |
| |           +----------------------------------+     |     |
| |           | Règle 2                          |     |     |
| |           | ~~~~~~~                          |     |     |
| |           | paquet TCP ?                     |     |     |
| |           | lié à une connexion déjà établie |     |     |
| |           | action: accepter                 |     |     |
| |           +----------------------------------+     |     |
| |                                                    |     |
| |                    ...                             |     |
| +----------------------------------------------------+     |
|                                                            |
| +----------------------------------------------------+     |
| | Chaîne concernant le crochet du NAT en entrée      |     |
| | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~    |     |
| |                                                    |     |
| |           +----------------------------------+     |     |
| |           | Règle 1                          |     |     |
| |           | ~~~~~~~                          |     |     |
| |           | paquet provenant de a.b.c.d/m    |     |     |
| |           | paquet sortant par l'interface x |     |     |
| |           | action: snat to x.x.x.x          |     |     |
| |           +----------------------------------+     |     |
| |                                                    |     |
| |                    ...                             |     |
| +----------------------------------------------------+     |
|                                                            |
+------------------------------------------------------------+

                   +----------+
                   | Table 2  |
                   | ~~~~~~~  |
                   |   ...    |
                   +----------+

                       ...

Comme le décrit le schéma précédent, les tables sont juxtaposées les unes les autres. Lorsqu'un paquet est traité, selon le protocole utilisé, aucune, une ou plusieurs tables seront utilisées pour charger les règles à appliquer. À chaque étape de traitement du paquet, les chaînes correspondant au paquet seront alors appliquées.

Un paquet parcourt les règles d'une chaîne dans l'ordre de leur écriture. Si une action est indiquée dans le corps d'une règle, elle sera exécutée si toutes les conditions la précédant dans l'écriture de la règle sont vérifiées.

Le parcourt d'une chaîne s'arrête lorsqu'un verdict s'applique au paquet considéré. Un verdict est une action particulière parmi peut être :

l'abandon du paquet
l'abandon du paquet avec choix du message retourné à l'émetteur
L'acceptation du paquet
Le saut à une autre chaîne (avec retour à la chaîne en cours ensuite)
Le saut à une autre chaîne (sans retour à la chaîne en cours après)

Table

Une table est caractérisée par :

Un nom
Un type de paquet : principalement ip (pour l'IPv4), ip6 (pour l'IPv6) et inet (pour l'IPv4 et IPv6).

Une table peut être ajoutée avec la commande nft add table <nom de la table> si vous souhaitez utiliser la commande nft, ou avec le morceau de configuration suivant :

table <type> <nom de la table> {
	[contenu de la table (chaînes)]
}

Chaîne

Une chaîne est caractérisée par :

La table dans laquelle la chaîne se trouve
Le nom de la chaîne

Lors de la création / utilisation d'une chaîne, il faut aussi décider !

Le crochet NFTables concerné par la chaîne (input, output, ...)
Le type de la chaîne (filtre, nat, raw, mangle)
La priorité de la chaîne (filter (=0), srcnat (=-100), dstnat (=100)).

Une chaîne peut aussi avoir un verdict par défaut sur les paquet (accept, drop, reject [with MSG], ...).

Une chaîne peut être créée par la commande nft add chain <type de la table> <nom de la table> <nom de la chaîne> '{ type <type> hook <crochet> priority <priorité>; [policy <verdict par défaut>;] }', ou par le morceau de configuration textuelle suivant :

chain <nom de la chaîne> {
	type <type> hook <crochet> priority <priorité> ; policy <verdict par défaut>;
	[contenu de la chaîne]
}

Règle

Une règle est caractérisée par :

La chaîne dans laquelle elle est contenue.

Dans la définition d'une règle, il est possible d'indiquer :

des conditions écrites <type> <valeur>, où le type est un champ du paquet et la valeur est la valeur du champ, comme par exemple ip protocol udp (type : ip protocol représentant le champ du protocole de couche 4 dans un paquet IPv4, valeur tcp).

Les types peuvent être décrits par nft describe <type>.
des actions, parmi lesquelles "compter les paquets" (counter), logger les paquets (log prefix ...).

Pour ajouter une règle, il est possible d'utiliser nft add rule <type de la table> <nom de la table> <nom de la chaîne> '<règle>', ou d'ajouter la règle sur une ligne dans la configuration textuelle.

Divers

nft flush ruleset vide la table
nft -f <file> lit la configuration d'un ficher et l'applique
systemctl reload nftables a le même effet que nft -f /etc/nftables.conf si le service existe.
Si aucune chaîne / table / règle n'est traversée, le paquet est accepté par défaut (si on ne filtre pas, tout passe)?

7.6 KiB Raw Blame History