# Démonstration : sécurisation des mots de passe (MD5 vs Argon2)

## Objectif

Comprendre pourquoi les algorithmes de hachage rapides comme MD5 ne doivent **jamais** être utilisés pour stocker des mots de passe. Implémenter la méthode moderne et sécurisée, **Argon2id**, de manière asynchrone pour ne pas bloquer le serveur.

Nous allons utiliser le routeur `routes/users.js` de notre application Express.

Voici un aperçu du flux général de l'application utilisateur → serveur :

```mermaid
flowchart TD
    client["client http"]
    router["routes /users"]
    md5["route /users/register-bad hash md5"]
    argon["route /users/register-good hash argon2id"]

    client --> router
    router --> md5
    router --> argon
```

---

### Étape 1 : L'erreur (MD5) - ne faites pas ça ! (register)

L'objectif ici est de simuler ce qu'il ne faut **pas** faire.

Ouvrez le fichier `routes/users.js` et constatez que la route `POST /users/register-bad` est déjà créée pour vous.

Elle utilise l'algorithme de hachage MD5, qui est **inadapté** pour les mots de passe :

```javascript
// Indice pour le hachage MD5
const hash = crypto.createHash('md5').update(password).digest('hex');
```

### Étape 2 : La preuve du danger (register)

1. Démarrez votre serveur Express :
    ```bash
    nodemon ./bin/www
    ```
1.  Avec un outil comme Postman, faites un appel `POST` sur `http://localhost:3000/users/register-bad` avec le JSON suivant :
    ```json
    {
      "username": "testeur",
      "password": "123456"
    }
    ```
2.  **Notez le hash renvoyé.** (Il devrait être `e10adc3949ba59abbe56e057f20f883e`. Vous pouvez le confirmer également via ce site : https://www.md5hashgenerator.com/).
3.  Allez sur le site [crackstation.net](https://crackstation.net/).
4.  Collez ce hash dans leur outil. Que se passe-t-il ?


---

### Étape 3 : la correction (Argon2id Asynchrone)

Maintenant, implémentons la bonne pratique. Argon2 est conçu pour être lent et gourmand en mémoire, le rendant résistant aux attaques. Nous devons **absolument** l'utiliser en asynchrone pour ne pas bloquer le *thread* principal de Node.js.

1.  Installez la bibliothèque recommandée :
    ```bash
    npm install argon2
    ```
2.  Dans `routes/users.js`, importez `argon2` :
    ```javascript
    const argon2 = require('argon2');
    ```
3.  Complétez la route `POST /users/register-good` :
    * Cette route **doit** être `async`.
    * Récupérez `username` et `password` depuis `req.body`.
    * Utilisez `await argon2.hash(...)` pour hacher le mot de passe.
    * Utilisez un bloc `try...catch` pour gérer les erreurs de hachage.
    * Renvoie le nouveau hachage sécurisé.

```mermaid
sequenceDiagram
    participant c as client
    participant u as route /register-good
    participant a as argon2id

    c->>u: envoie username + password
    u->>a: "hash du mot de passe"
    a-->>u: "hash argon2id"
    u-->>c: "hash retourné"
```


### Étape 4 : la vérification (login)

Pour un cycle complet, testez les routes de connexion suivantes :

1.  `POST /users/login-bad` :
    * Récupère le mot de passe, le hache en MD5.
    * Compare le hash obtenu avec un hash "stocké" (ex: `e10adc3949ba59abbe56e057f20f883e`).
    * *Problème :* C'est une simple comparaison de chaînes de caractères.

2.  `POST /users/login-good` : implémentation à faire !
    * Route `async`.
    * Récupère le hash "stocké" (celui de l'étape 3) et le mot de passe de la tentative.
    * Utilise `await argon2.verify(hashStocke, motDePasseTentative)`.
    * Cette fonction renvoie `true` ou `false`.

```mermaid
sequenceDiagram
    participant c as client
    participant u as route /login-good
    participant a as argon2id

    c->>u: envoie password
    u->>a: "verification du mot de passe"
    a-->>u: "true ou false"
    u-->>c: resultat authentification
```