WIKI TP Jérôme -> KIEV

Créer la machine de service

Se connecter au serveur en tant que root :

ssh root@capbreton.plil.info

Créer le fichier de config de la VM :

xen-create-image --hostname=kiev --ip=172.26.145.103 --netmask=255.255.255.0 --gateway=172.26.145.254 --bridge=SE2A5 --dir=/usr/local/xen --password=glopglopglop

Démarrer la VM :

xen create /etc/xen/kiev.cfg

Lister les VM :

xen list

Se connecter à la VM depuis capbreton:

xen console

Configurer le SSH

Modifier le fichier /etc/ssh/sshd_config: Autoriser la connexion en root :

PermitRootLogin yes

Redémarrer le service SSH :

service ssh restart ou /etc/init.d/ssh restart

Se connecter en root via SSH :

ssh root@172.26.145.103

Créer les partitions LVM

Créer 2 partitions LVM sur capbreton pour y rattacher, par la suite /home et /var :

lvcreate -L10G -n kiev-home virtual
lvcreate -L10G -n kiev-var virtual

Dans /etc/xen/kiev.cfg, ajouter les 2 partitions :

phy:/dev/virtual/kiev-home, xvdb, w',
phy:/dev/virtual/kiev-var, xvdc, w',

 #  Disk device(s).
#
root        = '/dev/xvda2 ro'
disk        = [
                'file:/usr/local/xen/domains/HG/disk.img,xvda2,w',
                'file:/usr/local/xen/domains/HG/swap.img,xvda1,w',
                'phy:/dev/virtual/kiev-home,xvdb,w',
                'phy:/dev/virtual/kiev-var,xvdc,w',
            ]

Eteindre la VM xen shut kiev et la redémarrer.

Sur la VM, créer 2 répertoires, y placer le contenu de /var et /home pour ensuite monter notre disque dans /home et /var :

 mkdir /new_home
 mkdir /new_var
 mkfs /dev/xvdb //Formater les partitions LVM au format ext4 et y créer un système de fichier
 mkfs /dev/xvdc
 mount /dev/xvdb /new_home
 mount /dev/xvdc /new_var
 cp -r /var/* /new_var/

lsblk // Lister les LVM

 xvda1 202:1    0  512M  0 disk [SWAP]
 xvda2 202:2    0   10G  0 disk /
 xvdb1 202:17   0   10G  0 disk /new-home
 xvdb2 202:18   0   10G  0 disk /new-var

Dans /etc/fstab, ajouter :

 /dev/xvdb  /home ext4 defaults 0 2 *
 /dev/xvdc  /var ext4 defaults 0 2 *

Reboot la VM

 umount /new_var
 umount /new_home
 mount -a // Monter tous les systèmes de fichiers spécifiés dans le fichier "/etc/fstab".

lsblk // Lister les LVM

 xvda1 202:1    0  512M  0 disk [SWAP]
 xvda2 202:2    0   10G  0 disk /
 xvdb1 202:17   0   10G  0 disk /home
 xvdb2 202:18   0   10G  0 disk /var

Créer la machine mandataire

xen-create-image --hostname=balltrap --ip=193.48.57.163 --netmask=255.255.255.240 --bridge=SE2a5 --dir=/usr/local/xen --password=glopglop --gateway=193.48.57.161
xen create balltrap.cfg

Se connecter à la VM : xen console balltrap
Vérifier qu'on ping google.com

Dans /etc/network/interfaces, obtenir une IPv6 par DHCP: iface eth0 inet6 auto

Créer la mascarade

Sur capbreton, créer un bridge balltrap (pour ponter la carte réseau virtuelle de la VM à une carte réseau physique). Dans /etc/network/interfaces :

 #balltrap_bridge
 iface balltrap inet manual
 bridge_ports none
 post-up ip link set $IFACE up
 post-down ip link set $IFACE down

Up l'interface du bridge

ifup balltrap

Ajouter le bridge dans le fichier de config de chaque VM (dans vif):

ip=192.168.163.1, bridge=balltrap'

Redémarrer les VM et, dans /etc/network/interfaces, leur déclarer une nouvelle interface réseau (eth1) avec une IP privée statique :

balltrap = 192.168.163.1
kiev = 192.168.163.2
Riga = 192.168.163.3

Monter l'interface réseau eth1 nouvellement créée (et vérifier qu'elle est bien montée) :

 ifup -a
 ip a

Ping les autres IP dans ce réseau privé.

Créer une redirection de l'interface routée et notre interface privée sur la machine mandataire :

iptables -t nat -A POSTROUTING -j MASQUERADE -s 192.168.163.0/24
apt install iptables-persistant
iptables-save
iptables-save >> /etc/iptables/rules.v4

Vérifier dans /etc/iptables/rules.v4 les nouvelles règles de routage. Ping google.com depuis la machine mandataire et les machines de service.

Se connecter en ssh depuis capbreton à la machine de service en utilisant la machine mandataire comme jump :

ssh -J root@193.48.57.163 root@192.168.163.2

Supprimer l'IPV4 sur l'interface eth0 sur les machines de service :

 auto eth0
 iface eth0 inet6 auto

Activer le routage (autoriser la redirection d'IP en mode définitif) sur notre machine mandataire. Dans le dossier /etc/sysctl.conf :

sysctl net.ipv4.ip_forward=1

Créer maintenant des règles de routages pour se connecter en ssh aux machines de service en utilisant un port différent.

iptables -A PREROUTING -t nat -i eth0 -p tcp -m tcp --dport 2201 -j DNAT --to-destination 192.168.163.2:22
iptables -A PREROUTING -t nat -i eth0 -p tcp -m tcp --dport 2202 -j DNAT --to-destination 192.168.163.3:22

Se connecter en ssh à la machine de service depuis capbreton en utilisant sur le port 2201 :

 ssh root@193.48.57.163 -p 2201
 ssh root@193.48.57.163 -p 2202

Configurer le serveur DNS

Sur https://www.gandi.net, acheter le nom de domaine kievjeje.lol et spécifier les serveurs DNS (GlueRecords + externalServerNames):

DNS principal (machine de service) -> IPv6
DNS secondaire (machine mandataire) -> IPv4

Sur la machine de service, ajouter le serveur DNS de google (8.8.8.8) dans /etc/resolv.conf (nameserver)

Maintenant on peut télécharger bind9 sur la machine de service.

Configurer le bind9 : Dans /etc/bind/named.conf.local, créer la zone DNS (sur la machine de service et mandataire):

Sur la machine de service (master)

 zone "kievjeje.lol" {
   type master;
   file "/etc/bind/db.kievjeje.lol";
   allow-transfer {192.168.163.1; };
 };

Sur la machine mandataire (slave)

 zone "kievjeje.lol" {
   type slave;
   file "/etc/bind/db.kievjeje.lol";
   allow-transfer {192.168.163.2; };
 };*

Dans /etc/bind/named.conf.options :

 listen-on-v6 { any; }
 listen-on { any; };
 allow-recursion {127.0.0.1; };

allow-recursion spécifie les IPs ayant la permission de faire des requêtes récursives sur le DNS. Cela permet d'éviter que notre serveur ne serve de relais DNS ouvert.

Le fichier /etc/bind/db.kievjeje.lol contient les enregistrements DNS:

Vérifier qu'il n'y a pas d'erreur de conf DNS :

named-checkconf named.conf."" pour vérifier les fichiers de conf
named-checkzone kievjeje.lol db.kievjeje.lol
cat /var/log/daemon.log

Redémarrer le service DNS (ne pas oublier d'incrémenter le SN dans named.conf.local à chaque restart :

service bind9 restart

Vérifier qu'un serveur DNS est bien présent sur une machine pour la zone demandée (installer le package dnsutils préalablement) :

dig @localhost kievjeje.lol ou dig @192.168.163.2 kiev.jeje.lol

On observe bien 1 query 1 answer DNS sur la zone.

Installer apache2 sur la machine de service et vérifier avec un browser que notre site web www.kievjeje.lol est en ligne:

On peut aussi tester la résolution DNS avec nslookup ns1.kievjeje.lol et nslookup www.kievjeje.lol

Activer le HTTPS sur Apache2

Sur la machine de service, installer openssl, et générer une CSR (Certificate Signing Request SSL) :

https://docs.gandi.net/fr/ssl/operations_courantes/csr.html
openssl req -nodes -newkey rsa:2048 -sha256 -keyout kievjeje.lol.key -out kievjeje.lol.csr
(Attention à bien renseigner kievjeje.lol comme Common Name)
kievjeje.lol.key est notre clé privée ( -> elle est très importante, je la range dans /etc/ssl/private/) et je securise son accès : chmod 440 kievjeje.lol.key

Copier le certificat (kievjeje.lol.crt) obtenu sur Gandi.net et le copier dans /etc/ssl/certs/
Activer le mode SSL sur apache2 : a2enmod ssl et configurer apache2 pour gérer du HTTPS sur le port 443 :

Créer une nouvelle zone dans /etc/apache2/sites-available/vhosts-https.conf
Insérer la ligne de conf SSLEngine On et préciser l'emplacement de la clé privée du serveur et du certificat :
Clef privée du serveur (kievjeje.lol.key) via SSLCertificateKeyFile et certificat (kievjeje.lol.crt) via SSLCertificateFile

Redémarrer le service apache2 service apache2 restart

Sécuriser le DNS par DNSSEC

https://docs.gandi.net/en/domain_names/advanced_users/dnssec.html https://www.cloudflare.com/fr-fr/dns/dnssec/how-dnssec-works/
On choisit de gérer la gestion automatique des clefs en utilisant dnssec-policy au lieu de auto-dnssec:

https://shaunc.com/blog/article/migrating-from-autodnssec-to-dnssecpolicy-in-bind~aEpnuMVvmPF7
Pour cela il faut installer l'image Debian chimera.
Puis configurer named.conf.local comme ceci :

Si DNSSEC fonctionne bien, nous devrions voir les paires (privées et publiques) des clés ZSK et KSK s'ajouter dans /etc/bind/keys/

Ajouter photo ???

Dans /etc/bind/kievjeje.lol.dnssec/ :

Créer la clé asymétrique de signature de clefs de zone (KSK) : dnssec-keygen -a RSASHA256 -b 2048 -f KSK -n ZONE kievjeje.lol
- Renommer les paires de clés obtenues en kievjeje.lol-ksk.key et kievjeje.lol-ksk.private
Créer la clé asymétrique de la zone pour signer les enregistrements : dnssec-keygen -a RSASHA256 -b 1024 -n ZONE kievjeje.lol
- Renommer les paires de clés obtenues (privée et public) en kievjeje.lol-zsk.key et kievjeje.lol-zsk.private
Inclure les clés publiques dans notre fichier de zone db.kievjeje.lol :

 $include /etc/bind/kievjeje.lol.dnssec/kievjeje.lol-ksk.key
 $include /etc/bind/kievjeje.lol.dnssec/kievjeje.lol-zsk.key

Signer les enregistrements de la zone : dnssec-signzone -o <nom_de_zone> -k <nom_de_zone>-ksk ../<nom_de_zone> <nom_de_zone>-zsk

Atelier SysRes SE2a5 2023/2024 E9

Sommaire

WIKI TP Jérôme -> KIEV

Créer la machine de service

Configurer le SSH

Créer les partitions LVM

Créer la machine mandataire

Créer la mascarade

Configurer le serveur DNS

Activer le HTTPS sur Apache2

Sécuriser le DNS par DNSSEC

Menu de navigation

Atelier SysRes SE2a5 2023/2024 E9

WIKI TP Jérôme -> KIEV

Créer la machine de service

Configurer le SSH

Créer les partitions LVM

Créer la machine mandataire

Créer la mascarade

Configurer le serveur DNS

Activer le HTTPS sur Apache2

Sécuriser le DNS par DNSSEC

Menu de navigation

Rechercher