Procédure

1. Vérifier la configuration permanente du service firewalld:

   # firewall-cmd --check-config
   success

   Si la configuration permanente est valide, la commande renvoie success. Dans les autres cas, la commande renvoie une erreur avec des détails supplémentaires, tels que les suivants :

   # firewall-cmd --check-config
   Error: INVALID_PROTOCOL: 'public.xml': 'tcpx' not from {'tcp'|'udp'|'sctp'|'dccp'}

Procédure

1. Pour connaître l'état du service :

   # firewall-cmd --state

2. Pour plus d'informations sur l'état du service, utilisez la sous-commande systemctl status:

   # systemctl status firewalld
   firewalld.service - firewalld - dynamic firewall daemon
      Loaded: loaded (/usr/lib/systemd/system/firewalld.service; enabled; vendor pr
      Active: active (running) since Mon 2017-12-18 16:05:15 CET; 50min ago
        Docs: man:firewalld(1)
    Main PID: 705 (firewalld)
       Tasks: 2 (limit: 4915)
      CGroup: /system.slice/firewalld.service
              └─705 /usr/bin/python3 -Es /usr/sbin/firewalld --nofork --nopid

Procédure

1. Pour désactiver immédiatement le trafic réseau, activez le mode panique :

   # firewall-cmd --panic-on

   Important

   L'activation du mode panique interrompt tout le trafic réseau. C'est pourquoi il ne doit être utilisé que si vous avez un accès physique à la machine ou si vous êtes connecté à l'aide d'une console série.

2. La désactivation du mode panique ramène le pare-feu à ses paramètres permanents. Pour désactiver le mode panique, entrez :

   # firewall-cmd --panic-off

Procédure

1. Vérifiez que le service n'est pas déjà autorisé :

   # firewall-cmd --list-services
   ssh dhcpv6-client

2. Liste de tous les services prédéfinis :

   # firewall-cmd --get-services
   RH-Satellite-6 amanda-client amanda-k5-client bacula bacula-client bitcoin bitcoin-rpc bitcoin-testnet bitcoin-testnet-rpc ceph ceph-mon cfengine condor-collector ctdb dhcp dhcpv6 dhcpv6-client dns docker-registry ...

3. Ajouter le service aux services autorisés :

   # firewall-cmd --add-service=<service_name>

4. Les nouveaux paramètres doivent être conservés :

   # firewall-cmd --runtime-to-permanent

Procédure

1. Pour activer ou désactiver un service prédéfini ou personnalisé :

   1. Lancez l'outil firewall-config et sélectionnez la zone du réseau dont les services doivent être configurés.
   2. Sélectionnez l'onglet Zones puis l'onglet Services ci-dessous.
   3. Cochez la case pour chaque type de service que vous souhaitez autoriser ou décochez la case pour bloquer un service dans la zone sélectionnée.

2. Pour modifier un service :

   1. Lancez l'outil firewall-config.
   2. Sélectionnez Permanent dans le menu intitulé Configuration. D'autres icônes et boutons de menu apparaissent au bas de la fenêtre Services.
   3. Sélectionnez le service que vous souhaitez configurer.

1. Entrez la commande suivante pour ajouter un nouveau service vide :

   $ firewall-cmd --new-service=<service_name> --permanent

2. Pour ajouter un nouveau service à l'aide d'un fichier local, utilisez la commande suivante :

   $ firewall-cmd --new-service-from-file=<service_xml_file> --permanent

   Vous pouvez modifier le nom du service avec l'option supplémentaire --name=<service_name> supplémentaire.

3. Dès que les paramètres du service sont modifiés, une copie mise à jour du service est placée sur /etc/firewalld/services/.

   Comme root, vous pouvez entrer la commande suivante pour copier un service manuellement :

   # cp /usr/lib/firewalld/services/service-name.xml /etc/firewalld/services/service-name.xml

Procédure

1. Lancez l'outil firewall-config et sélectionnez la zone du réseau dont vous souhaitez modifier les paramètres.
2. Sélectionnez l'onglet Ports et cliquez sur le bouton Ajouter sur le côté droit. La fenêtre Port and Protocol s'ouvre.
3. Saisissez le numéro de port ou la plage de ports à autoriser.
4. Sélectionnez tcp ou udp dans la liste.

Procédure

1. Lancez l'outil firewall-config et sélectionnez la zone du réseau dont vous souhaitez modifier les paramètres.
2. Sélectionnez l'onglet Protocols et cliquez sur le bouton Add à droite. La fenêtre Protocol s'ouvre.
3. Sélectionnez un protocole dans la liste ou cochez la case Other Protocol et saisissez le protocole dans le champ.

Procédure

1. Lancez l'outil firewall-config et sélectionnez la zone réseau dont vous souhaitez modifier les paramètres.
2. Sélectionnez l'onglet Source Port et cliquez sur le bouton Add à droite. La fenêtre Source Port s'ouvre.
3. Saisissez le numéro de port ou la plage de ports à autoriser. Sélectionnez tcp ou udp dans la liste.

1. Liste de tous les ports autorisés :

   # firewall-cmd --list-ports

2. Ajouter un port aux ports autorisés pour l'ouvrir au trafic entrant :

   # firewall-cmd --add-port=port-number/port-type

   Les types de port sont soit tcp, udp, sctp, ou dccp. Le type doit correspondre au type de communication réseau.

3. Les nouveaux paramètres doivent être conservés :

   # firewall-cmd --runtime-to-permanent

   Les types de port sont soit tcp, udp, sctp, ou dccp. Le type doit correspondre au type de communication réseau.

1. Liste de tous les ports autorisés :

   # firewall-cmd --list-ports

   Avertissement

   Cette commande ne vous donnera qu'une liste des ports qui ont été ouverts en tant que ports. Vous ne pourrez pas voir les ports ouverts en tant que service. Par conséquent, vous devriez envisager d'utiliser l'option --list-all au lieu de --list-ports.

2. Retirer le port des ports autorisés pour le fermer au trafic entrant :

   # firewall-cmd --remove-port=port-number/port-type

3. Les nouveaux paramètres doivent être conservés :

   # firewall-cmd --runtime-to-permanent

Procédure

1. Pour connaître les zones disponibles sur votre système :

   # firewall-cmd --get-zones

   La commande firewall-cmd --get-zones affiche toutes les zones disponibles sur le système, mais n'indique aucun détail sur des zones particulières.

2. Pour obtenir des informations détaillées sur toutes les zones :

   # firewall-cmd --list-all-zones

3. Pour obtenir des informations détaillées sur une zone spécifique :

   # firewall-cmd --zone=zone-name --list-all

1. Affiche la zone par défaut actuelle :

   # firewall-cmd --get-default-zone

2. Définir la nouvelle zone par défaut :

   # firewall-cmd --set-default-zone <zone_name>

   Note

   En suivant cette procédure, le réglage est permanent, même sans l'option --permanent.

1. Liste des zones actives et des interfaces qui leur sont affectées :

   # firewall-cmd --get-active-zones

2. Assigner l'interface à une zone différente :

   # firewall-cmd --zone=zone_name --change-interface=interface_name --permanent

Procédure

1. Attribuer la zone au profil de connexion NetworkManager:

   # nmcli connection modify profile connection.zone zone_name

2. Activer la connexion :

   # nmcli connection up profile

Procédure

1. Créer une nouvelle zone :

   # firewall-cmd --permanent --new-zone=zone-name

2. Vérifiez si la nouvelle zone est ajoutée à vos paramètres permanents :

   # firewall-cmd --get-zones

3. Les nouveaux paramètres doivent être conservés :

   # firewall-cmd --runtime-to-permanent

1. Lister les informations pour la zone spécifique afin de voir la cible par défaut :

   # firewall-cmd --zone=zone-name --list-all

2. Fixer un nouvel objectif dans la zone :

   # firewall-cmd --permanent --zone=zone-name --set-target=<default|ACCEPT|REJECT|DROP>

Procédure

1. Liste de toutes les zones disponibles :

   # firewall-cmd --get-zones

2. Ajouter l'IP source à la zone de confiance en mode permanent :

   # firewall-cmd --zone=trusted --add-source=192.168.2.15

3. Les nouveaux paramètres doivent être conservés :

   # firewall-cmd --runtime-to-permanent

Procédure

1. Liste des sources autorisées pour la zone requise :

   # firewall-cmd --zone=zone-name --list-sources

2. Supprimer définitivement la source de la zone :

   # firewall-cmd --zone=zone-name --remove-source=<source>

3. Les nouveaux paramètres doivent être conservés :

   # firewall-cmd --runtime-to-permanent

Procédure

1. Liste de toutes les zones disponibles :

   # firewall-cmd --get-zones
   block dmz drop external home internal public trusted work

2. Ajoutez la plage d'adresses IP à la zone internal pour acheminer le trafic provenant de la source à travers la zone :

   # firewall-cmd --zone=internal --add-source=192.0.2.0/24

3. Ajouter le service http à la zone internal:

   # firewall-cmd --zone=internal --add-service=http

4. Les nouveaux paramètres doivent être conservés :

   # firewall-cmd --runtime-to-permanent

Procédure

1. Créer une nouvelle politique.

   # firewall-cmd --permanent --new-policy podmanToHost

2. Bloquer tout le trafic.

   # firewall-cmd --permanent --policy podmanToHost --set-target REJECT
   
   # firewall-cmd --permanent --policy podmanToHost --add-service dhcp
   
   # firewall-cmd --permanent --policy podmanToHost --add-service dns

   Note

   Red Hat recommande de bloquer tout le trafic vers l'hôte par défaut, puis d'ouvrir sélectivement les services dont vous avez besoin pour l'hôte.

3. Définir la zone d'entrée à utiliser avec la politique.

   # firewall-cmd --permanent --policy podmanToHost --add-ingress-zone podman

4. Définir la zone de sortie à utiliser avec la politique.

   # firewall-cmd --permanent --policy podmanToHost --add-egress-zone ANY

Procédure

1. Pour vérifier si le masquage IP est activé (par exemple, pour la zone external ), entrez la commande suivante en tant que root:

   # firewall-cmd --zone=external --query-masquerade

   La commande imprime yes avec l'état de sortie 0 si elle est activée. Dans le cas contraire, elle affiche no avec l'état de sortie 1. Si zone est omis, la zone par défaut sera utilisée.

2. Pour activer le masquage IP, entrez la commande suivante à l'adresse root:

   # firewall-cmd --zone=external --add-masquerade

3. Pour rendre ce paramètre persistant, ajoutez l'option --permanent à la commande.

4. Pour désactiver le masquage IP, entrez la commande suivante à l'adresse root:

   # firewall-cmd --zone=external --remove-masquerade

   Pour rendre ce paramètre permanent, ajoutez l'option --permanent à la commande.

1. Réglez l'objectif de votre zone sur DROP:

   # firewall-cmd --permanent --set-target=DROP

2. Ajoutez l'inversion de bloc ICMP pour bloquer toutes les demandes ICMP en même temps :

   # firewall-cmd --add-icmp-block-inversion

3. Ajoutez le bloc ICMP pour les requêtes ICMP que vous souhaitez autoriser :

   # firewall-cmd --add-icmp-block=<icmptype>

4. Les nouveaux paramètres doivent être conservés :

   # firewall-cmd --runtime-to-permanent

1. Réglez l'objectif de votre zone sur default ou ACCEPT:

   # firewall-cmd --permanent --set-target=default

2. Supprimer tous les blocs ajoutés pour les demandes ICMP:

   # firewall-cmd --remove-icmp-block=<icmptype>

3. Retirer le bloc d'inversion ICMP:

   # firewall-cmd --remove-icmp-block-inversion

4. Les nouveaux paramètres doivent être conservés :

   # firewall-cmd --runtime-to-permanent

Procédure

1. Pour savoir si le verrouillage est activé, utilisez la commande suivante à l'adresse root:

   # firewall-cmd --query-lockdown

   La commande affiche yes avec l'état de sortie 0 si le verrouillage est activé. Dans le cas contraire, elle affiche no avec l'état de sortie 1.

2. Pour activer le verrouillage, entrez la commande suivante à l'adresse root:

   # firewall-cmd --lockdown-on

3. Pour désactiver le verrouillage, utilisez la commande suivante à l'adresse root:

   # firewall-cmd --lockdown-off

Procédure

1. Activer le transfert de paquets dans le noyau :

   # echo "net.ipv4.ip_forward=1" > /etc/sysctl.d/95-IPv4-forwarding.conf
   # sysctl -p /etc/sysctl.d/95-IPv4-forwarding.conf

2. Assurez-vous que les interfaces entre lesquelles vous voulez activer le transfert intra-zone ne sont pas assignées à une zone différente de la zone internal:

   # firewall-cmd --get-active-zones

3. Si l'interface est actuellement affectée à une zone autre que internal, réaffectez-la :

   # firewall-cmd --zone=internal --change-interface=interface_name --permanent

4. Ajouter les interfaces enp1s0 et wlp0s20 à la zone internal:

   # firewall-cmd --zone=internal --add-interface=enp1s0 --add-interface=wlp0s20

5. Activer le transfert intra-zone :

   # firewall-cmd --zone=internal --add-forward

1. Connectez-vous à un hôte qui se trouve dans le même réseau que l'interface enp1s0 de l'hôte sur lequel vous avez activé le transfert de zone.

2. Démarrez un service d'écho avec ncat pour tester la connectivité :

   # ncat -e /usr/bin/cat -l 12345

3. Connectez-vous à un hôte qui se trouve dans le même réseau que l'interface wlp0s20.

4. Se connecter au serveur d'écho fonctionnant sur l'hôte qui se trouve dans le même réseau que enp1s0:

   # ncat <other_host> 12345

5. Tapez quelque chose et appuyez sur Entrée, puis vérifiez que le texte est renvoyé.

Procédure

1. Créez un fichier playbook, par exemple ~/reset-firewalld.ymlavec le contenu suivant :

   ---
   - name: Reset firewalld example
     hosts: managed-node-01.example.com
     tasks:
     - name: Reset firewalld
       include_role:
         name: rhel-system-roles.firewall
   
       vars:
         firewall:
           - previous: replaced

2. Exécutez le manuel de jeu :

   # ansible-playbook ~/configuring-a-dmz.yml

Procédure

1. Créez un fichier playbook, par exemple ~/port_forwarding.ymlavec le contenu suivant :

   ---
   - name: Configure firewalld
     hosts: managed-node-01.example.com
     tasks:
     - name: Forward incoming traffic on port 8080 to 443
       include_role:
         name: rhel-system-roles.firewall
   
       vars:
         firewall:
           - { forward_port: 8080/tcp;443;, state: enabled, runtime: true, permanent: true }

2. Exécutez le manuel de jeu :

   # ansible-playbook ~/port_forwarding.yml

Procédure

1. Créez un fichier playbook, par exemple ~/opening-a-port.ymlavec le contenu suivant :

   ---
   - name: Configure firewalld
     hosts: managed-node-01.example.com
     tasks:
     - name: Allow incoming HTTPS traffic to the local host
       include_role:
         name: rhel-system-roles.firewall
   
       vars:
         firewall:
           - port: 443/tcp
             service: http
             state: enabled
             runtime: true
             permanent: true

   L'option permanent: true rend les nouveaux paramètres persistants à travers les redémarrages.

2. Exécutez le manuel de jeu :

   # ansible-playbook ~/opening-a-port.yml

Procédure

1. Créez un fichier playbook, par exemple ~/configuring-a-dmz.ymlavec le contenu suivant :

   ---
   - name: Configure firewalld
     hosts: managed-node-01.example.com
     tasks:
     - name: Creating a DMZ with access to HTTPS port and masquerading for hosts in DMZ
       include_role:
         name: rhel-system-roles.firewall
   
       vars:
         firewall:
           - zone: dmz
             interface: enp1s0
             service: https
             state: enabled
             runtime: true
             permanent: true

2. Exécutez le manuel de jeu :

   # ansible-playbook ~/configuring-a-dmz.yml

Procédure

1. Inscrivez les règles iptables et ip6tables dans un fichier :

   # iptables-save >/root/iptables.dump
   # ip6tables-save >/root/ip6tables.dump

2. Convertir les fichiers dump en instructions nftables:

   # iptables-restore-translate -f /root/iptables.dump > /etc/nftables/ruleset-migrated-from-iptables.nft
   # ip6tables-restore-translate -f /root/ip6tables.dump > /etc/nftables/ruleset-migrated-from-ip6tables.nft

3. Examinez et, si nécessaire, mettez à jour manuellement les règles générées sur nftables.

4. Pour permettre au service nftables de charger les fichiers générés, ajoutez ce qui suit au fichier /etc/sysconfig/nftables.conf:

   include "/etc/nftables/ruleset-migrated-from-iptables.nft"
   include "/etc/nftables/ruleset-migrated-from-ip6tables.nft"

5. Arrêtez et désactivez le service iptables:

   # systemctl disable --now iptables

   Si vous avez utilisé un script personnalisé pour charger les règles iptables, assurez-vous que le script ne démarre plus automatiquement et redémarrez pour vider toutes les tables.

6. Activez et démarrez le service nftables:

   # systemctl enable --now nftables

Procédure

1. Modifiez le fichier /etc/sysconfig/nftables.conf.

   • Si vous avez modifié les scripts *.nft créés dans /etc/nftables/ lors de l'installation du paquet nftables, décommentez la déclaration include pour ces scripts.

   • Si vous avez écrit de nouveaux scripts, ajoutez les instructions include pour inclure ces scripts. Par exemple, pour charger le script /etc/nftables/example.nft au démarrage du service nftables, ajoutez :

     include "/etc/nftables/_example_.nft"

2. Facultatif : Démarrez le service nftables pour charger les règles du pare-feu sans redémarrer le système :

   # systemctl start nftables

3. Activer le service nftables.

   # systemctl enable nftables

Procédure

1. Créez une table nommée nftables_svc avec la famille d'adresses inet afin que la table puisse traiter les paquets IPv4 et IPv6 :

   # nft add table inet nftables_svc

2. Ajoutez une chaîne de base nommée INPUT, qui traite le trafic réseau entrant, à la table inet nftables_svc:

   # nft add chain inet nftables_svc INPUT { type filter hook input priority filter \; policy accept \; }

   Pour éviter que l'interpréteur de commandes n'interprète les points-virgules comme la fin de la commande, échappez les points-virgules à l'aide du caractère \.

3. Ajoutez des règles à la chaîne INPUT. Par exemple, autoriser le trafic TCP entrant sur les ports 22 et 443 et, en tant que dernière règle de la chaîne INPUT, rejeter tout autre trafic entrant avec un message ICMP (Internet Control Message Protocol) de port inaccessible :

   # nft add rule inet nftables_svc INPUT tcp dport 22 accept
   # nft add rule inet nftables_svc INPUT tcp dport 443 accept
   # nft add rule inet nftables_svc INPUT reject with icmpx type port-unreachable

   Si vous saisissez les commandes nft add rule comme indiqué, nft ajoute les règles dans le même ordre à la chaîne que celui dans lequel vous exécutez les commandes.

4. Affiche l'ensemble de règles actuel, y compris les poignées :

   # nft -a list table inet nftables_svc
   table inet nftables_svc { # handle 13
     chain INPUT { # handle 1
       type filter hook input priority filter; policy accept;
       tcp dport 22 accept # handle 2
       tcp dport 443 accept # handle 3
       reject # handle 4
     }
   }

5. Insérez une règle avant la règle existante avec la poignée 3. Par exemple, pour insérer une règle qui autorise le trafic TCP sur le port 636, entrez :

   # nft insert rule inet nftables_svc INPUT position 3 tcp dport 636 accept

6. Ajoutez une règle après la règle existante avec la poignée 3. Par exemple, pour insérer une règle qui autorise le trafic TCP sur le port 80, entrez :

   # nft add rule inet nftables_svc INPUT position 3 tcp dport 80 accept

7. Affichez à nouveau l'ensemble de règles avec les poignées. Vérifiez que les règles ajoutées ultérieurement ont été ajoutées aux positions spécifiées :

   # nft -a list table inet nftables_svc
   table inet nftables_svc { # handle 13
     chain INPUT { # handle 1
       type filter hook input priority filter; policy accept;
       tcp dport 22 accept # handle 2
       tcp dport 636 accept # handle 5
       tcp dport 443 accept # handle 3
       tcp dport 80 accept # handle 6
       reject # handle 4
     }
   }

8. Retirer la règle à l'aide de la poignée 6 :

   # nft delete rule inet nftables_svc INPUT handle 6

   Pour supprimer une règle, vous devez spécifier la poignée.

9. Affichez le jeu de règles et vérifiez que la règle supprimée n'est plus présente :

   # nft -a list table inet nftables_svc
   table inet nftables_svc { # handle 13
     chain INPUT { # handle 1
       type filter hook input priority filter; policy accept;
       tcp dport 22 accept # handle 2
       tcp dport 636 accept # handle 5
       tcp dport 443 accept # handle 3
       reject # handle 4
     }
   }

10. Supprimer toutes les règles restantes de la chaîne INPUT:

    # nft flush chain inet nftables_svc INPUT

11. Affichez l'ensemble de règles et vérifiez que la chaîne INPUT est vide :

    # nft list table inet nftables_svc
    table inet nftables_svc {
      chain INPUT {
        type filter hook input priority filter; policy accept
      }
    }

12. Supprimer la chaîne INPUT:

    # nft delete chain inet nftables_svc INPUT

    Vous pouvez également utiliser cette commande pour supprimer les chaînes qui contiennent encore des règles.

13. Affichez le jeu de règles et vérifiez que la chaîne INPUT a été supprimée :

    # nft list table inet nftables_svc
    table inet nftables_svc {
    }

14. Supprimez le tableau nftables_svc:

    # nft delete table inet nftables_svc

    Vous pouvez également utiliser cette commande pour supprimer les tables qui contiennent encore des chaînes.

    Note

    Pour supprimer l'ensemble des règles, utilisez la commande nft flush ruleset au lieu de supprimer manuellement toutes les règles, chaînes et tables dans des commandes distinctes.

Procédure

1. Créer un tableau :

   # nft add table nat

2. Ajoutez les chaînes prerouting et postrouting au tableau :

   # nft add chain nat postrouting { type nat hook postrouting priority 100 \; }

   Important

   Même si vous n'ajoutez pas de règle à la chaîne prerouting, le cadre nftables exige que cette chaîne corresponde aux réponses des paquets entrants.

   Notez que vous devez passer l'option -- à la commande nft pour éviter que le shell n'interprète la valeur négative de la priorité comme une option de la commande nft.

3. Ajoutez une règle à la chaîne postrouting qui correspond aux paquets sortants sur l'interface ens3:

   # nft add rule nat postrouting oifname "ens3" masquerade

Procédure

1. Créer un tableau :

   # nft add table nat

2. Ajoutez les chaînes prerouting et postrouting au tableau :

   # nft add chain nat postrouting { type nat hook postrouting priority 100 \; }

   Important

   Même si vous n'ajoutez pas de règle à la chaîne postrouting, le cadre nftables exige que cette chaîne corresponde aux réponses des paquets sortants.

   Notez que vous devez passer l'option -- à la commande nft pour éviter que le shell n'interprète la valeur négative de la priorité comme une option de la commande nft.

3. Ajoutez une règle à la chaîne postrouting qui remplace l'IP source des paquets sortants via ens3 par 192.0.2.1:

   # nft add rule nat postrouting oifname "ens3" snat to 192.0.2.1

Procédure

1. Créer un tableau :

   # nft add table nat

2. Ajoutez les chaînes prerouting et postrouting au tableau :

   # nft -- add chain nat prerouting { type nat hook prerouting priority -100 \; }
   # nft add chain nat postrouting { type nat hook postrouting priority 100 \; }

   Important

   Même si vous n'ajoutez pas de règle à la chaîne postrouting, le cadre nftables exige que cette chaîne corresponde aux réponses des paquets sortants.

   Notez que vous devez passer l'option -- à la commande nft pour éviter que le shell n'interprète la valeur négative de la priorité comme une option de la commande nft.

3. Ajoutez une règle à la chaîne prerouting qui redirige le trafic entrant vers les ports 80 et 443 sur l'interface ens3 du routeur vers le serveur web avec l'adresse IP 192.0.2.1:"

   # nft add rule nat prerouting iifname ens3 tcp dport { 80, 443 } dnat to 192.0.2.1

4. En fonction de votre environnement, ajoutez une règle SNAT ou de masquage pour modifier l'adresse source des paquets renvoyés par le serveur web à l'expéditeur :

   1. Si l'interface ens3 utilise une adresse IP dynamique, ajoutez une règle de masquage :

      # nft add rule nat postrouting oifname "ens3" masquerade

   2. Si l'interface ens3 utilise une adresse IP statique, ajoutez une règle SNAT. Par exemple, si l'interface ens3 utilise l'adresse IP 198.51.100.1:

      # nft add rule nat postrouting oifname "ens3" snat to 198.51.100.1

5. Activer le transfert de paquets :

   # echo "net.ipv4.ip_forward=1" > /etc/sysctl.d/95-IPv4-forwarding.conf
   # sysctl -p /etc/sysctl.d/95-IPv4-forwarding.conf

Procédure

1. Créer un tableau :

   # nft add table nat

2. Ajoutez la chaîne prerouting à la table :

   # nft -- add chain nat prerouting { type nat hook prerouting priority -100 \; }

   Notez que vous devez passer l'option -- à la commande nft pour éviter que le shell n'interprète la valeur négative de la priorité comme une option de la commande nft.

3. Ajoutez une règle à la chaîne prerouting qui redirige le trafic entrant sur le port 22 vers le port 2222:

   # nft add rule nat prerouting tcp dport 22 redirect to 2222

Procédure

1. Par exemple, pour ajouter une règle à example_chain dans example_table qui autorise le trafic entrant vers les ports 22, 80 et 443:

   # nft add rule inet example_table example_chain tcp dport { 22, 80, 443 } accept

2. Optionnel : Afficher toutes les chaînes et leurs règles sur example_table:

   # nft list table inet example_table
   table inet example_table {
     chain example_chain {
       type filter hook input priority filter; policy accept;
       tcp dport { ssh, http, https } accept
     }
   }

Procédure

1. Créez un ensemble vide. Les exemples suivants créent un ensemble pour les adresses IPv4 :

   • Pour créer un ensemble pouvant stocker plusieurs adresses IPv4 individuelles :

     # nft add set inet example_table example_set { type ipv4_addr \; }

   • Pour créer un ensemble capable de stocker des plages d'adresses IPv4 :

     # nft add set inet example_table example_set { type ipv4_addr \; flags interval \; }

   Important

   Pour éviter que l'interpréteur de commandes n'interprète les points-virgules comme la fin de la commande, vous devez les faire précéder d'une barre oblique inverse.

2. Facultatif : Créez des règles qui utilisent l'ensemble. Par exemple, la commande suivante ajoute une règle à l'ensemble example_chain dans l'ensemble example_table qui supprimera tous les paquets provenant des adresses IPv4 de l'ensemble example_set.

   # nft add rule inet example_table example_chain ip saddr @example_set drop

   Comme example_set est toujours vide, la règle n'a actuellement aucun effet.

3. Ajouter des adresses IPv4 à example_set:

   • Si vous créez un ensemble qui stocke des adresses IPv4 individuelles, entrez :

     # nft add element inet example_table example_set { 192.0.2.1, 192.0.2.2 }

   • Si vous créez un ensemble qui stocke des plages IPv4, entrez :

     # nft add element inet example_table example_set { 192.0.2.0-192.0.2.255 }

     Lorsque vous spécifiez une plage d'adresses IP, vous pouvez également utiliser la notation CIDR (Classless Inter-Domain Routing), comme 192.0.2.0/24 dans l'exemple ci-dessus.

Procédure

1. Créer un nouveau tableau :

   # nft add table inet example_table

2. Créez la chaîne tcp_packets dans example_table:

   # nft add chain inet example_table tcp_packets

3. Ajoutez une règle à tcp_packets qui compte le trafic dans cette chaîne :

   # nft add rule inet example_table tcp_packets counter

4. Créer la chaîne udp_packets dans example_table

   # nft add chain inet example_table udp_packets

5. Ajoutez une règle à udp_packets qui compte le trafic dans cette chaîne :

   # nft add rule inet example_table udp_packets counter

6. Créez une chaîne pour le trafic entrant. Par exemple, pour créer une chaîne nommée incoming_traffic dans example_table qui filtre le trafic entrant :

   # nft add chain inet example_table incoming_traffic { type filter hook input priority 0 \; }

7. Ajouter une règle avec une carte anonyme à incoming_traffic:

   # nft add rule inet example_table incoming_traffic ip protocol vmap { tcp : jump tcp_packets, udp : jump udp_packets }

   La carte anonyme distingue les paquets et les envoie aux différentes chaînes de comptage en fonction de leur protocole.

8. Pour dresser la liste des compteurs de trafic, affichez example_table:

   # nft list table inet example_table
   table inet example_table {
     chain tcp_packets {
       counter packets 36379 bytes 2103816
     }
   
     chain udp_packets {
       counter packets 10 bytes 1559
     }
   
     chain incoming_traffic {
       type filter hook input priority filter; policy accept;
       ip protocol vmap { tcp : jump tcp_packets, udp : jump udp_packets }
     }
   }

   Les compteurs des chaînes tcp_packets et udp_packets affichent le nombre de paquets et d'octets reçus.

Procédure

1. Créez une table. Par exemple, pour créer une table nommée example_table qui traite les paquets IPv4 :

   # nft add table ip example_table

2. Créer une chaîne. Par exemple, pour créer une chaîne nommée example_chain dans example_table:

   # nft add chain ip example_table example_chain { type filter hook input priority 0 \; }

   Important

   Pour éviter que l'interpréteur de commandes n'interprète les points-virgules comme la fin de la commande, vous devez les faire précéder d'une barre oblique inverse.

3. Créez une carte vide. Par exemple, pour créer une carte pour les adresses IPv4 :

   # nft add map ip example_table example_map { type ipv4_addr : verdict \; }

4. Créez des règles qui utilisent la carte. Par exemple, la commande suivante ajoute une règle à example_chain dans example_table qui applique des actions aux adresses IPv4 qui sont toutes deux définies dans example_map:

   # nft add rule example_table example_chain ip saddr vmap @example_map

5. Ajouter les adresses IPv4 et les actions correspondantes à example_map:

   # nft add element ip example_table example_map { 192.0.2.1 : accept, 192.0.2.2 : drop }

   Cet exemple définit les correspondances entre les adresses IPv4 et les actions. En combinaison avec la règle créée ci-dessus, le pare-feu accepte les paquets provenant de 192.0.2.1 et laisse tomber les paquets provenant de 192.0.2.2.

6. Facultatif : Améliorez la carte en ajoutant une autre adresse IP et une déclaration d'action :

   # nft add element ip example_table example_map { 192.0.2.3 : accept }

7. Facultatif : Supprimer une entrée de la carte :

   # nft delete element ip example_table example_map { 192.0.2.1 }

8. Facultatif : Affichez l'ensemble de règles :

   # nft list ruleset
   table ip example_table {
     map example_map {
       type ipv4_addr : verdict
       elements = { 192.0.2.2 : drop, 192.0.2.3 : accept }
     }
   
     chain example_chain {
       type filter hook input priority filter; policy accept;
       ip saddr vmap @example_map
     }
   }

Procédure

1. Créez le fichier /etc/rsyslog.d/nftables.conf avec le contenu suivant :

   :msg, startswith, "nft drop" -/var/log/nftables.log
   & stop

   Avec cette configuration, le service rsyslog enregistre les paquets abandonnés dans le fichier /var/log/nftables.log au lieu de /var/log/messages.

2. Redémarrez le service rsyslog:

   # systemctl restart rsyslog

3. Créez le fichier /etc/logrotate.d/nftables avec le contenu suivant pour faire pivoter /var/log/nftables.log si la taille dépasse 10 Mo :

   /var/log/nftables.log {
     size +10M
     maxage 30
     sharedscripts
     postrotate
       /usr/bin/systemctl kill -s HUP rsyslog.service >/dev/null 2>&1 || true
     endscript
   }

   Le paramètre maxage 30 définit que logrotate supprime les journaux en rotation âgés de plus de 30 jours lors de la prochaine opération de rotation.

Procédure

1. Créez le script /etc/nftables/firewall.nft avec le contenu suivant :

   # Remove all rules
   flush ruleset
   
   
   # Table for both IPv4 and IPv6 rules
   table inet nftables_svc {
   
     # Define variables for the interface name
     define INET_DEV = enp1s0
     define LAN_DEV  = enp7s0
     define DMZ_DEV  = enp8s0
   
   
     # Set with the IPv4 addresses of admin PCs
     set admin_pc_ipv4 {
       type ipv4_addr
       elements = { 10.0.0.100, 10.0.0.200 }
     }
   
   
     # Chain for incoming trafic. Default policy: drop
     chain INPUT {
       type filter hook input priority filter
       policy drop
   
       # Accept packets in established and related state, drop invalid packets
       ct state vmap { established:accept, related:accept, invalid:drop }
   
       # Accept incoming traffic on loopback interface
       iifname lo accept
   
       # Allow request from LAN and DMZ to local DNS server
       iifname { $LAN_DEV, $DMZ_DEV } meta l4proto { tcp, udp } th dport 53 accept
   
       # Allow admins PCs to access the router using SSH
       iifname $LAN_DEV ip saddr @admin_pc_ipv4 tcp dport 22 accept
   
       # Last action: Log blocked packets
       # (packets that were not accepted in previous rules in this chain)
       log prefix "nft drop IN : "
     }
   
   
     # Chain for outgoing traffic. Default policy: drop
     chain OUTPUT {
       type filter hook output priority filter
       policy drop
   
       # Accept packets in established and related state, drop invalid packets
       ct state vmap { established:accept, related:accept, invalid:drop }
   
       # Accept outgoing traffic on loopback interface
       oifname lo accept
   
       # Allow local DNS server to recursively resolve queries
       oifname $INET_DEV meta l4proto { tcp, udp } th dport 53 accept
   
       # Last action: Log blocked packets
       log prefix "nft drop OUT: "
     }
   
   
     # Chain for forwarding traffic. Default policy: drop
     chain FORWARD {
       type filter hook forward priority filter
       policy drop
   
       # Accept packets in established and related state, drop invalid packets
       ct state vmap { established:accept, related:accept, invalid:drop }
   
       # IPv4 access from LAN and Internet to the HTTPS server in the DMZ
       iifname { $LAN_DEV, $INET_DEV } oifname $DMZ_DEV ip daddr 198.51.100.5 tcp dport 443 accept
   
       # IPv6 access from Internet to the HTTPS server in the DMZ
       iifname $INET_DEV oifname $DMZ_DEV ip6 daddr 2001:db8:b::5 tcp dport 443 accept
   
       # Access from LAN and DMZ to HTTPS servers on the Internet
       iifname { $LAN_DEV, $DMZ_DEV } oifname $INET_DEV tcp dport 443 accept
   
       # Last action: Log blocked packets
       log prefix "nft drop FWD: "
     }
   
   
     # Postrouting chain to handle SNAT
     chain postrouting {
       type nat hook postrouting priority srcnat; policy accept;
   
       # SNAT for IPv4 traffic from LAN to Internet
       iifname $LAN_DEV oifname $INET_DEV snat ip to 203.0.113.1
     }
   }

2. Inclure le script /etc/nftables/firewall.nft dans le fichier /etc/sysconfig/nftables.conf:

   include "/etc/nftables/firewall.nft"

3. Activer le transfert IPv4 :

   # echo "net.ipv4.ip_forward=1" > /etc/sysctl.d/95-IPv4-forwarding.conf
   # sysctl -p /etc/sysctl.d/95-IPv4-forwarding.conf

4. Activez et démarrez le service nftables:

   # systemctl enable --now nftables

Vérification

1. Facultatif : Vérifiez l'ensemble de règles nftables:

   # nft list ruleset
   ...

2. Essayez d'effectuer un accès que le pare-feu empêche. Par exemple, essayez d'accéder au routeur en utilisant SSH depuis la zone démilitarisée :

   # ssh router.example.com
   ssh: connect to host router.example.com port 22: Network is unreachable

3. En fonction de vos paramètres de journalisation, vous pouvez effectuer une recherche :

   • Le journal systemd pour les paquets bloqués :

     # journalctl -k -g "nft drop"
     Oct 14 17:27:18 router kernel: nft drop IN : IN=enp8s0 OUT= MAC=... SRC=198.51.100.5 DST=198.51.100.1 ... PROTO=TCP SPT=40464 DPT=22 ... SYN ...

   • Le fichier /var/log/nftables.log pour les paquets bloqués :

     Oct 14 17:27:18 router kernel: nft drop IN : IN=enp8s0 OUT= MAC=... SRC=198.51.100.5 DST=198.51.100.1 ... PROTO=TCP SPT=40464 DPT=22 ... SYN ...

Procédure

1. Créez une table nommée nat avec la famille d'adresses ip:

   # nft add table ip nat

2. Ajoutez les chaînes prerouting et postrouting au tableau :

   # nft -- add chain ip nat prerouting { type nat hook prerouting priority -100 \; }

   Note

   Passez l'option -- à la commande nft pour éviter que le shell n'interprète la valeur négative de la priorité comme une option de la commande nft.

3. Ajoutez une règle à la chaîne prerouting qui redirige les paquets entrants sur le port 8022 vers le port local 22:

   # nft add rule ip nat prerouting tcp dport 8022 redirect to :22

Procédure

1. Créez une table nommée nat avec la famille d'adresses ip:

   # nft add table ip nat

2. Ajoutez les chaînes prerouting et postrouting au tableau :

   # nft -- add chain ip nat prerouting { type nat hook prerouting priority -100 \; }
   # nft add chain ip nat postrouting { type nat hook postrouting priority 100 \; }

   Note

   Passez l'option -- à la commande nft pour éviter que le shell n'interprète la valeur négative de la priorité comme une option de la commande nft.

3. Ajoutez une règle à la chaîne prerouting qui redirige les paquets entrants sur le port 443 vers le même port sur 192.0.2.1:

   # nft add rule ip nat prerouting tcp dport 443 dnat to 192.0.2.1

4. Ajoutez une règle à la chaîne postrouting pour masquer le trafic sortant :

   # nft add rule ip nat postrouting daddr 192.0.2.1 masquerade

5. Activer le transfert de paquets :

   # echo "net.ipv4.ip_forward=1" > /etc/sysctl.d/95-IPv4-forwarding.conf
   # sysctl -p /etc/sysctl.d/95-IPv4-forwarding.conf

Procédure

1. Créer un ensemble dynamique d'adresses IPv4 :

   # nft add set inet example_table example_meter { type ipv4_addr\; flags dynamic \;}

2. Ajoutez une règle qui n'autorise que deux connexions simultanées au port SSH (22) à partir d'une adresse IPv4 et qui rejette toutes les autres connexions à partir de la même IP :

   # nft add rule ip example_table example_chain tcp dport ssh meter example_meter { ip saddr ct count over 2 } counter reject

3. Facultatif : Affichez le jeu créé à l'étape précédente :

   # nft list set inet example_table example_meter
   table inet example_table {
     meter example_meter {
       type ipv4_addr
       size 65535
       elements = { 192.0.2.1 ct count over 2 , 192.0.2.2 ct count over 2  }
     }
   }

   L'entrée elements affiche les adresses qui correspondent actuellement à la règle. Dans cet exemple, elements répertorie les adresses IP qui ont des connexions actives au port SSH. Notez que la sortie n'affiche pas le nombre de connexions actives ou si les connexions ont été rejetées.

Procédure

1. Créez la table filter avec la famille d'adresses ip:

   # nft add table ip filter

2. Ajoutez la chaîne input au tableau filter:

   # nft add chain ip filter input { type filter hook input priority 0 \; }

3. Ajoutez un ensemble nommé denylist à la table filter:

   # nft add set ip filter denylist { type ipv4_addr \; flags dynamic, timeout \; timeout 5m \; }

   Cette commande crée un ensemble dynamique d'adresses IPv4. Le paramètre timeout 5m définit que nftables supprime automatiquement les entrées après cinq minutes afin d'éviter que l'ensemble ne se remplisse d'entrées périmées.

4. Ajoutez une règle qui ajoute automatiquement à l'ensemble denylist l'adresse IP source des hôtes qui tentent d'établir plus de dix nouvelles connexions TCP en l'espace d'une minute :

   # nft add rule ip filter input ip protocol tcp ct state new, untracked add @denylist { ip saddr limit rate over 10/minute } drop

Procédure

1. Ajoutez une nouvelle règle avec le paramètre counter à la chaîne. L'exemple suivant ajoute une règle avec un compteur qui autorise le trafic TCP sur le port 22 et compte les paquets et le trafic qui correspondent à cette règle :

   # nft add rule inet example_table example_chain tcp dport 22 counter accept

2. Pour afficher les valeurs du compteur :

   # nft list ruleset
   table inet example_table {
     chain example_chain {
       type filter hook input priority filter; policy accept;
       tcp dport ssh counter packets 6872 bytes 105448565 accept
     }
   }

Procédure

1. Affiche les règles de la chaîne, y compris leurs poignées :

   # nft --handle list chain inet example_table example_chain
   table inet example_table {
     chain example_chain { # handle 1
       type filter hook input priority filter; policy accept;
       tcp dport ssh accept # handle 4
     }
   }

2. Ajoutez le compteur en remplaçant la règle par le paramètre counter. L'exemple suivant remplace la règle affichée à l'étape précédente et ajoute un compteur :

   # nft replace rule inet example_table example_chain handle 4 tcp dport 22 counter accept

3. Pour afficher les valeurs du compteur :

   # nft list ruleset
   table inet example_table {
     chain example_chain {
       type filter hook input priority filter; policy accept;
       tcp dport ssh counter packets 6872 bytes 105448565 accept
     }
   }

Procédure

1. Affiche les règles de la chaîne, y compris leurs poignées :

   # nft --handle list chain inet example_table example_chain
   table inet example_table {
     chain example_chain { # handle 1
       type filter hook input priority filter; policy accept;
       tcp dport ssh accept # handle 4
     }
   }

2. Ajoutez la fonction de traçage en remplaçant la règle par les paramètres meta nftrace set 1. L'exemple suivant remplace la règle affichée à l'étape précédente et active le traçage :

   # nft replace rule inet example_table example_chain handle 4 tcp dport 22 meta nftrace set 1 accept

3. Utilisez la commande nft monitor pour afficher le suivi. L'exemple suivant filtre la sortie de la commande pour n'afficher que les entrées contenant inet example_table example_chain:

   # nft monitor | grep "inet example_table example_chain"
   trace id 3c5eb15e inet example_table example_chain packet: iif "enp1s0" ether saddr 52:54:00:17:ff:e4 ether daddr 52:54:00:72:2f:6e ip saddr 192.0.2.1 ip daddr 192.0.2.2 ip dscp cs0 ip ecn not-ect ip ttl 64 ip id 49710 ip protocol tcp ip length 60 tcp sport 56728 tcp dport ssh tcp flags == syn tcp window 64240
   trace id 3c5eb15e inet example_table example_chain rule tcp dport ssh nftrace set 1 accept (verdict accept)
   ...

   Avertissement

   En fonction du nombre de règles dont le traçage est activé et de la quantité de trafic correspondant, la commande nft monitor peut afficher un grand nombre de résultats. Utilisez grep ou d'autres utilitaires pour filtrer la sortie.