---
# System prepended metadata

title: Notes du projet du module Risque - SR06

---

# 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 &rarr; directory puis read / write / execute &rarr; 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--` &rarr; `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 &rarr; `sudo apt remove telnet`et `sudo apt remove telnetd`
* Lynx &rarr; `sudo apt remove lynx`
* Tree &rarr; `sudo apt remove tree`
* Zsh &rarr; `sudo apt remove zsh`
* Gcc &rarr; `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 &rarr; nom-de-la-vm &rarr; Snapshots &rarr; 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 &rarr; vm-web &rarr; Hardware &rarr; add &rarr; Hard disk &rarr; 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
``` 
&rarr; 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
![Connexion au site web depuis la vm-cli-ext](https://i.imgur.com/zLywvfX.png)
![Connexion au site web depuis la vm-cli-int](https://i.imgur.com/AABYlen.png)





## 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. 
![Exemple de trafic intercepté puis visualisé sur wireshark](https://i.imgur.com/BEGvFPA.png)
![Ici on voit les données échangées](https://i.imgur.com/ZwPyiLV.png)

#### 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
