Table des matières
Iptables et ferm
Liens:
Bases
ne pas oublier de charger , au préalable, le module ip_tables.
commande
On va creer un fichier en composant des regles relativement lisible.
En passant ce fichier a la moulinette de “ferm”, il va y avoir creation des commandes iptables.
Exemple:
# ferm vite_1.conf
Et hop, le firewall est en service !
On peut ajouter “-n” pour ne pas appliquer les regles immediatement!
Et aussi “-l” pour voir ce qui est fait:
# ferm -n -l vite_1.conf # Generated by ferm 2.0.3 on Sat Jul 17 13:10:48 2003 *filter :FORWARD ACCEPT [0:0] :INPUT DROP [0:0] :OUTPUT ACCEPT [0:0] -A INPUT --match state --state RELATED,ESTABLISHED --jump ACCEPT -A INPUT --protocol tcp --dport http --jump ACCEPT -A INPUT --protocol tcp --dport ftp --jump ACCEPT -A INPUT --protocol tcp --dport ssh --jump ACCEPT COMMIT
Et encore, en règles “iptables” plus classique, en ajoutant –slow :
# ferm -n -l --slow vite_1.conf /sbin/iptables -t filter -P FORWARD ACCEPT /sbin/iptables -t filter -P INPUT ACCEPT /sbin/iptables -t filter -P OUTPUT ACCEPT /sbin/iptables -t filter -F /sbin/iptables -t filter -X /sbin/iptables -t filter -P INPUT DROP /sbin/iptables -t filter -A INPUT --match state --state RELATED,ESTABLISHED --jump ACCEPT /sbin/iptables -t filter -A INPUT --protocol tcp --dport http --jump ACCEPT /sbin/iptables -t filter -A INPUT --protocol tcp --dport ftp --jump ACCEPT /sbin/iptables -t filter -A INPUT --protocol tcp --dport ssh --jump ACCEPT
Et enfin, l'option -i afin d'être sur de ne pas faire de betise !
# ferm -i vite_1.conf ferm has applied the new firewall rules. Please type 'yes' to confirm:
Si on ne tape “yes” dans les 30 secondes, ferm remet en place les règles précédentes.
simples
vite_1.conf
chain INPUT {
policy DROP;
mod state state (RELATED ESTABLISHED) ACCEPT;
proto tcp dport (http ftp ssh) ACCEPT;
}
vite_1b.conf
Ajouter simplement:
chain INPUT if lo ACCEPT;
Cela permet d'ouvrir *tout* les services locaux… et par exemple faire:
firefox http://localhost:49152 &
vite_2.conf
# interface a autoriser
@def $LAN_IF = eth0;
# Politique par defaut: tout fermer
chain ( INPUT OUTPUT FORWARD ) policy DROP;
# autoriser l'interface 'lo'
chain INPUT if lo ACCEPT;
chain OUTPUT of lo ACCEPT;
# autoriser quelques entrées
chain INPUT if $LAN_IF {
mod state state NEW {
proto tcp dport ( http ftp ssh ) ACCEPT;
proto udp dport ( openvpn domain ) ACCEPT;
proto icmp icmp-type echo-request ACCEPT;
}
mod state state ( ESTABLISHED RELATED ) ACCEPT;
}
# autoriser toutes les sorties
chain OUTPUT of $LAN_IF mod state state ( NEW ESTABLISHED RELATED ) ACCEPT;
La partie “mod state state ( NEW ESTABLISHED RELATED )“ va demander a iptables de faire un suivit (tracking) de toutes les connexions : cela peut poser des problèmes si certains modules ne sont pas chargés.
modules
Lien: http://www.docunext.com/wiki/Ferm
Si vous avez un message comme ça (au boot par exemple):
iptables-save v1.4.2: Unable to open /proc/net/ip_tables_names: No such file or directory
C'est parce que le module “ip_tables” n'est pas chargé:
# modprobe ip_tables
Et pour le prochain boot, ajouter dans /etc/modules :
ip_tables
iptables
Liens:
http://taltan.free.fr/index/2006/06/08/21-netfilter-scripts-de-configuration-iptables
http://www.nbs-system.com/article/iptables_howto
http://christian.caleca.free.fr/netfilter/iptables.htm
http://www.linux-france.org/prj/inetdoc/guides/iptables-tutorial/
http://www.lea-linux.org/cached/index/Reseau-secu-murdefeu.html
iptables Howto
http://www.queret.net/wiki/index.php/Linux/How-to/CreerPaquetDebian
http://www.netfilter.org/documentation/FAQ/fr/netfilter-faq-3.html
Et pour un firewall sous debian:
NetFilter / Iptables
Netfilter est l’implémentation noyau du firewall sous Linux.
Iptables est la commande permettant de paramétrer le filtre Netfilter du noyau et donc de configurer son firewall.
iptables - Activer le FORWARD :
# cat /proc/sys/net/ipv4/ip_forward 0 # echo 1 >/proc/sys/net/ipv4/ip_forward # cat /proc/sys/net/ipv4/ip_forward 1
Voir aussi: /etc/sysctl.conf
iptables - Sauver / restaurer / Observer
Extraire l'etat d' iptables pour une eventuelle restauration:
# iptables-save >le_fichier_de_sauvegarde.rules
Restorer:
# iptables-restore <le_fichier_de_sauvegarde.rules
Observer ce qui vient d'une IP (par exemple):
# tcpdump src net adresse_ip
Ou ce qui va vers une IP:
# tcpdump dst net adresse_ip
Ou ce qui va et vient:
# tcpdump net adresse_ip
Voir ce qui va et vient sur le port 80
# tcpdump -Ai eth0 host **mon_ip** and port 80 and tcp
Si on ne precise pas “mon_ip” , on peut y voir plein de chose sans interet a destination d'autres machines.
C'est a dire, pour voir ce qui arrive sur le port 80, mais pas destiné a mon_ip :
# tcpdump -Ai eth0 host ! **mon_ip** and port 80 and tcp
Voir le contenu des paquets:
# tcpdump -X -i eth0 net <ip>
sniffer
Utiliser dsniff et urlsnarf:
# apt-get install dsniff
iptables - le minimum pour commencer
Il faut d'abord monter les modules et activer le forward
#!/bin/sh
# les pilotes utiles modprobe ip_conntrack_ftp modprobe ip_nat_ftp
# activer le routage... echo 1 > /proc/sys/net/ipv4/ip_forward
Astuces !
Les pilotes peuvent aussi etre chargé au boot, si on les met dans:
Editer /etc/modules
... # tj pour iptables ip_conntrack_ftp ip_nat_ftp
On peut activer le routage au moment du boot comme cela aussi:
Editer /etc/sysctl.conf
# tj pour iptables # autoriser forward # equivalent de echo 1 > /proc/sys/net/ipv4/ip_forward net.ipv4.ip_forward=1
Et comme j'ai eu des problemes (non resolu) avec le cache arp: Neighbour table overflow., j'ajoute:
# augmenter cache arp: net.ipv4.neigh.default.gc_thresh3=4096 net.ipv4.neigh.default.gc_thresh2=2048 net.ipv4.neigh.default.gc_thresh1=1024
iptables - Scripte pour un RAZ complet du FireWall
Cela entraine l'“arrêt” du FireWall: il revient a son état (presque) initial.
#!/bin/sh IPTABLES=/sbin/iptables
# On vide toutes les regles **en fermant tout** : $IPTABLES -F $IPTABLES -X
# ----------- # Ferme totalement l'acces aux reseaux # ----------- $IPTABLES -P INPUT DROP $IPTABLES -P OUTPUT DROP $IPTABLES -P FORWARD DROP # ----------
$IPTABLES -t nat -F $IPTABLES -t nat -X $IPTABLES -t nat -P PREROUTING ACCEPT $IPTABLES -t nat -P POSTROUTING ACCEPT $IPTABLES -t nat -P OUTPUT ACCEPT
$IPTABLES -t mangle -F $IPTABLES -t mangle -X $IPTABLES -t mangle -P PREROUTING ACCEPT $IPTABLES -t mangle -P INPUT ACCEPT $IPTABLES -t mangle -P OUTPUT ACCEPT $IPTABLES -t mangle -P FORWARD ACCEPT $IPTABLES -t mangle -P POSTROUTING ACCEPT
En l'etat, le reseau est totalement sourd et muet ! Il faut donc vite ouvrir les ports et autoriser les accès. Par exemple, on peut tout ouvrir comme ça:
# On accepte toutes les requetes, dans tout les sens $IPTABLES -P INPUT ACCEPT $IPTABLES -P OUTPUT ACCEPT $IPTABLES -P FORWARD ACCEPT
Mais ce n'est pas ce qu'on fera dans les exemples ci-aprés, sinon le Firewall ne sert a rien ! (sauf a Nater)
Si on veut faire complement tomber le reseau, il faut decharger les modules et en voici une methode:
echo "On décharge les modules." rmmod `lsmod | grep -E "^ip" | cut -d" " -f 1`
iptables - Scripte pour un simple FireWall
Dans le contexte d'un poste n'ayant aucun réseau a nater et pourvu d'une seule carte réseau.
On suppose qu'on a monté les pilotes, activé le forward et fait une remise a zéro en début de script. (voir ci-dessus)
#!/bin/sh
# --------- Un FireWall simple: # Autoriser tous en direction d'Internet # Refuser tout a l'initiative d'Internet
IPTABLES=/sbin/iptables WAN_IF="eth0"
# ... monter modules , activer forward et RAZ des tables ...
# On rejete tout $IPTABLES -P INPUT DROP $IPTABLES -P OUTPUT DROP $IPTABLES -P FORWARD DROP
# --------------------- # LOCAL # --------------------- # Autoriser le trafic interne (Interface: **lo**) $IPTABLES -A INPUT -i lo -j ACCEPT $IPTABLES -A OUTPUT -o lo -j ACCEPT $IPTABLES -A FORWARD -i lo -j ACCEPT $IPTABLES -A FORWARD -o lo -j ACCEPT
# --------------------- # WAN # --------------------- # Autoriser toutes connexions sortantes $IPTABLES -A INPUT -i $WAN_IF -m state --state ESTABLISHED,RELATED -j ACCEPT $IPTABLES -A OUTPUT -o $WAN_IF -m state --state NEW,ESTABLISHED,RELATED -j ACCEPT
Explications (en gros):
-AAjouter a la fin INPUTtable des paquets entrant OUTPUTtable des paquets sortant -i $WAN_IFce qui entre par l'interface -o $WAN_IFce qui sort par l'interface -m statepreparer les options d'etat –stateles etats attendus ESTABLISHEDpaquet de communication etablie/en cours RELATEDpaquet en relation/en rapport avec la communication en cours NEWpaquet de nouvelle communication (mise en relation,ouverture,connexion) -j ACCEPTon accepte ces paquets, parce que la cible est ACCEPT
En français:
La règle $IPTABLES -A INPUT s'applique au traffic entrant (tous les paquets IP entrant seront soumis à cette règle). … Puis on a mis -m state –state ESTABLISHED,RELATED pour préciser que cette règle ne s'applique qu'aux paquets IP qui proviennent soit d'une liaison “établie” (ESTABLISHED), soit d'une liaison en relation (RELATED) avec une liaison déjà établie. Enfin on précise -j ACCEPT pour dire qu'on accepte tous les paquets qui vérifient toutes ces conditions : les paquets venant de n'importe où et déja établie. –state NEW précise en plus que les paquets ont le droit d'initier une nouvelle connexion.
A partir d'ici, toutes connexions peut être initié vers Internet (WAN), et les communications fonctionnent. Mais d'Internet, on ne peut pas etablir de connexion puisqu'il n'y aucune règle NEW qui l'autorise.
Autoriser la connexion à sshd :
# Autoriser a se connecter a sshd depuis l'exterieur $IPTABLES -A INPUT -i $WAN_IF -p tcp --dport ssh -m state --state NEW,ESTABLISHED,RELATED -j ACCEPT $IPTABLES -A OUTPUT -o $WAN_IF -p tcp --sport ssh -m state --state ESTABLISHED,RELATED -j ACCEPT
-p tcp précise le protocole … –dport ssh precise le port de destination (du paquet qui vient du NET) –sport ssh precise le port source (du paquet qui va vers le NET)
Mais il n'est pas necessaire d'etre aussi bavard, car on a dejà autorisé certaines choses en amont. Donc on va simplifier pour le même resultat:
# Autoriser a se connecter a sshd depuis l'exterieur $IPTABLES -A INPUT -i $WAN_IF -p tcp --dport ssh -m state --state NEW -j ACCEPT
Et ca suffit.
Autoriser SSH, mais pas trop
Une machine exposé sur Internet attire des vilains pirates… Voici comment les décourager d'essayer d'acceder a votre serveur par un port ssh (ou tout autre port ouvert).
Le but, est d'empecher plus de 4 connexions par minutes sur le port SSH… sauf pour les IP de confiance bien sur:
# -------------------------- # PRE-LIMIT # -------------------------- $IPTABLES -N PRE_LIMIT $IPTABLES -N PRE_LIMIT_DROP # Limiter aux ports SSH $IPTABLES -A INPUT -p tcp --dport 22 -j PRE_LIMIT # ------------------------------------------------------------------------------- # ---- PRE_LIMIT # a ne pas appliquer en local $IPTABLES -A PRE_LIMIT -i $LAN_IF -s 192.168.0.0/24 -j RETURN $IPTABLES -A PRE_LIMIT -i $LAN_IF -s 192.168.1.0/24 -j RETURN # ou au IP de "confiance" $IPTABLES -A PRE_LIMIT -i $WAN_IF -s 222.222.222.0/24 -j RETURN # sinon, pour les autres $IPTABLES -A PRE_LIMIT -m state --state NEW -m recent --name "pre_limit" --set $IPTABLES -A PRE_LIMIT -m state --state NEW -m recent --name "pre_limit" --update --seconds 120 --hit # ---- PRE_LIMIT_DROP $IPTABLES -A PRE_LIMIT_DROP -m limit --limit 3/s -j LOG --log-prefix='FW=pre_limit_drop ' --log-level $IPTABLES -A PRE_LIMIT_DROP -j DROP # -------------------------------------------------------------------------------
Attention: *toutes* les interfaces sont filtrées, y compris lo. Donc, mettre les règles ci-dessus aprés le classique:
$IPTABLES -A INPUT -i lo -j ACCEPT $IPTABLES -A OUTPUT -o lo -j ACCEPT
Sinon, vous serez privé de ssh 0 par exemple… 
Le module recent se base sur l'IP source ( et pas le module limit ).
Autoriser le **ping**, mais 1 ping par seconde maximum !
Le ping icmp (le plus connu):
# Autoriser le ping depuis le WAN # Pas plus de 1 ping par seconde... $IPTABLES -A INPUT -i $WAN_IF -p icmp -m state --state NEW -m limit --limit 1/s -j ACCEPT
1/s pourrait etre remplacé par 10/min pour 10 ping par minute max.
Accepter les pings en UDP ou TCP ("ping echo")
(Toujours avec la limitation de 1/s) C'est le port echo qui est utilisé
# PING UDP/ ECHO # Activer reponse (legere) au ping # Pas plus de 1 ping par seconde... $IPTABLES -A INPUT -i $WAN_IF -p udp --dport echo -m state --state NEW -m limit --limit 1/s -j ACCEPT
# PING TCP/ ECHO # Activer reponse (legere) au ping # Pas plus de 1 ping par seconde... $IPTABLES -A INPUT -i $WAN_IF -p tcp --dport echo -m state --state NEW -m limit --limit 1/s -j ACCEPT
Si on a d'autres serveurs:
un serveur web
# ******* WWW *************** $IPTABLES -A INPUT -i $WAN_IF -p tcp --dport www -m state --state NEW -j ACCEPT # HTTPS #$IPTABLES -A INPUT -i $WAN_IF -p tcp --dport https -m state --state NEW -j ACCEPT # ***************************
Un serveur FTP
# ******* FTP *************** # Autoriser le serveur ftp $IPTABLES -A INPUT -i $WAN_IF -p tcp --dport ftp -m state --state NEW -j ACCEPT
Et il ne faut surtout pas oublier de charger les modules concernant le ftp (sinon, les transferts foirent)
# FTP: pour passive off (qui est l'etat par defaut) #$IPTABLES -A INPUT -i $WAN_IF -p tcp --dport ftp-data -m state --state NEW,ESTABLISHED,RELATED -j ACCEPT #$IPTABLES -A OUTPUT -o $WAN_IF -p tcp --sport ftp-data -m state --state ESTABLISHED,RELATED -j ACCEPT # ***************************
iptables - mode parano
C'est le cas où l'on configure le firewall pour tout fermer…
Fermer les sorties vers le NET
Simple, il suffit de ne pas faire:
$IPTABLES -A INPUT -i $WAN_IF -m state --state ESTABLISHED,RELATED -j ACCEPT $IPTABLES -A OUTPUT -o $WAN_IF -m state --state NEW,ESTABLISHED,RELATED -j ACCEPT
Mais de faire (si nécessaire) :
$IPTABLES -A INPUT -i $WAN_IF -j DROP $IPTABLES -A OUTPUT -o $WAN_IF -j DROP
On peut peut-être glisser une règle comme cela:
$IPTABLES -A INPUT -i $WAN_IF -m state --state ESTABLISHED,RELATED -j ACCEPT
On autorise les requetes DNS:
# autoriser l'acces au domain $IPTABLES -A OUTPUT -o $WAN_IF -p udp --dport domain -m state --state NEW -j ACCEPT
On autorise le www et https:
# Autoriser le surf www $IPTABLES -A OUTPUT -o $WAN_IF -p tcp --dport www -m state --state NEW -j ACCEPT
# Autoriser le surf https $IPTABLES -A OUTPUT -o $WAN_IF -p tcp --dport https -m state --state NEW -j ACCEPT
Grosso merdo, on ne peut que surfer sur Internet… sans mule, sans msn, sans FTP, etc…
FTP client
modprobe ip_conntrack_ftp
# ------------ # FTP CLIENT # ------------
# Autoriser le ftp en client $IPTABLES -A OUTPUT -o $WAN_IF -p tcp --dport ftp -m state --state NEW -j ACCEPT
# FTP: pour passive off (qui est l'etat par defaut) $IPTABLES -A OUTPUT -o $WAN_IF -p tcp --dport ftp-data -m state --state NEW -j ACCEPT
FTP Naté
Pour que le reseau local est accès au FTP externe:
modprobe ip_nat_ftp
iptables-modules
Les modules présents:
$ lsmod | grep "^ip" iptable_nat 6980 0 ip_nat 16748 1 iptable_nat ip_conntrack 48320 3 xt_state,iptable_nat,ip_nat iptable_filter 3072 1 ip_tables 12932 2 iptable_nat,iptable_filter ipv6 222304 12
NAT
Partager une connexion Internet
Pour qu'une connexion a Internet soit partagé par tout un réseau local, il suffit de faire:
#!/bin/sh
WAN_IF="eth0" WAN_IP="212.27.256.256" # <=== c'est volontairement erroné ;-) LAN_IF="eth1" LAN_IP="172.16.1.1"
# ... vider toutes les tables etc... # ... etc ... etc...
# ------------------- # LAN # ------------------- # Autoriser le trafic local $IPTABLES -A INPUT -i $LAN_IF -j ACCEPT $IPTABLES -A OUTPUT -o $LAN_IF -j ACCEPT
$IPTABLES -A FORWARD -i $LAN_IF -j ACCEPT $IPTABLES -A FORWARD -o $LAN_IF -j ACCEPT
# rend le WAN accessible au LAN # suffit de definir la gw vers ici # restriction: NAT uniquement les adresse 172.16.1.* $IPTABLES -t nat -A POSTROUTING -s 172.16.1.0/24 -o $WAN_IF -j SNAT --to $WAN_IP
# activons le forward pour l'acces du NET par le LAN $IPTABLES -A FORWARD -i $LAN_IF -o $WAN_IF -s 172.16.1.0/24 -m state --state NEW,ESTABLISHED,RELATED -j ACCEPT $IPTABLES -A FORWARD -i $WAN_IF -o $LAN_IF -d 172.16.1.0/24 -m state --state ESTABLISHED,RELATED -j ACCEPT
# Maintenant, le LAN (en 172.16.1.*) a acces au NET
Le SNAT va permettre de substituer l'adresse “locale” par l'adresse du firewall, et uniquement au moment de partir sur le réseau. D'autres ecoles parle de la cible MASQUERADE, mais en y regardant bien, c'est adapté pour les connexions a Internet qui n'ont pas d'IP fixe ! Ce qui n'est pas mon cas.
Si c'etait une connexion susceptible de tomber et de remonter avec une nouvelle adresse public, il aurait été préférable de faire:
$IPTABLES -t nat -A POSTROUTING -s 172.16.1.0/24 -o $WAN_IF -j MASQUERADE
Ce qui fera la même chose, avec quelques subtilités que je ne detaillerais pas (pas fini de comprendre).
Nater le réseau local
On suppose que les postes effectuent un routage vers la passerelle qui est le firewall lui-même.
Vers SSH:
# SSH poste bureau $IPTABLES -A PREROUTING -t nat -i $WAN_IF -p tcp --dport 3922 -j DNAT --to 172.16.0.99:22 $IPTABLES -A FORWARD -i $WAN_IF -p tcp -d 172.16.0.99 --dport 22 -j ACCEPT
Vers VNC:
# VNC poste bureau $IPTABLES -A PREROUTING -t nat -i $WAN_IF -p tcp --dport 5901 -j DNAT --to 172.16.0.99 $IPTABLES -A FORWARD -i $WAN_IF -p tcp -d 172.16.0.99 --dport 5901 -j ACCEPT
Restriction a 1 IP ou plusieurs
# VNC sur 1 poste $IPTABLES -A PREROUTING -t nat -i $WAN_IF -p tcp -s 82.129.211.254 --dport 5900 -j DNAT --to 172.16.0.99 $IPTABLES -A FORWARD -i $WAN_IF -p tcp -d 172.16.0.99 --dport 5900 -j ACCEPT
# Et pour une classe $IPTABLES -A PREROUTING -t nat -i $WAN_IF -p tcp -s 82.129.211.0/24 --dport 5900 -j DNAT --to 172.16.0.99 $IPTABLES -A FORWARD -i $WAN_IF -p tcp -d 172.16.0.99 --dport 5900 -j ACCEPT
Nater sans routage
On va nater vers un bécanne qui est sur le LAN, mais dont la passerelle n'est pas le firewall…
Pour forcer le client a communiquer en direction du firewall, il suffit de modifier l'adresse de la source: au lieu que la source soit “quelque part sur le net”, on va dire que la source c'est le firewall lui-même. Ensuite, le firewall remettra l'adresse source original et le paquet continuera sa route.
Exemple avec VNC:
# VNC poste bureau $IPTABLES -A PREROUTING -t nat -i $WAN_IF -p tcp --dport 5900 -j DNAT --to 172.16.0.199 $IPTABLES -A FORWARD -i $WAN_IF -p tcp -d 172.16.0.199 --dport 5900 -j ACCEPT $IPTABLES -A POSTROUTING -t nat -o $LAN_IF -p tcp -d 172.16.0.199 --dport 5900 -j SNAT --to $LAN_IP
Le defaut de cette technique: l'adresse source d'origine est inconnu et l'on peut avoir la fausse impression que la communication est limité au réseau local. C'est un trou dans la sécurité du réseau, si le destinataire du NAT ne fait pas de controle par mot de passe, mais uniquement par l'adresse source. On peut reduire ses risques en effectuant le controle au niveau du firewall, mais ce n'est pas toujours possible. Exemple:
$IPTABLES -A PREROUTING -t nat -i $WAN_IF -p tcp -s 82.129.211.254 --dport 5900 -j DNAT --to 172.16.0.199 ... et la suite comme ci-dessus
Nat et bridge : NOTRACK
Si vous avez une configuration qui mélange Bridge et Firewall, vous aurez peut être des problèmes: Pour désactiver le suivit des connexions sur un bridge:
$IPTABLES -A PREROUTING -t raw -i br0 -j NOTRACK
Ainsi, le suivit (tracking) des connexions est désactivés pour le Bridge.
iptables en prod
Les principaux problèmes sont faire charger les regles IpTables au demarrage, et s'assurer qu'une erreur dans la configuration nous permettent quand même de reprendre le controle…
Les regles chargés au demarrage
On a besoin de 2 scriptes, dont les originaux viennent de là:
[[http://www.queret.net/wiki/index.php/Linux/How-to/CreerPaquetDebian|Creer un paquet Debian]]
Scripts: …?
Le script iptables impose les besoins suivant:
Un répertoire /etc/network/iptables.d
# mkdir /etc/network/iptables.d
Dans ce répertoire:
iptables.rulesdump/sauvegarde des regles iptables. iptables-rescuescript qui essaye de remettre en place un accès a la machine
Les commandes avec /etc/init.d/iptables :
startcharge les regles précédement sauvé stoparrete le firewall, notamment en effacant toutes les tables panicbloque totalement les accès reseaux a la machine ! c'est rigolo rescueexecuter le script iptables-rescue vu ci-dessus checktest la presence du fichier ssh_ping.txt sinon execute rescue
Dans /etc/network/iptables.d, j'ai donc (et aussi) ajouté:
- rwx—— 1 root root 1593 2006-10-03 13:12 iptables.new-rules1
- rwx—— 1 root root 3296 2006-10-03 13:12 iptables-rescue2
- rw——- 1 root root 984 2006-10-03 13:12 iptables.rules3
- rw——- 1 root root 1020 2006-10-03 13:12 iptables.rules-old4
- les nouvelles regles (ou les plus recentes) en bash
- le fameux fichier de secours
- les regles sauvegardés
- les anciennes regles sauvegardés avant sauvegarde
J'effectue les modifications dans iptables.new-rules, donc la structure est globalement:
- fermer tous les accès (DROP)
- vider toutes les tables
- ajouter les regles
Si aprés ça, je perd le controle de la machine, et si le cron adéquat existe, l'execution d'un
/etc/init.d/iptables check
devrait me sauver, dans les 2 heures qui suivent… (c'est long non ?)
Lorsqu'on a finit d'ecrire ces règles dans iptables.new-rules, faire:
# ./iptables.new-rules
ca marche encore ? continuons
# /etc/init.d/iptables save
On a ecrit l'etat des regles dans iptables.rules
Et enfin, pour que le script soit executé au demarrage (et a l'arret) du systeme:
# update-rc.d iptables defaults Adding system startup for /etc/init.d/iptables ... /etc/rc0.d/K20iptables -> ../init.d/iptables /etc/rc1.d/K20iptables -> ../init.d/iptables /etc/rc6.d/K20iptables -> ../init.d/iptables /etc/rc2.d/S20iptables -> ../init.d/iptables /etc/rc3.d/S20iptables -> ../init.d/iptables /etc/rc4.d/S20iptables -> ../init.d/iptables /etc/rc5.d/S20iptables -> ../init.d/iptables
On peut rebooter.
Tester la communiquation
On considère qu'on a le controle sur une machine, a partir du moment où elle est accessible par SSH. Donc, on va simplement definir un pool de machines (par exemple, 2 machines sur 2 sites differents) de regulierement générer un fichier. La cible (celle qui use d'IpTables) va simplement s'assurer qu'un fichier existe: s'il n'existe plus, alors la machine est devenu inaccessible de l'extérieur et il faut charger les regles connu qui fonctionne.
Creer un repertoire:
# mkdir -p /var/run/network/iptables/ping # cd /var/run/network/iptables # chown :adm ping # chmod g+w ping
On s'attend a ce qu'un fichier ssh_ping.txt soit creer.
Le script des clients qui cron toutes les 10 minutes:
#!/bin/sh ssh user@machine_A "echo `date +H-S`\"|\"$HOSTNAME >>/var/run/network/iptables/ping/ssh_ping.txt" ssh user@machine_B "echo `date +H-S`\"|\"$HOSTNAME >>/var/run/network/iptables/ping/ssh_ping.txt"
etc...
Faire en sorte que le user est accès à la machine sans mot de passe et avec les droits d'ecritures dans le repertoire si dessus. (group: adm)
Sur le serveur, il y a un cron toutes les heures. Il suffit d'executer en root:
/etc/init.d/iptables check >/dev/null 2>&1
Le scripte teste simplement l'existence du fichier ssh_ping.txt et l'efface. S'il n'existe pas, la commande …
/etc/init.d/iptables rescue
… est executé, le FireWall est replacer dans un etat ouvert en ssh. (un mail est envoyé automatiquement a root)
Rappel: mail pour root
# vi /etc/aliases root: mon_mail@fai.fr :wq
Puis configurer exim pour qu'il redirige les mails:
# dpkg-reconfigure exim4-config
...
**Envoi via relais ("smarthost") - pas de courrier local**
**Nom de courriel du système: machine.mon_domain.fr**
**Relais de courriel ("smarthost") pour ce hôte: l'IP du SMTP**
Et puis tester l'envoi d'un mail
$ echo "hello ducon" | mail -s "test ducon" -c mail_en_cc@free.fr root@localhost
J'ai recu le mail.
Iptables pour les winners
Augmenter les capacites de conntrack
Lorsque ip_conntrack n'a plus suffisament de ressource pour gerer les connexions… Par defaut ip_conntrack gere 4096 connexion. Pour augmenter a 8192 par exemple:
# echo "8192" > /proc/sys/net/ipv4/ip_conntrack_max
Ceci dit, mon fw dit ça:
$ cat /proc/sys/net/ipv4/ip_conntrack_max 65536
Donc j'ai de la marge…
Statistique
# iptables -L -v -n
Et voila des stats.
ports dynamiques
Lien: http://www.ncftp.com/ncftpd/doc/misc/ephemeral_ports.html
Pour connaitre les ports utilisés dynamiquement par Linux, il faut faire ca:
cat /proc/sys/net/ipv4/ip_local_port_range 32768 61000
Dans un scripte “iptables”, j'ai fait ça pour obtenir un parametre ”–dport” ou “–sport” compatible:
LOCALPR=$( cat /proc/sys/net/ipv4/ip_local_port_range | awk '{ print $1":"$2 }' )
Ce qui donne: LOCALPR=32768:61000
Y a surement plus simple !