{"id":5837,"date":"2017-09-27T10:18:10","date_gmt":"2017-09-27T10:18:10","guid":{"rendered":"https:\/\/blog.hostinger.io\/fr-tutoriels\/?p=5837"},"modified":"2026-08-20T16:55:00","modified_gmt":"2026-08-20T09:55:00","slug":"iptables","status":"publish","type":"post","link":"\/fr\/tutoriels\/iptables\/","title":{"rendered":"Tutoriel iptables : s\u00e9curisez un VPS avec un pare-feu Linux"},"content":{"rendered":"

Iptables est un outil de pare-feu Linux qui vous permet de contrôler le trafic qui atteint votre VPS en configurant des règles pour autoriser, bloquer, transférer et filtrer les paquets.<\/p>

Il s’appuie sur le framework netfilter intégré au noyau Linux et reste l’une des solutions de pare-feu les plus utilisées sur les serveurs Linux.<\/p>

Iptables organise les règles en tables, chaînes, critères de correspondance et cibles. Pour configurer votre pare-feu en toute sécurité, commencez par autoriser SSH et les connexions établies avant d’appliquer des règles DROP<\/code>. Vous devez également enregistrer explicitement les règles pour les conserver après un redémarrage.<\/p>

UFW et nftables constituent également des alternatives adaptées selon vos besoins.<\/p>

Les principales étapes pour configurer iptables sont les suivantes :<\/p>

    \n
  1. Vérifiez et installez iptables.<\/li>\n\n\n\n
  2. Affichez les règles existantes.<\/li>\n\n\n\n
  3. Autorisez SSH avant d’appliquer des règles restrictives.<\/li>\n\n\n\n
  4. Ajoutez les règles de pare-feu de base.<\/li>\n\n\n\n
  5. Ouvrez les ports des services courants.<\/li>\n\n\n\n
  6. Supprimez ou videz les règles.<\/li>\n\n\n\n
  7. Enregistrez les règles de manière permanente.<\/li>\n<\/ol>

    Qu’est-ce qu’iptables ?<\/h2>

    Iptables est un outil de pare-feu en ligne de commande qui gère les règles de pare-feu Linux par l’intermédiaire de netfilter, un système de filtrage des paquets directement intégré au noyau Linux. Chaque paquet qui entre dans votre serveur ou qui en sort passe par netfilter, tandis qu’iptables fournit les règles qui déterminent son traitement.<\/p>

    Iptables gère le trafic IPv4. Pour le trafic IPv6, vous devez utiliser ip6tables, qui reprend la même syntaxe mais fonctionne avec un ensemble de règles distinct.<\/p>

    Le fonctionnement d’iptables repose sur cinq concepts fondamentaux :<\/p>

    Concept<\/strong><\/th>Description<\/strong><\/th><\/tr><\/thead>
    Table<\/strong><\/td>Ensemble de chaînes regroupées selon leur fonction. Les principales tables sont filter<\/strong>, nat<\/strong> et mangle<\/strong>.<\/td><\/tr>
    Chaîne<\/strong><\/td>Liste de règles au sein d’une table. Les chaînes intégrées comprennent INPUT<\/strong>, OUTPUT<\/strong> et FORWARD<\/strong>.<\/td><\/tr>
    Règle<\/strong><\/td>Condition à laquelle un paquet est comparé. Si le paquet correspond à cette condition, iptables applique la cible.<\/td><\/tr>
    Critère de correspondance<\/strong><\/td>Critères utilisés pour évaluer un paquet : adresse IP source, port de destination, protocole, etc.<\/td><\/tr>
    Cible<\/strong><\/td>Action effectuée lorsqu’un paquet correspond à une règle : ACCEPT<\/strong>, DROP<\/strong>, RETURN<\/strong> ou REJECT<\/strong>.<\/td><\/tr><\/tbody><\/table><\/figure>

    La plupart des configurations de base pour la sécurité des VPS<\/a> utilisent la table filter<\/strong>, qui contient trois chaînes par défaut. INPUT<\/strong> gère les paquets entrants destinés au serveur. OUTPUT<\/strong> gère les paquets sortants du serveur. FORWARD<\/strong> gère les paquets acheminés vers une destination autre que le serveur.<\/p>

    Comment fonctionne iptables ?<\/h3>

    Iptables compare chaque paquet aux règles d’une chaîne, de haut en bas. Dès qu’un paquet correspond à une règle, celle-ci s’applique et iptables cesse d’examiner les règles suivantes de la chaîne. L’ordre est donc important : une règle placée plus haut peut autoriser ou bloquer le trafic avant que les suivantes ne soient évaluées.<\/p>

    Vous pouvez ajouter des règles de deux manières : l’option -A<\/strong> ajoute une règle à la fin d’une chaîne, tandis que l’option -I<\/strong> permet d’en insérer une à un emplacement précis. Cette dernière est utile lorsqu’une règle doit être évaluée avant celles qui existent déjà. Si vous ajoutez une règle DROP<\/code> générale avant celle qui autorise SSH, vous perdrez l’accès au serveur. Ajouter les règles dans le bon ordre permet d’éviter ce problème.<\/p>

    Ajoutez toujours les règles d’autorisation indispensables, en particulier celle de SSH, avant toute règle qui bloque ou rejette le trafic.<\/p>

    Quelle est la différence entre iptables, ip6tables et nftables ?<\/h3>

    Iptables gère les règles de pare-feu IPv4. ip6tables gère celles d’IPv6 avec la même syntaxe de commande, mais les deux ensembles de règles sont totalement distincts : une règle iptables n’a aucun effet sur le trafic IPv6, et inversement.<\/p>

    Nftables est le framework de pare-feu Linux plus récent qui remplace à la fois iptables et ip6tables. Il gère IPv4 et IPv6 au sein d’un même ensemble de règles et utilise une syntaxe plus claire. Sur les versions récentes d’Ubuntu, les commandes iptables peuvent s’exécuter de manière transparente via un backend nftables. Dans ce cas, les règles iptables sont en réalité stockées et traitées par nftables.<\/p>

    Si vous préférez simplifier la gestion du pare-feu sous Ubuntu sans écrire directement de règles iptables, UFW est présenté plus loin dans ce guide.<\/p>

    Comment configurer iptables sur un VPS Ubuntu<\/h2>

    Pour configurer le pare-feu d’un VPS<\/a> avec iptables en toute sécurité, ajoutez les règles dans un ordre précis : vérifiez d’abord les règles existantes, puis autorisez SSH, les connexions établies et les ports des services nécessaires avant de bloquer le moindre trafic.<\/p>

    Appliquez les règles DROP en dernier. Si vous ne respectez pas cet ordre, vous risquez de perdre l’accès à un serveur auquel vous ne pourrez plus vous connecter.<\/p>

    1. Vérifiez et installez iptables<\/h3>

    Iptables est préinstallé sur la plupart des distributions Linux. Ce tutoriel utilise principalement un VPS Ubuntu comme exemple. Pour vérifier si iptables est déjà disponible sur votre système, exécutez :<\/p>

    iptables --version<\/pre>
    Si la commande renvoie un numéro de version, iptables est déjà installé. Sur les versions récentes d’Ubuntu, la sortie peut faire référence au backend nftables, ce qui signifie que les commandes iptables sont traitées par nftables. Dans les deux cas, la syntaxe reste la même.<\/p>
    Si iptables n’est pas installé, exécutez :<\/p>
    sudo apt update\n\nsudo apt install iptables<\/pre>
    2. Affichez les règles iptables existantes<\/h3>
    Vérifiez les règles existantes avant d’en ajouter de nouvelles. Une règle peut déjà autoriser ou bloquer le trafic que vous souhaitez configurer. L’ajout de règles en double ou contradictoires peut entraîner un comportement imprévisible.<\/p>
    Affichez toutes les règles actuelles avec des informations détaillées et les numéros de ligne :<\/p>
    sudo iptables -L -v -n --line-numbers<\/pre>
    L’option -n<\/strong> affiche les adresses IP et les numéros de port sous forme numérique au lieu de les résoudre en noms d’hôtes, ce qui est plus rapide et plus lisible. Les numéros de ligne indiquent la position de chaque règle dans la chaîne. Vous en aurez besoin pour supprimer ou insérer des règles à des emplacements précis.<\/p>
    Les compteurs de paquets et d’octets dans la sortie indiquent si du trafic correspond effectivement à chaque règle, ce qui facilite le dépannage.<\/p>
    3. Autorisez SSH avant de modifier les règles du pare-feu<\/h3>
    \n\n\n    
    \n        \n            \n                \n            <\/svg>\n            Warning        <\/span>\n        
    \n            Si vous appliquez des règles de pare-feu restrictives avant d’autoriser SSH, vous perdrez l’accès à votre VPS. Aucun message d’erreur ne s’affichera : la connexion sera simplement interrompue et vous ne pourrez plus accéder au serveur.        <\/p>\n    <\/div>\n\n    \n\n\n\n<\/p>
    Autorisez SSH avant d’ajouter toute règle DROP ou REJECT. Le port SSH par défaut est le port 22 :<\/p>
    sudo iptables -A INPUT -p tcp --dport 22 -j ACCEPT<\/pre>
    Si vous avez modifié le port SSH de votre VPS, remplacez 22<\/strong> par le numéro de port correspondant. En cas de doute, vérifiez la configuration de votre serveur en ouvrant ce fichier :<\/p>
    sudo nano \/etc\/ssh\/sshd_config<\/pre>
    Les mots de passe constituent la méthode d’authentification SSH la plus courante, mais il est plus sûr de configurer des clés SSH avant de renforcer les restrictions de votre pare-feu.<\/p>
    Après avoir ajouté la règle SSH, gardez votre session actuelle ouverte et testez l’accès depuis une deuxième fenêtre de terminal avant d’enregistrer des règles restrictives. Si la deuxième connexion réussit, vous pouvez continuer en toute sécurité.<\/p>
    4. Ajoutez les règles de pare-feu iptables de base<\/h3>
    Les règles suivantes complètent votre pare-feu par ordre de priorité. Ajoutez-les dans l’ordre indiqué ci-dessous pour éviter de bloquer le trafic dont vous avez besoin.<\/p>
    Autorisez le trafic sur localhost<\/strong><\/p>
    Le trafic de l’interface de bouclage reste à l’intérieur du serveur. Le bloquer interromprait les communications internes entre les services exécutés sur la même machine, par exemple entre une application web et une base de données locale :<\/p>
    sudo iptables -A INPUT -i lo -j ACCEPT<\/pre>
    Autorisez les connexions établies et associées<\/strong><\/p>
    Cette règle autorise le trafic associé aux connexions que votre serveur a déjà initiées ou acceptées. Sans elle, les réponses aux requêtes sortantes seraient bloquées :<\/p>
    sudo iptables -A INPUT -m conntrack --ctstate ESTABLISHED,RELATED -j ACCEPT<\/pre>
    Autorisez HTTP et HTTPS<\/strong><\/p>
    Ouvrez les ports 80 et 443 pour autoriser le trafic web :<\/p>
    sudo iptables -A INPUT -p tcp --dport 80 -j ACCEPT\n\nsudo iptables -A INPUT -p tcp --dport 443 -j ACCEPT<\/pre>
    Bloquez une adresse IP spécifique<\/strong><\/p>
    Pour bloquer tout le trafic provenant d’une seule adresse IP :<\/p>
    sudo iptables -A INPUT -s 192.0.2.1 -j DROP<\/pre>
    Bloquez une plage d’adresses IP<\/strong><\/p>
    Utilisez le module iprange<\/strong> pour bloquer le trafic provenant d’une plage d’adresses :<\/p>
    sudo iptables -A INPUT -m iprange --src-range 192.0.2.1-192.0.2.254 -j DROP<\/pre>
    Bloquez les paquets non valides<\/strong><\/p>
    Les paquets non valides n’appartiennent à aucune connexion connue et sont souvent utilisés dans les attaques réseau. Bloquez-les avant qu’ils n’atteignent vos services :<\/p>
    sudo iptables -A INPUT -m conntrack --ctstate INVALID -j DROP<\/pre>
    Bloquez tout autre trafic entrant<\/strong><\/p>
    Ajoutez cette règle en dernier. Elle bloque tout trafic entrant qui n’a pas correspondu à une règle ACCEPT précédente. Si vous la placez avant vos règles d’autorisation, elle bloquera tout le trafic, y compris SSH :<\/p>
    sudo iptables -A INPUT -j DROP<\/pre>
    5. Ouvrez les ports des services courants avec iptables<\/h3>
    Chaque service exécuté sur votre VPS utilise un port spécifique. Iptables nécessite une règle explicite pour autoriser le trafic sur ce port :<\/p>
    Service<\/strong><\/th>Protocole<\/strong><\/th>Port<\/strong><\/th>Remarques<\/strong><\/th><\/tr><\/thead>
    SSH<\/strong><\/td>TCP<\/td>22<\/td>Modifiez le port par défaut si possible<\/td><\/tr>
    HTTP<\/strong><\/td>TCP<\/td>80<\/td>Nécessaire pour le trafic web non chiffré<\/td><\/tr>
    HTTPS<\/strong><\/td>TCP<\/td>443<\/td>Nécessaire pour le trafic web chiffré<\/td><\/tr>
    MySQL<\/strong><\/td>TCP<\/td>3306<\/td>Limitez l’accès aux adresses IP de confiance<\/td><\/tr>
    PostgreSQL<\/strong><\/td>TCP<\/td>5432<\/td>Limitez l’accès aux adresses IP de confiance<\/td><\/tr>
    SMTP<\/strong><\/td>TCP<\/td>25<\/td>Uniquement si vous exploitez un serveur de messagerie<\/td><\/tr>
    IMAP<\/strong><\/td>TCP<\/td>993<\/td>Uniquement si vous exploitez un serveur de messagerie<\/td><\/tr><\/tbody><\/table><\/figure>
    N’ouvrez jamais les ports de base de données tels que les ports 3306 et 5432 sur internet. Limitez plutôt leur accès à une adresse IP de confiance ou à une interface réseau privée :<\/p>
    sudo iptables -A INPUT -p tcp --dport 3306 -s 192.0.2.1 -j ACCEPT<\/pre>
    Remplacez 192.0.2.1<\/strong> par l’adresse IP de la machine qui doit accéder à la base de données.<\/p>
    6. Supprimez ou videz les règles iptables<\/h3>
    La suppression d’une règle précise ne modifie pas le reste de votre configuration, tandis que le vidage supprime toutes les règles en une seule fois.<\/p>
    Supprimez une règle spécifique<\/strong><\/p>
    Pour supprimer une règle sans affecter les autres, utilisez son numéro de ligne. Commencez par afficher les règles avec leurs numéros :<\/p>
    sudo iptables -L INPUT --line-numbers<\/pre>
    Supprimez ensuite la règle à la position souhaitée. Pour supprimer la règle nº 3 de la chaîne INPUT :<\/p>
    sudo iptables -D INPUT 3<\/pre>
    Videz toutes les règles<\/strong><\/p>
    Pour supprimer toutes les règles en une seule fois, utilisez l’option -F<\/strong> :<\/p>
    sudo iptables -F<\/pre>
    \n\n\n    
    \n        \n            \n                \n            <\/svg>\n            Warning        <\/span>\n        
    \n            Vider les règles d’un VPS distant supprime toutes les règles d’autorisation et de blocage. Si la politique par défaut des chaînes est DROP, le vidage vous fera perdre l’accès au serveur. Si la politique par défaut est ACCEPT, tous les ports seront exposés. Vérifiez votre politique par défaut avant de vider les règles.        <\/p>\n    <\/div>\n\n    \n\n\n\n<\/p>
    DROP ou REJECT<\/strong><\/p>
    Pour bloquer le trafic, vous avez deux possibilités. DROP écarte silencieusement le paquet : l’expéditeur ne reçoit aucune réponse et la connexion finit par expirer. REJECT rejette le paquet et renvoie un message d’erreur à l’expéditeur. Cette méthode facilite le dépannage, mais confirme également à l’expéditeur que le port existe.<\/p>
    Utilisez DROP pour les règles destinées aux services accessibles depuis Internet lorsque vous ne souhaitez pas divulguer d’informations sur votre serveur. Utilisez REJECT dans les environnements internes ou de développement, où un retour plus rapide est utile.<\/p>
    7. Enregistrez les règles iptables de manière permanente<\/h3>
    Par défaut, les règles iptables sont stockées en mémoire et ne sont pas conservées après un redémarrage. Pour les conserver après le redémarrage du VPS, enregistrez-les dans un fichier.<\/p>
    Installez iptables-persistent<\/strong><\/p>
    Le paquet iptables-persistent<\/strong> enregistre et charge automatiquement les règles. Sous Ubuntu, son installation entraîne également celle de netfilter-persistent<\/strong>, le service sous-jacent qui charge les règles enregistrées au démarrage :<\/p>
    sudo apt install iptables-persistent<\/pre>
    Pendant l’installation, vous serez invité à enregistrer vos règles IPv4 et IPv6 actuelles. Choisissez Oui<\/strong> dans les deux cas.<\/p>
    Enregistrez les règles manuellement<\/strong><\/p>
    Si vous avez installé iptables-persistent<\/strong>, le répertoire \/etc\/iptables\/<\/strong> existe déjà. Après avoir ajouté ou modifié des règles, enregistrez-les pour les conserver après les redémarrages :<\/p>
    sudo netfilter-persistent save<\/pre>
    Cette commande enregistre respectivement les règles IPv4 et IPv6 dans \/etc\/iptables\/rules.v4<\/strong> et \/etc\/iptables\/rules.v6<\/strong>.<\/p>
    Restaurez les règles manuellement<\/strong><\/strong><\/p>
    Pour recharger les règles enregistrées sans redémarrer le serveur :<\/p>
    sudo iptables-restore < \/etc\/iptables\/rules.v4\n\nsudo ip6tables-restore < \/etc\/iptables\/rules.v6<\/pre>
    Vérifiez les règles après le redémarrage<\/strong><\/p>
    Après avoir redémarré votre VPS, vérifiez que les règles ont été correctement chargées :<\/p>
    sudo iptables -L -v -n<\/pre>
    La sortie doit correspondre aux règles que vous avez enregistrées avant le redémarrage.<\/p>
    Comment configurer le NAT et la redirection de ports avec iptables<\/h2>
    Le NAT et la redirection de ports sont utilisés lorsque votre VPS fait office de passerelle, de routeur, de point de terminaison VPN<\/a> ou sert à transférer du trafic, en acheminant des paquets entre différents réseaux ou en redirigeant le trafic d’un port vers un autre. Ces règles utilisent la table nat<\/strong>, et non la table filter<\/strong> utilisée dans les étapes précédentes.<\/p>
    La redirection de ports nécessite également d’activer le transfert IP au niveau du noyau. Pour l’activer temporairement :<\/p>
    sudo sysctl -w net.ipv4.ip_forward=1<\/pre>
    Pour rendre cette modification permanente, ajoutez la ligne suivante dans \/etc\/sysctl.conf<\/strong> :<\/p>
    net.ipv4.ip_forward=1<\/pre>
    Appliquez ensuite la modification :<\/p>
    sudo sysctl -p<\/pre>
    Pour rediriger le trafic arrivant sur le port 80 vers un autre hôte de votre réseau :<\/p>
    sudo iptables -t nat -A PREROUTING -p tcp --dport 80 -j DNAT --to-destination 192.0.2.1:80\n\nsudo iptables -t nat -A POSTROUTING -j MASQUERADE<\/pre>
    Si la politique de votre chaîne FORWARD<\/strong> est définie sur DROP<\/strong>, vous devez également autoriser explicitement le trafic acheminé :<\/p>
    sudo iptables -A FORWARD -p tcp -d 192.0.2.1 --dport 80 -j ACCEPT<\/pre>
    iptables ou UFW : quel outil de pare-feu choisir ?<\/h2>
    Iptables vous offre un contrôle direct sur tous les aspects de votre pare-feu, notamment l’ordre des règles, le NAT, la redirection de ports, les chaînes personnalisées et la compatibilité avec les scripts existants. Ce niveau de contrôle a toutefois un coût : la syntaxe est assez lourde, l’ordre des règles ne laisse aucune place à l’erreur et une mauvaise configuration sur un VPS distant peut vous faire perdre immédiatement l’accès au serveur.<\/p>
    UFW (Uncomplicated Firewall) est une interface pour iptables qui simplifie les tâches courantes de gestion du pare-feu sous Ubuntu. Si vous devez uniquement autoriser SSH, HTTP et HTTPS, vous pouvez configurer un pare-feu sous Ubuntu avec UFW<\/a> à l’aide de quelques commandes, sans risquer de commettre d’erreur dans l’ordre des règles.<\/p>
    Nftables est le framework plus récent destiné à remplacer iptables à long terme. Il gère IPv4 et IPv6 dans un même ensemble de règles et utilise une syntaxe plus claire, mais nécessite de se familiariser avec un nouveau framework en partant de zéro.<\/p>
    Le choix dépend de vos besoins :<\/p>