⚠️ Avant de commencer cette quête, on te recommande de jeter un coup d'œil à celle-ci :

Dans le monde réel, les APIs ont besoin d'un moyen d'authentifier les utilisateurs afin d'autoriser ou de restreindre certaines fonctionnalités (favoris, édition de profil...).

Afin d'authentifier les utilisateurs de notre service Web, ils doivent d'abord pouvoir s'enregistrer en saisissant des informations d'identification (e-mail/mot de passe) qu'ils pourront utiliser pour se connecter ultérieurement à l'application.

🤓 Dans cette quête, tu vas apprendre :

✅ Comment hasher un mot de passe ✅ Ajouter un middleware sur une route

⌨️ Mise en place

Si tu ne l'as pas déjà sur ta machine, clone ce dépôt et switch sur la branche express07.

Ouvre express_quests.sql. À ce stade, notre table users est déclarée ainsi :

// ...

CREATE TABLE users (
    id int primary key NOT NULL AUTO_INCREMENT,
    firstname varchar(255) NOT NULL,
    lastname varchar(255) NOT NULL,
    email varchar(255) UNIQUE NOT NULL,
    city varchar(255) DEFAULT NULL,
    language varchar(255) DEFAULT NULL
) ENGINE = InnoDB DEFAULT CHARSET = utf8;

// ...

Nous avons déjà un champ email que nous pouvons utiliser pour identifier une personne de façon unique plus tard lors de sa connexion. Mais nous n'avons pas encore de champ password...

Avant d'ajouter un champ password, lis cette ressource :

Comme tu l'as lu, le stockage de mots de passe en clair dans une base de données pose un énorme problème de sécurité.

Nous devrions plutôt hacher le mot de passe (transformer le mot de passe simple en charabia) avant de le stocker, afin qu'il soit inutilisable par les pirates si la base de données est compromise.

Ajoute la colonne hashedPassword dans ta table users et ajoute des exemples de mots de passe pour nos 6 membres :

// ...

CREATE TABLE users (
    id int primary key NOT NULL AUTO_INCREMENT,
    firstname varchar(255) NOT NULL,
    lastname varchar(255) NOT NULL,
    email varchar(255) UNIQUE NOT NULL,
    city varchar(255) DEFAULT NULL,
    language varchar(255) DEFAULT NULL,
    hashedPassword varchar(255) NOT NULL
) ENGINE = InnoDB DEFAULT CHARSET = utf8;

INSERT INTO
  users (firstname, lastname, email, city, language, hashedPassword)
VALUES
  (
    'John',
    'Doe',
    'john.doe@example.com',
    'Paris',
    'English',
    "$argon2id$v=19$m=16,t=2,p=1$emVmZXpmemZlemVmZWR6ZXplZg$rqZkhxu5YbqCGHPNrjJZpQ"
  ),(
    'Valeriy',
    'Appius',
    'valeriy.ppius@example.com',
    'Moscow',
    'Russian',
    '$argon2id$v=19$m=16,t=2,p=1$emVmemVmemZlemZ6ZnpmZQ$eSetR6KPUNAGW+q+wDadcw'
  ),(
    'Ralf',
    'Geronimo',
    'ralf.geronimo@example.com',
    'New York',
    'Italian',
    '$argon2id$v=19$m=16,t=2,p=1$emVmemVmemZlemZ6ZnpmZXphZGF6ZGQ$a0bg5DZB6H6v3jjQC81DXg'
  ),(
    'Maria',
    'Iskandar',
    'maria.iskandar@example.com',
    'New York',
    'German',
    '$argon2id$v=19$m=16,t=2,p=1$emVmemVmemZlenplZHpkZnpmemZlemFkYXpkZA$V1qAnJDyMuuWG7g9yoGYXA'
  ),(
    'Jane',
    'Doe',
    'jane.doe@example.com',
    'London',
    'English',
    '$argon2id$v=19$m=16,t=2,p=1$emVmemVmemZlenplZHpkZGZ6ZnpmZXphZGF6ZGQ$VCzq45PL9t8khtc44Kk5iw'
  ),(
    'Johanna',
    'Martino',
    'johanna.martino@example.com',
    'Milan',
    'Spanish',
    '$argon2id$v=19$m=16,t=2,p=1$emVmemVmemVmemZlenplZHpkZGZ6ZnpmZXphZGF6ZGQ$UKaGZ9hGFn/S5SBQDMe/Uw'
  );

// ...

Tu peux maintenant réinitialiser ta base de données à l'aide du script SQL. Connecte-toi à MySQL dans le dossier du projet, utilise ta base de données puis source le fichier comme ceci :

USE express_quests;
source express_quests.sql;

Utilisation d'un algorithme de hash dans Node.js

Il existe de nombreuses bibliothèques qui peuvent t'aider à hash un mot de passe, par exemple Scrypt ou Bcrypt. Mais puisque l'OWASP recommande l'algorithme Argon2, c'est celui que nous allons utiliser :

Commençons par installer le package :

npm i argon2

Nous voulons hacher le mot de passe avant d'insérer l'utilisateur dans la base de données. Une bonne idée ici est de s'appuyer sur l'architecture basée middleware d'Express : une route peut prendre plusieurs middlewares en paramètres. Tu as peut-être déjà vu un exemple de ce genre :

const step1 = (req, res, next) => {
  req.message = "I went through step1";
  next();
};

const step2 = (req, res, next) => {
  req.message += " and step2";
  next();
};

const lastStep = (req, res) => {
  res.send(req.message);
};

app.get("/justToTest", step1, step2, lastStep);

Ici step1, step2 et lastStep sont des middlewares, et seront exécutés l'un après l'autre au déclenchement de la route. La fonction next après les paramètres req et res est utilisée pour dire "J'ai fini ma partie, vous pouvez passer à la suivante". C'est une pratique courante d'utiliser req comme outil pour transmettre des données au middleware suivant. Dans cet exemple, step1 ajoute une propriété message à l'objet req avec une valeur initiale "I went through step1". Ensuite, step2 complète le message qui est finalement envoyé en réponse. Si tu essayais une requête sur cette route, elle répondrait "I went through step1 and step2".

Revenons à notre quête de hachage. Nous pouvons créer un middleware hashPassword (dans un fichier dédié auth.js pour garder la base de code bien organisée) et l'ajouter aux routes concernées par l'envoi de mot de passe à la base de donnée dans app.js :

• La route POST /api/users
• La route PUT /api/users/:id

Comme ceci :

// in auth.js

const argon2 = require("argon2");

const hashPassword = (req, res, next) => {
  // hash the password using argon2 then call next()
};

module.exports = {
  hashPassword,
};

// in app.js

const { hashPassword } = require("./auth.js");

app.post("/api/users", hashPassword, userHandlers.postUser);
app.put("/api/users/:id", hashPassword, userHandlers.updateUser);

Le middleware hashPassword ici sera exécuté en premier et préparera les données pour userHandlers.postUser et userHandlers.updateUser.

La documentation de argon2 (cette page en particulier) montre des exemples de code utilisant async/await :

const hashedPassword = await argon2.hash(password, hashingOptions);

Juste pour aider, un code équivalent en utilisant then/catch :

argon2
  .hash(password, hashingOptions)
  .then((hashedPassword) => {
    // do something with hashedPassword
  })
  .catch((err) => {
    // do something with err
  });

C'est à toi maintenant ! Essaie de compléter hashPassword à partir des instructions suivantes :

• OWASP recommande la configuration suivante pour Argon2 : "Utiliser Argon2id avec une configuration minimale de 15 Mio de mémoire, un nombre d'itérations de 2 et 1 degré de parallélisme".
• Tu dois récupérer le mot de passe à hacher à partir de req.body.password.
• Une fois que tu as obtenu la version hachée, utiliser console.log() pour l'afficher dans le terminal.
• Tu dois stocker le mot de passe haché dans req.body.hashedPassword.
• Pour t'assurer que le mot de passe en clair ne pourra plus être utilisé après ton middleware, supprime-le.

N'oublie pas : étape par étape ;)

Afficher la solution|||javascript|||Tu as des doutes sur comment faire ?|||0|||Masquer
const argon2 = require("argon2");

const hashingOptions = {
  type: argon2.argon2id,
  memoryCost: 2 ** 16,
  timeCost: 5,
  parallelism: 1,
};

const hashPassword = (req, res, next) => {
  argon2
    .hash(req.body.password, hashingOptions)
    .then((hashedPassword) => {
      console.log(hashedPassword);

      req.body.hashedPassword = hashedPassword;
      delete req.body.password;

      next();
    })
    .catch((err) => {
      console.error(err);
      res.sendStatus(500);
    });
};

module.exports = {
  hashPassword,
};

Essaie de POST un nouvel utilisateur (avec un mot de passe). Tu devrais voir quelque chose comme ça dans ta console :

$argon2id$v=19$m=65536,t=5,p=1$6F4WFjpSx9bSq9k4lp2fiQ$cjVgCHF/voka5bZI9YAainiaT+LkaQxfNN638b/h4fQ

Tu n'as probablement pas exactement la même chose et c'est parfaitement normal. Si tu déclenches la route à nouveau avec le même mot de passe, tu verras que le hachage produit est toujours différent, et c'est le but.

Tu peux supprimer le console.log() dans hashPassword() : ton middleware est prêt !

💪 Challenge

Tu as vu comment hacher un mot de passe via un middleware. Maintenant, les fonctions postUser et updateUser dans userHandlers.js devraient intégrer le mot de passe haché lors de leur exécution :

• Adapte les pour que le mot de passe haché soit envoyé dans la base de données.
• Vérifie (et corrige si nécessaire) les routes liées aux utilisateurs afin qu'elles n'envoient jamais le mot de passe (même haché) en dehors du serveur.

Héberge ton application améliorée sur GitHub et partage l'URL en solution.

🧐 Critères de validation

• [ ] L'application permet de poster et de mettre à jour un utilisateur avec un mot de passe
• [ ] Le mot de passe donné n'est pas stocké dans la base de données, mais un hachage du mot de passe est stocké à la place
• [ ] Les routes liées aux utilisateurs ne doivent renvoyer aucune information sensible (attention aux SELECT * ... !)

==$==

Ce que tu devrais avoir dans :

// ...

const userHandlers = require("./userHandlers");
const { hashPassword } = require("./auth");

app.get("/api/users", userHandlers.getUsers);
app.get("/api/users/:id", userHandlers.getUserById);
app.post("/api/users", hashPassword, userHandlers.postUser);
app.put("/api/users/:id", hashPassword, userHandlers.updateUser);
app.delete("/api/users/:id", userHandlers.deleteUser);

// ...

const argon2 = require("argon2");

const hashingOptions = {
  type: argon2.argon2id,
  memoryCost: 2 ** 16,
  timeCost: 5,
  parallelism: 1,
};

const hashPassword = (req, res, next) => {
  argon2
    .hash(req.body.password, hashingOptions)
    .then((hashedPassword) => {
      req.body.hashedPassword = hashedPassword;
      delete req.body.password;

      next();
    })
    .catch((err) => {
      console.error(err);
      res.sendStatus(500);
    });
};

module.exports = {
  hashPassword,
};

// ...

const getUsers = (req, res) => {
  const initialSql = "select id, firstname, lastname, email, city, language from users";
  const where = [];

  // ...

  database
    .query(
      where.reduce(
        (sql, { column, operator }, index) =>
          `${sql} ${index === 0 ? "where" : "and"} ${column} ${operator} ?`,
        initialSql
      ),
      where.map(({ value }) => value)
    )
    .then(([users]) => {
      res.json(users);
    })
    .catch((err) => {
      console.error(err);
      res.status(500).send("Error retrieving data from database");
    });
};

const getUserById = (req, res) => {
  const id = parseInt(req.params.id);

  database
    .query("select id, firstname, lastname, email, city, language from users where id = ?", [id])
    .then(([users]) => {
      if (users[0] != null) {
        res.json(users[0]);
      } else {
        res.status(404).send("Not Found");
      }
    })
    .catch((err) => {
      console.error(err);
      res.status(500).send("Error retrieving data from database");
    });
};

const postUser = (req, res) => {
  const { firstname, lastname, email, city, language, hashedPassword } = req.body;

  database
    .query(
      "INSERT INTO users(firstname, lastname, email, city, language, hashedPassword) VALUES (?, ?, ?, ?, ?, ?)",
      [firstname, lastname, email, city, language, hashedPassword]
    )
    .then(([result]) => {
      res.location(`/api/users/${result.insertId}`).sendStatus(201);
    })
    .catch((err) => {
      console.error(err);
      res.status(500).send("Error saving the user");
    });
};

const updateUser = (req, res) => {
  const id = parseInt(req.params.id);
  const { firstname, lastname, email, city, language, hashedPassword } = req.body;

  database
    .query(
      "update users set firstname = ?, lastname = ?, email = ?, city = ?, language = ?, hashedPassword = ? where id = ?",
      [firstname, lastname, email, city, language, hashedPassword, id]
    )
    .then(([result]) => {
      if (result.affectedRows === 0) {
        res.status(404).send("Not Found");
      } else {
        res.sendStatus(204);
      }
    })
    .catch((err) => {
      console.error(err);
      res.status(500).send("Error editing the user");
    });
};

// ...