# Notes du projet du module Risque - SR06
## Préparation des machines virtuelles
### Adresse IP des Vms
* vm-web : 172.23.3.31 ou 10.10.10.183 (depuis vm-cli-int)
* vm-cli-ext : 172.23.3.184
* vm-cli-int : 10.10.10.201
### 1. Vulnérabliltés du TD.R2
#### 1. Mot de passe remplacés
Choix de mots de passe respectant les recommandations :
* vm-web
* etu : Thrash9-Fragrance!-Refusal
* edite : Taco9-Gondola-Landscape!
* publie : Gigantic7-Playlist-Habitual
* controle : Brisket-Upbeat-Closure4
* vm-cli-int
* etu : Gluten6-Stylized-Wilt!
* vm-cli-ext
* etu : Chuck-Cardboard-!Hanky2
On vérifie ensuite pour les fichiers `/etc/passwd` et `/etc/shadow` que les droits sont les bons :
```bash=
etu@passoire ~ → ls -l /etc/passwd
-rw-r--r-- 1 root root 1856 Apr 22 16:40 /etc/passwd
```
```bash=
etu@passoire ~ → ls -l /etc/shadow
-rw------- 1 root shadow 1292 Apr 22 16:40 /etc/shadow
```
**Rappel :** drwxrwxrwx → directory puis read / write / execute → user / group / other
#### 2. `setuid bit`
Définition : "*Il s'agit de bits de contrôle d'accès appliqués aux fichiers et répertoires d'un système d'exploitation UNIX*". Cela signifie que les fichiers exécutables `setuid` ou `setgid` sont particulièrement sensibles car ils s’exécutent avec les privilèges de leur utilisateur (ou groupe) propriétaire et non celui de l’utilisateur courant.
Dans le guide de l'ANSSI [Recommandations de Configuration d'un Système GNU/LINUX](https://www.ssi.gouv.fr/uploads/2016/01/linux_configuration-fr-v1.2.pdf), on trouve à la partie 6.5.3 des informations relatives aux fichiers exécutables `setuid` ou `setgid`.
La commande ci-dessous permet de lister l’ensemble des fichiers `setuid/setgid` présents sur le système :
```bash=
find / -type f -perm /6000 -ls 2>/dev/null
```
La syntaxe de la commande `find` peut être résumée ainsi : `find répertoire-de-recherche critères-de-sélection-des-fichiers traitement des fichiers`.
Option `-exec` de `find` :
`find répertoire critères-de-sélection-des-fichiers -exec commande`.
exemple : `find / -type f -perm /u-s -perm /g+s -exec \ls -l {} \; 2> /dev/null`
La première commande donne ce résultat :
```bash=
etu@passoire ~ → find / -type f -perm /6000 -ls 2>/dev/null
394362 40 -rwsr-xr-x 1 root root 39144 Jul 21 2020 /usr/bin/umount
394067 68 -rwsr-xr-x 1 root root 68208 May 28 2020 /usr/bin/passwd
394293 164 -rwsr-xr-x 1 root root 166056 Jan 19 14:21 /usr/bin/sudo
394034 44 -rwsr-xr-x 1 root root 44784 May 28 2020 /usr/bin/newgrp
410183 344 -rwxr-sr-x 1 root ssh 350504 Mar 9 14:17 /usr/bin/ssh-agent
393752 84 -rwxr-sr-x 1 root shadow 84512 May 28 2020 /usr/bin/chage
393886 88 -rwsr-xr-x 1 root root 88464 May 28 2020 /usr/bin/gpasswd
393763 52 -rwsr-xr-x 1 root root 53040 May 28 2020 /usr/bin/chsh
393689 56 -rwsr-sr-x 1 daemon daemon 55560 Nov 12 2018 /usr/bin/at
393868 40 -rwsr-xr-x 1 root root 39144 Mar 7 2020 /usr/bin/fusermount
394404 36 -rwxr-sr-x 1 root tty 35048 Jul 21 2020 /usr/bin/wall
393757 84 -rwsr-xr-x 1 root root 85064 May 28 2020 /usr/bin/chfn
394292 68 -rwsr-xr-x 1 root root 67816 Jul 21 2020 /usr/bin/su
394020 56 -rwsr-xr-x 1 root root 55528 Jul 21 2020 /usr/bin/mount
394088 32 -rwsr-xr-x 1 root root 31032 Aug 16 2019 /usr/bin/pkexec
393702 16 -rwxr-sr-x 1 root tty 14488 Mar 30 2020 /usr/bin/bsd-write
393850 32 -rwxr-sr-x 1 root shadow 31312 May 28 2020 /usr/bin/expiry
393787 44 -rwxr-sr-x 1 root crontab 43720 Feb 13 2020 /usr/bin/crontab
529519 16 -rwxr-sr-x 1 root utmp 14648 Sep 30 2019 /usr/lib/x86_64-linux-gnu/utempter/utempter
394576 16 -rwsr-xr-x 1 root root 14488 Jul 8 2019 /usr/lib/eject/dmcrypt-get-device
411391 16 -rwsr-xr-- 1 root telnetd 14744 Mar 23 2020 /usr/lib/telnetlogin
394569 52 -rwsr-xr-- 1 root messagebus 51344 Jun 11 2020 /usr/lib/dbus-1.0/dbus-daemon-launch-helper
394791 24 -rwsr-xr-x 1 root root 22840 Aug 16 2019 /usr/lib/policykit-1/polkit-agent-helper-1
417562 464 -rwsr-xr-x 1 root root 473576 Mar 9 14:17 /usr/lib/openssh/ssh-keysign
400553 44 -rwxr-sr-x 1 root shadow 43168 Jul 21 2020 /usr/sbin/pam_extrausers_chkpwd
400600 44 -rwxr-sr-x 1 root shadow 43160 Jul 21 2020 /usr/sbin/unix_chkpwd
411383 20 -rwsr-xr-x 1 root root 16928 Mar 8 19:02 /usr/local/bin/readfile-s
```
D'après les recommandations de l'ANSSI, il nous faut retirer les droits *setuid* ou *setgid* comme suit :
| Exécutable | Recommandation |
| -------- | -------- |
| `/usr/bin/umount` | À désactiver, sauf si absolument nécessaire pour les utilisateurs.|
| `/usr/bin/passwd` | À désactiver, sauf si des utilisateurs non root doivent pouvoir changer leur mot de passe.
| `/usr/bin/newgrp` | À désactiver si pas d’authentification de groupe.|
| `/usr/bin/chage` | À désactiver.|
| `/usr/bin/chsh` | À désactiver.|
| `/usr/bin/sudo` | Changement d’utilisateur. Ne pas désactiver.|
| `/usr/bin/gpasswd` | À désactiver si pas d’authentification de groupe.|
| `/usr/bin/at` | À désactiver si atd n’est pas utilisé.|
| `/usr/bin/fusermount` | À désactiver sauf si des utilisateurs doivent monter des partitions FUSE.|
| `/usr/bin/wall` | À désactiver.|
| `/usr/bin/chfn` | À désactiver.|
| `/usr/bin/su` | Changement d’utilisateur. Ne pas désactiver.|
| `/usr/bin/mount` | À désactiver, sauf si absolument nécessaire pour les utilisateurs.|
| `/usr/bin/pkexec` | À désactiver si PolicyKit n’est pas utilisé.|
| `/usr/bin/crontab` | À désactiver si cron n’est pas requis.|
| `/usr/lib/x86_64-linux-gnu/utempter/utempter` | À désactiver si le profil utempter SELinux n’est pas utilisé.|
| `/usr/lib/dbus-1.0/dbus-daemon-launch-helper` | À désactiver quand D-BUS n’est pas utilisé.|
| `/usr/lib/openssh/ssh-keysign` | À désactiver.|
| `/usr/sbin/unix_chkpwd` | Permet de vérifier le mot de passe utilisateur pour des programmes non root. À désactiver si inutilisé. |
À l'aide des commandes ci-dessous nous pouvons retirer les droits *setuid* ou *setgid* des fichiers qui le requièrent:
```bash=
chmod u-s <fichier > # Retire le bit setuid
chmod g-s <fichier > # Retire le bit setgid
```
Finalement, seules les fichiers ci-dessous ont encore leurs droits *setuid* ou *setgid*.
```bash=
etu@passoire ~ → find / -type f -perm /6000 -ls 2>/dev/null
394293 164 -rwsr-sr-x 1 root root 166056 Jan 19 14:21 /usr/bin/sudo
394292 68 -rwsr-xr-x 1 root root 67816 Jul 21 2020 /usr/bin/su
411383 20 -rwsr-xr-x 1 root root 16928 Mar 8 19:02 /usr/local/bin/readfile-s
```
#### 3. `umask`
À nouveau, selon le guide de l'ANSSI, le *umask* "est par défaut très permissif (généralement 0022, soit : tout fichier créé est lisible par tous)." "Le umask système doit être positionné à 0027 (par défaut, tout fichier créé n’est lisible que par l’utilisateur et son groupe, et modifiable uniquement par son propriétaire). Le umask pour les utilisateurs doit être positionné à 0077 (tout fichier créé par un utilisateur n’est lisible et modifiable que par lui)."
Pour ce faire, on modifie le fichier `/etc/login.defs` : `UMASK 022` devient `UMASK 027`.
Pour configurer un *umask* spécifique pour un utilisateur, il faut modifier le fichier `/etc/profile` en tant que `root` et y insérer une ligne indiquant `umask 077`.
Cela signifie que tout utilisateur nouvellement créé aura par défaut la valeur de `umask` spécifiée dans `/etc/profile`.
#### 4. `sticky bit`
Définition : "Ce droit est utilisé pour manier de façon plus subtile les droits d'écriture d'un répertoire. En effet, le droit d'écriture signifie que l'on peut créer et supprimer les fichiers de ce répertoire. Le sticky bit permet de faire la différence entre les deux droits."
"Tous les répertoires accessibles en écriture par tous doivent avoir le *sticky bit* armé."
La commande suivante permet de lister l’ensemble des répertoires modifiables par tous et sans *sticky bit* :
```bash=
find / -type d \( -perm -0002 -a \ ! -perm -1000 \) -ls 2>/dev/null
```
"Il faut aussi s’assurer que le propriétaire du répertoire est bien *root*, sans quoi l’utilisateur propriétaire pourra à loisir modifier son contenu et ce malgré le *sticky bit*."
La commande suivante permet de lister l’ensemble des répertoires modifiables par tous et dont le propriétaire n’est pas root :
```bash=
find / -type d -perm -0002 -a \ ! -uid 0 -ls 2>/dev/null
```
#### 5. Anomalies de configuration dans le système de fichier
La commande suivante permet de trouver tous les fichiers et répertoires qui sur lesquels le droit d'écriture est activé mais qui n'appartiennent pas à l'utilisateur `root` :
```bash=
find / -type d -perm /o+w -a \! -uid 0 -print 2> /dev/null
```
La commande `find / -tyfind / -type f \( -nouser -o -nogroup \) -print 2>` renvoie le résultat suivant :
```bash=
/home/tournesol/.sudo_as_admin_successful
/home/tournesol/readfile
/home/tournesol/.bash_history
/home/tournesol/.bashrc
/home/tournesol/.profile
/home/tournesol/.bash_logout
/home/tournesol/readfile.c
```
Malgré le fait que nous avons supprimé l'utilisateur `tournesol`, son répertoire `/home` est quant à lui toujours présent.
La commande `sudo rm -rf /home/tournesol` nous permet de supprimer tous les fichiers (potentiellement malicieux) que l'utilisateur `tournesol` a pu laisser derrière lui.
### 2. Vultnérabilités du TD.3
#### 1. Suppression des services réseaux non sécurisés
Suppression de telnet :
```bash=
sudo apt remove telnet
sudo apt remove telnetd
```
#### 2. Correction des anomalies dans /etc/passwd
Un coup d'oeil au fichier `/etc/passwd` montre que l'utilisateur `www-data` n'est pas bien configuré. Il possède un shell par défaut, bash, alors qu'il devrait être en nologin.
```bash=
www-data:x:33:33:www-data:/var/www:/bin/bash
```
Pour corriger l'anomalie nous modifions la ligne correspondante à l'utilisateur `www-data` :
```bash=
www-data:x:33:33:www-data:/var/www:/usr/sbin/nologin
```
Ainsi, la commande `grep -v nologin /etc/passwd | grep -v false`renvoie :
```bash=
etu@passoire ~ → grep -v nologin /etc/passwd | grep -v false
root:x:0:0:root:/root:/bin/bash
sync:x:4:65534:sync:/bin:/bin/sync
etu:x:1001:1001:,,,:/home/etu:/usr/bin/bash
```
### 3. Machines uniques
#### 1. Nom configuré
Changement du nom des vm à l'aide de la commande suivante :
```bash=
sudo hostname <new-name>
```
Il faut également modifier les fichiers `/etc/hosts` et `/etc/hostname`
#### 2. Adresse IP unique
Éditer le fichier `00-installer-config.yaml` du répertoire `/etc/netplan`
* Ajouter la ligne `dhcp-identifier: mac` après la ligne `dhcp4: true` en respectant le même alignement que cette ligne (ne pas utiliser de tabulations).
* Appliquer la nouvelle configuration avec les commandes `sudo netplan apply` puis `sudo netplan generate`.
* Constater les changements dans le fichier `/var/run/systemd/network/10-netplan-ens18.network`.
#### 3. Machine-id réinitialisé
```bash=
cat /etc/machine-id # pour consulter le machine ID
sudo rm /etc/machine-id # pour le supprimer
sudo systemd-machine-id-setup # pour en générer un nouveau
```
#### 4. Clés ssh re-créées.
Suppression des clés du serveur avec la commande `sudo rm /etc/ssh/ssh_host_*`.
Généreration de nouvelles clés en relançant la configuration du serveur ssh via la commande `sudo dpkg-reconfigure openssh-server`.
## Serveur web
### 1. Configuration réseau
#### 1. vm-web dispose de deux interfaces réseaux, l'une vers le réseau de l'entreprise, l'autre vers Internet
Ajout d'une nouvelle interface réseau à la vm-web-RB sur Proxmox avec un bridge vmbr0 différent de celui de l'interface déjà présente (vmbr2) et sans Firewall.
On obtient :
```bash=
etu@vm-web-RB ~ → dmesg | grep -i eth
[ 2.117091] virtio_net virtio4 ens19: renamed from eth1
[ 2.138466] virtio_net virtio3 ens18: renamed from eth0
```
On édite le fichier de configuration à l'aide de la commande `sudo vim /etc/netplan/00-installer-config.yaml` afin qu'il soit comme suit :
```yaml=
# This is the network config written by 'subiquity'
network:
ethernets:
ens18:
dhcp4: true
dhcp-identifier: mac
ens19:
dhcp4: true
dhcp-identifier: mac
dhcp4-overrides:
route-metric: 300
version: 2
```
La valeur de 300 pour le route-metric permet de s'assurer que l'interface vmbr0 ne permet pas de rejoindre l'extérieur. Il s'agit de l'interface consacrée au réseau interne.
On applique ensuite les modifications avec `sudo netplan generate` et `sudo netplan apply`.
On demande alors l'attribution d'un adress IP avec `sudo dhclient`. On vérifie :
```bash=
etu@vm-web-RB ~ → ip address show
1: lo: <LOOPBACK,UP,LOWER_UP> mtu 65536 qdisc noqueue state UNKNOWN group default qlen 1000
link/loopback 00:00:00:00:00:00 brd 00:00:00:00:00:00
inet 127.0.0.1/8 scope host lo
valid_lft forever preferred_lft forever
inet6 ::1/128 scope host
valid_lft forever preferred_lft forever
2: ens18: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500 qdisc fq_codel state UP group default qlen 1000
link/ether 56:e3:fb:cb:0f:e1 brd ff:ff:ff:ff:ff:ff
inet 172.23.4.134/16 brd 172.23.255.255 scope global dynamic ens18
valid_lft 3324sec preferred_lft 3324sec
inet6 fe80::54e3:fbff:fecb:fe1/64 scope link
valid_lft forever preferred_lft forever
3: ens19: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500 qdisc fq_codel state UP group default qlen 1000
link/ether 72:f5:84:06:19:8c brd ff:ff:ff:ff:ff:ff
inet 10.10.10.203/24 brd 10.10.10.255 scope global dynamic ens19
valid_lft 10367964sec preferred_lft 10367964sec
inet6 fe80::70f5:84ff:fe06:198c/64 scope link
valid_lft forever preferred_lft forever
```
#### 2. Interdire le routage entre les deux interfaces réseaux (configuration de `net.ipv4.ip_forward` via `sysctl`)
Définition : "L’IP forwarding permet à un système d’exploitation (ici Linux) de faire suivre des paquets comme le fait un routeur ou plus généralement de les router au travers d’autres réseaux"
On vérifie que les lignes suivantes sont bien commentées dans le fichier `/etc/sysctl.conf` :
```bash=
#net.ipv4.conf.default.rp_filter=1
#net.ipv4.conf.all.rp_filter=1
#net.ipv4.tcp_syncookies=1
#net.ipv4.ip_forward=1
#net.ipv6.conf.all.forwarding=1
```
La commande `sysctl -p` permet aux éventuelles modifications de prendre effet.
```bash=
sudo sysctl net.ipv4.ip_forward
net.ipv4.ip_forward = 0 //ip_forward désactivé
```
### 2. Installer Apache
On installe apache2 : `sudo apt-get install apache2`.
On vérifie que le serveur web est lancé :
```bash=
etu@vm-web-RB ~ → sudo service apache2 status
● apache2.service - The Apache HTTP Server
Loaded: loaded (/lib/systemd/system/apache2.service; enabled; vendor preset: enabled)
Active: active (running) since Fri 2021-04-23 09:58:09 UTC; 55s ago
Docs: https://httpd.apache.org/docs/2.4/
Main PID: 1597 (apache2)
Tasks: 55 (limit: 2281)
Memory: 5.1M
CGroup: /system.slice/apache2.service
├─1597 /usr/sbin/apache2 -k start
├─1599 /usr/sbin/apache2 -k start
└─1600 /usr/sbin/apache2 -k start
```
Sauvegarde de la page web par défaut avec les commandes :
```bash=
cd /var/www/html
sudo mv index.html index.sos
```
### 3. Développer un formulaire PHP simple qui permette aux clients de saisir des noms et de les stocker dans un fichier du serveur
Installation de php `sudo apt-get install php`.
Création d'une formulaire php minimaliste permettant au client de saisir des noms et de les stocker das un fichier du serveur :
```php=
# /var/www/php/formulaire.php
<?php
// recuperation du nom du fichier
if (isset($_POST['name']) && isset($_POST['email'])) { // si formulaire soumis
$contenu = "nom : " . $_POST['name'] . " email : " . $_POST['email'] . "\n";
//Ouverture du répertoire de destination
$fichierouvert = fopen("data.txt", "a");
//Copie du fichier
if (!fwrite($fichierouvert, $contenu)) {
echo "Impossible d'écrire dans le fichier ($filename)";
exit;
}
//Fermeture du fichier
fclose($fichierouvert);
echo "Merci on a enregistré le message <br>";
echo "$contenu";
}
```
Et d'un fichier html.
```htmlembedded=
<!-- /var/www/html/index.html -->
<html>
<head>
<title>Formulaires</title>
<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1" />
</head>
<body>
<form action="formulaire.php" method="post">
<p>
Nom: <input type="text" name="name" />
Email : <input type="text" name="email" />
<input type="submit" value="Valider" />
</p>
</form>
</body>
</html>
```
Et création d'un fichier `data.txt` dans `/var/www/data` avec les droits suivant :
`-rw-rw-r--` → `chmod 664 data.txt`
### 4. S'assurer qu'il n'y ait pas de services inutiles via un scan de port local
On utilise `nmap`pour ce faire :
```bash=
etu@vm-web-RB www → nmap localhost
Starting Nmap 7.80 ( https://nmap.org ) at 2021-04-23 10:23 UTC
Nmap scan report for localhost (127.0.0.1)
Host is up (0.00026s latency).
Not shown: 998 closed ports
PORT STATE SERVICE
22/tcp open ssh
80/tcp open http
```
### 5. Désinstaller les applications non nécessaires pour ce serveur destiné à héberger un serveur web exposé à Internet (navigateurs, compilateurs...)
On liste les paquets installés avec `apt list --installed`.
On désinstalle notamment :
* Telnet → `sudo apt remove telnet`et `sudo apt remove telnetd`
* Lynx → `sudo apt remove lynx`
* Tree → `sudo apt remove tree`
* Zsh → `sudo apt remove zsh`
* Gcc → `sudo apt remove gcc` et `sudo apt remove gcc-9-base` pas le 10
Puis petit `sudo apt autoremove` des familles pour mettre tout ça en ordre.
### 6. Séparer les tâches
#### 1. Créer un compte utilisateur non privilégié publie qui ait le droit d'arrêter et de relancer le serveur web (utiliser sudo)
Création du nouvel utilisateur : `useradd publie`.
Il faut modifier les deux lignes suivantes dans le fichier `/etc/sudoers` comme suit :
```bash=
Cmnd_Alias APACHE=/usr/sbin/apache2ctl
````
```bash=
publie ALL=APACHE
```
#### 2. Créer un compte utilisateur non privilégié edite qui ait le droit de modifier la page web (contenant le formulaire PHP)
Création du nouvel utilisateur : `useradd edite`.
Cet utilisateur doit être le propriétaire de `/var/www/html`. Pour se faire on se connecte à `edite` et on tape :
```bash=
sudo chown www-data.www-data -R /var/www/html # www-data devient propriétaire
sudo chown www-data.www-data -R /var/www/html/*
```
Puis on ajoute `edite` au groupe `www-data` :
```bash=
sudo usermod -a -G www-data edite # edite appartient au groupe www-data
```
`usermod` : Modifie un compte utilisateur
#### 3. Créer un compte utilisateur controle en cage (avec chroot), qui ait uniquement le droit d'afficher les processus en cours d'exécution (GI04 et plus uniquement)
Création du dossier `/var/isoler`, et des sous dossier `/var/isoler/bin`, `/var/isoler/lib/x86_64-linux-gnu`, `/var/isoler/lib64`
```bash=
mkdir /var/isoler/bin /var/isoler/lib/x86_64-linux-gnu /var/isoler/lib64`
```
Il faut maintenant copier les commandes `bash`, `ls`, `ps`, `grep` dans `/var/isoler/bin`.
**Détail de la procédure pour la commande `ls`** (il suffit de faire la même chose pour les trois autres commandes)
Copie de `ls` dans `/var/isoler/bin` : `cp /usr/bin/ls /var/isoler/bin/`.
On cherche ensuite les dépendances de la commande `ls` :
```bash=
etu@vm-web-RB isoler → ldd bin/ls
linux-vdso.so.1 (0x00007fffc010e000)
libselinux.so.1 => /lib/x86_64-linux-gnu/libselinux.so.1 (0x00007f35e9cb6000)
libc.so.6 => /lib/x86_64-linux-gnu/libc.so.6 (0x00007f35e9ac4000)
libpcre2-8.so.0 => /lib/x86_64-linux-gnu/libpcre2-8.so.0 (0x00007f35e9a34000)
libdl.so.2 => /lib/x86_64-linux-gnu/libdl.so.2 (0x00007f35e9a2e000)
/lib64/ld-linux-x86-64.so.2 (0x00007f35e9d10000)
libpthread.so.0 => /lib/x86_64-linux-gnu/libpthread.so.0 (0x00007f35e9a0b000)
```
Et on copie ces dépendances dans `/var/lib/x86_64-linux-gnu` ou dans `/var/lib64`.
Ajout du périphérique null (voir ce lien https://fr.wikipedia.org/wiki/P%C3%A9riph%C3%A9rique_nul) :
```bash=
mkdir /var/isoler/dev
mknod /var/isoler/dev/null c 1 3
test : ls bin toto 2> /dev/null # n'affiche rien
```
`mknod` : Créer des fichiers spéciaux
Ajout du systeme de fichier proc qui permet l’execution de la commande `ps` (https://www.linuxpedia.fr/doku.php/repertoire/proc) :
```bash=
mkdir /var/isoler/proc
mount --bind /proc /var/isoler/proc
```
`ps`fonctionne alors dans l'environnement isolé.
Création du script de lancement du shell isolé `/usr/local/bin/isoler.sh` :
```shell=
#!/bin/bash
echo "Shell de controle isolé (ls/grep/ps)"
/usr/sbin/chroot /var/isoler/ /bin/bash
```
Pour exécuter le script on modifie ses droits `sudo chmod a-x,o+x isoler.sh` (on ajoute le droit d'exécution pour l’utilisateur et retrait du droit d'exécution pour le groupe et les autres). Et finalement on ajoute le setuid bit `chmod u-s isoler.sh`.
Création du user controle :
`useradd controle -d /var/isoler -s /usr/local/bin/isoler.sh`.
Ajout du mot de passe à controle : `sudo passwd controle`.
Au final, on obtient l'environnement suivant :
```bash=
etu@vm-web-RB isoler → tree
.
├── bin
│ ├── bash
│ ├── grep
│ ├── ls
│ └── ps
├── dev
│ └── null
├── lib
│ └── x86_64-linux-gnu
│ ├── libc.so.6
│ ├── libdl.so.2
│ ├── libgcrypt.so.20
│ ├── libgpg-error.so.0
│ ├── liblz4.so.1
│ ├── liblzma.so.5
│ ├── libpcre.so.3
│ ├── libpcre2-8.so.0
│ ├── libprocps.so.8
│ ├── libpthread.so.0
│ ├── librt.so.1
│ ├── libselinux.so.1
│ ├── libsystemd.so.0
│ └── libtinfo.so.6
├── lib64
│ └── ld-linux-x86-64.so.2
└── proc
```
#### 4. S'assurer qu'il n'y ait pas d'utilisateurs inutiles
À l'aide de la commande `compgen -u` on liste les utilisateurs présents sur la machine afin de contrôler qu'il n'y en ait pas d'inutile
### 7. Séparation des espaces de stockage et montage restrictif (GI04 et plus uniquement)
#### 1. Réaliser un snapshot de votre machine virtuelle avant cette étape.
Sur l'interface en ligne de Proxmox → nom-de-la-vm → Snapshots → Take Snapshot.
Permet de rolback à tout moment et de revenir à l'état de la VM lors du snapshot si la VM est cassée avec les manipulations qui suivent.
#### 2. Ajouter un disque dur (ajuster la taille pour limiter l'encombrement sur Proxmox sans gêner le fonctionnement prévu de la VM)
Proxmox → vm-web → Hardware → add → Hard disk → Storage SAS + Disk Size
Mise en place d'un disk de 8Go (4Go par partition). Sachant que la taille du `/home` peut être limitée a 500Mo (voir moins) et celle de `/var` à 1Go (`/var` étant dynamique et imposant). Le choix du 8Go a été fait pour être serein pour les prochains projets.
#### 3. Repérer au démarrage le nouveau périphérique avec dmesg
`dmesg` : Commande qui affiche la mémoire tampon de message du noyau.
```bash=
dmesg | grep sdb
```
Pas simple à repérer sauf si on connaît déjà le nom du disk preférer la commande suivante :
```bash=
sudo fdisk -l
```
On obtient le résultat suivant :
```bash=
Disk /dev/sda: 32 GiB, 34359738368 bytes, 67108864 sectors
Disk model: QEMU HARDDISK
Units: sectors of 1 * 512 = 512 bytes
Sector size (logical/physical): 512 bytes / 512 bytes
I/O size (minimum/optimal): 512 bytes / 512 bytes
Disklabel type: gpt
Disk identifier: 82969DBC-C090-4744-BCFD-9B7A6B3FD34C
Device Start End Sectors Size Type
/dev/sda1 2048 4095 2048 1M BIOS boot
/dev/sda2 4096 2101247 2097152 1G Linux filesystem
/dev/sda3 2101248 67106815 65005568 31G Linux filesystem
Disk /dev/sdb: 8 GiB, 8589934592 bytes, 16777216 sectors
Disk model: QEMU HARDDISK
Units: sectors of 1 * 512 = 512 bytes
Sector size (logical/physical): 512 bytes / 512 bytes
I/O size (minimum/optimal): 512 bytes / 512 bytes
Disklabel type: dos
Disk identifier: 0xef8a20df
```
On repère facilement ici notre second disque `sdb` qui vient d'être ajouté
`fdisk` : permet de manipuler les tables de partitions. Il permet de créer, de supprimer, de lister les partitions sur un disque dur.
#### 4. Partitionner ce nouveau disque avec fdisk en créant deux partitions : `/var` et `/home`.
```bash=
fdisk /dev/sdb
```
→ permet de rajouter des partitions sur un disque (sudo)
En exemple, sur le disque `/dev/sda` :
```bash=
etu@vm-web:// $ sudo fdisk /dev/sda
Welcome to fdisk (util-linux 2.34).
Changes will remain in memory only, until you decide to write them.
Be careful before using the write command.
Command (m for help): n #Ajout d'une partiton
Partition number (4-128, default 4):
First sector (34-67108830, default 67106816):
Last sector, +/-sectors or +/-size{K,M,G,T,P} (67106816-67108830, default 67108830):
Created a new partition 4 of type 'Linux filesystem' and of size 1007.5 KiB.
Command (m for help): #w pour valider les modifications
```
#### 5. Dans chacune des partitions, créer un système de fichier ext4 avec fsck.ext4
N'ayant pas réussi à utiliser `fsck`, nous avons utilisé l'outil `mkfs`.
`fsck` : contrôle de l'intégrité et réparation de fichers système
`mksf` : créer un système de fichiers Linux
Création d'un système de fichier pour les disques sdb1 et sdb2 au format ext4 :
```bash=
sudo mkfs.ext4 /dev/sdb1
sudo mkfs.ext4 /dev/sdb2
```
Nous pouvons donc constater avec la commande `blkid` que le système de fichier de `/dev/sdb1` et `/dev/sdb2` sont ext4 :
```bash=
etu@vm-web:~ $ blkid
/dev/sda2: UUID="5d5a6eda-ac9a-448f-bc27-e1e460f7ea2d" TYPE="ext4" PARTUUID="13a95a6d-79af-40f0-8e7d-e1dc8061ced3"
/dev/sda3: UUID="jQY86v-Zig9-ElRh-cNKl-KdPR-dUrq-QDo5cy" TYPE="LVM2_member" PARTUUID="7964c78a-a601-47e8-bbfc-dfa8df362b7c"
/dev/sdb1: UUID="372d4142-2f14-47d3-926c-0e1679394d13" TYPE="ext4" PARTUUID="ef8a20df-01"
/dev/sdb2: UUID="ba0150f4-716c-4b9c-b8bc-7975522a756d" TYPE="ext4" PARTUUID="ef8a20df-02"
/dev/mapper/ubuntu--vg-ubuntu--lv: UUID="5a4baa97-3452-402e-be63-e0da469e08e0" TYPE="ext4"
```
#### 6. Monter temporairement ces partitions et y copier les contenus des répertoires actuels /var et /home.
Création de répertoires qui nous servira de point de montage au dossier /var et /home :
```bash=
etu@vm-web:~ $ sudo mkdir /mnt/new_home /mnt/new_var
```
Montage des partition sur les points de montages (le flag -t permet de préciser le type de filesystem) :
```bash=
etu@vm-web:~ $ sudo mount -t ext4 /dev/sdb1 /mnt/new_home
etu@vm-web:~ $ sudo mount -t ext4 /dev/sdb2 /mnt/new_var
```
Note : `df -h` permet de constater que les partitions sdb1 et sdb2 sont respectivement montées sur `/mnt/new_home` et `/mnt/new_var`
Copie des répertoires `/home` et `/var` dans `/mnt/new_home` et `/mnt/new_var` :
```bash=
etu@vm-web:~ $ sudo cp -r /home/. /mnt/new_home
etu@vm-web:~ $ sudo cp -r /var/. /mnt/new_var
```
#### 7. Modifier /etc/fstab de sorte que ces deux nouvelles partitions soient utilisées à la place des répertoires actuels /var et /home du premier disque. Utiliser les options de montage nosuid, nodev, noexec
Modification du fichier fstab : il contient une liste des disques utilisés au démarrage et des partitions de ces disques.
Ajout de nos deux partitions à monter à chaque démarrage du système :
* On recupére l’UUID des partitions (id) :
```bash=
blkid /dev/sdb1 ou blkid /dev/sdb1 >> /etc/fstab
blkid /dev/sdb2 ou blkid /dev/sdb2 >> /etc/fstab
```
* Edition du fichier fstab :
```bash=
vi /etc/fstab
```
* Ajout des ligne suivante :
```bash=
UUID=372d4142-2f14-47d3-926c-0e1679394d13 /home ext4 defaults 0 2
UUID=ba0150f4-716c-4b9c-b8bc-7975522a756d /var ext4 defaults 0 2
```
* Reboot de la machine + verif des partitions avec `df -h` :
```bash=
/dev/sdb1 3.9G 57M 3.7G 2% /home
/dev/sdb2 3.9G 521M 3.2G 14% /var
```
Note : les disques sdb1 et sdb2 sont désormais monté sur `/home` et `/var` au lieux de `/mnt/new_home` et `/mnt/new_var`
## Clients web
### 1. Configuration réseau
#### 1. Elles ne disposent que d'une seule interface réseau
* La vm-cli-int ne dispose que de l'interface ens19 de type vmbr0.
* La vm-cli-ext ne dispose que de l'interface ens18 de type vmbr2.
#### 2. vm-cli-int doit pouvoir communiquer avec vm-web mais pas avec vm-cli-ext
C'est vérifié car ces deux VMs ne sont pas connectées à vm-web par la même interface. De plus, puisque nous avons interdit le routage entre les deux interfaces réseaux (grâce à `net.ipv4.ip_forward`), les deux VM clientes ne peuvent communiquer entre elles.
Définition : "L'IP forwarding permet à un système d'exploitation (ici Linux) de faire suivre des paquets comme le fait un routeur ou plus généralement de les router au travers d'autres réseaux"
#### 3. vm-cli-ext doit pouvoir communiquer avec vm-web mais pas avec vm-cli-int
Même réponse.
### 2. Supprimer tous les services non indispensables sur ces clients (Apache...)
```bash=
sudo apt-get remove apache
```
### 3. Installer lynx pour disposer d'un navigateur web léger
```bash=
sudo apt-get install lynx
```
### 4. Tester les accès au serveur Apache de vm-web via le formulaire
## Surveillance du serveur web
### 1. Surveillance des log Apache
#### 1. Se connecter sur vm-web depuis vm-cli-int et visualiser les logs du serveur Apache (cf. commande tail -f et répertoire /var/log/apache2 )
Pour se connecter a la vm-cli-int :
```bash=
ssh 10.10.10.201 ou ssh vm-cli-int
Password :
```
Pour se connecter à la vm-web depuis vm-cli-int :
```bash=
ssh 10.10.10.183 ou ssh vm-web
Password :
```
`tail` : affiche, ou imprime, les 10 dernières lignes du fichier qui lui a été donné via l’entrée standard et délivre le résultat dans la sortie standard.
`-f` : examine un fichier à la recherche de variations
```bash=
root@vm-web:/var/log/apache2# tail -f access.log
172.30.215.22 - - [24/Apr/2021:09:32:26 +0000] "POST /formulaire.php HTTP/1.1" 200 346 "http://172.23.3.31/" "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/90.0.4430.85 Safari/537.36"
172.30.213.122 - - [24/Apr/2021:09:34:23 +0000] "GET / HTTP/1.1" 200 578 "-" "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/90.0.4430.85 Safari/537.36"
172.30.213.122 - - [24/Apr/2021:09:34:29 +0000] "POST /formulaire.php HTTP/1.1" 200 265 "http://172.23.3.31/" "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/90.0.4430.85 Safari/537.36"
172.30.215.22 - - [24/Apr/2021:09:52:46 +0000] "GET / HTTP/1.1" 200 578 "-" "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/90.0.4430.85 Safari/537.36"
172.30.215.22 - - [24/Apr/2021:09:52:53 +0000] "POST /formulaire.php HTTP/1.1" 200 339 "http://172.23.3.31/" "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/90.0.4430.85 Safari/537.36"
10.10.10.201 - - [24/Apr/2021:10:13:14 +0000] "GET / HTTP/1.0" 200 541 "-" "Lynx/2.9.0dev.5 libwww-FM/2.14 SSL-MM/1.4.1 GNUTLS/3.6.13"
172.23.3.184 - - [24/Apr/2021:10:16:34 +0000] "GET / HTTP/1.0" 200 541 "-" "Lynx/2.9.0dev.5 libwww-FM/2.14 SSL-MM/1.4.1 GNUTLS/3.6.13"
172.23.3.184 - - [24/Apr/2021:10:16:43 +0000] "GET / HTTP/1.0" 200 541 "-" "Lynx/2.9.0dev.5 libwww-FM/2.14 SSL-MM/1.4.1 GNUTLS/3.6.13"
172.23.3.184 - - [24/Apr/2021:10:16:44 +0000] "GET / HTTP/1.0" 200 541 "-" "Lynx/2.9.0dev.5 libwww-FM/2.14 SSL-MM/1.4.1 GNUTLS/3.6.13"
10.10.10.201 - - [24/Apr/2021:10:19:48 +0000] "GET / HTTP/1.0" 200 541 "-" "Lynx/2.9.0dev.5 libwww-FM/2.14 SSL-MM/1.4.1 GNUTLS/3.6.13"
```
#### 2. Depuis vm-cli-ext, se connecter au serveur web de vm-web
Plusieurs type de log : Access.log / error.log
Connexion à la page :
```bash=
172.23.3.184 - - [24/Apr/2021:12:14:23 +0000] "GET / HTTP/1.0" 200 541 "-" "Lynx/2.9.0dev.5 libwww-FM/2.14 SSL-MM/1.4.1 GNUTLS/3.6.13"
```
Envoi du formulaire :
```bash=
172.23.3.184 - - [24/Apr/2021:12:18:56 +0000] "POST /formulaire.php HTTP/1.0" 200 294 "http://172.23.3.31/" "Lynx/2.9.0dev.5 libwww-FM/2.14 SSL-MM/1.4.1 GNUTLS/3.6.13"
```
#### 3. Expliquer les logs Apache obtenus.
IP : - : utlisateur si document protégé (ici non donc -) : Heure/Date : Requête Client (Methode + Ressource + Protocole) : code de statut (réponse) : taille de l'objet retourné : adresse : infos navigateur
### 2. Capture de trafic (GI04 uniquement)
#### 1. Capturer le trafic sur l'interface réseau de vm-web qui est connectée à vmbr2 avec tcpdump
On utilise pour cela la commande `sudo tcpdump -i ens18 -s 1500 port not 22`. L'argument `port not 22` permet de spécifier que nous ne voulons pas capturer le trafic des connections SSH que nous utilisons pour nous connecter à nos VMs.
#### 2. Renvoyer ce trafic sur une machine graphique disposant de wireshark
Pour ce faire nous avons installé Wireshark sur nos machines.
Dans le terminal de la vm-web, nous avons lancé la commande
```bash=
sudo tcpdump -s0 -n -U -w - -i ens18 'not port 3000 and not port 22' | nc -k -l 3000
```
Elle nous permet de capturer le trafic de l'interface ens18 à l'aide de `tcpdump`. Les options `-s0 -n -U -w` permettent de formater les messages capturés afin de les rendre lisibles par Wireshark.
Les options `not port 3000 and not port 22` permettent de spécifier à `tcpdump` qu'il ne doit pas capturer le trafic de ces deux ports : en effet, le port 22 sert aux communications SSH que nous utilisons pour accéder à nos VMs ; et le port 3000 est celui utilisé par la communication Netcat. Ces deux ports sont donc chargés de trafic qui agirait comme du bruit pour notre capture.
Sur nos machines, nous avons lancé la commande
```bash=
nc 172.23.3.31 3000 | wireshark -k -i -
```
Celle-ci nous permet de nous connecter au canal de communication Netcat sur le port 3000 de la vm-web afin récupérer le trafic capturé par `tcpdump`. Puis ce trafic est redirigé vers Wireshark.
#### 3. Expliquer les échanges réseau
On voit bien qu'il y a différents échanges entre notre serveur et notre client pour une seule requête. On suppose qu'il y a des echanges `TCP` de connexion et d'information ainsi que des requêtes `HTTP` qui correspondent aux échangent sur notre site internet.
Remarque prof :
Desintaller Nmap pour vm-web
Stockage de data.txt
Google Drive
Gist
Clipboard
Sign in with Wallet
