Nftables

1. Aperçu
2. Variables de Rôle
   • Variables Spécifiques à l'OS
   • Dictionnaires de Règles
3. Exemples
   • Avec des playbooks
   • Avec group_vars et host_vars
4. Configuration
   • Intégration avec Fail2ban
5. Développement
6. Licence
7. Informations sur l'Auteur

Aperçu

Un rôle pour gérer les règles et les paquets Nftables.

Fortement inspiré par le rôle de pare-feu de Mike Gleason (3 niveaux de définition des règles et templates), merci ! J'espère ne pas avoir complexifié sa philosophie… (Je suis assez sûr d'avoir maintenant complexifié :D) ^^

Variables de Rôle

• nft_enabled : Activer ou désactiver le support pour Nftables [par défaut : true].
• nft_pkg_state : État du ou des nouveaux paquets nftables [par défaut : present].
• nft_old_pkg_list : La liste des paquets inutiles à supprimer (comme Iptables,…) [par défaut : iptables].
• nft_old_pkg_state : État du ou des anciens paquets [par défaut : absent].
• nft_old_pkg_manage : Si le ou les anciens paquets doivent être gérés avec ce rôle [par défaut : true].
• nft_conf_dir_path : Répertoire pour stocker les différents fichiers de configuration Nftables [par défaut : /etc/nftables.d].
• nft_main_conf_path : Fichier de configuration principal chargé par l'unité systemd [par défaut : /etc/nftables.conf].
• nft_main_conf_content : Template utilisé pour générer le fichier de configuration principal précédent [par défaut : etc/nftables.conf.j2].
• nft_input_conf_path : Fichier de configuration d'entrée inclus dans le fichier de configuration principal [par défaut : {{ nft_conf_dir_path }}/filter-input.nft].
• nft_input_conf_content : Template utilisé pour générer le fichier de configuration d'entrée précédent [par défaut : etc/nftables.d/filter-input.nft.j2].
• nft_output_conf_path : Fichier de configuration de sortie inclus dans le fichier de configuration principal [par défaut : {{ nft_conf_dir_path }}/filter-output.nft].
• nft_output_conf_content : Template utilisé pour générer le fichier de configuration de sortie précédent [par défaut : etc/nftables.d/filter-output.nft.j2].
• nft_forward_conf_path : Fichier de configuration de transmission inclus dans le fichier de configuration principal [par défaut : {{ nft_conf_dir_path }}/filter-forward.nft].
• nft_forward_conf_content : Template utilisé pour générer le fichier de configuration de transmission précédent [par défaut : etc/nftables.d/filter-forward.nft.j2].
• nft_define_conf_path : Fichier de définition des variables inclus dans le fichier de configuration principal [par défaut : {{ nft_conf_dir_path }}/defines.nft].
• nft_define_conf_content : Template utilisé pour générer le fichier de définition des variables précédent [par défaut : etc/nftables.d/defines.nft.j2].
• nft_sets_conf_path : Fichier de définition des ensembles et des cartes inclus dans le fichier de configuration principal [par défaut : {{ nft_conf_dir_path }}/sets.nft].
• nft_sets_conf_content : Template utilisé pour générer le fichier de définition des ensembles et des cartes précédent [par défaut : etc/nftables.d/sets.nft.j2].
• nft_global_default_rules : Définir des règles par défaut pour la chaîne global. D'autres chaînes seront dirigées vers global avant d'appliquer leurs propres règles spécifiques.
• nft_global_rules : Vous pouvez ajouter des règles global ou remplacer celles définies par nft_global_default_rules pour tous les hôtes.
• nft_global_group_rules : Vous pouvez ajouter des règles global ou remplacer celles définies par nft_global_default_rules et nft_global_rules pour un groupe.
• nft_global_host_rules : Les hôtes peuvent également ajouter ou remplacer toutes les règles précédentes.
• nft__custom_content : Contenu personnalisé (tables, inclusions,…) à ajouter dans la configuration Nftables [par défaut : ''].
• nft_input_default_rules : Définir des règles par défaut pour la chaîne input.
• nft_input_rules : Vous pouvez ajouter des règles input ou remplacer celles définies par nft_input_default_rules pour tous les hôtes.
• nft_input_group_rules : Vous pouvez ajouter des règles input ou remplacer celles définies par nft_input_default_rules et nft_input_rules pour un groupe.
• nft_input_host_rules : Les hôtes peuvent également ajouter ou remplacer toutes les règles précédentes input.
• nft_output_default_rules : Définir des règles par défaut pour la chaîne output.
• nft_output_rules : Vous pouvez ajouter des règles output ou remplacer celles définies par nft_output_default_rules pour tous les hôtes.
• nft_output_group_rules : Vous pouvez ajouter des règles output ou remplacer celles définies par nft_output_default_rules et nft_output_rules pour un groupe.
• nft_output_host_rules : Les hôtes peuvent également ajouter ou remplacer toutes les règles précédentes output.
• nft_forward_default_rules : Définir des règles par défaut pour la chaîne forward.
• nft_forward_rules : Vous pouvez ajouter des règles forward ou remplacer celles définies par nft_forward_default_rules pour tous les hôtes.
• nft_forward_group_rules : Vous pouvez ajouter des règles forward ou remplacer celles définies par nft_forward_default_rules et nft_forward_rules pour un groupe.
• nft_forward_host_rules : Les hôtes peuvent également ajouter ou remplacer toutes les règles précédentes forward.
• nft__forward_table_manage : Si la table de forwarding doit être gérée [par défaut : False].
• nft__nat_table_manage : Si la table nat doit être gérée [par défaut : False].
• nft__nat_default_prerouting_rules : Définir des règles par défaut pour la chaîne prerouting de la table nat.
• nft__nat_prerouting_rules : Définir des règles pour la chaîne prerouting de la table nat pour tous les hôtes dans l'inventaire Ansible.
• nft__nat_group_prerouting_rules : Définir des règles pour la chaîne prerouting de la table nat pour les hôtes dans un groupe spécifique de l'inventaire Ansible.
• nft__nat_host_prerouting_rules : Définir des règles pour la chaîne prerouting de la table nat pour des hôtes spécifiques dans l'inventaire Ansible.
• nft__nat_prerouting_conf_path : Fichier de configuration de prerouting inclus dans la configuration principale [par défaut : {{ nft_conf_dir_path }}/nat-prerouting.nft].
• nft__nat_prerouting_conf_content : Template utilisé pour générer le fichier de configuration de prerouting précédent [par défaut : etc/nftables.d/nat-prerouting.nft.j2].
• nft__nat_default_postrouting_rules : Définir des règles par défaut pour la chaîne postrouting de la table nat.
• nft__nat_postrouting_rules : Définir des règles pour la chaîne postrouting de la table nat pour tous les hôtes dans l'inventaire Ansible.
• nft__nat_group_postrouting_rules : Définir des règles pour la chaîne postrouting de la table nat pour les hôtes dans un groupe spécifique de l'inventaire Ansible.
• nft__nat_host_postrouting_rules : Définir des règles pour la chaîne postrouting de la table nat pour des hôtes spécifiques dans l'inventaire Ansible.
• nft__nat_postrouting_conf_path : Fichier de configuration de postrouting inclus dans la configuration principale [par défaut : {{ nft_conf_dir_path }}/nat-postrouting.nft].
• nft__nat_postrouting_conf_content : Template utilisé pour générer le fichier de configuration de postrouting précédent [par défaut : etc/nftables.d/nat-postrouting.nft.j2].
• nft_define_default : Définir des variables par défaut disponibles dans toutes les règles.
• nft_define : Vous pouvez ajouter des variables ou remplacer celles définies par nft_define_default pour tous les hôtes.
• nft_define_group : Vous pouvez ajouter des variables ou remplacer celles définies par nft_define_default et nft_define pour un groupe.
• nft_define_host : Vous pouvez ajouter ou remplacer toutes les variables précédentes.
• nft_service_manage : Si le service nftables doit être géré avec ce rôle [par défaut : true].
• nft_service_name : Nom du service nftables [par défaut : nftables].
• nft_service_enabled : Définir le service nftables disponible au démarrage [par défaut : true].
• nft__service_protect : Si l'unité systemd doit protéger le système et l'hôte [par défaut : true].
• nft_merged_groups : Si les variables des groupes d'hôtes Ansible doivent être fusionnées [par défaut : false].
• nft_merged_groups_dir : Le dictionnaire où se trouvent les règles de groupe nftables, nommées comme les groupes Ansible [par défaut : vars/].
• nft_debug : Activer ou désactiver une sortie plus détaillée. [par défaut : 'false'].

Variables Spécifiques à l'OS

Veuillez consulter la valeur par défaut par fichier d'Operating System dans le répertoire [vars][vars directory].

• nft_pkg_list : La liste du ou des paquets à fournir pour nftables.
• nft__bin_location : Chemin vers l'exécutable nftables. [par défaut : /usr/sbin/nft]

Templates de Règles

Le dictionnaire nft_templates contient une bibliothèque de règles utiles, destinées à être standardisées et prêtes à l'emploi dans votre pare-feu. Par exemple, {{ nft_templates.allow_mdns }} se développera en règles couvrant mDNS pour IPv4 et IPv6 :

  - meta l4proto udp ip6 daddr ff02::fb    udp dport mdns counter accept comment "mDNS IPv6 service discovery"
  - meta l4proto udp ip  daddr 224.0.0.251 udp dport mdns counter accept comment "mDNS IPv4 service discovery"

Utilisation prévue dans des ensembles de règles personnalisés :

nft_host_input_rules:
  ...
  010 allow mdns: "{{ nft_templates.allow_mdns }}"

Parmi d'autres, le dictionnaire nft_templates contient des règles mettant en œuvre des recommandations complètes pour le transfert et les pare-feux de trafic d'entrée comme défini dans RFC 4890, RFC 7126 et RFC 9288. Pour plus de détails et d'exemples, voir defaults/main.yml.

Dictionnaires de Règles

Chaque type de dictionnaire de règles sera fusionné et les règles seront appliquées dans l'ordre alphabétique des clés (la raison d'utiliser 000 à 999 comme préfixe). Donc :

• nft_*_default_rules : Définit des règles par défaut pour tous les nœuds. Vous pouvez les définir dans group_vars/all.
• nft_*_rules : Peut ajouter des règles et remplacer celles définies par nft_*_default_rules. Vous pouvez les définir dans group_vars/all.
• nft_*_group_rules : Peut ajouter des règles et remplacer celles définies par nft_*_default_rules et nft_*_rules. Vous pouvez les définir dans group_vars/webservers.
  • Si 'nft_merged_groups' est défini sur true, plusieurs règles de groupe des groupes Ansible seront également fusionnées.
• nft_*_host_rules : Peut ajouter des règles et remplacer celles définies par nft_*_default_rules, nft_*_group_rules et nft_*_rules. Vous pouvez les définir dans host_vars/www.local.domain.

defaults/main.yml :

# règles
nft_global_default_rules:
  005 état gestion :
    - ct state established,related accept
    - ct state invalid drop
nft_global_rules: {}
nft_merged_groups: false
nft_merged_groups_dir: vars/
nft_global_group_rules: {}
nft_global_host_rules: {}

nft_input_default_rules:
  000 politique :
    - type filter hook input priority 0; policy drop;
  005 global :
    - jump global
  010 drop indésirable :
    - ip daddr @blackhole counter drop
  015 localhost :
    - iif lo accept
  210 input tcp accepté :
    - tcp dport @in_tcp_accept ct state new accept
nft_input_rules: {}
nft_input_group_rules: {}
nft_input_host_rules: {}

nft_output_default_rules:
  000 politique :
    - type filter hook output priority 0; policy drop;
  005 global :
    - jump global
  015 localhost :
    - oif lo accept
  050 icmp :
    - ip protocol icmp accept
    - ip6 nexthdr icmpv6 counter accept
  200 output udp accepté :
    - udp dport @out_udp_accept ct state new accept
  210 output tcp accepté :
    - tcp dport @out_tcp_accept ct state new accept
nft_output_rules: {}
nft_output_group_rules: {}
nft_output_host_rules: {}

# définir les variables nft
nft_define_default:
  diffusion et multicast :
    desc: 'diffusion et multicast'
    name: badcast_addr
    value: '{ 255.255.255.255, 224.0.0.1, 224.0.0.251 }'
  input tcp accepté :
    name: in_tcp_accept
    value: '{ ssh }'
  output tcp accepté :
    name: out_tcp_accept
    value: '{ http, https, hkp }'
  output udp accepté :
    name: out_udp_accept
    value: '{ bootps, domain, ntp }'
nft_define: {}
nft_define_group: {}
nft_define_host: {}

# ensembles et cartes
nft_set_default:
  blackhole:
    - type ipv4_addr;
    - elements = $badcast_addr
  in_tcp_accept:
    - type inet_service; flags interval;
    - elements = $in_tcp_accept
  out_tcp_accept:
    - type inet_service; flags interval;
    - elements = $out_tcp_accept
  out_udp_accept:
    - type inet_service; flags interval;
    - elements = $out_udp_accept
nft_set: {}
nft_set_group: {}
nft_set_host: {}

Ces valeurs par défaut généreront la configuration suivante :

#!/usr/sbin/nft -f
# Géré par Ansible

# nettoyage
flush ruleset

include "/etc/nftables.d/defines.nft"

table inet filter {
    chain global {
        # 000 état gestion
        ct state established,related accept
        ct state invalid drop
    }
    include "/etc/nftables.d/sets.nft"
    include "/etc/nftables.d/filter-input.nft"
    include "/etc/nftables.d/filter-output.nft"
}

Et vous pouvez obtenir toutes les règles et définitions en affichant le jeu de règles sur l’hôte : $ nft list ruleset :

table inet filter {
    set blackhole {
        type ipv4_addr
        elements = { 255.255.255.255, 224.0.0.1, 224.0.0.251}
    }

    set out_tcp_accept {
        type inet_service
        flags interval
        elements = { http, https, hkp}
    }

    set out_udp_accept {
        type inet_service
        flags interval
        elements = { domain, bootps, ntp}
    }

    chain global {
        ct state established,related accept
        ct state invalid drop
    }

    chain input {
        type filter hook input priority 0; policy drop;
        jump global
        ip daddr @blackhole counter packets 0 bytes 0 drop
        iif "lo" accept
        tcp dport @in_tcp_accept ct state new accept
    }

    chain output {
        type filter hook output priority 0; policy drop;
        jump global
        oif "lo" accept
        ip protocol icmp accept
        udp dport @out_udp_accept ct state new accept
        tcp dport @out_tcp_accept ct state new accept
    }
}

Exemples

Avec des playbooks

- hôtes: serverXYZ
  rôles:
    - rôle: ipr-cnrs.nftables

- hôtes: serverXYZ
  vars:
      nft_input_rules:
        400 input torrent accepté:
          - udp dport 6881 ct state new accept
  rôles:
    - rôle: ipr-cnrs.nftables

- hôtes: serverXYZ
  vars:
      nft_input_rules:
        400 input http accepté:
          - tcp dport { 80, 443, 8080-8082 } ct state new accept
  rôles:
    - rôle: ipr-cnrs.nftables

- hôtes: serverXYZ
  vars:
    - nft_define_group:
        input http accepté:
          desc: HTTP et HTTPS
          name: in_http_accept
          value: '{ 80, 443 }'
      nft_input_group_rules:
        400 input http accepté:
          - tcp dport $in_http_accept ct state new accept
  rôles:
    - rôle: ipr-cnrs.nftables

- hôtes: serverXYZ
  vars:
      nft_set_group:
        in_udp_accept:
          - type inet_service; flags interval;
          - elements = { 6881-6887, 6889 }
      nft_input_group_rules:
        200 input udp accepté:
          - udp dport @in_udp_accept ct state new accept
  rôles:
    - rôle: ipr-cnrs.nftables

- hôtes: serverXYZ
  vars:
      nft_input_host_rules:
        050 icmp:
          - ip protocol icmp  ip saddr != 192.168.0.0/24  counter  drop
          - ip protocol icmp  icmp type echo-request  ip length <= 84  counter  limit rate 10/minute  accept
  rôles:
    - rôle: ipr-cnrs.nftables

- hôtes: serverXYZ
  vars:
    - nft_define:
      input tcp accepté:
        desc: Port SSH personnalisé et torrent
        name: in_tcp_accept
        value: '{ 2201, 6881 }'
  rôles:
    - rôle: ipr-cnrs.nftables

- hôtes: serverXYZ
  vars:
      nft_output_default_rules:
        000 politique:
          - type filter hook output priority 0; policy drop;
        005 état gestion:
          - ct state established,related accept
          - ct state invalid drop
        015 localhost:
          - oif lo accept
        050 ma règle pour XXX hôtes et services:
          - tcp dport 2000  ip saddr { xxx.xxx.xxx.xxx, yyy.yyy.yyy.yyy }  ct state new  accept
        250 reset-ssh:  # permettre à l'hôte de réinitialiser les connexions SSH pour éviter un délai de 10 minutes à partir du contrôleur Ansible
          - tcp sport ssh tcp flags { rst, psh | ack } counter accept
  rôles:
    - rôle: ipr-cnrs.nftables

- hôtes: serverXYZ
  vars:
      nft_output_host_rules:
        210 output tcp accepté:
          -
  rôles:
    - rôle: ipr-cnrs.nftables

Avec group_vars et host_vars

nft_input_group_rules:
  020 icmp:
    - ip protocol icmp icmp type echo-request ip length <= 84 counter limit rate 1/minute accept
  999 count policy packet:
    - counter

Configuration

Ce rôle va :

• Installer nftables sur le système.
• Activer le service nftables par défaut au démarrage.
• Générer un fichier de configuration par défaut qui inclut tous les fichiers suivants et est chargé par l'unité systemd.
• Générer des fichiers de règles d'entrée et de sortie inclus appelés par le fichier de configuration principal.
• Générer des variables dans un fichier et des ensembles et cartes dans un autre fichier.
• Assurer que nftables est démarré et activé au démarrage.
• (re)démarrer le service nftables lors de la première exécution ou lorsque les unités systemd sont modifiées.
• Recharger le service nftables lors des prochaines exécutions pour éviter de laisser l'hôte sans règles de pare-feu en raison d'une syntaxe invalide.

Intégration avec Fail2ban

Avant Debian Bullseye, l'unité systemd pour Fail2ban ne proposait pas une intégration décente avec Nftables. Ce rôle créera un fichier de substitution pour l'unité fail2ban, sauf si nft_fail2ban_service_override est défini sur false. Par défaut, il est ajouté même s'il n'est pas (encore) disponible sur l'hôte. Cela garantit :

• L'unité fail2ban est démarrée après l'unité nftables.
• L'unité fail2ban est redémarrée lorsque l'unité nftables redémarre.

Développement

Ce code source provient de notre instance Gitea et le repo Github existe juste pour pouvoir envoyer le rôle à Ansible Galaxy…

Mais n'hésitez pas à signaler des problèmes/PR ici :)

Merci à ce hook, GitHub obtient automatiquement des mises à jour de notre instance Gitea :)

Licence

WTFPL

Informations sur l'Auteur

Jérémy Gardais

• IPR (Institut de Physique de Rennes)