Je suis certain que les administrateurs système de Linux connaissent bien iptablesl'interface utilisateur du netfiltercadre de filtrage de paquets.

Maintenant, cette "Question" est censée être un Wiki de la communauté pour rassembler divers fragments de iptablessagesse. Rien n'est trop commun ou trop obscur. Publiez tout ce que vous savez qui aiderait les autres à en tirer le meilleur parti iptables.

Utiliser la liste blanche et la liste noire avec iptables

#!/bin/bash

WHITELIST=/whitelist.txt
BLACKLIST=/blacklist.txt

#THIS WILL CLEAR ALL EXISTING RULES!
echo 'Clearing all rules'
iptables -F

#
## Whitelist
#

for x in `grep -v ^# $WHITELIST | awk '{print $1}'`; do
        echo "Permitting $x..."
        $IPTABLES -A INPUT -t filter -s $x -j ACCEPT
done

#
## Blacklist
#

for x in `grep -v ^# $BLACKLIST | awk '{print $1}'`; do
        echo "Denying $x..."
        $IPTABLES -A INPUT -t filter -s $x -j DROP
done

Script pour ouvrir les ports

#!/bin/bash
ALLOWEDTCP="80 3128 3784"
ALLOWEDUDP="3128 3784"

#
## Permitted Ports
#

for port in $ALLOWEDTCP; do
       echo "Accepting port TCP $port..."
       $IPTABLES -A INPUT -t filter -p tcp --dport $port -j ACCEPT
done

for port in $ALLOWEDUDP; do
        echo "Accepting port UDP $port..."
        $IPTABLES -A INPUT -t filter -p udp --dport $port -j ACCEPT
done

Blocage de portscan

# Attempt to block portscans
# Anyone who tried to portscan us is locked out for an entire day.
iptables -A INPUT   -m recent --name portscan --rcheck --seconds 86400 -j DROP
iptables -A FORWARD -m recent --name portscan --rcheck --seconds 86400 -j DROP

# Once the day has passed, remove them from the portscan list
iptables -A INPUT   -m recent --name portscan --remove
iptables -A FORWARD -m recent --name portscan --remove

# These rules add scanners to the portscan list, and log the attempt.
iptables -A INPUT   -p tcp -m tcp --dport 139 -m recent --name portscan --set -j LOG --log-prefix "Portscan:"
iptables -A INPUT   -p tcp -m tcp --dport 139 -m recent --name portscan --set -j DROP

iptables -A FORWARD -p tcp -m tcp --dport 139 -m recent --name portscan --set -j LOG --log-prefix "Portscan:"
iptables -A FORWARD -p tcp -m tcp --dport 139 -m recent --name portscan --set -j DROP

Paquets spoofés / invalides

# Reject spoofed packets
# These adresses are mostly used for LAN's, so if these would come to a WAN-only server, drop them.
iptables -A INPUT -s 10.0.0.0/8 -j DROP
iptables -A INPUT -s 169.254.0.0/16 -j DROP
iptables -A INPUT -s 172.16.0.0/12 -j DROP
iptables -A INPUT -s 127.0.0.0/8 -j DROP

#Multicast-adresses.
iptables -A INPUT -s 224.0.0.0/4 -j DROP
iptables -A INPUT -d 224.0.0.0/4 -j DROP
iptables -A INPUT -s 240.0.0.0/5 -j DROP
iptables -A INPUT -d 240.0.0.0/5 -j DROP
iptables -A INPUT -s 0.0.0.0/8 -j DROP
iptables -A INPUT -d 0.0.0.0/8 -j DROP
iptables -A INPUT -d 239.255.255.0/24 -j DROP
iptables -A INPUT -d 255.255.255.255 -j DROP

# Drop all invalid packets
iptables -A INPUT -m state --state INVALID -j DROP
iptables -A FORWARD -m state --state INVALID -j DROP
iptables -A OUTPUT -m state --state INVALID -j DROP

Bloquer les attaques de Schtroumpf

# Stop smurf attacks
iptables -A INPUT -p icmp -m icmp --icmp-type address-mask-request -j DROP
iptables -A INPUT -p icmp -m icmp --icmp-type timestamp-request -j DROP
iptables -A INPUT -p icmp -m icmp -j DROP

# Drop excessive RST packets to avoid smurf attacks
iptables -A INPUT -p tcp -m tcp --tcp-flags RST RST -m limit --limit 2/second --limit-burst 2 -j ACCEPT

Bloquer ICMP (aka ping)

# Don't allow pings through
iptables -A INPUT -p icmp -m icmp --icmp-type 8 -j DROP

Optimiser les performances de netfilter avec ipset

Si vous écrivez beaucoup de règles similaires basées sur une simple adresse IP, un port ou les deux, envisagez de les utiliser ipsetpour optimiser les performances de netfilter.

Par exemple:

iptables -s 192.168.1.11 -j ACCEPT
iptables -s 192.168.1.27 -j ACCEPT
iptables -s 192.168.1.44 -j ACCEPT
... hundreds of similar rules ...
iptables -s 192.168.251.177 -j ACCEPT

Cela signifie qu'un paquet avec l'adresse source 192.168.251.177 doit d'abord traverser des centaines de règles avant de pouvoir obtenir le verdict d'ACCEPT.

Bien sûr, les administrateurs système expérimentés diviseront les règles par sous-réseau. Mais cela signifie toujours des centaines de règles.

ipset à la rescousse!

Tout d’abord, définissez un ensemble IP de ipmaptype:

ipset -N Allowed_Hosts ipmap --network 192.168.0.0/16

Ensuite, remplissez-le avec les adresses:

for ip in $LIST_OF_ALLOWED_IP; do ipset -A Allowed_Hosts $ip; done

Enfin, remplacez les centaines de règles iptables ci-dessus par une seule règle:

iptables -m set --match-set Allowed_Hosts src -j ACCEPT

Quand un paquet arrive, netfilter effectuera une recherche très rapide de bitmap pour l’adresse IP source (src) du paquet par rapport à l’ Allowed_Hostsensemble IP. Tous les paquets provenant de 192.168.0.0/16 connaîtront une règle. Et croyez-moi, rechercher un bitmap est plus rapide d'au moins deux ordres de grandeur que d'effectuer des centaines de vérifications de règles iptables.

ipsetn'est pas limité aux adresses IP. Il peut également correspondre aux ports, au tuple de port IP, aux adresses réseau / sous-réseau, au tuple IP-MAC, etc. Et il peut correspondre à ces critères en tant que source ou destination ou un mélange des deux (dans le cas de n-uplets).

Et enfin, avec ipsetvous pouvez automatiquement mettre les adresses IP dans les listes noires / blanches. Ces listes noires / listes blanches peuvent également «vieillir», supprimant ainsi automatiquement l'adresse IP après un laps de temps configurable.

Veuillez vous référer à ipsetla page de manuel de pour plus de détails.

NOTE TRÈS IMPORTANTE:

Certaines distributions Linux peuvent ne pas avoir un support "prêt à l'emploi " ipset(par exemple, Ubuntu 10.04 avait ce problème). Sur ces systèmes, une méthode consiste à installer à ipsetpartir du code source.

A la place, téléchargez ipsetla source sur son site Web: http://ipset.netfilter.org/install.html

Alternativement, si vous utilisez xtables-addons, ipset est inclus dans sa source: http://xtables-addons.sourceforge.net/

Ajoutez des commentaires à vos règles:

-m comment --comment "Comments help to read output of iptables -nvL"

Bloquer les attaques TCP bien connues

Ajoutez les règles suivantes, de préférence dans -t raw -A PREROUTING

-p tcp --tcp-flags FIN,SYN FIN,SYN -j DROP
-p tcp --tcp-flags SYN,RST SYN,RST -j DROP
-p tcp --tcp-flags FIN,SYN,RST,PSH,ACK,URG FIN,PSH,URG -j DROP
-p tcp --tcp-flags FIN,SYN,RST,PSH,ACK,URG FIN -j DROP
-p tcp --tcp-flags FIN,SYN,RST,PSH,ACK,URG NONE -j DROP
-p tcp --tcp-flags FIN,SYN,RST,PSH,ACK,URG FIN,SYN,RST,PSH,ACK,URG -j DROP

Les attaques bloquées sont, respectivement:

• Attaque SYN-FIN
• Attaque SYN-RST
• Attaque de mas
• Analyse nmap FIN
• NULLflags attaque
• Attaque de tous les drapeaux

(n'hésitez pas à éditer les noms des attaques ci-dessus)

Activer le NAT

1. echo 1 > /proc/sys/net/ipv4/ip_forward
2. /sbin/iptables -t nat -A POSTROUTING -o eth0 -j MASQUERADE

L'étape 1 définit le paramètre du noyau pour autoriser le transfert d'adresse IP, l'étape 2 configure une règle iptables qui active la traduction d'adresses réseau sur l'interface eth0.

Bloquer les attaques ICMP

Ajoutez les règles suivantes, de préférence dans -t raw -A PREROUTING

-p icmp -m u32 ! --u32 "4&0x3FFF=0"   -j DROP
-p icmp -m length --length 1492:65535 -j DROP

La première règle bloque tous les paquets ICMP dont le "drapeau de fragmentation" n'est pas 0 (ICMP ne devrait jamais être fragmenté; ils devraient transporter de petites charges utiles).

La deuxième règle bloque les paquets ICMP surdimensionnés non fragmentés.

en utilisant FireHOL - wrapper iptables

Je l'ai trouvé beaucoup plus intuitif que les commandes directes iptables. Particulièrement pour les personnes ayant une expérience antérieure avec d'autres pare-feu:

FireHOL est un générateur de pare-feu iptables produisant des pare-feu à filtrage de paquets iptables avec état, sur des hôtes et des routeurs Linux avec un nombre quelconque d’interfaces réseau, un nombre quelconque de routes, un nombre quelconque de services servis, un nombre quelconque de complexité entre les variations des services (y expressions).

(de mon fichier iptables_tricks.txt, recompilé depuis de nombreux endroits: P)

Permet à iptables d’attendre 15 secondes entre les nouvelles connexions de la même adresse IP sur le port 22 (SSH):

 iptables -A INPUT -p tcp -i eth0 -m state --state NEW --dport 22 -m recent --update --seconds 15 -j DROP
 iptables -A INPUT -p tcp -i eth0 -m state --state NEW --dport 22 -m recent --set -j ACCEPT

Tutoriels vidéo IPTABLES

Épisode 1 http://www.youtube.com/watch?v=ldB8kDEtTZA&feature=player_embedded

Épisode 2 http://www.youtube.com/watch?v=aDaEXxRHeXY&feature=related

Dernier épisode

http://www.youtube.com/watch?v=JojqHKcSxpo&feature=player_embedded

Sera un bon début pour tout débutant.

Les ensembles IP revisités

Il existe déjà une réponse mentionnant les ensembles IP. Cependant, il est plutôt unidimensionnel dans la mesure où il se concentre sur les gains de performances par rapport aux règles classiques et sur le fait que les ensembles IP atténuent le problème rencontré avec de nombreuses adresses IP individuelles qui ne peuvent pas être facilement exprimées sous forme de sous-réseau dans la notation CIDR.

Notation utilisée ci-dessous

Pour que ipsetje vais utiliser la notation lue par ipset restoreécrit et par ipset save.

De manière correspondante pour iptables(et ip6tables) les règles, je vais utiliser la notation lue iptables-restoreet écrite par iptables-save. Cela donne une notation plus courte et me permet de mettre en évidence les règles potentielles uniquement IPv4 (préfixées -4) ou IPv6 uniquement (préfixées -6).

Dans certains exemples, nous allons transférer le flux de paquets dans une autre chaîne. La chaîne est supposée exister à ce point, ainsi les lignes pour créer les chaînes ne sont pas produites (ni le nom de la table ni les commandes COMMIT-ted à la fin).

Ensembles IP avancés

Les ensembles IP peuvent faire beaucoup plus que ce qui a été mentionné dans la réponse précédente et vous devez absolument lire la documentation de cet ensemble IP ( ipset(8)) ainsi que iptables-extensions(8)cette brève entrée ici.

Par exemple , je vais me concentrer principalement sur trois types de set: hash:ip, hash:netet list:set, mais il y a plus de ceux -ci et ils ont tous les cas d'utilisation valides.

Vous pouvez par exemple également faire correspondre les numéros de port, pas seulement les adresses IP .

Sauvegarde et restauration des ensembles IP comme avec iptables-saveetiptables-restore

Vous pouvez créer des déclarations d'ensemble IP en bloc et les importer en les canalisant dans ipset restore. Si vous voulez rendre votre commande plus résistante aux entrées existantes, utilisez ipset -exist restore.

Si vos règles sont dans un fichier appelé, default.setvous utiliseriez:

ipset -exist restore < default.set

Un fichier comme celui-ci peut contenir des entrées dans des createensembles et des addentrées. Mais généralement, la plupart des commandes de la ligne de commande semblent avoir une version correspondante dans les fichiers. Exemple (création d'un ensemble de serveurs DNS):

create dns4 hash:ip family inet
create dns6 hash:ip family inet6
# Google DNS servers
add dns4 8.8.8.8
add dns4 8.8.4.4
add dns6 2001:4860:4860::8888
add dns6 2001:4860:4860::8844

Ici, un ensemble est créé pour IPv4 ( dns4) et un autre pour IPv6 ( dns6).

Délais d'attente sur les postes IP

Les délais dans les ensembles IP peuvent être définis par défaut par ensemble et également par entrée. Ceci est très utile pour les scénarios dans lesquels vous souhaitez bloquer une personne temporairement (par exemple, pour analyser un port ou tenter de forcer brutalement votre serveur SSH).

Voici comment cela fonctionne (par défaut lors de la création d’ensembles IP):

create ssh_loggedon4 hash:ip  family inet  timeout 5400
create ssh_loggedon6 hash:ip  family inet6 timeout 5400
create ssh_dynblock4 hash:ip  family inet  timeout 1800
create ssh_dynblock6 hash:ip  family inet6 timeout 1800

Nous reviendrons sur ces ensembles particuliers ci-dessous et sur les raisons de leur définition.

Si vous souhaitez définir votre délai d’expiration pour une adresse IP particulière, vous pouvez simplement dire:

add ssh_dynblock4 1.2.3.4 timeout 7200

Pour bloquer IP 1.2.3.4 pendant deux heures au lieu de la demi-heure par défaut (définie).

Si vous envisagiez cela ipset save ssh_dynblock4après un moment, vous verriez quelque chose comme:

create ssh_dynblock4 hash:ip family inet hashsize 1024 maxelem 65536 timeout 1800
add ssh_dynblock4 1.2.3.4 timeout 6954

Mises en garde de délai

• les délais d'attente sont une caractéristique de n'importe quel ensemble. Si le jeu n'a pas été créé avec une prise en charge du délai d'attente, vous recevrez une erreur (par exemple Kernel error received: Unknown error -1).
• les délais d'attente sont donnés en secondes. Utilisez les expressions arithmétiques Bash pour passer de minutes en secondes, par exemple. Par exemple:sudo ipset add ssh_dynblock4 1.2.3.4 timeout $((120*60))

Vérifier si une entrée existe dans un ensemble IP donné

Dans vos scripts, il peut être utile de voir si une entrée existe déjà. Ceci peut être réalisé avec ipset testqui renvoie zéro si l'entrée existe et différent de zéro sinon. Donc, les vérifications habituelles peuvent être appliquées dans un script:

if ipset test dns4 8.8.8.8; then
  echo "Google DNS is in the set"
fi

Cependant, dans de nombreux cas, vous souhaiterez plutôt utiliser le -existcommutateur to ipsetafin de ne pas se plaindre des entrées existantes.

Remplir des ensembles IP à partir de iptablesrègles

Ceci, à mon avis, est l’une des caractéristiques les plus meurtrières des ensembles IP. Vous pouvez non seulement faire correspondre les entrées d'un ensemble IP, vous pouvez également ajouter de nouvelles entrées à un ensemble IP existant.

Par exemple, dans cette réponse à cette question, vous avez:

-A INPUT -p tcp -i eth0 -m state --state NEW --dport 22 -m recent --update --seconds 15 -j DROP
-A INPUT -p tcp -i eth0 -m state --state NEW --dport 22 -m recent --set -j ACCEPT

... avec l'intention de limiter le nombre de tentatives de connexion à SSH (port TCP 22). Le module utilisé recentgarde une trace des tentatives de connexion récentes. Au lieu du statemodule, je préfère cependant le conntrackmodule.

# Say on your input chain of the filter table you have
   -A INPUT -i eth+ -p tcp --dport ssh -j SSH
# Then inside the SSH chain you can
# 1. create an entry in the recent list on new connections
   -A SSH -m conntrack --ctstate NEW -m recent --set --name tarpit
# 2. check whether 3 connection attempts were made within 2 minutes
#    and if so add or update an entry in the ssh_dynblock4 IP set
-4 -A SSH -m conntrack --ctstate NEW -m recent --rcheck --seconds 120 --hitcount 3 --name tarpit -j SET --add-set ssh_dynblock4 src --exist
-6 -A SSH -m conntrack --ctstate NEW -m recent --rcheck --seconds 120 --hitcount 3 --name tarpit -j SET --add-set ssh_dynblock6 src --exist
# 3. last but not least reject the packets if the source IP is in our
#    IP set
-4 -A SSH -m set --match-set ssh_dynblock4 src -j REJECT
-6 -A SSH -m set --match-set ssh_dynblock6 src -j REJECT

Dans ce cas, je redirige le flux vers la SSHchaîne de sorte que je n'ai pas à me répéter -p tcp --dport sshpour chaque règle.

Recommencer:

• -m setfait iptablessavoir que nous utilisons des commutateurs du setmodule (qui gère les ensembles IP)
• --match-set ssh_dynblock4 srcindique de iptablesfaire correspondre l' adresse source ( src) à l'ensemble nommé ( ssh_dynblock4)
  • cela correspond à sudo ipset test ssh_dynblock4 $IP(où $IPcontient l'adresse IP source du paquet)
• -j SET --add-set ssh_dynblock4 src --existajoute ou met à jour l' adresse source ( src) du paquet dans l'ensemble IP ssh_dynblock4. Si une entrée existe ( --exist), elle sera simplement mise à jour.
  • cela correspond à sudo ipset -exist add ssh_dynblock4 $IP(où $IPcontient l'adresse IP source du paquet)

Si vous souhaitez faire correspondre l'adresse de destination / destination à la place, vous utiliserez à la dstplace de src. Consultez le manuel pour plus d'options.

Ensembles d'ensembles

Les ensembles IP peuvent contenir d'autres ensembles. Maintenant, si vous avez suivi l'article jusqu'à présent, vous vous êtes déjà demandé s'il était possible de combiner des ensembles. Et bien sûr que ça l'est. Pour les ensembles IP ci-dessus, nous pouvons créer deux ensembles conjoints ssh_dynblocket ssh_loggedoncontenir respectivement les ensembles IPv4 uniquement et IPv6 uniquement:

create ssh_loggedon4 hash:ip  family inet  timeout 5400
create ssh_loggedon6 hash:ip  family inet6 timeout 5400
create ssh_dynblock4 hash:ip  family inet  timeout 1800
create ssh_dynblock6 hash:ip  family inet6 timeout 1800
# Sets of sets
create ssh_loggedon  list:set
create ssh_dynblock  list:set
# Populate the sets of sets
add ssh_loggedon ssh_loggedon4
add ssh_loggedon ssh_loggedon6
add ssh_dynblock ssh_dynblock4
add ssh_dynblock ssh_dynblock6

Et la question suivante qui devrait vous être posée est de savoir si cela nous permet de faire correspondre et de manipuler les ensembles IP de manière indépendante de la version IP.

Et la réponse à cela est un retentissant: OUI! (hélas, cela n'a pas été documenté explicitement la dernière fois que j'ai vérifié)

Par conséquent, les règles de la section précédente peuvent être réécrites comme suit:

-A INPUT -i eth+ -p tcp --dport ssh -j SSH
-A SSH -m conntrack --ctstate NEW -m recent --set --name tarpit
-A SSH -m conntrack --ctstate NEW -m recent --rcheck --seconds 120 --hitcount 3 --name tarpit -j SET --add-set ssh_dynblock src --exist
-A SSH -m set --match-set ssh_dynblock src -j REJECT

ce qui est beaucoup plus concis. Et oui, cela a fait ses preuves et fonctionne à merveille.

Rassembler tout cela: la défense de force brute SSH

Sur mes serveurs, j'ai un script exécuté comme un crontravail qui prend un tas de noms d'hôtes et les résout en adresses IP, puis les alimente dans l'IP défini pour les "hôtes approuvés". L'idée est que les hôtes de confiance ont plus de tentatives de connexion au serveur et ne sont pas nécessairement bloqués aussi longtemps que quiconque.

À l'inverse, des pays entiers sont empêchés de se connecter à mon serveur SSH, à l'exception (potentielle) des hôtes de confiance (c'est-à-dire que l'ordre des règles est important).

Cependant, cela reste comme un exercice pour le lecteur. Ici, je voudrais ajouter une solution soignée qui utilisera les ensembles contenus dans l' ssh_loggedonensemble pour permettre aux tentatives de connexion ultérieures d'être transmises et non soumises au même contrôle que les autres paquets.

Il est important de garder à l'esprit les délais d'expiration par défaut de 90 minutes ssh_loggedonet de 30 minutes ssh_dynblocklorsque vous examinez les iptablesrègles suivantes :

-A INPUT -i eth+ -p tcp --dport ssh -j SSH
-A SSH -m set --match-set ssh_loggedon src -j ACCEPT
-A SSH -m conntrack --ctstate RELATED,ESTABLISHED -j ACCEPT
-A SSH -m conntrack --ctstate NEW -m recent --set --name tarpit
-A SSH -m conntrack --ctstate NEW -m recent --rcheck --seconds 120 --hitcount 3 --name tarpit -j SET --add-set ssh_dynblock src --exist
-A SSH -m set --match-set ssh_dynblock src -j REJECT

A présent, vous devriez vous demander comment l'adresse IP de connexion se retrouve dans les ssh_loggedonsous-ensembles. Alors lisez la suite ...

Bonus: ajout de l'IP avec laquelle vous vous connectez lors de la connexion SSH

Si vous avez expérimenté avec des sshrcamis, vous aurez appris ses inconvénients. Mais PAM vient à la rescousse. Un module nommé pam_exec.sonous permet d’appeler un script lors de la connexion SSH à un moment où nous savons que l’utilisateur est admis.

En /etc/pam.d/sshddessous des entrées pam_envet, pam_selinuxajoutez la ligne suivante:

session    optional     pam_exec.so stdout /path/to/your/script

et assurez-vous que votre version du script ( /path/to/your/scriptci-dessus) existe et est exécutable.

PAM utilise des variables d'environnement pour communiquer ce qui se passe, vous pouvez donc utiliser un script simple comme celui-ci:

#!/bin/bash
# When called via pam_exec.so ...
SETNAME=ssh_loggedon
if [[ "$PAM_TYPE" == "open_session" ]] && [[ -n "$PAM_RHOST" ]]; then
    [[ "x$PAM_RHOST" != "x${PAM_RHOST//:/}" ]] && SETNAME="${SETNAME}6" || SETNAME="${SETNAME}4"
    ipset -exist add $SETNAME "$PAM_RHOST"
fi

Malheureusement, l' ipsetutilitaire ne semble pas avoir l'intelligence intégrée de netfilter. Nous devons donc faire la distinction entre IPv4 et IPv6 lorsque vous ajoutez notre entrée. Sinon ipset, supposons que nous voulions ajouter un autre ensemble à l'ensemble des ensembles, au lieu de l'adresse IP. Et bien sûr, il est peu probable qu'il y ait un ensemble nommé d'après une adresse IP :)

Nous vérifions donc :l'adresse IP et ajoutons 6le nom de l'ensemble dans ce cas et dans les autres cas 4.

La fin.

Firewall Builder est une autre interface graphique pouvant être utilisée pour configurer iptables . Il permet aux utilisateurs de créer des éléments de règle en tant qu'objets dans une base de données, puis de les glisser-déposer dans un éditeur de règles pour créer la stratégie de pare-feu souhaitée. L'application génère ensuite un fichier de script avec toutes les commandes iptables requises pour implémenter les règles.

Contrairement à d'autres solutions d'interface graphique iptables dans lesquelles vous ne pouvez gérer qu'une configuration à la fois, avec Firewall Builder, vous pouvez gérer un grand nombre de configurations iptables à partir d'une seule application. Firewall Builder fonctionne sous Linux, Windows et Mac OS X, existe depuis plus de 10 ans et compte des milliers d'utilisateurs actifs dans le monde entier.

Full Disclosure - Je suis le cofondateur de NetCitadel, la société qui développe Firewall Builder.

connecter la connexion sortante avec uid

iptables -A OUTPUT -m state --state NEW -m tcp -p tcp -m limit --limit 5/m -j LOG --log-uid --log-prefix="outgoing connection: "

transfert de port / connexion:

iptables -A PREROUTING -t nat -i eth1 -p tcp --dport 80 -j DNAT --to 10.0.1.7:80
iptables -A INPUT -p tcp -m state --state NEW --dport 80 -i eth1 -j ACCEPT

Faire correspondre plusieurs noms d'interface avec un caractère générique

Exemple: vous avez eth0 et eth1 souhaitez autoriser le trafic entre eux?

iptables -A FORWARD -i eth+ -o eth+ -j ACCEPT

Je l'ai déjà utilisé pour faire correspondre les veth<something>interfaces créées dynamiquement et nommées par LXC. Donc, je peux faire correspondre tout à la fois avec veth+.

J'ai aussi intentionnellement nommé certaines interfaces _<something>afin de les comparer _+.

Bloquer les valeurs MSS inhabituelles

iptables -t mangle -A PREROUTING -p tcp \
-m conntrack --ctstate NEW -m tcpmss ! --mss 536:65535 -j DROP

SYNPROXY cible pour la protection DDos

Le but de cette cible est de vérifier si l’hôte qui a envoyé le paquet SYN établit la connexion ou ne fait rien après le lancement de la connexion SYN. S'il ne fait rien, il rejette le paquet avec un effort minimal.

Définir les paquets syn à la table de suivi de connexion dans la table brute

iptables -t raw -A PREROUTING -p tcp -m tcp --dport 80 --syn -j CT --notrack

Activer synproxy pour le serveur http:

iptables -A INPUT -p tcp -m tcp --dport 80 -m conntrack --ctstate INVALID,UNTRACKED \
-j SYNPROXY --sack-perm --timestamp --wscale 7 --mss 1460

Ressource: cible SYNPROXY du blog RHEL

Limiter toutes les adresses IP individuelles à un quota de bande passante sortante avec des ensembles IP

Vous pouvez configurer votre serveur de manière à n’autoriser que chaque utilisation individuelle de la bande passante IP 15Gi par octet, dans l’espoir de refléter ou d’éviter une attaque contre l’utilisation de la bande passante, éventuellement pour votre quota de bande passante mesurée chez votre fournisseur de services Internet. Cela peut être accompli comme suit:

Commencez par créer les ensembles IP pour IPv4 et IPv6:

ipset create IP_QUOTA_SET_OUT hash:ip timeout 345600 counters
ipset create IP_QUOTA_SET_OUT_INET6 hash:ip timeout 345600 counters family inet6

Ajoutez maintenant vos règles iptables. La première ligne ajoutera l'adresse IP à l'ensemble si ce n'est déjà fait. La deuxième ligne ne correspondra pas si les octets transférés pour l’IP dans l’ensemble sont supérieurs au montant spécifié. Ensuite, la même chose est faite pour IPv6.

iptables -I OUTPUT -m set ! --match-set IP_QUOTA_SET_OUT dst -j SET --add-set IP_QUOTA_SET_OUT dst --timeout 345600
iptables -I OUTPUT -m set --match-set IP_QUOTA_SET_OUT dst --bytes-gt 16106127360 -j DROP

ip6tables -I OUTPUT -m set ! --match-set IP_QUOTA_SET_OUT_INET6 src -j SET --add-set IP_QUOTA_SET_OUT_INET6 src --timeout 345600
ip6tables -I OUTPUT -m set --match-set IP_QUOTA_SET_OUT_INET6 src --bytes-gt 16106127360 -j DROP

Cela empêchera des attaques telles qu'un utilisateur demandant un fichier volumineux à votre serveur Web pendant une longue période, ou à tout service de ce fait. La même chose peut être faite pour la chaîne INPUT.

Une des choses que je fais, principalement à cause de mon ignorance d'une solution plus élégante, consiste à vérifier manuellement mes journaux Nginx toutes les 4 heures et le serveur de messagerie enregistre toutes les 2 minutes afin de détecter tout accès excessif par IP. Je lance quelques scripts ensemble qui:

1. Consultez access.loget répertoriez les 10 principales adresses IP organisées en fonction du nombre de visites sur le serveur.
2. Vider les résultats dans un fichier journal
3. Demandez à un autre script d'examiner ce fichier journal et d'interdire toute adresse IP ayant touché le serveur plus de X fois au cours des X dernières heures
4. Sauver ma iptables.save

Voici à quoi ça ressemble:

#!/bin/bash

# This script checks the last 2 minutes of log entries to see if any 
# IP has made over 99 connections

now=$(date +"%m_%d_%Y")

/root/bin/checkBadIPs_mail.sh > /home/ipChecker/ipcheckMAIL_$now.txt
cat /home/ipChecker/ipcheckMAIL_$now.txt | \
    grep " \\(\\([9][9]\\)\\|\\([0-9][0-9][0-9]\\+\\)\\) " | \
    awk '{print $2}' > /home/ipChecker/badMailIPs_$now.sh
sed -i "s/^/\/usr\/local\/sbin\/blockIP /g" /home/ipChecker/badMailIPs_$now.sh
/bin/bash /home/ipChecker/badMailIPs_$now.sh
cat /home/ipChecker/ipcheckMAIL_$now.txt >> /home/ipChecker/ipcheckMAIL_$now.log
rm /home/ipChecker/ipcheckMAIL_$now.txt
rm /home/ipChecker/badMailIPs_$now.sh

Il est TRÈS important de noter ici que vous devez BESOIN d’établir une liste blanche ou vous allez commencer à bloquer beaucoup d’adresses IP authentiques provenant de serveurs pour lesquels vous venez de recevoir beaucoup d’e-mails ou, dans le cas d’autres journaux, des adresses IP qui frappez beaucoup votre serveur pour des raisons légitimes. Ma liste blanche est simplement intégrée à ce script en ajoutant des tuyaux grep juste après | grep ']' | qui ressemble à ceci "grep -v 127.0 |" .
Vous devez prendre le temps d'enseigner à votre serveur quelles adresses IP à fort trafic sont légitimes et lesquelles ne le sont pas. Pour moi, cela signifiait que je devais passer la première semaine environ à vérifier mes journaux manuellement toutes les deux heures, à rechercher des adresses IP à fort trafic sur iplocation.net, puis à ajouter des adresses légitimes comme amazon, box.com ou même mon domicile / bureau. IP va à cette liste blanche. Si vous ne le faites pas, vous serez probablement bloqué depuis votre propre serveur ou vous allez commencer à bloquer les serveurs de courrier électronique / Web légitimes et provoquer des interruptions dans le courrier électronique ou le trafic.

cat /var/log/mail.log | awk \
    -v d1="$(date --date="-2 min" "+%b %_d %H:%M")" \
    -v d2="$(date "+%b %_d %H:%M")" \
    '$0 > d1 && $0 < d2 || $0 ~ d2' | \
    grep '\[' | grep '\]' | \
    grep -Eo '[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}' | grep -v 127.0 | \
    awk '{print $1}' | sort | uniq -c | sort -n | tail -10

#!/bin/bash
sudo iptables -I INPUT -s $1 -j DROP
sudo bash -c "iptables-save > /etc/network/iptables.save"

Encore une fois, je sais que c’est cruel et qu’il existe probablement un protocole propre et efficace qui fait tout cela, mais je ne le savais pas et cette situation dure depuis un an ou deux maintenant et met les méchants à distance. La seule chose que je recommanderais TRÈS GRAVEMENT est que vous ayez un proxy ou un autre serveur dans les coulisses que vous pouvez utiliser pour accéder à votre serveur principal. La raison en est que si vous faites du développement Web un jour à l'improviste, vous cinglez vous-même 2000 fois en 5 heures pour certains tests, vous pourriez être bloqué sans aucun retour, sauf pour un proxy.

Vous pouvez voir que checkBadIPs.shj'ai mis grep -v 127.0 et que dans mes fichiers réels, j'ai une tonne de règles d'ignorance pour ma propre adresse IP et d'autres plages d'adresses IP de confiance, mais parfois votre adresse IP change, vous oubliez de mettre à jour, puis vous êtes verrouillé. sur votre propre serveur.

Quoi qu'il en soit, espérons que cela aide.

MISE À JOUR

J'ai un peu changé les choses afin qu'au lieu de vérifier toutes les deux heures, je vérifie quelques journaux toutes les 2 minutes, principalement mon journal d'authentification ssh et le journal de messagerie au fur et à mesure qu'ils se faisaient pilonner :(.

Je configure des scripts spécifiques pour chaque fichier journal, même si le script manuel que je m'utilise moi-même me permet de contrôler les journaux. Ressemble à ça:

#!/bin/bash

log=$1 time=$2

cat /var/log/${log} | awk \
    -v d1="$(date --date="-${time} min" "+%b %_d %H:%M")" \
    -v d2="$(date "+%b %_d %H:%M")" \
    '$0 > d1 && $0 < d2 || $0 ~ d2' | \
    grep '\[' | grep '\]' | \
    grep -Eo '[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}' | \
    sort | uniq -c | sort -n | tail -10

Cela nécessite 2 entrées lors de l’exécution, le fichier journal que vous souhaitez analyser et la période écoulée dans le passé que vous souhaitez analyser.

Donc, si je voulais vérifier mail.log pour les comptes d'IP, disons 75 minutes dans le passé, je lancerais:

$ sudo script.sh mail.log 75

Je suis d'accord avec les commentaires sur les ipsets et les drapeaux tcp, mais il manque encore beaucoup:

Utilisez la correspondance geoip d'xtables-addons au lieu d'ipsets pour les listes de pays. Mettez à jour les données geoip régulièrement (au moins une fois par mois). Les données sont plus dynamiques qu’une liste ipset feu et oublie.

Envisagez le suivi de l'état de la connexion avec les drapeaux TCP. Par exemple, un RTC ou ACK TCP n'a de sens que pour une connexion établie. SYN n'a de sens que pour les connexions nouvelles et connexes. Un SYN pour une connexion établie signifie que votre SYN + ACK a été perdu ou une tentative de piratage. Il doit être réinitialisé car les deux côtés de la connexion ne sont pas d’accord pour le dire.

Bien que aucune, SYN + RST et FIN + RST soient des combinaisons illégales, SYN + FIN est maintenant valide sous TCP à ouverture rapide (option TCP 34), en particulier pour DNS. Les paquets SYN, même à ouverture rapide, ne doivent pas être fragmentés. Je ne considère pas les règles avec les drapeaux PSH et URG comme utiles. Ne confondez pas l'état de suivi de connexion avec l'état TCP: une réponse RST à un paquet SYN est établie à des fins de suivi.

SYNPROXY est destiné aux paquets transférés et n’ajoute rien pour les paquets livrés localement au-delà du support syncookie.

Les paquets d'erreur ICMP seront toujours dans l'état associé et de longueur 48: 576 s'ils sont valides. Longueur 84: 1280 pour IPv6. Tous les autres doivent être ignorés. Comme leur taille maximale est également le MTU minimum, ils ne doivent jamais être fragmentés. Les requêtes ICMP (pings, horodatages, etc.) seront toujours nouvelles et les réponses établies. Déposez les paquets ICMP dans d'autres états.

Comme dans l'exemple SSH avec une liste récente et n'acceptant que les paquets SYN ultérieurs, il devrait en être de même pour SMTP. Cette procédure est similaire à «liste grise» sur la seule donnée d'adresse IP.

Dans la table de filtrage, la première règle (ou la seconde, si les paquets d'état établis sont acceptés en premier), dans les chaînes d'entrée et de sortie, doit accepter tout ce qui se trouve sur l'interface de bouclage. Vous devriez faire confiance à vos propres paquets internes. Si vous ne pouvez pas, vous avez des problèmes plus graves au-delà d'une solution de pare-feu.

Enfin, ne copiez pas aveuglément les règles, sauf si vous comprenez vraiment ce qu'elles font. De nombreuses listes de règles similaires le font, et la plupart du temps, le résultat est risible.

#!/bin/bash
# The following iptables/ip6tables configurations have
# been kindly shared with us from ArckWiki. There are
# a few additions apart from what has been defined.
#
#=================Flush current definitions==============
    iptables -F
    ip6tables -F
    iptables -X
    ip6tables -X

#
#=================Chains=================================
#
#----Define chains for opened ports
    iptables -N TCP
    ip6tables -N TCP
    iptables -N UDP
    ip6tables -N UDP

#
#----Setting up the filter table for NAT
#   iptables -N fw-interfaces
#   ip6tables -N fw-interfaces
#   iptables -N fw-open
#   ip6tables -N fw-open

#
#================Default Chain reactions=================
#
#----Default FORWARD reaction
    iptables -P FORWARD DROP
    ip6tables -P FORWARD DROP

#
#----Default OUTPUT reaction
    iptables -P OUTPUT ACCEPT
    ip6tables -P OUTPUT ACCEPT

#
#----Shellshock
    iptables -A INPUT -m string --algo bm --hex-string '|28 29 20 7B|' -j DROP
    ip6tables -A INPUT -m string --algo bm --hex-string '|28 29 20 7B|' -j DROP

#
#----Default INPUT reaction
    iptables -P INPUT DROP
    ip6tables -P INPUT DROP
#
#----Drop spoofing packets
    iptables -A INPUT -i eth0 -s 127.0.0.0/8 -j DROP
    iptables -A INPUT -i wlan0 -s 127.0.0.0/8 -j DROP
    iptables -A INPUT -i wlan1 -s 127.0.0.0/8 -j DROP
    iptables -A INPUT -s 10.0.0.0/8 -j DROP
    iptables -A INPUT -s 169.254.0.0/16 -j DROP
    iptables -A INPUT -s 172.16.0.0/12 -j DROP
    iptables -A INPUT -s 224.0.0.0/4 -j DROP
    iptables -A INPUT -d 224.0.0.0/4 -j DROP
    iptables -A INPUT -s 240.0.0.0/5 -j DROP
    iptables -A INPUT -d 240.0.0.0/5 -j DROP
    iptables -A INPUT -s 0.0.0.0/8 -j DROP
    iptables -A INPUT -d 0.0.0.0/8 -j DROP
    iptables -A INPUT -d 239.255.255.0/24 -j DROP
    iptables -A INPUT -d 255.255.255.255 -j DROP

#
#================Ping rate limiting globally=============
    iptables -A INPUT -p icmp --icmp-type 8 -m limit --limit 30/min --limit-burst 8 -j ACCEPT
    ip6tables -A INPUT -p icmpv6 --icmpv6-type 8 --match limit --limit-burst 8 -j ACCEPT
    iptables -A INPUT -p icmp --icmp-type 8 -j DROP
    ip6tables -A INPUT -p icmpv6 --icmpv6-type 8 -j DROP

#
#----flooding RST packets, smurf attack Rejection
    iptables -A INPUT -p tcp -m tcp --tcp-flags RST RST -m limit --limit 2/second --limit-burst 2 -j ACCEPT
    ip6tables -A INPUT -p tcp -m tcp --tcp-flags RST RST -m limit --limit 2/second --limit-burst 2 -j ACCEPT

#
#----Bogus packet DROP
    iptables -A INPUT -p tcp -m tcp --tcp-flags SYN,FIN SYN,FIN -j DROP
    ip6tables -A INPUT -p tcp -m tcp --tcp-flags SYN,FIN SYN,FIN -j DROP
    iptables -A INPUT -p tcp -m tcp --tcp-flags SYN,RST SYN,RST -j DROP
    ip6tables -A INPUT -p tcp -m tcp --tcp-flags SYN,RST SYN,RST -j DROP

#
#================RELATED,ESTABLISHED reaction============
    iptables -A INPUT --match conntrack --ctstate RELATED,ESTABLISHED -j ACCEPT
    ip6tables -A INPUT --match conntrack --ctstate RELATED,ESTABLISHED -j ACCEPT

#
#================unfetered loopback======================
    iptables -A INPUT -i lo -j ACCEPT
    ip6tables -A INPUT -i lo -j ACCEPT

#
#================INVALID catagory of packets=============
    iptables -A INPUT -p 41 -j ACCEPT
    iptables -A INPUT --match conntrack --ctstate INVALID -j DROP
    ip6tables -A INPUT --match conntrack --ctstate INVALID -j DROP

#
#================IPv6 reactions and definitions==========
    ip6tables -A INPUT -s fe80::/10 -p icmpv6 -j ACCEPT
    ip6tables -t raw -A PREROUTING -p icmpv6 -s fe80::/10 -j ACCEPT
    ip6tables -t raw -A PREROUTING --match rpfilter -j ACCEPT
    ip6tables -t raw -A PREROUTING -j DROP
#
#=======Acceptable INVALIDs and a curteous response======
    iptables -A INPUT -p udp --match conntrack --ctstate NEW -j UDP
    ip6tables -A INPUT -p udp --match conntrack --ctstate NEW -j UDP
    iptables -A INPUT -p tcp --syn --match conntrack --ctstate NEW -j TCP
    ip6tables -A INPUT -p tcp --syn --match conntrack --ctstate NEW -j TCP

#
#================Defining the TCP and UDP chains
#
#########################################################
#            Notes for port open definitions            #
# It is important to note that this should be config-   #
# ured differently if you're providing any routing      #
# activity for any purpose. it is up to you to actively #
# define what suites your needs to get the job done.    #
# In this example, I'm exempting IPv6 from being able   #
# to interact with SSH protocols for two reasons. The   #
# first is because it is generally easier and more com- #
# for internal networks to be deployed with IPv4. The   #
# second reason is, IPv6 can be deployed globally.      #
#########################################################
#
#----SSH configured for eth0
    iptables -A TCP -i eth0 -p tcp --dport ssh -j ACCEPT

#!---Blocking SSH interactions in IPv6
    ip6tables -A TCP -p tcp --dport ssh -j DROP

#!---Leave commented for end service device
#   iptables -A TCP -p tcp --dport 80 -j ACCEPT
#   ip6tables -A TCP -p tcp --dport 80 -j ACCEPT
#   iptables -A TCP -p tcp --dport 443 -j ACCEPT
#   ip6tables -A TCP -p tcp --dport 443 -j ACCEPT
#
#!---Uncomment for remote service to this device
#   iptables -A TCP -p tcp --dport 22 -j ACCEPT
#   ip6tables -A TCP -p tcp --dport 22 -j ACCEPT
#
#!---Uncomment if you're providing routing services
#   iptables -A UDP -p udp 53 -j ACCEPT
#   ip6tables -A UDP -p udp 53 -j ACCEPT
#
#=================Tricking port scanners=================
#
#----SYN scans
    iptables -I TCP -p tcp --match recent --update --seconds 60 --name TCP-PORTSCAN -j DROP
    ip6tables -I TCP -p tcp --match recent --update --seconds 60 --name TCP-PORTSCAN -j DROP
    iptables -A INPUT -p tcp --match recent --set --name TCP-PORTSCAN -j DROP
    ip6tables -A INPUT -p tcp --match recent --set --name TCP-PORTSCAN -j DROP

#
#----UDP scans
    iptables -I UDP -p udp --match recent --update --seconds 60 --name UDP-PORTSCAN -j DROP
    ip6tables -I UDP -p udp --match recent --update --seconds 60 --name UDP-PORTSCAN -j DROP
    iptables -A INPUT -p udp --match recent --set --name UDP-PORTSCAN -j DROP
    ip6tables -A INPUT -p udp --match recent --set --name UDP-PORTSCAN -j DROP

#
#----For SMURF attack protection
    iptables -A INPUT -p icmp -m icmp --icmp-type address-mask-request -j DROP
    iptables -A INPUT -p icmp -m icmp --icmp-type timestamp-request -j DROP
    iptables -A INPUT -p icmp -m limit --limit 2/second --limit-burst 2 -j ACCEPT
    ip6tables -A INPUT -p icmpv6 -m limit --limit 2/second --limit-burst 2 -j ACCEPT

#
#----Ending all other undefined connections
    iptables -A INPUT -j DROP
    ip6tables -A INPUT -j DROP

#
#=======Defining the IN_SSH chain for bruteforce of SSH==
#
#!---I've elected to keep IPv6 out of this realm for
#!---ease of use
    iptables -N IN_SSH
    iptables -A INPUT -p tcp --dport ssh --match conntrack --ctstate NEW -j IN_SSH
    iptables -A IN_SSH --match recent --name sshbf --rttl --rcheck --hitcount 3 --seconds 10 -j DROP
    iptables -A IN_SSH --match recent --name sshbf --rttl --rcheck --hitcount 4 --seconds 1800 -j DROP
    iptables -A IN_SSH --match recent --name sshbf --set -j ACCEPT
    iptables -A INPUT -p tcp --dport ssh -m conntrack --ctstate NEW -j IN_SSH

#
#==================Setting up a NAT gateway==============
#
#########################################################
#                                                       #
# I commented this half out because it's not something  #
# that will apply to all setups. Make note of all par-  #
# tinate interfaces and what exactly is going on.       #
#                                                       #
#########################################################
#
#----Setting up the FORWARD chain
#   iptables -A FORWARD --match conntrack --ctstate RELATED,ESTABLISHED -j ACCEPT
#   ip6tables -A FORWARD --match conntrack --ctstate RELATED,ESTABLISHED -j ACCEPT
#
#
#----Defining the fw-interfaces/open chains for FORWARD
#   iptables -A FORWARD -j fw-interfaces
#   ip6tables -A FORWARD -j fw-interfaces
#   iptables -A FORWARD -j fw-open
#   ip6tables -A FORWARD -j fw-open
#   iptables -A FORWARD -j DROP # Should be REJECT. But, fuck them
#   ip6tables -A FORWARD -j DROP
#   iptables -P FORWARD DROP
#   ip6tables -P FORWARD DROP
#
#
#----Setting up the nat table
#   iptables -A fw-interfaces -i ### -j ACCEPT
#   ip6tables -A fw-interfaces -i ### -j ACCEPT
#   iptables -t nat -A POSTROUTING -s w.x.y.z/S -o ppp0 -j MASQUERADE
#   ip6tables -t nat -A POSTROUTING -s fe::/10 -o ppp0 -j MASQUERADE
#----The above lines should be repeated specifically for EACH interface
#
#----Setting up the PREROUTING chain
#
#######################################################
#                             #
# The PREROUTING chain will redirect either port      #
# targets to be redirected. This can also redirect    #
# traffic inbound to your network from the gateway    #
# to this machine. This can be useful if you're using #
# a honeypot or have any service within your network  #
# that you want to be pointed to a specific device.   #
#                             #
#######################################################
#
#----SSH honeypot server
#   iptables -A fw-open -d HONEYPOT_IP -p tcp --dport 22 -j ACCEPT
#   ip6tables -A fw-open -d HONEYPOT_IP -p tcp --dport 22 -j ACCEPT
#----With intuition, you can configure the above to also direct specific
#----requests to other devices providing those services. The bellow will
#----be for a squid server
#   iptables -A fw-open -d SQUID_IP -p tcp --dport 80 -j ACCEPT
#   ip6tables -A fw-open -d SQUID_IP -p tcp --dport 80 -j ACCEPT
#   iptables -t nat -A PREROUTING -i ppp0 -p tcp --dport 8000 -j DNAT --to SQUID_IP
#   ip6tables -t nat -A PREROUTING -i ppp0 -p tcp --dport 8000 -j DNAT --to SQUID_IP
#
#===============Declare configurations=================
    iptables -nvL
    ip6tables -nvL