My1' Blog

Iptables est un firewall très fiable remplaçant ipchains (avec le noyau 2.2) tournant sous Linux. Iptables permet de faire du firewalling stateful (à états), de la translation de port et d’adresse, du filtrage au niveau 3 et 4 du modèle OSI.

Iptables est l’interface d’administration et de configuration de Netfilter qui est le module intégré à Linux.

Iptables est donc intégré à Linux et sans doute il est déjà installé sur votre machine (noyau >= 2.4). Pour voir quelle version du noyau vous avez, faites un ‘uname -a’.

Avant tout,rappelons qu’un firewall est un dispositif de sécurité réseau qui se place en général au niveau des couches 3 et 4 du modèle OSI et il ne voit que ces couches, rien au dessus. Il est donc capable de savoir quel type de données il filtre (pages web, mails, streaming) en se basant sur les informations contenues dans les en-têtes de paquets IP.
Un firewall ne filtre donc pas les contenus réels des messages échangés, il ne fait donc pas la différence entre un mail contenant un virus et un mail normal, c’est le rôle d’un antivirus…

Tout d’abord, voici un peu de vocabulaire :

- Une règle est la brique de base permettant de fabriquer son firewall, en gros ce elle qui contient les descriptions et les actions… Le paquet est identifié (description) et il est analysé (actions) pour savoir si il peut continuer ou pas. Vous me suivez ?

- Une chaîne est une série de règles.
exemple de chaîne : INPUT : elle contient toutes les règles en entrée (up), c’est à dire tout ce qu’on m’envoie.

- Une table est un ensemble de chaînes
Il y a 3 tables principales :
-filter (contient les chaînes et règles de filtrage)
-nat (chaînes et règles NAT*)
-mangle (modifications arbitraires sur les paquets de tous les types)

*NAT : paquets qui veulent traverser une machine sans s’y arrêter (la machine filtrante n’est ni source ni destination)
Chaque règle que l’on créera contiendra une action :

Chaque règle contiendra une action :
- ACCEPT : le paquet filtré sera accepté
- REJECT : le paquet filtré sera rejeté, c’est à dire que la machine émettrice recevra de nous un paquet signifiant “port fermé”
- DROP : le paquet sera filtré “silencieusement”, la machine émettrice ne sait pas qu’il a été filtré par nous.

Voici les options principales de notre commande iptables :

-A chaîne : pour ajouter une règle en fin de chaîne
-I chaîne : pour insérer une règle en début de chaîne
-D n°chaîne : pour supprimer une chaîne n°
-P chaîne action : permet de donner la politique par défaut
-p : définit le protocole (tcp, udp, icmp…)
-dport : définit le port de destination (service que l’on émet)
-sport : définit le port source (service que l’on reçoit)
-s : @IP source
-d : @IP destination
-i : interface réseau empruntée par le paquet pour entrer sur la machine (seulement pour la chaîne INPUT)
-o : interface réseau de sortie (seulement pour la chaîne OUTPUT)
-m : utiliser le module spécial
-f : vider les règles
-x : vider les chaînes
-L : visualiser vos chaînes

Voici mon script iptables que je rend disponible librement ici, bien sûr, j’attends vos remarques et questions…

Plus de documentation sur ce site.

Voici un tutoriel tout frais qui va vous permettre comme moi d’avoir son propre serveur VPN (Virtual Private Network).

Un serveur VPN, c’est quoi ? Pennons mon exemple : J’ai un serveur à la maison et j’ai un pc portable avec lequel je bouge beaucoup. J’avais envie d’un système me permettant d’être dans mon réseau local partout où j’irais dans le monde. C’est le but du VPN, il va agir comme un tunnel chiffré entre le client et le serveur via des certificats.

J’ai donc choisis une solution libre : OpenVPN accouplé à OpenSSL pour le chiffrement.
Pour cela, une bête de course n’est pas nécessaire, juste de quoi installer une Debian. Pour ma part j’ai une vieille tour trouvée dans ma cave avec un céléron, 32 Mo de mémoire vive et un vieux chipset graphique. De toute façon, pas question d’installer un environnement graphique : les paquetages minimum sont suffisants.

Voici mon architecture réseau :

Mon routeur : 192.168.0.254

Mon serveur VPN derrière le routeur : 192.168.0.111

L’interface TUN sur le serveur VPN qui va faire le lien : 10.8.0.1

L’interface TUN sur le client : 10.8.0.6

Le client étant connecté sur Internet via une autre connexion que la mienne.

Une fois votre serveur installé et mis à jour, installer ces paquets :

# aptitude install openvpn

# aptitude install liblzo

# aptitude install openssl

Vous êtres prêt pour la suite.
Notre VPN sera sécurisé à l’aide de certificats 1024 bits chiffrés RSA.

Sur le serveur :

cd /usr/share/doc/openvpn/examples/easy-rsa/
Edittez le fichier “vars” et à la fin remplissez les champs du certificat, comme par exemple :

- export KEY_COUNTRY=FR
- export KEY_PROVINCE=France
- export KEY_CITY=Paris
- export KEY_ORG=”MonOrganisation”
- export KEY_EMAIL=”contact@MonOrganisation.fr”

Initialisez les clés :

# . ./vars
# ./clean-all

Nous allons créer le certificat principal :

# ./build-ca
Tous les champs sont dejà rentrés sauf “Common Name” où il faut renseigner (par exemple “principal”)

Ensuite nous allons créer le certificat propre au serveur :

# ./build-key-server serveur
Tous les champs sont dejà rentrés sauf “Common Name” où il faut renseigner (par exemple “serveur”)

Création du certificat pour le client :

# cd /usr/share/doc/openvpn/examples/easy-rsa/
# . ./vars
# ./build-key client
# ./build-key client

Création du paramètre Diffie Hellman :

# ./build-dh

Copie des clés dans le répertoire de configuration d’OpenVPN :
# cp ./keys/ca.crt /etc/openvpn/
# cp ./keys/ca.key /etc/openvpn/
# cp ./keys/serveur.crt /etc/openvpn/
# cp ./keys/serveur.key /etc/openvpn/
# cp ./keys/dh1024.pem /etc/openvpn/

Création du fichier de configuration d’OpenVPN :

# vim /etc/openvpn/openvn.conf

#Port en écoute utilisé pour la connexion VPN

port XXX

#Protocole utilisé (Le protocole udp est plus sécurisé que le tcp)

proto tcp

#Type d’interface réseau virtuelle créée

dev tun

#Nom des fichiers servant à l’authentification des clients via OpenSSL

ca /etc/openvpn/ca.crt
cert /etc/openvpn/serveur.crt
key /etc/openvpn/serveur.key
dh /etc/openvpn/dh1024.pem

#Adresse du réseau virtuel (Le serveur aura l’adresse 192.168.0.1)

server 10.8.0.0 255.255.255.0

#Cette ligne ajoute sur le client la route du réseau du serveur

push “route 192.168.0.0 255.255.255.0″

#Ces lignes indiquent aux clients l’adresse des serveur DNS et WINS

push “dhcp-option DNS 192.168.0.254″
push “dhcp-option WINS 192.168.0.254″

# Cette ligne permet aux clients de voire les autres clients

client-to-client
keepalive 10 120

#Cette ligne active la compression

comp-lzo

#Ces lignes permettent de rendre persistante la connexion

persist-key
persist-tun

#Cette ligne permet d’indiquer le niveau de log souhaité (de 1 à 9)

verb 3

Voila pour la configuration serveur.

Si comme moi vous avez un routeur, pensez à ouvrir le port que vous aurez choisit sur le routeur !

Sur le serveur, il nous reste encore à activer le module tun du noyau :

# modprobe tun

Puis à configurer le réseau :

echo 1 > /proc/sys/net/ipv4/ip_forward
iptables -t -nat -A POSTROUTING -o eth0 -s 192.168.0.254 -j MASQUERADE
iptables -t nat -A FORWARD -in-interface tun0 -j ACCEPT
iptables --table nat --append POSTROUTING --out-interface eth0 -j MASQUERADE

# /etc/init.d/openvpn restart

Via SCP ou clé USB, importer les certificats clients vers le poste client (les fichiers nécéssaires sont ca.crt, client.crt et client.key).
Mettez les dans votre répertoire /etc/openvpn/

Maintenant, travaillons sur le poste client pour en finir :

Editez le fichier de configuration OpenVPN :

# vim /etc/openvpn/openvpn.conf

#nous sommes client
client
tls-client

#le serveur
remote XX.XX.XX.XX XX #@IP publique du serveur et port d’écoute
proto tcp
dev tun
ifconfig 10.8.0.2 10.8.0.1

#Certification de l’AC
ca /etc/openvpn/ca.crt

#notre certificat
cert /etc/openvpn/client.crt

#clef secrete
key /etc/openvpn/client.key

#negociation
reneg-sec 21600

#compression
comp-lzo

#verbosité
verb 3

Voilà pour la configuration.

Maintenant configurons le réseau :

# echo 1 > /proc/sys/net/ipv4/ip_forward

# route add -net 10.8.0.0 netmask 255.255.255.0 gw 192.168.0.111

# /etc/init.d/openvpn restart

Et maintenant, connectons nous au VPN sur le client :

# openvpn --config /etc/openvpn/openvpn.conf
# ping 192.168.0.111

PING 192.168.0.111 (192.168.0.111) 56(84) bytes of data.
64 bytes from 192.168.0.111: icmp_seq=1 ttl=64 time=3.17 ms
64 bytes from 192.168.0.111: icmp_seq=2 ttl=64 time=2.62 ms
64 bytes from 192.168.0.111: icmp_seq=3 ttl=64 time=3.34 ms
64 bytes from 192.168.0.111: icmp_seq=4 ttl=64 time=2.77 ms

Et voilà le travail.

Vous êtes en réseau local de n’importe où dans le monde.
Cela permet par exemple de détourner des ports fermés lors d’une connection bridée et vous permettrait de les avoir tous ouverts comme à la maison

Si vous avez la moindre question ou un problème, contactez moi.

J’ai remis mon blog en place. Il ne me reste plus qu’a remettre des articles !