Aller au contenu
Réussir mon BTS SIO

Tape une notion, une commande ou le nom d'une épreuve.

Par exemple

Exercice 6 / 6Difficile

Service login : trouver user + comparer hash

À toi

Implémente authService.login(deps, email, motDePasse) :

  • deps est un objet { trouverUser, verifierHash, signerToken } (toutes async).
    1. const user = await deps.trouverUser(email);
    1. Si pas de user → throw Error("identifiants invalides") avec err.statusCode = 401.
    1. const ok = await deps.verifierHash(motDePasse, user.password_hash);
    1. Si !ok → même erreur 401 "identifiants invalides" (jamais distinguer email vs mot de passe — info utile pour un attaquant).
    1. Sinon → retourne await deps.signerToken({ id: user.id, email: user.email }).

Pourquoi injecter deps : pour pouvoir tester sans lib bcrypt ni JWT réelles.

Service login : le flow complet

Le login est plus subtil qu'il n'y paraît. Voici le schéma à connaître par cœur, ici sur une borne où un employé se connecte avec son matricule et un code PIN :

javascript
const borneService = {
  async connecter({ trouverEmploye, verifierPin, ouvrirSession }, matricule, pin) {
    const refus = new Error("connexion refusée");
    refus.statusCode = 401;

    const employe = await trouverEmploye(matricule);
    if (!employe) throw refus;

    const pinOk = await verifierPin(pin, employe.pin_hash);
    if (!pinOk) throw refus; // même erreur, volontairement

    return ouvrirSession({ id: employe.id, service: employe.service });
  },
};

Trois étapes : trouver, vérifier le hash, produire le résultat. Une seule erreur pour les 2 échecs.

Règle d'or : message d'erreur identique

javascript
// ✗ MAUVAIS
if (!user) throw new Error("email inconnu");
if (!ok)   throw new Error("mot de passe incorrect");

C'est un cadeau pour un attaquant : il peut deviner les emails enregistrés. Tu donnes une information de timing + message qui aide la enumeration.

javascript
// ✓ BON
const erreur = new Error("connexion refusée");
if (!user || !ok) throw erreur;

Pour aller plus loin : si le user n'existe pas, fais quand même un faux verifierHash pour que le temps de réponse soit constant. Sinon l'attaquant peut deviner via le timing :

javascript
const fakeHash = "$2b$10$..."; // un hash quelconque
const ok = await verifierHash(motDePasse, user?.password_hash ?? fakeHash);
if (!user || !ok) throw erreur;

C'est ce que font les libs sérieuses.

Ne jamais mettre le hash dans le token

javascript
// ✗ Le token entier circule dans les requêtes
signerToken({ id, email, password_hash }) // catastrophe

Le payload JWT n'est pas chiffré, juste signé. N'importe qui peut le décoder en base64. Mets uniquement ce dont les autres middlewares ont besoin : id, email, role.

Pourquoi injecter les dépendances

Le service ne connaît ni la BDD ni la lib bcrypt ni JWT. Il reçoit 3 fonctions async :

javascript
{
  trouverUser:  (email) => Promise<User | null>,
  verifierHash: (clair, hash) => Promise<boolean>,
  signerToken:  (payload) => Promise<string>,
}

En prod tu les construis avec Supabase + bcrypt + jsonwebtoken. En test tu passes des stubs. Le service reste pur.

Statut HTTP

401 = identifiants invalides. Pas 400 (ce n'est pas une bad request, c'est une auth failure). Pas 403 (qui suppose qu'on connaît l'identité, pas le cas ici).

Le contrôleur HTTP au-dessus

javascript
app.post("/login", async (req, res) => {
  try {
    const token = await authService.login(deps, req.body.email, req.body.motDePasse);
    res.json({ token });
  } catch (e) {
    res.status(e.statusCode || 500).json({ error: e.message });
  }
});

Même pattern que dans le module MVC service-layer.

Ton code

Connecte-toi pour faire cet exercice

C'est gratuit, avec ton compte Google : un clic, et tu reviens ici. Ta progression te suit ensuite sur tous tes appareils.

Le site garde ton nom et ton email, rien d'autre. Tes données