🛡️ Pare-feu Linux : iptables, nftables & NAT

iptables organise les règles en Tables, basées sur le but (objectif) de la règle.

Important : Si vous ne spécifiez pas de table (-t), iptables utilise la table filter par défaut.

Les Chaînes (Chains) sont des listes de règles attachées aux "Hooks" Netfilter. Comprendre quand chaque chaîne est traversée est la clé.

Une "règle" est composée de Matches (Critères) (ex: "SI c'est TCP et Port 80") et d'une Cible (Target) (ex: "ALORS FAIRE ACCEPT").

Syntaxe (Exemple)

iptables -t filter -A INPUT -i eth0 -p tcp -s 1.2.3.4 --dport 22 -j ACCEPT

Matches (Critères) Courants

La Cible (Target) (-j [TARGET]) est l'action à entreprendre si le paquet "matche" la règle.

DROP vs REJECT (Sécurité)

• DROP (Recommandé pour WAN) : (Mode "Stealth"/Furtif) Ne donne aucune information à un attaquant (scan Nmap). L'attaquant ne sait pas si l'hôte existe ou si le firewall le bloque (Timeout).
• REJECT (Recommandé pour LAN) : (Poli) Permet au client (légitime) de savoir immédiatement que le port est fermé ("Connection refused"). (Meilleur pour le débogage interne).

La cible LOG est une "non-terminating target". Elle enregistre (logge) le paquet, puis le paquet continue son chemin (vers la règle suivante).

Usage (Débogage)

Très utile pour déboguer pourquoi des paquets sont "droppés" (bloqués) par la règle "Deny All" finale.

# (En haut de la chaîne INPUT, avant le DROP final)

# 1. Logger le paquet (avec un préfixe lisible)
iptables -A INPUT -m limit --limit 5/min -j LOG \
         --log-prefix "IPTABLES (DROP): " --log-level 7

# 2. Dropper le paquet
iptables -A INPUT -j DROP

• -m limit --limit 5/min : (Important) Limite le logging (ex: 5/min) pour éviter de noyer (Flood) les logs (dmesg) lors d'une attaque DoS.

Lire les Logs

# (Les logs iptables (Kernel) vont souvent dans 'dmesg' ou 'syslog')
$ sudo dmesg -w

[12345.67] IPTABLES (DROP): IN=eth0 OUT= MAC=... SRC=1.2.3.4 DST=... PROTO=TCP DPT=23 ...

conntrack (Connection Tracking) est le moteur stateful de Netfilter. C'est un sous-système du noyau qui "mémorise" toutes les connexions (sessions) actives qui traversent le firewall.

Il est chargé automatiquement lorsque vous utilisez -m state ou la table nat.

La Table de Suivi (State Table)

Vous pouvez inspecter la table conntrack (sur Linux) :

# (Installer 'conntrack-tools' ou lire /proc)
$ cat /proc/net/nf_conntrack

(Exemple de ligne)
tcp 6 120 ESTABLISHED
  src=192.168.1.50 dst=1.1.1.1 sport=12345 dport=22
  src=1.1.1.1 dst=80.1.2.3 sport=22 dport=12345
  [ASSURED] ...

• Montre la connexion (SSH) de 192.168.1.50 (client) vers 1.1.1.1 (serveur).
• Montre la traduction (NAT) attendue pour la réponse (dst=80.1.2.3 est le NAT).
• Montre l'état (ESTABLISHED).

Le match -m state (ou -m conntrack --ctstate) est la pierre angulaire du firewall stateful. Il permet de filtrer basé sur l'état de la connexion (trouvée dans la table conntrack).

La Règle d'Or (Stateful)

La première règle (après -i lo) de votre chaîne INPUT (et FORWARD) doit toujours être :

# Autoriser tout ce qui est "déjà connu"
iptables -A INPUT -m state --state RELATED,ESTABLISHED -j ACCEPT

# (Ne filtrer (NEW) que ce qui reste)

La Politique (Policy) (-P) est le "verdict" par défaut d'une chaîne (s'il n'y a pas de DROP/REJECT explicite à la fin).

iptables -P INPUT ACCEPT
iptables -A INPUT -p tcp --dport 23 -j DROP

iptables -P INPUT DROP
iptables -A INPUT -p tcp --dport 22 -j ACCEPT
iptables -A INPUT -p tcp --dport 80 -j ACCEPT

Si votre politique INPUT est DROP (voir 4.1), la première règle que vous devez ajouter est d'autoriser le trafic "loopback".

# (Règle 1)
iptables -A INPUT -i lo -j ACCEPT

Pourquoi ?

L'interface lo (loopback) est une interface virtuelle (IP: 127.0.0.1) que les processus sur le serveur utilisent pour communiquer entre eux (Inter-Process Communication - IPC) via des sockets TCP/IP.

Risque : Si vous bloquez -i lo, votre base de données (MySQL) (écoutant sur 127.0.0.1:3306) ne pourra pas parler à votre serveur web (PHP) (sur 127.0.0.1). Le site sera en panne, même si les ports 80/443 sont ouverts.

Scénario complet pour un serveur web Linux (Politique : Whitelist/DROP).

#!/bin/sh
# Vider toutes les règles (Flush)
iptables -F
iptables -X

# 1. Politique par défaut (Tout bloquer)
iptables -P INPUT DROP
iptables -P FORWARD DROP
iptables -P OUTPUT ACCEPT # (On fait confiance à nos propres processus sortants)

# 2. Autoriser le Loopback (localhost)
iptables -A INPUT -i lo -j ACCEPT

# 3. Autoriser le trafic déjà établi (Stateful)
# (La règle la plus importante)
iptables -A INPUT -m state --state RELATED,ESTABLISHED -j ACCEPT

# 4. Autoriser Ping (ICMP Echo)
iptables -A INPUT -p icmp --icmp-type 8 -j ACCEPT

# 5. Autoriser SSH (TCP 22)
iptables -A INPUT -p tcp --dport 22 -m state --state NEW -j ACCEPT

# 6. Autoriser le Web (TCP 80, 443)
# (Utilisation du module 'multiport')
iptables -A INPUT -p tcp -m multiport --dports 80,443 -m state --state NEW -j ACCEPT

# (Note: Tout le reste (ex: UDP, Port 23...) est bloqué par
#  la politique INPUT DROP)

Pour utiliser Linux comme un routeur/firewall (ex: pfSense, OPNsense), on utilise la table nat (-t nat).

Cette table est consultée avant la table filter (pour DNAT) et après (pour SNAT).

Chaînes nat

Objectif : Permettre au LAN (ex: 192.168.1.0/24 sur eth1) d'accéder à Internet via l'IP publique (sur eth0).

Chaîne : POSTROUTING (Car on modifie la source *après* que le routage (FORWARD) ait eu lieu, juste avant la sortie).

# Activer le routage (Kernel)
sysctl -w net.ipv4.ip_forward=1

# (eth0 = WAN, eth1 = LAN)
# (Trafic sortant sur 'eth0', venant du sous-réseau '192...')
iptables -t nat -A POSTROUTING -o eth0 -s 192.168.1.0/24 -j MASQUERADE

# (N'oubliez pas d'autoriser le FORWARD dans 'filter', voir 6.1 !)

# Activer le routage
sysctl -w net.ipv4.ip_forward=1

# (Trafic sortant sur 'eth0', venant du LAN...)
iptables -t nat -A POSTROUTING -o eth0 -s 192.168.1.0/24 \
         -j SNAT --to-source 80.1.2.3

Objectif : Rediriger le trafic entrant (ex: Port 80) vers un serveur interne (DMZ/LAN). C'est le Port Forwarding.

Chaîne : PREROUTING (Car on modifie la destination *avant* que le noyau ne décide où router le paquet).

Cible : DNAT (Destination NAT)

# Activer le routage
sysctl -w net.ipv4.ip_forward=1

# 1. Règle DNAT (Table 'nat')
# (Trafic entrant sur 'eth0' (WAN) pour port 80...)
iptables -t nat -A PREROUTING -i eth0 -p tcp --dport 80 \
         -j DNAT --to-destination 192.168.1.100
         
# (On peut aussi changer le port de destination)
iptables -t nat -A PREROUTING -i eth0 -p tcp --dport 2222 \
         -j DNAT --to-destination 192.168.1.100:22

Attention : Cette règle ne suffit pas ! (Voir 6.1). Le paquet est maintenant destiné à 192.168.1.100, mais il doit encore être autorisé à être routé (FORWARDED).

C'est l'erreur n°1 lors de la configuration d'un routeur Linux. Le NAT (-t nat) et le Filtre (-t filter) sont deux tables séparées.

DNAT (5.3) traduit l'adresse, mais ne l'autorise pas.

Vous devez ajouter une règle FORWARD (dans la table filter) pour autoriser le paquet (maintenant translaté) à passer.

Exemple (Complément du DNAT)

# (Après la règle DNAT de 5.3...)

# (Règle 2 : Autoriser le FORWARDING du paquet)
# (Note : On filtre sur la *nouvelle* destination (192...))
iptables -A FORWARD -i eth0 -o eth1 \
         -d 192.168.1.100 -p tcp --dport 80 \
         -m state --state NEW,ESTABLISHED \
         -j ACCEPT
         
# (Et autoriser le retour !)
iptables -A FORWARD -i eth1 -o eth0 \
         -s 192.168.1.100 \
         -m state --state ESTABLISHED \
         -j ACCEPT

# Lister les règles (Table filter)
# -n (Numérique : ne pas résoudre DNS/Ports)
# -v (Verbeux : affiche paquets/octets)
# --line-numbers (CRUCIAL : affiche les numéros)
$ sudo iptables -L -n -v --line-numbers

# Lister les règles (Table nat)
$ sudo iptables -t nat -L -n -v --line-numbers

# Vider (Flush) toutes les règles (filter)
$ sudo iptables -F
# Vider toutes les règles (nat)
$ sudo iptables -t nat -F

# Vider les chaînes perso (avant -F)
$ sudo iptables -X

# Mettre les Politiques par défaut à ACCEPT (avant de vider !)
$ sudo iptables -P INPUT ACCEPT
$ sudo iptables -P FORWARD ACCEPT

# Supprimer (Delete) une règle par son numéro
# (Ex: Supprimer la règle 3 de INPUT)
$ sudo iptables -D INPUT 3

# Insérer (Insert) une règle au début (numéro 1)
$ sudo iptables -I INPUT 1 -p tcp --dport 22 -j ACCEPT

Le Piège : Les règles iptables sont volatiles ! Elles sont stockées en RAM (Kernel) et sont perdues au redémarrage (reboot).

Pour les rendre persistantes, il faut les sauvegarder/restaurer.

# 1. Sauvegarder (Dump) la config actuelle
# (Inclut TOUTES les tables : filter, nat...)
$ sudo iptables-save > /etc/iptables/rules.v4

# 2. Restaurer (au boot)
# (Généralement via un script @reboot ou un service)
$ sudo iptables-restore < /etc/iptables/rules.v4

# 1. Installer le paquet
$ sudo apt-get install iptables-persistent

# (L'installeur demande "Sauvegarder les règles actuelles ?")
# (Il crée /etc/iptables/rules.v4 et rules.v6)

# 2. (Après modification) Sauvegarder manuellement
$ sudo iptables-save > /etc/iptables/rules.v4
# (ou '$ sudo netfilter-persistent save')

# 3. (Au prochain boot, le service 'netfilter-persistent'
#    exécutera 'iptables-restore' automatiquement)

nftables est le remplaçant moderne de iptables. Il est basé sur Netfilter (comme iptables), mais résout ses problèmes fondamentaux.

Outil de Traduction

nftables fournit des outils pour aider la migration :

# Convertit vos règles iptables actuelles en syntaxe nftables
$ iptables-translate -A INPUT -p tcp --dport 22 -j ACCEPT
nft add rule ip filter INPUT tcp dport 22 accept

UFW est un "frontend" (une interface de gestion simplifiée) pour iptables, très populaire sur Ubuntu.

Il est conçu pour rendre la configuration d'un firewall hôte (Stateful) très simple.

Exemple de Workflow

# 1. Activer le firewall (avec les politiques par défaut)
# (Par défaut : DENY incoming, ALLOW outgoing, DENY forward)
$ sudo ufw enable

# 2. Ouvrir des ports (Règles PERMIT)
# (UFW lit /etc/services pour les noms)
$ sudo ufw allow ssh       (Port 22)
$ sudo ufw allow http      (Port 80)
$ sudo ufw allow 443/tcp   (Port 443)

# 3. Autoriser une IP spécifique (ex: IP Admin)
$ sudo ufw allow from 1.2.3.4 to any port 22

# 4. Voir le statut
$ sudo ufw status verbose
Status: active
To                         Action      From
--                         ------      ----
22/tcp                     ALLOW IN    Anywhere
80/tcp                     ALLOW IN    Anywhere
443/tcp                    ALLOW IN    Anywhere
22/tcp                     ALLOW IN    1.2.3.4

firewalld (utilisé par RHEL, CentOS, Fedora) est un frontend dynamique qui utilise nftables (ou iptables en fallback).

Son concept clé est la Gestion de "Zones" (similaire aux Zones de confiance d'un firewall appliance).

Zones (Exemples)

• public : (Défaut pour le WAN) Non fiable. (Bloque tout, sauf ex: SSH).
• internal : (Pour le LAN) Fiable. (Autorise plus de services).
• dmz : (Zone Démilitarisée).
• drop : Jette tout (Blackhole).

Fonctionnement (Dynamique)

Une interface (ex: eth0) est assignée à une Zone (ex: public). Un changement de règle (firewall-cmd) est appliqué immédiatement, sans recharger tout le firewall.

# Voir la zone active (par défaut)
$ firewall-cmd --get-default-zone
public

# Voir les règles de la zone 'public'
$ firewall-cmd --zone=public --list-all
public (active)
  services: cockpit dhcpv6-client ssh

# Ajouter HTTP à la zone 'public' (temporairement)
$ firewall-cmd --zone=public --add-service=http

# Ajouter HTTP (permanent)
$ firewall-cmd --zone=public --add-service=http --permanent
$ firewall-cmd --reload