# Authentification avec Passport.js

Passport.js est un middleware permettant de gérer l'authentification. Il s'intègre très bien avec Express.js. L'authentification est le processus de vérification qu'un utilisateur est bien celui qu'il prétend être.

Notre système d'authentification utilisera un JSON web token.

## Comprendre ce qu'est un JSON web token (JWT)

Un JWT permet à un utilisateur de certifier certaines informations. Il est composé de 3 parties:

- le header
- le payload
- la signature

Chacune de ces parties est séparée par une point.

```
header.payload.signature
```

Exemple de JWT:

```
eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiaWF0IjoxNTE2MjM5MDIyfQ.SflKxwRJSMeKKF2QT4fwpMeJf36POk6yJV_adQssw5c
```

- le header contient les informations liées au JWT, et particulièrement l'algorithme utilisé pour signer le JWT. (encodé en base64)
- le paylad contient les informations certifiées par le JWT. Par exemple, je suis le user ABC. (encodé en base64)
- la signature correspond à la concaténation du header et du payload encodé en base64, puis signé avec l'algorithme du header et un secret (ou une clé privée).

Ces informations sont ensuite misent bout à bout comme ci-dessus et constitue le JWT.

## Sécurité

Le JWT n'assure aucune sécurité au niveau de vos données qui sont dans le payload. **Aucune**. Le payload est **encodé** en base64 pour qu'il puisse être transmit plus facilement, mais peut être décodé. Le payload et le header sont **signés** pour permettre à un système de vérification de l'authenticité de vos "prétentions" (je suis le user ABC). Le JWT n'est **pas encrypté**, et donc vos données sont **lisibles**.

## La vérification du JWT

Il y a 2 types d'algorithmes pour les JWTs.

- les algorithmes dit symétrique (que nous utiliserons dans ce TP), c'est à dire que l'on utilise la même information pour signer et pour vérifier la signature. On l'appelle le `secret`.
- les algorithmes dit asymétrique, qui utilise deux informations différentes, une pour signé (la clé privée), et une pour vérifier la signature (la clé publique).

L'avantage des algorithmes asymétriques est qu'ils permettent à une application de vérifier l'identité d'un utilisateur sans pouvoir créer de JWT.

Dans notre cas, nous avons un `secret`. Le JWT que l'utilisateur nous envoie contient les 3 parties `header.payload.signature`. Pour vérifier que le JWT est valide, nous allons signer à nouveau la partie `header.payload` et vérifier que la signature obtenu est bien la même. Si c'est bien le cas, le JWT est considéré comme valide et le serveur peut faire confiance aux informations du payload.

## Mettre en place un système d'authentification avec Passport.js

### Dépendances

Passport.js utilise des `strategies` pour authentifier ses utilisateurs. Une stratégie peut par exemple être d'aller chercher un utilisateur dans une base de données pour vérifier son existance, et une autre d'appeler une API pour vérifier un user.

Dans notre cas notre stratégie sera de faire de la vérification de JWT, nous allons donc installer les dépendances correspondantes. Créez un nouveau dossier avec un fichier index.js puis:

```
npm init -y
npm install express --save
npm install jsonwebtoken --save
npm install passport --save
npm install passport-jwt --save
```

### Génération du JWT

nous allons créer une application express simple:

```js
const express = require('express')

const app = express()

app.get('/public', (req, res) => {
  res.send('I am public folks!')
})

app.get('/private', (req, res) => {
  res.send('Hello XXX')
})

app.post('/login', (req, res) => {
  res.json({
    jwt: '' // TODO
  })
})

app.listen(3000, () => {
  console.log('app running on port 3000')
})
```

**Exercice 1:** Grâce à la librairie `jsonwebotken` que vous avez installé, renvoyez un JWT contenant le payload:

```js
{
  test: 'jwt'
}
```

Ce JWT doit être signé avec l'algorithme HS256, un algorithme symétrique.

**Exercice 2:** Ajoutez un tableau d'utilisateurs prédéfinis (email-password), et faîtes en sorte que, lors d'un login, votre fonction récupère dans le body les informations de login et vérifie ces informations dans le tableau. Elle renvoie le JWT d'un user avec le payload suivant en cas de succès:

```js
{
  user: 'email@goes.here'
}
```

et renvoie une erreur si l'utilisateur ou le mot de passe ne correspondent pas.

### Envoie et vérification du JWT

Le but de cet exercice va être d'utiliser le middleware passport et la stratégie passport-jwt pour vérifier le jwt d'un user dans les routes réservées aux utilisateurs.

**Exercice 3:** Ajoutez le middleware passport ainsi que la stratégie JWT afin de vérifier qu'un utilisateur est valide quand il fournit son JWT pour accéder à la route `/private`. La route doit répondre 'Hello ADRESSE-EMAIL'.

Note: Pour pouvoir tester votre route, il faut envoyer votre JWT dans une header:

```
Authorization: 'Bearer VOTREJWTICI'
```

Vous pouvez faire ça avec postman dans la section header.