*Le projet :*
-------------

Ce tp est la continuation du tp1, il a pour but d'installer avec une machine virtuelle (Virtual Box) de type Amd64 un serveur Linux avec la distribution stable GNU / Linux Debian 9 « Stretch », que nous allons configurer tout au long de l'installation. Par la suite l'installation et la configuration de ssh vont être nécessaire afin de pouvoir connecter un root distant à la machine.

*Connection SSH Root :*
-----------------------

Pour cela, nous nous connectons à notre machine une fois celle-ci opérationnelle. Nous installons ssh grâce aux commandes suivantes :
```apt-get search ssh``` permet de chercher les paquets, ```apt-get install ssh``` permettant l'installation des paquets.

Il faut par la suite procéder à la configuration ssh disponible avec le chemin d'accès suivant :
```cd etc/ssh``` puis ```vim sshd_config``` (vim doit être installé grâce à la commande suivante ```apt-get install vim```

Puis modifier la ligne ```PermitRootLogin prohibit-password``` en ```PermitRootLogin yes```, il faut également ne pas oublier de décommenter la ligne afin que celle-ci soit prise en compte.

Après avoir changé la configuration ssh, nous passons à la connexion.

Plusieurs options s'offrent à nous :

* **forced-commands-only** qui n’autorise la connexion root qu'avec l'utilisation de clés dont l’option **command** est définie.

* **no** pour que le root ne puisse pas se connecter à la machine.

* **without-password** pour une connexion à la machine sans mot de passe.


*Authentification et génération de clefs :*
-------------------------------------------

Afin de générer une clé RSA j'utilise la commande suivante : ```ssh-keygen -t rsa```

*J'ai par la suite obtenu la clé suivante :* ```tMBlykX539uuGYgd6gJJlvWtQWAGVSwwSPnbRprdtbc``` que je peux retrouver dans le dossier ```/.ssh```.

Une **passphrase** est une petite phrase comprenant plusieurs mots dîte "sécurisé à vie" et facile à retenir. Cependant

*Authentification par clef / Connection serveur :*
--------------------------------------------------

Par la suite, je sauvegarde la clé publique sur mon fichier authorized-keys présent dans le dossier **.ssh** grâce à la commande : ```cat id_rsa.pub | ssh root@134.157.46.182 "cat > ~/.ssh/authorized_keys"```

Afin de donner les droits de Lecture/Ecriture/Execution j'utilise la commande ```chmod 700 authorized_keys```, je peux après cela, remarquer que l'utilisateur possède les droits rwx.

*Authentification par clef : sous Windows :*
--------------------------------------------

On modifie tout d'abord la valeur de **PermitRootLogin** a ```without-password``` puis on se connecte avec la commande ```ssh -i .ssh/id_rsa root@134.157.46.182```.

*Exercice : Securisez :*
------------------------

Afin de sécuriser l'accès à la machine contre plusieurs tentatives infructueuses, j'utilise **fail2ban**. Après un certain nombre de tentatives, l'adresse ip de la personne ayant obtenu un grand nombre d'échec est bannie.

Les attaques de type **brute-force ssh** consistent à essayer toutes sortes de combinaisons de clé possibles, ce qui est nuisible pour le serveur.

Nous pouvons également sécuriser l'accès à la machine avec les méthodes suivantes :

*  Modifier la valeur de la ligne ```MaxAuthTries``` du fichier **sshd-config** afin de limiter les tentatives de connexion sur un nombre précis. (Même système que fail2ban).

*  L'utilisation d'un pare feu SSH.


*Etude des processus UNIX :*
----------------------------

* L'information **TIME** montre le temps processeur qui a été nécessaire à l'exécution de ce processus.

* Le processus ayant le plus utilisé le le processeur sur la machine est : ```-bash```.

* Le processus ayant été le premier lancé après le démarrage du système est : ```/bin/login```.

* La machine a été démarrer à 14:09 avec la commande ```ps u ou ps -ef```.

* Le nombre approximatif de processus créés depuis le démarrage **boot** est de 115 avec la commande ```ps aux```.


La commande ```ps -o ppid= -p [num_PID]``` permet d'afficher le PPID d'un processus.

Il apparaît avec la commande ps la liste des processus qui sont :

* /bin/login
* -bash
* ps all

Avec la commande ```pstree``` que l'on installe avec ```apt-get install psmisc``` on obtient la liste ordonnée de tous les processus ancêtres de la commande ps en cours d'exécution :
```
   systemd─┬─cron
           ├─dbus-daemon
           ├─dhclient
           ├─fail2ban-server---2[fail2ban-server]
           ├─login──bash──pstree
           ├─rsyslogd├─in:imklog
                     ├─in:imuxsock
                     ├─rs:main Q:Reg
           ├─sshd
           ├─systemd────(sd-pam)
           ├─systemd─journal
           ├─systemd─logind
           ├─systemd─timesyn────[sd-resolve]
           ├─systemd─udevd
```

La commande ```top``` permet d'afficher les processus en fonction de la mémoire.

Le plus gros processus sur ma machine correspond à **sshd**

Il existe plusieurs commandes interactives permettant de :

*  Passer en couleur avec ```z```.

*  Mettre en avant la colonne de trie avec ```x```.

*  Changer la colonne de trie avec ```<``` et ```>```.

Afin d'utiliser htop il faut tout d'abord l'installer avec la commande : ```apt-get install htop```

Par la suite, on peut remarquer que **htop** possède une interface en couleur et une structure plus simple, ce qui permet une meilleure visibilité et une compréhension plus simple.

*Arrêt d'un processus :*
----------------------

Un script shell permet d'automatiser une série d'opérations

Je crée un fichier **date.sh** avec la commande ```touch date.sh``` puis je l'édite avec ```vim date.sh```

J'accorde les permissions utilisateur sur le fichier avec la commande ```chmod 700 ./date.sh```

Par la suite, j'exécute le fichier en faisant ```./date.sh``` puis ```CTRL+Z```

Cela m'affiche :

```
date16:42:22
date16:42:23
date16:42:24
date16:42:25
date16:42:26
^Z
[1] + Stoppé
```

Concernant le fichier **date-toto.sh**, il affiche la date mais 5 heures auparavant, on a donc :

```
date11:53:08
date11:53:09
date11:53:10
date11:53:11
^Z
[2] + Stoppé
```
Avec la commande ```kill [ %kill_id ]``` et ```fg [ %job_id ]``` permet d'exécuter un script arrêter.

La commande ```CTRL -C``` permet de mettre fin à un script.

```
[1] Stoppé ./date.sh
[2]-Stoppé ./date-toto.sh
```

La commande ```ps``` affiche les différentes exécutions des fichiers qui ont eu lieu.

**Explications des scripts**

Le script **date.sh**

*  La première ligne **#!/bin/sh** indique au shell quel interpréteur doit être utilisé pour exécuter le script.

*  **La boucle while** true permet d'exécuter indéfiniment le script.

*  **do sleep 1** permet d'attendre le laps de temps passer en paramètre (ici 1)

*  **echo -n 'date; date +%T** affiche la date actuelle, et uniquement l'heure.

Le script **date-toto.sh**

*  Il s'agit du même script que pour **date.sh**, seulement ici, la date afficher est la date actuelle avec -5 heures produit par le bout de script suivant : ```date --date '5 hour ago'```


*Les tubes :*
------------

**cat** permet d'afficher le contenu d'un fichier tandis que **tee**  permet de lire sur l'entrée standard et écrire sur la sortie standard.

```ls | cat``` affiche les fichiers sous forme de liste.

```ls -l | cat > liste``` déplace le contenu de la liste dans le fichier liste.

```ls -l | tee liste``` écrit la sortie dans le fichier liste.

```ls -l | tee liste | wc -l``` affiche le nombre de lignes générées par la commande ```ls -l```.


*Journal système rsylog :*
--------------------------

Oui, le service rsyslog est activé sur le système, on peut le voir avec la commande ```rsyslogd```.

Le PID du démon est ici de 390 présent dans le fichier ```rsyslogd.pid```.

Les messages issus des services standars sont écrit dans le fichier **syslog** présent dans **/var/log**.

**Le service CRON :**

Ce service permet de planifier des tâches qui seront exécutées à une heure précise.

La commande ```tail -f``` permet d'afficher les 10 dernières lignes d'un fichier.

Le fichier **/etc/logrotate.conf** permet de limiter la taille des fichiers.

Avec la commande ```dmesg``` j'obtient :

```IPv6: ADDRCONF (NETDEV_CHANGE): enp0s3```