script de conseiller de règles iptables

Il existe un serveur sans aucune défense iptables :ACCEPT all..

Il pourrait y avoir des applications personnalisées sur ce serveur.

Si nous devons durcir ce serveur (donc nier tout, et ne laisser que ce dont les applications ont besoin) avec des règles iptables strictes, nous devons trouver à la main ce que l'application utilise dst/src port/protocolet ensuite nous devons écrire les règles iptables pour leur..

La question : existe-t-il des scripts qui peuvent aider à collecter ces informations à partir d'une machine en cours d'exécution? (à partir des journaux?) - Et générer automatiquement les règles iptables?

Comme s'il y audit2allowen avait SELinux. Juste pour iptables!

La machine ne doit pas avoir de panne!

Ex.: Le script "MAGIC" devrait s'exécuter une semaine / mois sur la machine, collectant les informations, puis, après une semaine / mois, le script pourra produire un fichier de règles iptables que nous pourrons utiliser.

Beaucoup de gens pourraient se retrouver dans cette situation (comment durcir un serveur concernant iptables). Et ce serait formidable s'il y avait un script / solution qui peut faire ceci: \

Faites-le manuellement

sudo ss -tuanp

ou

sudo netstat -tuanp

Explication:

-t - show tcp sockets
-u - show udp sockets
-a - show all sockets
-n - show numeric, don't resolve 
-p - show process name

Exécutez tcpdumpsur la machine pendant environ une semaine pour capturer le trafic moyen. Ensuite, vous pouvez parcourir le trafic à l'aide de Wireshark plus tard pour voir quels ports sont utilisés.

La commande pour cela serait tcpdump -i <interface> -s 65535 -w <some-file>

Vous pouvez ensuite mapper cela en arrière netstat -tuanppour voir quels PID / applications utilisent quels ports.

Théoriquement, cela pourrait être écrit.

Vous pouvez commencer avec un modèle très basique comme - https://gist.github.com/jirutka/3742890 , qui n'autorise que ssh et ping, et ajouter autre chose manuellement.

un hack de script rapide pour générer des règles iptables pour votre application à l'écoute sur l'interface publique (0.0.0.0) / tcp

netstat -lnpt | egrep '0.0.0.0:[0-9]+' | awk '{print $4,$7}' | \
sed -E -e 's/0.0.0.0://g' -e 's|[0-9]+/||' | \
awk '{printf ("iptables -A INPUT -p tcp --dport %5d --syn -m conntrack --ctstate NEW -m comment %s \n", $1,$2) }'

vous pouvez également utiliser le iptables -I INPUT <number>pour injecter les règles dans un emplacement spécifique, que vous pouvez répertorier aveciptables -nvL --line-numbers INPUT

Malheureusement, je n'ai jamais vu un tel script qui puisse fonctionner en mode d'apprentissage ou en mode passif, enregistrant toute votre utilisation du réseau, prenant ses résultats et générant un pare-feu réel à iptablespartir de ses journaux.

Votre meilleur pari va être de commencer simplement et de continuer à ajouter les différentes pièces au fur et à mesure que vous commencez à bien comprendre quels services votre système fournit. Vous devrez utiliser des outils tels que netstatpour voir quels ports sont utilisés pour les différents services que vous hébergez, ainsi que les adresses IP qui y accèdent.

$ sudo netstat -tlpn
Active Internet connections (only servers)
Proto Recv-Q Send-Q Local Address               Foreign Address             State       PID/Program name   
tcp        0      0 0.0.0.0:25                  0.0.0.0:*                   LISTEN      26292/sendmail      
tcp        0      0 0.0.0.0:890                 0.0.0.0:*                   LISTEN      26149/ypbind        
tcp        0      0 0.0.0.0:445                 0.0.0.0:*                   LISTEN      26321/smbd          
tcp        0      0 127.0.0.1:2207              0.0.0.0:*                   LISTEN      26226/python        
tcp        0      0 127.0.0.1:2208              0.0.0.0:*                   LISTEN      26221/./hpiod       
tcp        0      0 127.0.0.1:199               0.0.0.0:*                   LISTEN      26237/snmpd         
tcp        0      0 0.0.0.0:809                 0.0.0.0:*                   LISTEN      26067/rpc.statd     
tcp        0      0 0.0.0.0:139                 0.0.0.0:*                   LISTEN      26321/smbd          
tcp        0      0 0.0.0.0:587                 0.0.0.0:*                   LISTEN      26292/sendmail      
tcp        0      0 0.0.0.0:111                 0.0.0.0:*                   LISTEN      26038/portmap       
tcp        0      0 0.0.0.0:35604               0.0.0.0:*                   LISTEN      -                   
tcp        0      0 0.0.0.0:22                  0.0.0.0:*                   LISTEN      26249/sshd          
tcp        0      0 0.0.0.0:631                 0.0.0.0:*                   LISTEN      26257/cupsd         
tcp        0      0 :::22                       :::*                        LISTEN      26249/sshd          
tcp        0      0 :::631                      :::*                        LISTEN      26257/cupsd         

REMARQUE: Dans ce qui précède, vous pouvez voir les services que j'exécute sur un serveur qui acceptent les connexions TCP, c'est-à-dire qu'ils "écoutent" les connexions sur différents ports.

Il est plus simple de commencer avec des choses comme SSH (port 22) et HTTP (port 80), si elles sont typiques de votre système, donc je ferais ces types de services en masse en même temps. Pour d'autres services tels que LDAP ou NIS, vous souhaiterez peut-être les faire de manière plus contrôlée, en vous assurant que les choses ne se cassent pas lorsque vous les introduisez.

Des outils tels que FireHOL , Firewall Builder (fwbuilder) et eztables peuvent être utiles lorsque vous attaquez ce projet, car ils fournissent une belle couche d'abstraction d'avoir à créer des iptablerègles personnalisées à la main, ce qui peut être délicat.

FireHOL est un langage (et un programme pour l'exécuter) qui crée des pare-feu sécurisés et dynamiques de toute complexité à partir de configurations faciles à comprendre et lisibles par l'homme.

exemple

transparent_squid 8080 "squid root" inface eth0

interface eth0 mylan
    policy accept

interface ppp+ internet
    server smtp accept
    server http accept
    server ftp  accept
    server ssh  accept src example.firehol.org

    client all  accept

router mylan2internet inface eth0 outface ppp+
    masquerade
    route all accept

Fwbuilder est un outil de pare-feu graphique unique qui permet à l'utilisateur de créer des objets, puis de faire glisser et déposer ces objets dans des pare-feu, pour créer un système de sécurité puissant pour un seul PC ou un réseau de PC. Fwbuilder prend en charge une large gamme de pare-feu (Cisco ASA / PIX, iptables Linux, ipfilter de FreeBSD, pf d'OpenBSD, etc.), de sorte que ses règles peuvent être déployées sur plusieurs plates-formes. Jetons un coup d'œil à l'utilisation de Fwbuilder sur Linux, qui pourrait bien devenir une affaire à vie avec un puissant système de sécurité.

exemple

Eztables vous permet de configurer rapidement un pare-feu sans jamais toucher à iptables. La syntaxe des règles de pare-feu est conçue pour être facile à lire et à appliquer.

Voici comment vous autorisez l'ensemble d'Internet à accéder à votre serveur Web sur le port TCP 80:

  allow_in any $eth0 any 80/tcp

Eztables est conçu pour être simple, mais puissant. Peu importe si vous souhaitez protéger votre ordinateur portable, configurer un routeur domestique ou créer un pare-feu d'entreprise.

Utilisation de Fail2Ban

Avec un iptablespare-feu rudimentaire en place, vous voudrez probablement le complimenter en utilisant un outil tel que Fail2Ban .

Fail2ban analyse les fichiers journaux (par exemple / var / log / apache / error_log) et interdit les adresses IP qui montrent les signes malveillants - trop de défaillances de mot de passe, recherche d'exploits, etc. Généralement Fail2Ban est ensuite utilisé pour mettre à jour les règles de pare-feu pour rejeter les adresses IP pendant une durée spécifiée, bien que toute autre action arbitraire (par exemple l'envoi d'un e-mail) puisse également être configurée. Prêt à l'emploi, Fail2Ban est livré avec des filtres pour divers services (apache, courrier, ssh, etc.).

L'utilisation d'outils tels que celui-ci contribuera à limiter l'exposition que votre système devra supporter pendant que vous continuez à le durcir. Même après avoir été assez convaincu que votre système a été renforcé, vous souhaiterez peut-être continuer à utiliser Fail2Ban dans le cadre de vos mesures de sécurité.

Références

• Créez des pare-feu Linux puissants avec Firewall Builder
• Exemple FireHOL
• Page principale du projet FirewallBuilder
• Exemple de base de pare-feu / iptables

Utilisez des règles iptables pour enregistrer les nouvelles connexions, ce qui enregistrera également udp.

iptables -I INPUT -m state --state NEW -j LOG --log-prefix "New inbound connection: "
iptables -I OUTPUT -m state --state NEW -j LOG --log-prefix "New outbound connection: "

Vous pouvez spécifier différent --log-level d'avoir les journaux dans un autre fichier que / var / log / messages (vous devrez configurer le démon syslog).

Je pense que vous devriez lire les principaux journaux des applications car certains serveurs ont une activité très périodique comme midi, fin de semaine, fin de mois (trimestre, année) afin de ne pas manquer une activité réseau importante du serveur.

Comme le serveur est critique, fait la matrice de flux réseau du serveur sur une belle feuille de calcul (source ip, destination ip, protocole, port, application) qui vous aidera à construire les règles.

Je sais que ce n'est pas un script et ce n'est pas une réponse à la question d'OP mais c'est une de mes idées que je veux partager avec OP.

J'ai tous les ports d'écoute avec:

netstat -an | egrep 'tcp .*LISTEN' | awk -F" " '{print $4}' | awk -F":" '{print $NF}'

Peut-être que cela peut vous rapprocher de l'écriture de votre propre script. :)

Vous pouvez commencer avec quelque chose comme ceci:

netstat -n -l -p | egrep "^(tcp|tcp6|udp)" | grep LISTEN | sed -r 's!^(tcp|tcp6|udp)\s.*:([0-9]+).*LISTEN\s+.*/(.*)!iptables -A INPUT -p \1 --dport \2 -j ACCEPT # \3!'

puis le suivre avec

iptables -P INPUT DROP

ou

iptables -A INPUT -j REJECT --reject-with icmp-host-prohibited

La première ligne utilise Netstat pour répertorier les processus d'écoute et leurs ports. Il générera ensuite des lignes «iptables» pour permettre chacune de ces connexions entrantes. La petite substitution de regex sed a été personnalisée pour la sortie netstat sur mon serveur, donc cela pourrait nécessiter quelques ajustements pour vous. Lorsque cela fonctionne, vous devriez vous retrouver avec quelque chose qui ressemble à:

iptables -A INPUT -p tcp --dport 111 -j ACCEPT # rpcbind       
iptables -A INPUT -p tcp --dport 22 -j ACCEPT # sshd          
iptables -A INPUT -p tcp --dport 25 -j ACCEPT # master        
iptables -A INPUT -p tcp --dport 3306 -j ACCEPT # mysqld        
iptables -A INPUT -p tcp --dport 49476 -j ACCEPT # rpc.statd     
iptables -A INPUT -p tcp --dport 5432 -j ACCEPT # postgres.bin  
iptables -A INPUT -p tcp --dport 55371 -j ACCEPT # rpc.statd

Deux choses importantes à noter:

1) Ces règles ne font rien pour vous jusqu'à ce que vous mettiez une ligne DROP ou REJECT à la fin ou que vous en fassiez la politique par défaut pour les paquets sans correspondance. Ces règles autorisent les paquets, ce qui est théorique, si la stratégie par défaut autorise tout ce qui ne correspond pas.

2) Ces règles sont ambivalentes sur l' IP source . D'après votre message d'origine, il semble que vous souhaitiez autoriser tous vos clients à utiliser le serveur, puis examinez les journaux pour obtenir les adresses IP source pour aller avec les ports de destination. Je ne connais pas d'outil pour le faire, donc ce script empêchera seulement les gens de faire de nouveaux services sur votre serveur qui écoutent sur d'autres ports ... ce qui est quelque chose .