Objectif

Avoir ssh sur ses serveurs c'est vraiment sympa pour les administrer à distance mais devoir laisser son port ssh accessible 24/7 pour notre petit confort c'est pas top niveau sécurité ...

On peut tenter de verrouiller les accès au port ssh histoire de pas se faire brute forcer son mot de passe avec quelque chose de ce style :

iptables -I INPUT -p tcp --dport 22 -i eth0 -m state --state NEW -m recent --set
iptables -I INPUT -p tcp --dport 22 -i eth0 -m state --state NEW -m recent --update --seconds 60 --hitcount 4 -j DROP

ce qui aura pour effet d'ignorer les requêtes arrivant à un rythme supérieur à 3 par minute. C'est pas mal déjà, mais en ce moment la mode est au port Knocking, et c'est pas si compliqué...

Il suffit de 10 lignes dans iptables pour établir un port Knocking de trois "tocs" afin d'ouvrir le port ssh si les bons ports ont été "Knockés" (et dans le bon ordre :)

Le principe

Avant de pouvoir utiliser le port 22 on doit le débloquer en contactant des ports précis dans un ordre précis, ce qui constitue la "clef" pour ouvrir notre port 22.

Dans notre exemple la clef est 103 202 301, si on contacte ces ports dans cet ordre, le port 22 sera ouvert pendant 5 secondes, juste le temps pour nous de faire une connexion ssh qui sera maintenue au delà de 5 secondes grâce aux règles qui acceptent les connexions ESTABLISHED.

Le script

iptables -N Step2
iptables -A Step2 -m recent --name Key1 --remove
iptables -A Step2 -m recent --name Key2 --set

iptables -N Step3
iptables -A Step3 -m recent --name Key2 --remove
iptables -A Step3 -m recent --name Key3 --set

iptables -A INPUT -p tcp --dport 103 -m recent --set --name Key1
iptables -A INPUT -p tcp --dport 202 -m recent --rcheck --name Key1 -j Step2
iptables -A INPUT -p tcp --dport 301 -m recent --rcheck --name Key2 -j Step3

iptables -A INPUT -p tcp --dport 22 -m recent --rcheck --seconds 5 --name Key3 -j ACCEPT

Les explications

On utilise ici le module "recent" d'iptables : iptables -m recent --help

recent v1.2.11 options:
[!] --set Add source address to list, always matches.
[!] --rcheck Match if source address in list.
[!] --update Match if source address in list, also update last-seen time.
[!] --remove Match if source address in list, also removes that address from list.
--seconds seconds For check and update commands above.
Specifies that the match will only occur if source address last seen within
the last 'seconds' seconds.
--name name Name of the recent list to be used. DEFAULT used if none given.
--rsource Match/Save the source address of each packet in the recent list table (default).
--rdest Match/Save the destination address of each packet in the recent list table.
ipt_recent v0.3.1: Stephen Frost <sfrost@snowman.net>. http://snowman.net/projects/ipt_recent/

Ce module permet de créer des listes dans lesquelles on va pouvoir lire/enregistrer des IPs ...
On créer deux chaînes, Step2 et Step3, pour vérifier que la séquence des tocs sur nos ports est bien respectée :

iptables -N Step2
iptables -A Step2 -m recent --name Key1 --remove
iptables -A Step2 -m recent --name Key2 --set
ici, lorsque le paquet traverse Step2, on ajoute l'adresse source du paquet qui est précédemment passé par le port 103 dans la liste "Key2" et on la retire de "Key1"

iptables -N Step3
iptables -A Step3 -m recent --name Key2 --remove
iptables -A Step3 -m recent --name Key3 --set
ici, lorsque le paquet traverse Step3, on ajoute l'adresse source du paquet qui est précédemment passé par le port 202 dans la liste "Key3" et on la retire de "Key2"

la ligne :
iptables -A INPUT -p tcp --dport 103 -m recent --set --name Key1
ajoute l'adresse source d'un paquet qui arriverait sur le port 103 dans la liste "Key1"

la ligne :
iptables -A INPUT -p tcp --dport 202 -m recent --rcheck --name Key1 -j Step2
ajoute l'adresse source d'un paquet qui arriverait sur le port 202 et dont l'adresse source serait dans "Key1" dans la liste "Key2" (cela se produit en traversant la chaîne "Step2")

la ligne :
iptables -A INPUT -p tcp --dport 301 -m recent --rcheck --name Key2 -j Step3
ajoute l'adresse source d'un paquet qui arriverait sur le port 301 et dont l'adresse source serait dans "Key2" dans la liste "Key3" (cela se produit en traversant la chaîne "Step3")

Enfin, la ligne suivante laisse passer les paquets à destination du port 22 dont l'adresse source est dans la liste "Key3" depuis moins de 5 secondes :
iptables -A INPUT -p tcp --dport 22 -m recent --rcheck --seconds 5 --name Key3 -j ACCEPT

Un script de test complet pour un serveur pourrait être :

#On fait le ménage
iptables -F
iptables -X
iptables -t nat -F
iptables -t nat -X
iptables -t mangle -F
iptables -t mangle -X

#On est pas causant par défaut
iptables -P INPUT DROP
iptables -P OUTPUT DROP
iptables -P FORWARD DROP

#On accepte de parler et d'entendre les réponses à nos questions
iptables -A INPUT -m state --state ESTABLISHED -j ACCEPT
iptables -A OUTPUT -m state --state NEW,ESTABLISHED -j ACCEPT

#On met en place un port Knocking afin d'ouvrir le port ssh 5 secondes
iptables -N Step2
iptables -A Step2 -m recent --name Key1 --remove
iptables -A Step2 -m recent --name Key2 --set

iptables -N Step3
iptables -A Step3 -m recent --name Key2 --remove
iptables -A Step3 -m recent --name Key3 --set

iptables -A INPUT -p tcp --dport 103 -m recent --set --name Key1
iptables -A INPUT -p tcp --dport 202 -m recent --rcheck --name Key1 -j Step2
iptables -A INPUT -p tcp --dport 301 -m recent --rcheck --name Key2 -j Step3

iptables -A INPUT -p tcp --dport 22 -m recent --rcheck --seconds 5 --name Key3 -j ACCEPT

Bon maintenant qu'on a la partie serveur, voyons la partie client :

Il faut faire toc toc sur les ports 103 puis 202 puis 301, certains conseillent d'utiliser telnet avec des commandes du style :

$> alias toc='telnet ip_address'
$> toc 103 ; toc 202 ; toc 301 ; ssh ip_address
puis Ctrl-C 3 fois pour killer les telnets et retomber sur la commande ssh

il m'a semblé que telnet introduisait trop de latence et que globalement ca marchait pas.

Je préfère utiliser un petit script "knock" du style :

nmap -PA103,202,301 -r -M1 $1
ssh $1

Explications : pour être certain que nmap contacte les ports dans l'ordre indiqué on ajoute "-r" et on fixe le maximum de sockets à 1 avec "-M1" pour être bien certain qu'il fera chaque toc l'un après l'autre.

Finalement

sous GNU/Linux on contacte notre serveur ssh avec la commande :

#./knock ip_address

et sous Windows ca marche aussi didon :

il nous faut nmap pour win32 : http://www.insecure.org/nmap/download.html
et winpcap : http://www.winpcap.org/install/default.htm
on met putty dans le dossier d'nmap ...
plus l'équivalent de notre petit script :

----knock.bat----
set IP=%1
if %1.==. set /p IP=Adresse IP ?
nmap -p103,202,301 -r --host_timeout 2000 %IP%
putty %IP%
-----------------

Et voilà Youpi notre port ssh est joignable 5 secondes après 3 tocs secrets et fermé le reste du temps, quel bonheur cet iptables ;)

Les distributions linux live c'est super chouette, mais si il manque un paquet dedans comment on le rajoute ?

J'utilise GRML une distrib live basée sur debian à destination des administrateurs réseau, je voulais rajouter plusieurs logiciels sur cette distrib et faire quelques réglages, clavier français, etc ... J'ai trouvé quelques solutions sur le net qui m'ont paru bien compliquées ...

La procédure, relativement simple, que je vous livre ici devrait fonctionner pour toute distrib live qui utilise un système de fichiers squashfs ...

mots clef google friendly : Remastering Remasteriser GRML, Modifier distribution linux vive live

Sous Ubuntu, je suis dans le dossier /home/fred

- Etape 1 : Prérequis

créer un dossier pour monter l'iso de GRML

mkdir grml_iso

Créer un dossier pour monter le systeme squashfs de GRML

mkdir grml_squash

Créer un dossier pour manipuler le système de GRML

mkdir grml_system

Installer les outils nécessaires

apt-get install squashfs-tools kiso rsync

- Etape 2 : Monter l'iso originale de GRML (en lecture seule)

sudo mount -o loop grml_x.y.iso grml_iso

- Etape 3 : Exporter le système squashfs de l'iso dans le dossier courant

cp grml_iso/GRML/GRML .

- Etape 4 : Monter le système squashfs de GRML (en lecture seule)

sudo mount -o loop GRML grml_squash

- Etape 5 : Copier le contenu du squashfs dans grml_system (accessible en lecture et ecriture)

sudo rsync -av grml_squash grml_system

- Etape 6 : Entrer dans le système de GRML

sudo chroot grml_system /usr/bin/zsh

| Faire ses modifications (apt-get install trucbidule, rm machin ...)

exit

- Etape 7 : Créer le squashfs du système modifié

sudo mksquashfs grml_system newGRML

- Etape 8 : Sous Kiso, Mettre à jour le squashfs dans l'iso de GRML

- Ouvrir l'iso de GRML
- Supprimer le fichier GRML/GRML de l'iso
- Ajouter le fichier newGRML dans le dossier GRML de l'iso
- Renommer newGRML en GRML

- Etape 9 : Sous Kiso, Mettre à jour le checksum du nouveau squashfs

- md5sum newGRML
- nano grml_iso/md5sums (modifier la valeur du checksum de GRML/GRML)
- Enregistrer sous newmd5sums
- Supprimer le fichier md5sums de l'iso
- Ajouter le fichier newmd5sums
- Renommer newmd5sums en md5sums

- Etape 10 : Sous Kiso, Enregistrer une nouvelle image iso

- Enregistrer sous ... my_own_grml.iso

et voilà votre distrib live perso ...

Votre Objectif : Relier les réseaux des filiales d'une même entreprise de manière sécurisée et économique

Solution retenue : Utiliser un Réseau Privé Virtuel à travers Internet.

Shéma du réseau :

                                                                                                             
M1:eth0:192.168.1.100/24                                                            M2:eth0:192.168.2.100/24
           |                                                                                   |            
           |                                                                                   |            
           |                                                                                   |            
           |                                                                                   |            
R1:eth0:192.168.1.1/24--------------------RWan:eth0:11.0.0.1/8----------------------R2:eth0:192.168.2.1/24  
   tun1:10.0.0.1/8                             eth1:12.0.0.1/8                         tun1:10.0.0.2/8      
   tun2:10.0.0.11/8                            eth2:13.0.0.1/8                         eth1:12.0.0.100/8    
   eth1:11.0.0.100/8                                  |                                                     
                                                      |                                                     
                                                      |                                                     
                                                      |                                                     
                                          R3:eth0:192.168.3.1/24                                            
                                             tun1:10.0.0.3/8                                                
                                             eth1:11.0.0.100/8                                              
                                                      |                                                     
                                                      |                                                     
                                                      |                                                     
                                          M3:eth0:192.168.1.100/24                                          

Explications :

M1, M2 et M3 représentent une Machine (Client et/ou Serveur) de chaque filiale.
RWAN représente le réseau public (Internet), c'est un routeur simple, sans aucun filtre.
R1, R2 et R3 représentent les Passerelles d'accès au web de chaque filiale. Ces passerelles sont des firewalls Debian GNU/Linux Iptables/NAT.

Nous allons établir un VPN entre les 3 réseaux en créant 2 tunnels OpenVPN. Un entre R1 et R2, L'autre entre R1 et R3.

Astuces :

Pour configurer M1, M2 & M3 (distribution Live GRML) à la main vite fait :

# loadkeys fr
# ifconfig eth0 192.168.[1,2,3].100 netmask 255.255.255.0 up
# route add -net 0.0.0.0 gateway 192.168.[1,2,3].1

Le Script Iptables de R1, R2 et R3 :
- Toutes les connexions sortantes (Lan->Wan) sont autorisées
- Ne sont autorisées en entrée (Wan->Lan) que les connexions en réponse à des requetes initiées du Lan
- Aucune requete Wan->Lan n'est autorisée

#On doit activer le "routage"
#echo 1 > /proc/sys/net/ipv4/ip_forward (A faire aussi sur RWAN)

#configuration
ext_if="eth1"
int_if="eth0"
loc_if="lo"

#on vide toutes les règles des chaines prédéfinies et personnelles
iptables -F
iptables -X
iptables -t nat -F
iptables -t nat -X
iptables -t mangle -F
iptables -t mangle -X

#on applique un NAT sur tout ce qui sort par $ext_if
iptables -t nat -A POSTROUTING -o $ext_if -j MASQUERADE

#politiques par défaut
iptables -P INPUT DROP
iptables -P OUTPUT DROP
iptables -P FORWARD DROP

#regles de base

#Accepter le trafic LOCAL interne
iptables -A OUTPUT -o $loc_if -j ACCEPT
iptables -A INPUT -i $loc_if -j ACCEPT

#Accepter le trafic LOCAL vers WAN
iptables -A OUTPUT -o $ext_if -j ACCEPT
iptables -A INPUT -i $ext_if -m state --state ESTABLISHED,RELATED -j ACCEPT

#Accepter le trafic de/vers $int_if
iptables -A INPUT -i $int_if -j ACCEPT
iptables -A OUTPUT -o $int_if -j ACCEPT

#Accepter toute connexion du LAN vers le WAN
iptables -A FORWARD -i ! $ext_if -o $ext_if -m state --state NEW,ESTABLISHED,RELATED -j ACCEPT

#Accepter du WAN vers le LAN les connexions déjà établies
iptables -A FORWARD -i $ext_if -o ! $ext_if -m state --state ESTABLISHED,RELATED -j ACCEPT

Installation et test d'OpenVPN

R1, R2 et R3 disposent du logiciel OpenVPN, que l'on peut installer avec la commande :

# apt-get install openvpn openssl

Quand l'architecture réseau est fonctionnelle (M1 ping R2 et M2 ping R1), on peut établir une liaison VPN de test entre R1 et R2 :

Sur R1 : openvpn --remote 12.0.0.100 --dev tun1 --ifconfig 10.0.0.1 10.0.0.2 --verb 9

Sur R2 : openvpn --remote 11.0.0.100 --dev tun1 --ifconfig 10.0.0.2 10.0.0.1 --verb 9

Le tunnel doit maintenant être fonctionnel, R1 doit pouvoir pinguer l'interface TUN de R2 et inversement.

Il reste à activer le routage entre les filiales 1 et 2 :

Sur R1 : route add -net 192.168.2.0 netmask 255.255.255.0 gw 10.0.0.2

Sur R2 : route add -net 192.168.1.0 netmask 255.255.255.0 gw 10.0.0.1

Les machines M1 et M2 doivent maintenant pouvoir communiquer à travers le VPN.

Sécurisation des transferts de données entre les filiales : Génération de clef de chiffrement

Le dossier easy-rsa contient les scripts nécessaires à une configuration des clients et du serveur TLS. La norme TLS (Transport Layer Security) est une norme de sécurisation, par chiffrement, du transport de l'information au sein des réseaux informatiques (anciennement SSL)).

debian:~# find / -name "easy-rsa" -print
/usr/share/doc/openvpn/examples/easy-rsa
debian:~# ls /usr/share/doc/openvpn/examples/easy-rsa
build-ca build-key build-key-server clean-all openssl.cnf.gz revoke-full
build-dh build-key-pass build-req list-crl README.gz sign-req
build-inter build-key-pkcs12 build-req-pass make-crl revoke-crt vars

Il nous faut générer plusieurs types de clef et certificats :

• une clef de pour le protocole d'échange diffie-hellman (dh1024.key)

• une clef et un certificat pour l'autorité de certification (à moins que vous en utilisiez une officielle comme par exemple www.verisign.com ou www.freessl.com, mais cela revient cher). (ca.crt, ca.key)

• une clef et un certificat pour le serveur (vpnserver.key, vpnserver.crt)

• une clef et un certificat pour chaque client ([nom client].crt, [nom client].key

• une clef qui sert à autoriser les accès au daemon (ta.key)

On désigne R1 comme serveur TLS, R2 et R3 comme client TLS ...

Editez le fichier vars de /usr/share/doc/openvpn/examples/easy-rsa/ , A titre d'exemple :

export D=/etc/openvpn
export KEY_CONFIG=$D/openssl.cnf
export KEY_DIR=$D/keys
export KEY_SIZE=1024
export KEY_COUNTRY=FR
export KEY_PROVINCE=BREIZH
export KEY_CITY=RENNES
export KEY_ORG="MonVPN"
export KEY_EMAIL="monnom@mondomaine.com"

Ceci va charger les précédentes variables en mémoire pour que les scripts puissent les utiliser ...

cd /usr/share/doc/openvpn/examples/easy-rsa
source ./vars
mkdir keys
touch keys/index.txt
echo 01 > keys/serial

Enfin, générer les différentes clefs :

./build-dh
./build-ca
./build-key-server [NOM DE VOTRE SERVEUR]

Vous pouvez aussi dès a présent générer les clefs des clients :

./build-key [nom de votre client] 

Les fichiers .key sont "top secret", ils ne doivent en aucun cas être diffusés publiquement. Enfin, il vous faut générer une clef spéciale pour éviter les attaques dites "Man in the middle" ou "homme du milieu" en français. (ce sont des attaques d'interception de clefs).

	openvpn --genkey --secret keys/ta.key
	chown -R nobody /etc/openvpn

Les différentes clef et certificats sont maintenant stockés dans le répertoire /etc/openvpn/keys/

Copiez les fichiers nécessaires aux clients TLS R2 et R3 dans leur dossier /etc/openvpn/keys/ (cf lignes de commandes plus bas)

Voila, vous avez généré/configuré tout ce qu'il faut, on peut passer à la configuration des clients et du serveur.

Test du VPN entre le serveur VPN R1 et les clients VPN R2 et R3 avec les clefs de chiffrement TLS

Sur R1 :

openvpn --remote 12.0.0.100 --dev tun1 --ifconfig 10.0.0.1 10.0.0.2
--tls-server --dh dh1024.pem --ca ca.crt --cert R1.crt --key R1.key --tls-auth ta.key 0
--route 192.168.2.0 255.255.255.0 10.0.0.2 &

openvpn --port 5000 --remote 13.0.0.100 --dev tun2 --ifconfig 10.0.0.11 10.0.0.3
--tls-server --dh dh1024.pem --ca ca.crt --cert R1.crt --key R1.key –tls-auth ta.key 0
--route 192.168.3.0 255.255.255.0 10.0.0.3 &

Sur R2 :

openvpn --remote 11.0.0.100 --dev tun1 --ifconfig 10.0.0.2 10.0.0.1
--tls-client --ca ca.crt --cert R2.crt --key R2.key --tls-auth ta.key 1
--route 192.168.1.0 255.255.255.0 10.0.0.1
--route 192.168.3.0 255.255.255.0 10.0.0.1 &

Sur R3 :

openvpn --port 5000 --remote 11.0.0.100 --dev tun1 --ifconfig 10.0.0.3 10.0.0.11
--tls-client --ca ca.crt --cert R3.crt --key R3.key --tls-auth ta.key 1
--route 192.168.1.0 255.255.255.0 10.0.0.11
--route 192.168.2.0 255.255.255.0 10.0.0.11 &

Automatisation du chargement du VPN

- Ecrire les commandes openvpn dans un script : /etc/init.d/vpn

- Rendre ce script exécutable : chmod +x /etc/init.d/vpn

- Planifier l'exécution du script /etc/init.d/vpn au démarrage :

update-rc.d /etc/init.d/vpn defaults

ou

Appeler /etc/init.d/vpn depuis la section start et restart de /etc/init.d/networking

Sources :

- Le man d'openvpn et openvpn.net

- http://www.nbs-system.com/html/services/vpn

Fin

ps : Youpi