Découvrez des informations sur l'accès à l'hôte iptables. Ensemble minimum de règles Iptables pour les tâches typiques. Journalisation et blocage des paquets

25.04.2019

Programme éducatif

Malgré le fait qu'Internet regorge d'articles sur Iptables, je vois assez souvent des demandes visant à suggérer un ensemble de règles pour une situation spécifique. Les situations étant assez typiques, vous pouvez fournir un lien vers cette note sans explication. Je le répète, ce n'est pas un récit dont la lecture est obligatoire. C'est déjà assez bon, mais seulement un ensemble de règles pour les débutants avec un minimum de commentaires.
Quelque chose, bien sûr, mérite d'être dit pour comprendre :
Politique, clé -P. Citation du tutoriel :

Définit la politique par défaut pour la chaîne donnée. La politique par défaut détermine l'action appliquée aux paquets qui ne sont couverts par aucune des règles de la chaîne. La politique par défaut est DROP et ACCEPT.

En d’autres termes, si un paquet arrivant sur une interface réseau n’est décrit par aucune règle, alors il est traité par la politique par défaut. Il s'ensuit que vous pouvez configurer Iptables (et tout pare-feu) de deux manières/politiques :
1. Tout ce qui n'est pas interdit est permis. Ceux. Tout est permis.
2. Tout est interdit sauf ce qui est explicitement autorisé.
Évidemment, la deuxième approche est plus correcte, et nous en parlerons plus loin. Je suggère de laisser la politique de SORTIE sur ACCEPTER, sinon vous devrez faire face à de nombreux problèmes. Lorsque vous connaîtrez suffisamment bien Iptables, vous comprendrez pourquoi et pourrez le configurer dans DROP.
Et encore une remarque importante. Il est entendu que les règles sont appliquées par le script, et non saisies depuis la console une par une. Dans ce dernier cas, après la commande iptable -P INPUT DROP la connexion de la session SSH établie sera perdue. Lors de l'application de règles par script, la session ne sera pas interrompue, car Vient ensuite la règle permettant d'accepter des connexions déjà établies.

Avant d'appliquer des règles, vous devez effacer toutes les chaînes, tables et stratégies existantes :

Iptables -P INPUT ACCEPT iptables -P FORWARD ACCEPT iptables -P OUTPUT ACCEPT iptables -t nat -P PREROUTING ACCEPT iptables -t nat -P POSTROUTING ACCEPT iptables -t nat -P OUTPUT ACCEPT iptables -t mangle -P PREROUTING ACCEPT iptables -t mangle -P OUTPUT ACCEPT iptables -F iptables -t nat -F iptables -t mangle -F iptables -X iptables -t nat -X iptables -t mangle -X

Ensemble minimum de règles iptables pour ordinateur de bureau

Tâche : bloquer toutes les connexions entrantes. Les appels sortants sont illimités.

# Règles par défaut iptable -P INPUT DROP iptable -P FORWARD DROP iptable -P OUTPUT ACCEPT # Autoriser les connexions entrantes depuis l'hôte local iptables -A INPUT -i lo -j ACCEPT # Autoriser les connexions entrantes déjà établies iptables -A INPUT -m state -- état ÉTABLI, RELATIF -j ACCEPTER

Ensemble minimum de règles iptables pour un serveur avec une application

Tâche : fournir l'accès à un service, qu'il s'agisse d'un serveur Web fonctionnant sur le port 80 et refuser tout le reste.
Puisqu'il s'agit d'un serveur, il est nécessaire d'autoriser une connexion pour la gestion via SSH. Par analogie, vous pouvez ouvrir n'importe quel port ou ensemble de ports souhaité.

# Règles par défaut iptables -P INPUT DROP iptables -P FORWARD DROP iptables -P OUTPUT ACCEPT # Autoriser les connexions entrantes depuis l'hôte local iptables -A INPUT -i lo -j ACCEPT # Autoriser les connexions entrantes déjà établies iptables -A INPUT -m state -- state ESTABLISHED,RELATED -j ACCEPT # Autoriser SSH iptables -A INPUT -p TCP --dport 22 -j ACCEPT # Autoriser le port HTTP iptables -A INPUT -p TCP --dport 80 -j ACCEPT

Ensemble minimum de règles iptables pour une passerelle

Tâche : 1. Distribuez Internet sur le réseau local à l'aide de NAT. 2. Autorisez les machines du réseau local à accéder aux serveurs HTTP, HTTPS et DNS externes. 3. Redirigez le port vers un serveur Web situé sur ce réseau local.

### Variables # Interface regardant vers Internet INET_IF="eth0" # Adresse IP blanche appartenant à $INET_IF INET_IP="x.x.x.x" # Ports TCP par lesquels les machines du réseau local sont autorisées à accéder à Internet FORWARD_TCP_PORTS="53,80,443 " # Ports UDP via lesquels les machines du réseau local sont autorisées à accéder à Internet FORWARD_UDP_PORTS="53" # Réseau local LOCAL_NET="192.168.0.0/24" # Adresse IP du serveur Web local WEB_SERVER="192.168.0.10" # Chemin vers sysctl SYSCTL=" /sbin/sysctl -w" # Activer le transfert des paquets IPv4 dans le noyau si [ "$SYSCTL" = "" ] then echo "1" > /proc/sys/net/ipv4/ip_forward else $SYSCTL net.ipv4.ip_forward=" 1" fi ### Règles par défaut iptables -P INPUT DROP iptables -P FORWARD DROP iptables -P OUTPUT ACCEPT ### INPUT # Autoriser les connexions entrantes depuis l'hôte local iptables -A INPUT -i lo -j ACCEPT # Autoriser l'acceptation de connexions déjà établies iptables -A INPUT -m state --state ESTABLISHED,RELATED -j ACCEPT # Autoriser SSH iptables -A INPUT -p TCP --dport 22 -j ACCEPT ### FORWARD # Autoriser les connexions de transfert déjà établies iptables -A FORWARD -m state --state ESTABLISHED,RELATED -j ACCEPT # Autoriser les machines du réseau local à accéder à Internet sur les ports TCP spécifiés iptables -A FORWARD -p TCP -s $LOCAL_NET -m multiport --dport $FORWARD_TCP_PORTS -j ACCEPT iptables -A FORWARD -p TCP -d $LOCAL_NET -m multiport --dport $FORWARD_TCP_PORTS -j ACCEPT # Autoriser les machines du réseau local à accéder à Internet sur les ports UDP spécifiés iptables -A FORWARD -p UDP -s $LOCAL_NET -m multiport --dport $FORWARD_UDP_PORTS -j ACCEPT iptables -A FORWARD -p UDP -d $LOCAL_NET -m multiport --dport $FORWARD_UDP_PORTS -j ACCEPT ### NAT # Activer NAT pour le sous-réseau local iptables -t nat -A POSTROUTING - s $LOCAL_NET -o $INET_IF -j SNAT - -to-source $INET_IP # Transférer le port vers le serveur Web local iptables -t nat -A PREROUTING -p TCP -d $INET_IP --dport 80 -j DNAT --to -destination $WEB_SERVER : 80

Il convient de noter que si un port autre que la liste $FORWARD_TCP_PORTS est transféré, alors il doit y être ajouté, car il sera supprimé par la politique par défaut.
En conséquence, le script iptables pour la passerelle ressemblera à ceci. Différent des règles précédentes.

#!/bin/sh # Effacer toutes les règles iptables -P INPUT ACCEPT iptables -P FORWARD ACCEPT iptables -P OUTPUT ACCEPT iptables -t nat -P PREROUTING ACCEPT iptables -t nat -P POSTROUTING ACCEPT iptables -t nat -P OUTPUT ACCEPT iptables -t mangle -P PREROUTING ACCEPTER iptables -t mangle -P OUTPUT ACCEPT iptables -F iptables -t nat -F iptables -t mangle -F iptables -X iptables -t nat -X iptables -t mangle -X ### Variables # Interface regardant vers Internet INET_IF="eth0" # Adresse IP blanche appartenant à $INET_IF INET_IP="x.x.x.x" # Réseau local LOCAL_NET="192.168.0.0/24" # Adresse IP du serveur web local WEB_SERVER="192.168.0.10" # Activer dans le noyau le transfert des paquets IPv4 # Chemin vers sysctl SYSCTL="/sbin/sysctl -w" if [ "$SYSCTL" = "" ] then echo "1" > /proc/sys/net/ipv4/ip_forward else $ SYSCTL net.ipv4.ip_forward="1" fi ### Règles par défaut iptables -P INPUT DROP iptables -P FORWARD DROP iptables -P OUTPUT ACCEPT ### INPUT # Autoriser les connexions entrantes depuis l'hôte local iptables -A INPUT -i lo - j ACCEPT # Autoriser l'acceptation de connexions déjà établies iptables -A INPUT -m state --state ESTABLISHED,RELATED -j ACCEPT # Autoriser SSH uniquement à partir du réseau local iptables -A INPUT -p TCP -s $LOCAL_NET --dport 22 -j ACCEPT # Autoriser les requêtes de mise en cache du serveur DNS uniquement à partir du réseau local iptables -A INPUT -p TCP -s $LOCAL_NET --dport 53 -j ACCEPT iptables -A INPUT -p UDP -s $LOCAL_NET --dport 53 -j ACCEPT ## # FORWARD # Autoriser les connexions de transfert déjà établies iptables -A FORWARD -m state --state ESTABLISHED,RELATED -j ACCEPT # Ports TCP sur lesquels les machines du réseau local sont autorisées à accéder à Internet FORWARD_TCP_PORTS="80,443" # Autoriser les machines sur le réseau local pour accéder à Internet sur les ports TCP spécifiés iptables -A FORWARD -p TCP -s $LOCAL_NET -m multiport --dport $FORWARD_TCP_PORTS -j ACCEPT iptables -A FORWARD -p TCP -d $LOCAL_NET -m multiport --dport $FORWARD_TCP_PORTS -j ACCEPT ### NAT # Activer NAT pour le sous-réseau local iptables -t nat -A POSTROUTING -s $LOCAL_NET -o $INET_IF -j SNAT --to-source $INET_IP # Transférer un port vers le serveur Web local vers un port non standard iptables -t nat -A PREROUTING -p TCP - d $INET_IP --dport 80 -j DNAT --to-destination $WEB_SERVER:8090

Sortie des règles actuelles

Afficher les règles de la table de filtrage, c'est-à-dire la commande affichera les règles de base d'iptables :

Iptables -L -n

Pour une table spécifique, par exemple nat et mangle :

Iptables -t nat -L -n iptables -t mangle -L -n

Tâche principale pare-feu(pare-feu) filtrage et traitement des paquets transitant par un réseau. Lors de l'analyse du paquet d'entrée, le pare-feu prend une décision sur le sort de ce paquet : supprimez le paquet ( BAISSE), accepter le paquet ( ACCEPTER) ou faire autre chose avec.

DANS Linux Le pare-feu est un module du noyau appelé netfilter et constitue un ensemble de hooks permettant de travailler avec la pile réseau. L'interface permettant de modifier les règles selon lesquelles le pare-feu traite les paquets est l'utilitaire iptables pour IPv4 et utilitaire ip6tables pour IPv6.

Tout le travail de filtrage du trafic est effectué par le noyau du système. Iptables n'est pas un démon et ne crée pas de nouveaux processus dans le système. Allumer ou éteindre iptables c'est juste envoyer un signal au noyau. Une plus grande vitesse de filtrage est obtenue en analysant uniquement les en-têtes de paquets.

Vers les principales fonctionnalités iptables référer:

filtrage du trafic basé sur les adresses de l'expéditeur et du destinataire des paquets, les numéros de port ;
redirection des paquets selon certains paramètres ;
organisation de l'accès au réseau (SNAT) ;
redirection de port du réseau mondial vers le réseau local (DNAT) ;
limiter le nombre de connexions ;
fixer des quotas de trafic ;
exécution des règles selon le calendrier ;

Regardons le processus de travail principal iptables(source de l'image rigacci.org).

Un paquet entrant atteint d'abord le périphérique réseau, après quoi il est intercepté par le pilote et transmis au noyau. Après cela, le paquet passe par un certain nombre de tables et est ensuite transféré vers l'application locale ou redirigé vers un autre système s'il s'agit d'un paquet de transit.

DANS iptables Trois types de tableaux sont utilisés :

mutiler– utilisé pour apporter des modifications à l'en-tête du paquet ;
Nat– utilisé pour traduire les adresses réseau ;
filtre– pour filtrer le trafic ;

table mutilée

Objectif principal du tableau mutiler- apporter des modifications à l'en-tête du paquet. Les actions suivantes peuvent être effectuées dans ce tableau :

définir le bit de type de service ;
définir le champ Durée de vie ;
définir une étiquette sur un paquet qui peut être vérifiée dans d'autres règles ;

Chaînes dans le tableau mutiler:

PRÉROUTAGE- utilisé pour apporter des modifications aux paquets à l'entrée d'iptables, avant de prendre une décision de routage ;
POSTROUTAGE- utilisé pour apporter des modifications aux paquets quittant iptables, après avoir pris une décision de routage ;
SAISIR- utilisé pour apporter des modifications aux packages avant qu'ils ne soient transférés vers l'application locale ;
SORTIR- utilisé pour apporter des modifications aux paquets provenant d'une application dans iptables ;
AVANT- utilisé pour apporter des modifications aux paquets de transit ;

Tableau Nat

Le tableau est utilisé pour la traduction d'adresses réseau et lorsqu'un paquet est rencontré et établit une nouvelle connexion. Les actions suivantes peuvent être effectuées dans ce tableau :

DNAT (traduction d'adresses du réseau de destination)– traduction de l'adresse de destination dans l'en-tête du paquet ;
SNAT (traduction d'adresses réseau source)– changer l'adresse source du paquet;
MASCARADE– utilisé aux mêmes fins que SNAT, mais vous permet de travailler avec des adresses IP dynamiques ;

Les chaînes dans ce tableau :

PRÉROUTAGE– utilisé pour apporter des modifications aux paquets entrant dans iptables ;
SORTIR– utilisé pour convertir les adresses en paquets avant un routage ultérieur ;
POSTROUTAGE– utilisé pour transformer les paquets avant de les envoyer au réseau ;

Filtre de tableau

Le tableau est utilisé pour filtrer les paquets. Il y a trois chaînes dans ce tableau :

SAISIR– chaîne pour les paquets entrants ;
AVANT– chaîne pour les paquets transmis (en transit);
SORTIR– chaîne pour les paquets sortants ;

Un paquet transitant par ces chaînes peut être soumis aux actions suivantes : ACCEPTER, BAISSE, REJETER, ENREGISTRER.

Pour résumer, le paquet arrivant passe par une chaîne de règles. Chaque règle contient condition Et cible(action). Si le paquet satisfait à la condition, alors il est transmis à la cible, sinon la règle suivante de la chaîne est appliquée au paquet. Si le paquet ne satisfait aucune des conditions de la chaîne, alors l'action par défaut lui est appliquée.

Chaîne	Tableau
Chaîne	filtre	Nat	mutiler
SAISIR	+		+
AVANT	+		+
SORTIR	+	+	+
PRÉROUTAGE		+	+
POSTROUTAGE		+	+

utilitaire iptables

Installer iptables

# sur Arch Linux yaourt -S iptables # sur Ubuntu sudo apt-get install iptables

Exécuter iptables

# sous Arch Linux sudo systemctl activer iptables sudo systemctl start iptables # sous Ubuntu sudo service iptables start

Règles de sauvegarde

# sous Arch Linux sudo sh -c "iptables-save > /etc/iptables/iptables.rules" # sous Ubuntu sudo sh -c "iptables-save > /etc/iptables.rules"

Restaurer des règles à partir d'un fichier

Restauration Iptables< firewall-config

Chaque règle dans iptables- il s'agit d'une ligne distincte, constituée selon certaines règles et contenant des critères et des actions. En général, la règle a le format suivant :

Commande Iptables [-t table]

t table - spécifie le nom de la table pour laquelle la règle sera créée ;
command - la commande qui définit l'action iptables- ajouter une règle, supprimer une règle, etc. ;
match - spécifie les critères de vérification qui déterminent si un paquet est soumis à la règle ou non ;
cible/saut - quelle action doit être effectuée lorsque le critère est rempli ;

Commandes iptables :

-A - en ajoutant une règle à la chaîne, la règle sera ajoutée à la fin de la chaîne ;
-D - supprime une règle de la chaîne ;
-R - remplacer une règle par une autre ;
-I - insérer une nouvelle règle dans la chaîne ;
-L - afficher une liste de règles dans une chaîne donnée ;
-F - réinitialise toutes les règles de la chaîne donnée ;
-Z - réinitialise tous les compteurs d'une chaîne donnée ;
-N - crée une nouvelle chaîne avec le nom donné ;
-X - supprime la chaîne ;
-P - définit la politique par défaut pour la chaîne ;
-E - renommer la chaîne d'utilisateurs ;

Exemples de commandes iptables

Les paquets peuvent être filtrés par les paramètres suivants :

Source du paquet

Pour filtrer par source, utilisez l'option -s. Par exemple, refusons tous les paquets entrants du nœud 192.168.1.95 :

Iptables -A INPUT -s 192.168.1.95 -j DROP

Vous pouvez utiliser un nom de domaine pour spécifier l'adresse de l'hôte :

Iptables -A INPUT -s test.host.net -j DROP

Vous pouvez également spécifier un réseau entier :

Iptables -A INPUT -s 192.168.1.0/24 -j DROP

Vous pouvez également utiliser la négation (signe !). Par exemple, tous les paquets provenant d'hôtes autres que 192.168.1.96 seront détruits :

Iptables -UNE ENTRÉE ! -s 192.168.1.96 -j DROP

Nous permettons au trafic de circuler via localhost :

Iptables -A INPUT 1 -i lo -j ACCEPTER

Nous enregistrons les tentatives d'usurpation d'identité avec le préfixe "IP_SPOOF A:" et abandonnons la connexion.

Iptables -A INPUT -i eth1 -s 10.0.0.0/8 -j LOG --log-prefix "IP_SPOOF A : " iptables -A INPUT -i eth1 -s 10.0.0.0/8 -j DROP

Adresse de destination

Pour ce faire, vous devez utiliser l'option -d. Par exemple, refusons tous les paquets sortants vers l'hôte 192.168.1.95 :

Iptables -A SORTIE -d 192.168.156.156 -j DROP

Refuser l'accès à la ressource

Iptables -A SORTIE -d vk.com -j REJETER

Comme pour la source du paquet, vous pouvez utiliser des adresses réseau et des noms de domaine. Le déni fonctionne également.

Protocole

L'option -p spécifie le protocole. Peut être utilisé tout, icmp, tcp, udp ou numéro de protocole (depuis /etc/protocoles).

Autoriser les demandes d'écho entrantes

Iptables -A INPUT -p icmp --icmp-type echo-request -j ACCEPT

Port source

Autoriser tous les paquets sortants du port 80 :

Iptables -A INPUT -p tcp --sport 80 -j ACCEPTER

Bloquez toutes les requêtes entrantes sur le port 80 :

Iptables -A INPUT -p tcp --dport 80 -j DROP

Pour spécifier le port, vous devez spécifier le protocole (tcp ou udp). Vous pouvez utiliser la négation.

Plage de ports ouverte

Iptables -A INPUT -m state --state NEW -m tcp -p tcp --dport 7000:7010 -j ACCEPT

Port de destination

Autoriser les connexions via HTTP

Iptables -A INPUT -p tcp --dport 80 -j ACCEPTER iptables -A INPUT -p tcp -i eth0 --dport 22 -j ACCEPTER

Autoriser la réception de données du serveur DHCP

Iptables -A INPUT -p UDP --dport 68 --sport 67 -j ACCEPTER

Télécommande exploitation des erreurs logicielles afin de le rendre inopérant ;
Inondation- l'envoi d'un grand nombre de colis dénués de sens à l'adresse de la victime. La cible d'une inondation peut être un canal de communication ou des ressources machine. Dans le premier cas, un flux de paquets occupe toute la bande passante et ne permet pas à la machine attaquée de traiter les requêtes légitimes. Dans le second cas, les ressources de la machine sont capturées via des appels répétés et très fréquents à un service qui effectue une opération complexe et gourmande en ressources. Il peut s'agir par exemple d'un appel de longue durée à l'un des composants actifs (script) du serveur Web. Le serveur dépense toutes les ressources de la machine pour traiter les requêtes de l'attaquant et les utilisateurs doivent attendre. Il existe différentes inondations : ICMP Flood, SYN Flood, UDP Flood et HTTP Flood.

Collecte d'informations sur les connexions réseau

Afficher les connexions ouvertes

Nombre de connexions au port 80

Netstat -na | grep ":80\" | toilettes -l

Dump de connexion TCP (auquel les requêtes de domaine sont envoyées le plus souvent)

Tcpdump -npi domaine de port eth0

L'inondation SYN peut être vérifiée en comptant le nombre de connexions TCP semi-ouvertes

Netstat -na | grep ":80" | grep SYN_RCVD

Protection contre différents types d'inondations.

Inondation ICMP. Une méthode très primitive pour obstruer la bande passante et créer des charges sur la pile réseau via l'envoi monotone de requêtes ICMP ECHO (ping). Facilement détectables en analysant les flux de trafic dans les deux sens : lors d’une attaque d’inondation ICMP, ils sont presque identiques. Une méthode presque indolore de protection absolue est basée sur la désactivation des réponses aux requêtes ICMP ECHO :

Sysctl net.ipv4.icmp_echo_ignore_all=1

Ou en utilisant iptabels:

Iptables -A INPUT -p icmp -j DROP --icmp-type 8

Inondation SYN. L’un des moyens courants non seulement d’obstruer le canal de communication, mais également de mettre la pile réseau du système d’exploitation dans un état où elle ne peut plus accepter de nouvelles demandes de connexion. Basé sur une tentative d'initialisation d'un grand nombre de connexions TCP simultanées en envoyant un paquet SYN avec une adresse de retour inexistante. Après plusieurs tentatives d'envoi d'un paquet de réponse ACK à une adresse inaccessible, la plupart des systèmes d'exploitation mettent en file d'attente la connexion non établie. Et seulement après la nième tentative, la connexion est fermée. Le flux de paquets ACK étant très important, la file d'attente devient rapidement pleine et le noyau refuse les tentatives d'ouverture d'une nouvelle connexion. Les robots DoS les plus intelligents analysent également le système avant de lancer une attaque afin d'envoyer des requêtes uniquement aux ports vitaux ouverts. Il est facile d’identifier une telle attaque : essayez simplement de vous connecter à l’un des services.

Plusieurs fois, j'ai été confronté au fait que même des personnes généralement intelligentes commettent des erreurs totalement impardonnables. Par exemple, ils ouvrent le port sur lequel la base de données s'exécute sur l'ensemble d'Internet. Cela arrive souvent aux débutants DevOps qui ont écrit du code toute leur vie, et leurs responsabilités incluent désormais également la configuration des serveurs. Il existe de bons tutoriels sur Internet sur la configuration de base du pare-feu sous Linux et autres * nix, mais il s'agit souvent de fiches sur plusieurs écrans. J'espère donc que ce tutoriel plus concis sera utile à quelqu'un.

Important! Il est très facile de pare-feu par erreur sur une machine à tel point que vous ne pouvez plus y accéder. Cela est particulièrement vrai pour l'hébergement cloud. Par exemple, si dans AWS vous fermez tous les ports de 1024 à 65536, pour une raison quelconque, la machine s'avère fermée après un redémarrage tout en général ports. Si vous êtes hébergé dans les cloud, il est préférable de mettre en place un pare-feu via l'interface web fournie par l'hébergement.

Une petite note sur la terminologie. Le pare-feu intégré au noyau Linux s'appelle Netfilter, et iptables est un utilitaire de gestion de ce pare-feu. Beaucoup de gens croient à tort que le pare-feu s'appelle iptables. C'est faux. En disant quelque chose comme « Je filtre les paquets en utilisant iptables », vous montrez aux autres votre ignorance.

En général, quels types de problèmes peuvent être résolus à l'aide de Netfilter :

Autoriser/refuser le trafic entrant vers certains ports en utilisant certains protocoles (IPv4/IPv6, TCP/UDP) à partir d'adresses spécifiées (IP, MAC) ou de sous-réseaux ;
Tout est pareil pour le trafic sortant ;
Vous pouvez, par exemple, ignorer complètement tous les paquets ICMP ;
Configuration du NAT, voir l'article sur un routeur basé sur Raspberry Pi ;
J'ai entendu dire que de vrais gourous peuvent mettre en place une protection contre les DDoS et la force brute, limiter l'accès au réseau à des applications, des utilisateurs ou des groupes spécifiques et faire d'autres choses folles ;

Je noterai que l'utilitaire iptables m'a personnellement semblé extrêmement gênant au début par rapport à ipfw dans FreeBSD. Heureusement, après avoir travaillé avec lui pendant un certain temps, tous ces nombreux indicateurs comme -A, -D, -j et d'autres deviennent familiers, alors soyez patient. Regardons les commandes de base.

Afficher toutes les règles :

iptables -L -n

Vous remarquerez peut-être que Netfilter a quelques « chaînes » - au moins INPUT, OUTPUT et FORWARD. Personnellement, j'ai aussi une chaîne DOCKER sur ma machine. Pour la première fois, vous pouvez considérer les deux premiers comme étant respectivement l’ensemble du trafic entrant et sortant, et oublier temporairement le reste. Il y a de fortes chances que vous n’en ayez jamais besoin.

Supprimez toutes les règles :

iptables -F

Changez la politique (comportement par défaut) de la chaîne :

iptables -P BAISSE D'ENTRÉE
iptables -P ENTREE ACCEPTER

Refuser l'accès depuis l'hôte/le sous-réseau :

iptables -A INPUT -s 123.45.67.89 -j DROP
iptables -A INPUT -s 123.45.0.0/ 16 -j DROP

Vous pouvez également utiliser des noms de domaine :

iptables -A INPUT -s exemple.ru -j DROP

Interdiction des connexions sortantes :

iptables -A SORTIE -d 123.45.67.89 -j DROP

Vous pouvez utiliser des négations dans les règles :

iptables -UNE ENTRÉE !

-s 123.45.67.89 -j DROP

Supprimer une règle par son numéro dans la chaîne :

iptables -D ENTRÉE 1

Supprimer une règle en fonction de ce qu'elle fait :

iptables -D INPUT -s 123.45.67.89 -j DROP L'option -p spécifie le protocole. Vous pouvez utiliser all, icmp, tcp, udp ou le numéro de protocole de /etc/protocols. Drapeau - -sport indique le port à partir duquel le paquet a été envoyé, et -

-dport spécifie le port de destination :
iptables -A INPUT -p tcp --sport 80 -j ACCEPTER

iptables -A INPUT -p tcp --dport 80 -j ACCEPTER

Insérer une règle en début de chaîne :

iptables -J'ENTRE...

Ou vous pouvez spécifier un poste spécifique :

iptables -J'ENTRE 3...

iptables-save > /etc/iptables.rules

Règles de restauration :< / etc/ iptables.rules

restauration iptables

Voyons maintenant quelques exemples pratiques. Par exemple, voici à quoi ressemble l'émulation netsplit dans un test qui vérifie le comportement d'une application qui utilise Akka Cluster : exécuter (nœud1, s)
"iptables -A INPUT -s $node2 -j DROP" exécuter (nœud1, s)
"iptables -A INPUT -s $node2 -j DROP" "iptables -A INPUT -s $node3 -j DROP")
"iptables -A INPUT -s $node2 -j DROP" "iptables -A SORTIE -d $node2 -j DROP")

"iptables -A SORTIE -d $node3 -j DROP"

Un autre exemple. Vous devez savoir quels ports écoutent sur la machine et fermer ceux qui ne sont pas nécessaires. Nous montons dans la voiture et disons :

netstat -tuwpln

Exemple de sortie :

Connexions Internet actives (serveurs uniquement)
Proto Recv-Q Send-Q Adresse locale Adresse étrangère État PID/Nom du programme
tcp 0 0 0.0.0.0:80 0.0.0.0:* ÉCOUTER 3210/nginx
tcp 0 0 0.0.0.0:4369 0.0.0.0:* ÉCOUTER 1789/epmd
tcp 0 0 0.0.0.0:22 0.0.0.0:* ÉCOUTER 797/sshd
tcp 0 0 127.0.0.1:5432 0.0.0.0:* ÉCOUTER 990/postgres

Nginx et SSHd regardent Internet, c'est normal. PostgreSQL n'écoute que l'interface locale, cela ne pose donc aucun problème non plus. Mais epmd ressort (vous pouvez le vérifier avec telnet depuis une autre machine), et ce n'est pas bon. Vous ne pouvez fermer que le port 4369. Comment procéder a été indiqué ci-dessus. Ou vous pouvez aller encore plus loin et refuser toutes les connexions extérieures vers le port 81 et les versions antérieures.

Iptables est principalement responsable du filtrage des paquets. Configurer Iptables manuellement est toute une tâche. Ne vous attendez pas à comprendre cela « à la hâte ». Heureusement, il existe de nombreux outils qui peuvent vous aider si vous n'avez pas encore compris iptables, mais que vous avez un besoin urgent de sécuriser le système : fwbuilder, firestarter, guarddog, arno firewall - il s'agit essentiellement d'une interface graphique pour iptables. Il n’y a pas de réponse claire quant à savoir laquelle est la meilleure. Le choix vous appartient. Cependant, l’article d’aujourd’hui est spécifiquement dédié à iptables et est divisé en deux parties : théorie et pratique. Les plus impatients peuvent immédiatement réaliser la partie pratique, même si cette démarche n’est pas recommandée.

Attention! Toutes les actions avec iptables sont effectuées au nom d'un utilisateur privilégié !

Théorie

Format d'entrée iptables iptables [-t table] [commande] [action] Exemple : iptables -t filter -A INPUT ACCEPT

Actes

ACCEPTER - Accepter le colis
DROP - Déposer un paquet
DNAT - Convertir l'adresse de destination
SNAT - Modifier l'adresse IP sortante dans l'en-tête du paquet
LOG - Journalisation des paquets et des événements
MARQUE - Mettre une marque sur un colis
MASQUERADE - Changer l'adresse IP sortante dans l'en-tête du paquet (différence avec SNAT - travailler avec des IP dynamiques)
QUEUE - Mettre un paquet en file d'attente pour le traitement
REDIRECT - Rediriger un paquet/flux vers un autre port
REJETER - Supprimer le paquet + en informer le système distant. que son colis a été rejeté
RETURN - Arrête le déplacement du paquet le long de la chaîne actuelle et renvoie-le à la chaîne appelante

Équipes

-A – Ajouter une règle à la chaîne
-D - Supprimer une règle de la chaîne
-R - Remplacer une règle par une autre
-I - Insérer une nouvelle règle
-L - Liste les règles existantes
-F - Réinitialiser les règles
-Z - Réinitialiser les compteurs dans une chaîne donnée
-N - Crée une nouvelle chaîne avec le nom donné
-X - Supprimer la chaîne
-P - Définir la politique par défaut pour la chaîne sélectionnée
-E - Renommer la chaîne d'utilisateurs

Critères (généraux)

-p - Spécifier le type de protocole
-s - adresse IP source du paquet
-d - Adresse IP du destinataire du paquet
-j - Spécifie l'action pour la règle
-i - Interface à partir de laquelle le paquet a été reçu
-o - Spécifiez le nom de l'interface de sortie
-f - Propager la règle à tous les fragments du paquet

Critères TCP :

–tcp-flags - Définir le masque de paquet et les indicateurs

Critères UDP :

–sport - Port à partir duquel le paquet a été envoyé
–dport - Port auquel le paquet est adressé

Plus de détails dans man iptables

Pratique

Afficher la configuration actuelle

$ sudo iptables -L Chain INPUT (politique ACCEPT) cible prot opt source destination Chain FORWARD (politique ACCEPT) cible prot opt source destination Chain OUTPUT (politique ACCEPT) cible prot opt source destination

Si vous voyez quelque chose comme ceci, cela signifie que votre pare-feu n'est pas encore configuré et autorise tout. Réparons la situation.

Définition de la stratégie par défaut

iptables -P INPUT DROP - blocage des paquets entrants
iptables -P OUTPUT ACCEPT - autorise les paquets sortants
iptables -P FORWARD DROP - traitement des paquets qui ont atteint le serveur depuis une autre machine et sont en attente d'un transfert ultérieur. Dans l'exemple, il est bloqué. Dans ce cas, vous devrez ajouter des règles pour les machines de confiance.

Puisque les paquets INPUT entrants sont bloqués, nous écrirons la règle suivante :

$ sudo iptables -A INPUT -m state --state RELATED,ESTABLISHED -j ACCEPT

Cela permettra d'accepter les paquets d'une connexion précédemment établie et d'accepter les nouveaux paquets générés par cette connexion.

Ou en indiquant le type de protocole :

$ sudo iptables -A INPUT -p TCP -m state --state ESTABLISHED,RELATED -j ACCEPT $ sudo iptables -A INPUT -p UDP -m state --state ESTABLISHED,RELATED -j ACCEPT

Maintenant l'interface locale :

$ sudo iptables -A INPUT -i lo -j ACCEPTER

NOUVEAU - données démarrant une nouvelle connexion.
ESTABLISHED - un paquet provenant d'une connexion déjà établie.
RELATED - un nouveau paquet de données, mais généré par une ancienne connexion établie
INVALIDE - donc c'est clair

$ sudo iptables-save > /etc/iptables.up.rules

Activez ces règles :

$ sudo iptables-restauration< /etc/iptables.up.rules

Et voyez la différence :

$sudo iptables -L

Lancez iptables au démarrage du système :

Dans le répertoire /etc/init.d, créez un fichier appelé iptables

$ sudo touch /etc/init.d/iptables

Nous y écrivons ce qui suit :

#!/bin/sh /sbin/iptables-restore< /etc/iptables.up.rules

Rendre le fichier iptables exécutable :

$ sudo chmod +x /etc/init.d/iptables

Ajoutez-le à l'exécution automatique

$ sudo update-rc.d -n valeurs par défaut d'iptables

Lancez iptables une fois connecté au réseau :

$ sudo echo "#! /sbin/iptables-restore" > /etc/network/if-up.d/iptables.up.rules $ sudo iptables-save >> /etc/network/if-up.d/iptables. up.rules $ sudo chmod +x /etc/network/if-up.d/iptables.up.rules

Note:à tout moment vous pouvez vérifier si vos règles sont chargées en entrant simplement iptables-save en tant que root

Pour archlinux, la sauvegarde des règles iptables se fait avec la commande :

$ sudo rc.d sauvegarder iptables

Un pare-feu fiable est l’un des aspects les plus importants de la protection de tout système d’exploitation moderne. La plupart des distributions Linux contiennent plusieurs outils de pare-feu différents. Ce guide est dédié à l'un des plus populaires : iptables.

Ainsi, iptables est le pare-feu standard inclus par défaut dans la plupart des distributions Linux (nftables est en cours de développement pour le remplacer). En fait, iptables est une interface utilisateur permettant de gérer le système netfilter, qui à son tour gère la pile réseau Linux. iptables compare chaque paquet entrant avec un ensemble de règles établies, puis décide quoi en faire ensuite.

La discussion portait sur le fonctionnement exact d'iptables. Cet article se concentre sur des exemples pratiques qui montrent comment créer un ensemble de règles de base pour un serveur Ubuntu 14.04.

Commandes iptables de base

Cette section contient des commandes de base avec lesquelles vous pouvez créer un ensemble complexe de règles et gérer l'interface iptables dans son ensemble.

Souviens-toi: les commandes iptables doivent être exécutées avec les privilèges root. Cela signifie que vous devez effectuer l'une des opérations suivantes :

connectez-vous en tant qu'utilisateur root ;
utilisez su ou sudo -i pour développer le shell racine ;
démarrez toutes les commandes avec sudo (méthode recommandée dans Ubuntu).

Ce guide utilise cette dernière option.

Donc, vous devez d’abord consulter la liste des règles iptables actuelles. Pour ce faire, utilisez l'indicateur -L :

sudo iptables -L
Chaîne INPUT (politique ACCEPTER)

cible prot opt source destination
SORTIE en chaîne (politique ACCEPTER)
cible prot opt source destination

Comme vous pouvez le voir, la liste contient trois chaînes par défaut (INPUT, OUTPUT et FORWARD), dont chacune a un ensemble de politiques par défaut (actuellement ACCEPT). Vous pouvez également voir les noms des colonnes. Mais cette liste n'inclut pas les règles elles-mêmes, car Ubuntu n'est pas livré avec un ensemble de règles par défaut.

À l'aide de l'indicateur -S, cette liste peut être visualisée dans un format différent qui reflète les commandes nécessaires pour activer les règles et politiques :

sudo iptables -S
-P ENTREE ACCEPTER
-P ACCEPTER AVANT
-P SORTIE ACCEPTER

Pour répliquer des configurations, il vous suffit de taper sudo iptables au début de chaque ligne de résultat. (En fonction de vos configurations, cette procédure peut être un peu plus complexe lors d'une connexion à distance ; si les règles qui autorisent la connexion en cours n'ont pas encore été définies, vous ne devez pas définir la politique DROP.)

Pour réinitialiser les règles actuelles (le cas échéant), tapez :

sudo iptables -F

Encore une fois, la politique par défaut est très importante à ce stade car elle ne sera pas modifiée par la commande précédente même si toutes les règles seront supprimées des chaînes.

Avant de réinitialiser les règles d'une connexion à distance, vous devez vous assurer que la stratégie ACCEPT est définie dans les chaînes INPUT et OUTPUT. Cela se fait comme ceci :

sudo iptables -P INPUT ACCEPTER
sudo iptables -P SORTIE ACCEPTER
sudo iptables -F

Une fois que vous avez créé des règles autorisant les connexions à distance, vous pouvez définir la stratégie DROP. Passons donc à la création des règles.

Créer des règles iptables

Comme mentionné ci-dessus, ce didacticiel se concentre sur l'utilisation de la chaîne INPUT car elle est responsable du trafic entrant. Tout d’abord, nous devons considérer la règle déjà mentionnée – la règle qui autorise la connexion SSH actuelle.

Cela ressemble à ceci :

sudo iptables -A INPUT -m conntrack --ctstate ESTABLISHED,RELATED -j ACCEPT

Bien sûr, cela peut sembler incroyablement compliqué au début ; Pour comprendre cette règle, familiarisez-vous avec ses composants :

-UNE ENTRÉE: flag -A ajoute ( ajouter) règle jusqu'à la fin de la chaîne. Cette partie de la commande indique à iptables d'ajouter une règle à la fin de la chaîne INPUT.
-m piste de connexion: en plus d'un ensemble de fonctions de base, iptables dispose également d'un ensemble d'extensions, ou modules, responsables de capacités de pare-feu supplémentaires. Cette partie de la commande indique que l'utilisateur doit accéder aux fonctions du module conntrack. Ce module vous permet d'utiliser des commandes qui décident quoi faire avec un paquet en fonction de sa relation avec les connexions précédentes.
--ctstate: une des commandes disponibles lors de l'appel du module conntrack. Cette commande vous permet de suivre la relation des packages avec d'autres packages qui ont été consultés précédemment. Il est défini sur ESTABLISHED (qui accepte les paquets faisant partie d'une connexion existante) et RELATED (accepte les paquets associés à une connexion déjà établie). C'est cette partie de la règle qui est responsable de la session SSH en cours.
— jACCEPTER: Spécifie l'action (cible) à effectuer sur un paquet qui correspond à la règle. Dans ce cas, iptables acceptera les paquets répondant aux critères précédents.

Cette règle doit être placée au début pour garantir que les connexions existantes correspondent aux règles, sont acceptées et quittent la chaîne sans atteindre les règles DROP.

En demandant une liste de règles, vous pouvez voir les changements :

sudo iptables -L
Chaîne INPUT (politique ACCEPTER)
cible prot opt source destination
ACCEPTER tout - n'importe où n'importe où ctstate LIÉ, ÉTABLI
Chaîne AVANT (politique ACCEPTER)
cible prot opt source destination
SORTIE en chaîne (politique ACCEPTER)
cible prot opt source destination

Une fois que vous êtes familiarisé avec la syntaxe de base, créez quelques règles supplémentaires acceptant une connexion.

Accepter d’autres connexions importantes

Auparavant, iptables recevait une commande non pas pour réinitialiser toutes les connexions actuelles, mais également pour accepter toutes les connexions qui leur sont associées. Vous devez maintenant créer des règles qui acceptent les connexions qui ne répondent pas aux critères ci-dessus.

Laissez deux ports ouverts : le port SSH (ce guide utilise le port par défaut 22 ; si cette valeur a été modifiée, assurez-vous de saisir la nouvelle valeur) ; De plus, supposons que sur cet ordinateur le serveur web s'exécute sur le port 80 par défaut (n'ajoutez pas cette règle si ce n'est pas le cas).

Ainsi, les lignes que vous devez utiliser pour créer de telles règles ressemblent à ceci :

sudo iptables -A INPUT -p tcp --dport 22 -j ACCEPTER
sudo iptables -A INPUT -p tcp --dport 80 -j ACCEPTER

Comme vous pouvez le constater, elles sont très similaires à la première règle ; peut-être ont-ils une structure encore plus simple. Nouvelles options :

— ptcp: Cette option permet le passage des paquets qui utilisent TCP (un protocole orienté flux utilisé par la plupart des applications car il fournit une communication fiable).
— déport: Cette option est disponible lors de l'utilisation de l'indicateur -p tcp. Il spécifie le port entrant auquel le port du paquet doit correspondre. La première règle autorise les paquets TCP destinés au port 22 et la seconde règle accepte le trafic TCP destiné au port 80.

Nous devons maintenant créer une autre règle ACCEPT pour garantir que le serveur fonctionne comme prévu. Généralement, les services communiquent en échangeant des paquets ; Pour ce faire, ils utilisent une interface réseau en pseudo-anneau - ce que l'on appelle le périphérique de bouclage, qui redirige le trafic vers sa source et non vers d'autres ordinateurs.

Autrement dit, si le service 1 doit communiquer avec le service 2 en écoutant les connexions sur le port 4555, le service 1 envoie un paquet au port 4555 à l'aide d'un périphérique de bouclage. Ce comportement doit être autorisé car il est essentiel au bon fonctionnement de nombreux programmes.

Pour ce faire, ajoutez la règle suivante :

sudo iptables -I INPUT 1 -i lo -j ACCEPTER

C'est un peu différent des règles précédentes ; regardez-le de plus près :

— jeENTRÉE 1: L'indicateur -I indique à iptables d'insérer une règle. Cet indicateur est différent de l'indicateur -A (qui ajoute simplement la règle à la fin de la chaîne) ; il spécifie la chaîne dans laquelle la règle doit être ajoutée et l'emplacement de la règle dans celle-ci. Dans ce cas, la règle doit être insérée au tout début de la chaîne INPUT, ce qui fait que toutes les règles se déplaceront d'une position. Cette règle doit être placée au début de la chaîne, puisqu’elle est l’une des règles principales et ne doit pas dépendre des autres.
— jevoilà: ce composant de règle autorise les paquets qui utilisent l'interface lo (« lo » est un autre nom pour le périphérique de bouclage). Cela signifie que tout paquet utilisant cette interface doit être accepté.

Pour afficher les règles actuelles, utilisez l'indicateur -S, car l'indicateur -L ne génère pas certaines informations (par exemple, l'interface à laquelle la règle est liée, ce qui est très important dans le cas de la dernière règle) :

sudo iptables -S
-P ENTREE ACCEPTER
-P ACCEPTER AVANT
-P SORTIE ACCEPTER
-A ENTRÉE -i lo -j ACCEPTER
-A INPUT -m conntrack --ctstate RELATED,ETABLISHED -j ACCEPT
-A INPUT -p tcp -m tcp --dport 22 -j ACCEPTER
-A INPUT -p tcp -m tcp --dport 80 -j ACCEPTER

Création de règles DROP

Ainsi, à l'heure actuelle, 4 règles ont été créées qui acceptent les paquets en fonction de certains critères. Cependant, le serveur ne bloque actuellement aucun autre paquet.

Si un paquet passe par la chaîne INPUT et ne correspond à aucune des quatre règles, la politique par défaut (ACCEPT) sera exécutée, qui acceptera le paquet d'une manière ou d'une autre. Maintenant, il faut le changer.

Cela peut être fait de deux manières, qui présentent des différences assez significatives.

La première consiste à modifier la politique par défaut de la chaîne INPUT ; pour faire ce type:

sudo iptables -P INPUT DROP

Cette politique surveillera et supprimera tous les paquets qui ne correspondent à aucune des règles de la chaîne INPUT. Une des conséquences de ce type de conception est qu’il abandonnera les paquets même après que les règles elles-mêmes aient été réinitialisées.

Bien entendu, cela augmente le niveau de sécurité du serveur ; cependant, cela peut avoir de graves conséquences si l'utilisateur n'a pas d'autre moyen de se connecter au serveur. Le plus souvent, les hébergeurs fournissent une console Web pour se connecter au serveur en cas de tels problèmes. Cette console fonctionne comme une connexion locale virtuelle, donc iptables n'y répondra pas.

Vous pouvez demander au serveur de réinitialiser automatiquement la connexion si les règles sont supprimées. Cela rendra le serveur plus sécurisé et plus difficile d’accès. Cela signifie également que vous pouvez insérer des règles à la fin de la chaîne et que tous les paquets indésirables seront supprimés.

Une approche alternative consiste à ajouter une règle à la fin de la chaîne qui élimine tous les paquets ne correspondant pas, tout en conservant la politique ACCEPT.

Pour renvoyer la stratégie ACCEPT à la chaîne INPUT, tapez :

sudo iptables -P INPUT ACCEPTER

Vous pouvez maintenant ajouter une règle à la fin de cette chaîne qui supprimera tous les paquets ne correspondant pas :

sudo iptables -A INPUT -j DROP

Dans des conditions de fonctionnement normales, le résultat sera exactement le même que celui obtenu avec la politique DROP. Cette règle supprime tous les paquets qui l'atteignent, empêchant ainsi les paquets qui ne correspondent pas aux règles d'atteindre le serveur.

Fondamentalement, la deuxième approche est utilisée lorsqu'il est nécessaire de préserver la politique ACCEPT qui accepte le trafic. Autrement dit, même si toutes les règles sont réinitialisées, l'utilisateur peut toujours accéder à la machine sur le réseau. Cette approche vous permet d'effectuer les actions par défaut sans avoir à modifier la politique qui sera appliquée à la chaîne vide.

Bien entendu, cela signifie également que toute règle devant être ajoutée à la fin de la chaîne doit précéder la règle de réinitialisation. Cela peut être fait soit en supprimant temporairement la règle de réinitialisation :

sudo iptables -D INPUT -j DROP
sudo iptables -A INPUT new_rule
sudo iptables -A INPUT -j DROP

soit en insérant une nouvelle règle en fin de chaîne (mais avant la règle de réinitialisation), en précisant le numéro de ligne. Pour saisir une règle à la ligne 4, tapez :

sudo iptables -I INPUT 4 new_rule

S'il existe de nombreuses règles, le calcul manuel du numéro de ligne est assez problématique ; dans ce cas, iptables peut numéroter les lignes :

sudo iptables -L --numéros de ligne
Chaîne INPUT (politique DROP)

1 ACCEPTER TOUT -- n'importe où n'importe où
2 ACCEPTER TOUT -- n'importe où n'importe où ctstate LIÉ, ÉTABLI
3 ACCEPTER TCP -- n'importe où n'importe où TCP dpt:ssh
4 ACCEPTER TCP -- n'importe où n'importe où TCP DPT : http
Chaîne AVANT (politique ACCEPTER)
num cible prot opt source destination
SORTIE en chaîne (politique ACCEPTER)
num cible prot opt source destination

Cela permet de vérifier que la règle a été saisie sur la bonne ligne.

Sauvegarde des paramètres iptables

Par défaut, toutes les règles non enregistrées restent en vigueur jusqu'au prochain redémarrage du serveur ; Immédiatement après un redémarrage, les règles non enregistrées seront perdues.

Dans certains cas, cela est utile car cela permet aux utilisateurs qui se sont accidentellement bloqués d'accéder au serveur. Cependant, dans la plupart des cas, il est toujours plus pratique de sauvegarder les règles et de les charger au démarrage du serveur.

Cela peut être fait de plusieurs manières ; Le plus simple consiste à utiliser le package iptables-persistent, qui peut être téléchargé depuis le référentiel Ubuntu par défaut :

sudo apt-get mise à jour
sudo apt-get install iptables-persistent

Lors de l'installation, le package précisera s'il est nécessaire de sauvegarder les règles actuelles pour un chargement automatique ultérieur ; Si les règles actuelles ont été testées (autorisant les connexions SSH) et répondent à toutes les exigences, elles peuvent être enregistrées.

Une fois l'installation terminée, un nouveau service appelé iptables-persistent apparaîtra, qui démarrera au redémarrage du serveur et reprendra les règles installées.

Résultats

Ce guide vous aide à configurer le pare-feu en fonction des besoins de l'utilisateur. Bien sûr, il existe de nombreux autres utilitaires similaires, et certains d'entre eux peuvent être plus faciles à utiliser ; Néanmoins, iptables est l'un des meilleurs outils, ne serait-ce que parce qu'il démontre certaines des structures de base de Netfilter et qu'il est inclus dans de nombreux systèmes.

Mots-clés : ,