Outils pour utilisateurs

Outils du site


reseaux_iptables

Iptables et ferm

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

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é:

  1. rwx—— 1 root root 1593 2006-10-03 13:12 iptables.new-rules1
  1. rwx—— 1 root root 3296 2006-10-03 13:12 iptables-rescue2
  2. rw——- 1 root root 984 2006-10-03 13:12 iptables.rules3
  3. rw——- 1 root root 1020 2006-10-03 13:12 iptables.rules-old4
  1. les nouvelles regles (ou les plus recentes) en bash
  2. le fameux fichier de secours
  3. les regles sauvegardés
  4. les anciennes regles sauvegardés avant sauvegarde

J'effectue les modifications dans iptables.new-rules, donc la structure est globalement:

  1. fermer tous les accès (DROP)
  2. vider toutes les tables
  3. 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 !

reseaux_iptables.txt · Dernière modification : 2010/07/17 11:16 de thierry