Avez-vous une question? (216) 97 656 803 hajjriadh@gmail.com
NestJS

Inscription et connexion des utilisateurs (AuthModule, UsersModule)

Cette leçon construit l'inscription et la connexion d'une API NestJS avec une base MySQL. Elle répartit le code entre un UtilisateursModule (entité avec mot de passe non sélectionné par défaut, servic...

0 chapitres 0 QCM Accès gratuit
Inscription et connexion des utilisateurs (AuthModule, UsersModule)

À propos de ce cours

Cette leçon construit l'inscription et la connexion d'une API NestJS avec une base MySQL. Elle répartit le code entre un UtilisateursModule (entité avec mot de passe non sélectionné par défaut, service) et un AuthModule (DTO avec règles de robustesse, hachage bcrypt, vérification des identifiants). L'exécution montre les cas réels : inscription, doublon, mot de passe faible, tentative de choisir son rôle, connexion réussie ou refusée avec un message unique. Elle mesure aussi une fuite d'information par chronométrage, et présente @Exclude avec ClassSerializerInterceptor. Activités corrigées.

Objectifs de la leçon

  • Organiser le code entre UtilisateursModule et AuthModule.
  • Enregistrer un utilisateur avec un mot de passe haché.
  • Vérifier des identifiants sans révéler d'information.
  • Ne jamais renvoyer le mot de passe, même haché.
Deux modules
  • UtilisateursModule: l'entité et l'accès aux données des utilisateurs. Il exporte son service.
  • AuthModule: tout ce qui concerne l'authentification (inscription, connexion, jetons). Il importe UtilisateursModule (leçon 5.2).
nest g res utilisateurs --no-spec   # puis garder entité, service, module
nest g mo auth && nest g s auth --no-spec && nest g co auth --no-spec
L'entité Utilisateur

📄 src/utilisateurs/utilisateur.entity.ts

import { Column, CreateDateColumn, Entity, PrimaryGeneratedColumn } from 'typeorm';

export enum Role {
  Admin = 'admin',
  Formateur = 'formateur',
  Stagiaire = 'stagiaire',
}

@Entity('utilisateurs')
export class Utilisateur {
  @PrimaryGeneratedColumn()
  id: number;

  @Column({ length: 120, unique: true })
  email: string;

  @Column({ length: 80 })
  nom: string;

  @Column({ name: 'mot_de_passe', length: 60, select: false })     // jamais lu par défaut
  motDePasse: string;

  @Column({ type: 'enum', enum: Role, default: Role.Stagiaire })
  role: Role;

  @Column({ default: true })
  actif: boolean;

  @Column({ type: 'varchar', name: 'refresh_hache', length: 64, nullable: true, select: false })
  refreshHache: string | null;

  @CreateDateColumn({ name: 'cree_le' })
  creeLe: Date;
}
  • select: false sur le mot de passe : un find() ordinaire ne le lit jamais ; seule une méthode dédiée le demande explicitement (leçon 11.3).
  • length: 60: un hachage bcrypt fait toujours 60 caractères.
  • La colonne refresh_hache servira à la leçon 13.8.

📄 src/utilisateurs/utilisateurs.service.ts

import { ConflictException, Injectable } from '@nestjs/common';
import { InjectRepository } from '@nestjs/typeorm';
import { QueryFailedError, Repository } from 'typeorm';
import { Role, Utilisateur } from './utilisateur.entity';

@Injectable()
export class UtilisateursService {
  constructor(@InjectRepository(Utilisateur) private readonly depot: Repository<Utilisateur>) {}

  findById(id: number) {
    return this.depot.findOneBy({ id });
  }

  // Seule méthode qui lit le mot de passe haché (select: false sur la colonne)
  findAvecMotDePasse(email: string) {
    return this.depot.findOne({
      where: { email: email.toLowerCase() },
      select: { id: true, email: true, nom: true, role: true, actif: true, motDePasse: true },
    });
  }

  async create(donnees: { email: string; nom: string; motDePasse: string; role?: Role }) {
    try {
      const enregistre = await this.depot.save(this.depot.create({ ...donnees, email: donnees.email.toLowerCase() }));
      const { motDePasse, refreshHache, ...public_ } = enregistre;
      void motDePasse; void refreshHache;
      return public_;                                     // on ne renvoie jamais le mot de passe, même haché
    } catch (e) {
      if (e instanceof QueryFailedError && (e as any).code === 'ER_DUP_ENTRY') {
        throw new ConflictException('Un compte existe déjà avec cet e-mail');
      }
      throw e;
    }
  }
}

📄 src/utilisateurs/utilisateurs.module.ts

import { Module } from '@nestjs/common';
import { TypeOrmModule } from '@nestjs/typeorm';
import { Utilisateur } from './utilisateur.entity';
import { UtilisateursService } from './utilisateurs.service';

@Module({
  imports: [TypeOrmModule.forFeature([Utilisateur])],
  providers: [UtilisateursService],
  exports: [UtilisateursService],                         // utilisé par AuthModule
})
export class UtilisateursModule {}
Le service d'authentification

📄 src/auth/auth.dto.ts

import { IsEmail, IsString, Length, Matches, MinLength } from 'class-validator';

export class InscriptionDto {
  @IsEmail()
  email: string;

  @IsString()
  @Length(2, 80)
  nom: string;

  @IsString()
  @MinLength(8, { message: 'Le mot de passe doit contenir au moins 8 caractères' })
  @Matches(/(?=.*[a-z])(?=.*[A-Z])(?=.*\d)/, { message: 'Le mot de passe doit contenir une minuscule, une majuscule et un chiffre' })
  motDePasse: string;
}

export class ConnexionDto {
  @IsEmail()
  email: string;

  @IsString()
  motDePasse: string;
}

📄 src/auth/auth.service.ts

import { Injectable, UnauthorizedException } from '@nestjs/common';
import * as bcrypt from 'bcrypt';
import { UtilisateursService } from '../utilisateurs/utilisateurs.service';
import { ConnexionDto, InscriptionDto } from './auth.dto';

const COUT_BCRYPT = 10;

@Injectable()
export class AuthService {
  constructor(private readonly utilisateurs: UtilisateursService) {}

  async inscrire(dto: InscriptionDto) {
    const motDePasse = await bcrypt.hash(dto.motDePasse, COUT_BCRYPT);
    return this.utilisateurs.create({ ...dto, motDePasse });     // le rôle n'est PAS choisi par le client
  }

  async verifierIdentifiants({ email, motDePasse }: ConnexionDto) {
    const utilisateur = await this.utilisateurs.findAvecMotDePasse(email);
    const valide = utilisateur !== null && (await bcrypt.compare(motDePasse, utilisateur.motDePasse));
    if (!utilisateur || !valide || !utilisateur.actif) {
      throw new UnauthorizedException('E-mail ou mot de passe incorrect');      // même message dans tous les cas
    }
    const { motDePasse: _, ...publicUtilisateur } = utilisateur;
    return publicUtilisateur;
  }
}

📄 src/auth/auth.controller.ts

import { Body, Controller, HttpCode, Post } from '@nestjs/common';
import { ConnexionDto, InscriptionDto } from './auth.dto';
import { AuthService } from './auth.service';

@Controller('auth')
export class AuthController {
  constructor(private readonly authService: AuthService) {}

  @Post('inscription')
  inscrire(@Body() dto: InscriptionDto) {
    return this.authService.inscrire(dto);
  }

  @Post('connexion')
  @HttpCode(200)                                  // une connexion ne crée pas de ressource
  connecter(@Body() dto: ConnexionDto) {
    return this.authService.verifierIdentifiants(dto);     // leçon 13.4 : renverra un jeton
  }
}

📄 src/auth/auth.module.ts

import { Module } from '@nestjs/common';
import { UtilisateursModule } from '../utilisateurs/utilisateurs.module';
import { AuthController } from './auth.controller';
import { AuthService } from './auth.service';

@Module({
  imports: [UtilisateursModule],
  controllers: [AuthController],
  providers: [AuthService],
})
export class AuthModule {}

Inscription et connexion

Le mot de passe est haché à l'inscription et comparé à la connexion.

  const b = '/api/auth';
  await appel('POST', `${b}/inscription`, { corps: { email: 'Sami@Exemple.tn', nom: 'Sami Ben Ali', motDePasse: 'Formation2026' } });
  await appel('POST', `${b}/inscription`, { corps: { email: 'sami@exemple.tn', nom: 'Copie', motDePasse: 'Formation2026' } });
  await appel('POST', `${b}/inscription`, { corps: { email: 'ines@exemple.tn', nom: 'Ines', motDePasse: 'azerty' } });
  await appel('POST', `${b}/inscription`, { corps: { email: 'pirate@exemple.tn', nom: 'Pirate', motDePasse: 'Formation2026', role: 'admin' } });
  await appel('POST', `${b}/connexion`, { corps: { email: 'sami@exemple.tn', motDePasse: 'Formation2026' } });
  await appel('POST', `${b}/connexion`, { corps: { email: 'sami@exemple.tn', motDePasse: 'mauvais' } });
  await appel('POST', `${b}/connexion`, { corps: { email: 'inconnu@exemple.tn', motDePasse: 'Formation2026' } });
  const [ligne] = await app.get(DataSource).query("SELECT id, email, role, mot_de_passe FROM utilisateurs");
  console.log('En base :', ligne);
  const chrono = async (email: string) => {
    const t0 = performance.now();
    await fetch(`http://localhost:${app.getHttpServer().address().port}${b}/connexion`, { method: 'POST', headers: { 'content-type': 'application/json' }, body: JSON.stringify({ email, motDePasse: 'mauvais' }) });
    return Math.round(performance.now() - t0);
  };
  await chrono('x@exemple.tn');
  const existe = [await chrono('sami@exemple.tn'), await chrono('sami@exemple.tn'), await chrono('sami@exemple.tn')];
  const inconnu = [await chrono('personne@exemple.tn'), await chrono('personne@exemple.tn'), await chrono('personne@exemple.tn')];
  console.log(`Durée d'un échec — compte existant : ${existe.join(', ')} ms | compte inconnu : ${inconnu.join(', ')} ms`);

Résultat réellement obtenu :

POST /api/auth/inscription → 201 {"id":1,"email":"sami@exemple.tn","nom":"Sami Ben Ali","role":"stagiaire","actif":true,"creeLe":"…"}
POST /api/auth/inscription → 409 {"message":"Un compte existe déjà avec cet e-mail","error":"Conflict","statusCode":409}
POST /api/auth/inscription → 400 {"message":["Le mot de passe doit contenir une minuscule, une majuscule et un chiffre","Le mot de passe doit contenir au moins 8 caractères"],"error":"Bad Request","statusCode":400}
POST /api/auth/inscription → 400 {"message":["property role should not exist"],"error":"Bad Request","statusCode":400}
POST /api/auth/connexion → 200 {"id":1,"email":"sami@exemple.tn","nom":"Sami Ben Ali","role":"stagiaire","actif":true}
POST /api/auth/connexion → 401 {"message":"E-mail ou mot de passe incorrect","error":"Unauthorized","statusCode":401}
POST /api/auth/connexion → 401 {"message":"E-mail ou mot de passe incorrect","error":"Unauthorized","statusCode":401}
En base : {
  id: 1,
  email: 'sami@exemple.tn',
  role: 'stagiaire',
  mot_de_passe: '$2b$10$gcSj1zESOVOCnKEqrfHn0OH6.jcMoXkAorIV96bDSkQY.tG2Wv1D.'
}
Durée d'un échec — compte existant : 80, 75, 75 ms | compte inconnu : 4, 3, 3 ms
Lecture des résultats
  • L'e-mail est enregistré en minuscules (Sami@Exemple.tn → sami@exemple.tn), ce qui évite les doublons de casse. La réponse ne contient pas le mot de passe ; en base, seul le hachage bcrypt est stocké.
  • Doublon → 409 ; mot de passe trop faible → 400 avec des messages en français.
  • Tenter de choisir son rôle ("role": "admin") est refusé par le ValidationPipe (forbidNonWhitelisted, leçon 8.4). Le service ne lit de toute façon que les champs du DTO : l'inscription publique crée toujours un stagiaire. Les formateurs et administrateurs sont créés par un administrateur (TP 8).
  • Mot de passe faux et compte inexistant donnent exactement la même réponse. Un message « cet e-mail n'existe pas » permettrait à un attaquant de dresser la liste des comptes.
Une fuite subtile : le temps de réponse

La dernière ligne mesure la durée d'une connexion refusée : environ 75 ms pour un compte existant (bcrypt est exécuté), 3 ms pour un compte inconnu (on s'arrête avant). Même avec un message identique, le chronomètre révèle si l'e-mail existe. La parade : exécuter bcrypt.compare dans tous les cas, avec un hachage factice quand le compte n'existe pas :

const HACHAGE_FACTICE = bcrypt.hashSync('mot-de-passe-factice', 10);   // calculé une fois, au chargement

const utilisateur = await this.utilisateurs.findAvecMotDePasse(email);
const valide = await bcrypt.compare(motDePasse, utilisateur?.motDePasse ?? HACHAGE_FACTICE);
if (!utilisateur || !valide || !utilisateur.actif) throw new UnauthorizedException('E-mail ou mot de passe incorrect');

Le TP 8 applique cette correction. L'inscription, elle, révèle forcément qu'un e-mail est déjà pris (409) : on limite alors le nombre de tentatives (chapitre 19).

Masquer automatiquement des champs : @Exclude

La leçon 8.1 annonçait une variante automatique du DTO de sortie. Avec class-transformer, on marque les champs à ne jamais sérialiser et on active ClassSerializerInterceptor (globalement ou par contrôleur) :

📄 src/compte.ts

import { Exclude, Expose } from 'class-transformer';

export class Compte {
  id: number;
  email: string;
  nom: string;

  @Exclude()                         // jamais sérialisé
  motDePasse: string;

  @Exclude()
  refreshHache: string | null;

  @Expose()                          // propriété calculée ajoutée à la sortie
  get initiales(): string {
    return this.nom.split(' ').map((m) => m[0]).join('');
  }

  constructor(donnees: Partial<Compte>) {
    Object.assign(this, donnees);
  }
}

📄 src/comptes.controller.ts

import { ClassSerializerInterceptor, Controller, Get, UseInterceptors } from '@nestjs/common';
import { Compte } from './compte';

const enBase = { id: 1, email: 'sami@exemple.tn', nom: 'Sami Ben Ali', motDePasse: '$2b$10$Ck6O…', refreshHache: null };

@Controller('comptes')
export class ComptesController {
  @Get('objet')
  objet() {
    return enBase;                                   // objet simple : rien n'est masqué
  }

  @Get('instance')
  @UseInterceptors(ClassSerializerInterceptor)       // applique les règles de class-transformer
  instance() {
    return new Compte(enBase);                       // une INSTANCE de la classe
  }
}

Résultat réellement obtenu :

GET /api/comptes/objet → 200 {"id":1,"email":"sami@exemple.tn","nom":"Sami Ben Ali","motDePasse":"$2b$10$Ck6O…","refreshHache":null}
GET /api/comptes/instance → 200 {"id":1,"email":"sami@exemple.tn","nom":"Sami Ben Ali","initiales":"SBA"}

Attention : l'intercepteur n'agit que sur des instances de la classe. Un objet simple (premier cas) ou le résultat d'un getRawMany() n'est pas filtré. Les entités TypeORM renvoyées par find() sont bien des instances : on peut donc placer @Exclude() directement sur l'entité. Ce mécanisme complète, sans remplacer, le select: false.

Activités

Activité 1 Corriger le chronométrage

Appliquez le hachage factice à votre AuthService et refaites la mesure de la leçon. Les deux durées doivent devenir proches. Pourquoi calculer le hachage factice une seule fois, au chargement ?

Voir le corrigé

Après correction, les deux cas prennent environ 75 ms. Le hachage factice est calculé une fois (au démarrage) : le recalculer à chaque connexion doublerait le coût de la requête pour un compte inconnu, ce qui recréerait une différence mesurable.

Activité 2 Compte désactivé

Ajoutez une route d'administration qui désactive un compte (actif = false). Vérifiez qu'un compte désactivé ne peut plus se connecter. Quel message renvoyer ?

Voir le corrigé

Le même message « E-mail ou mot de passe incorrect », pour ne rien révéler à un tiers qui essaierait ce compte. Certaines applications préfèrent un message explicite (« compte suspendu, contactez l'administration ») uniquement quand le mot de passe est correct : l'information n'est alors donnée qu'au titulaire du compte.

Activité 3 Normaliser les données

Un utilisateur s'inscrit avec " Sami@Exemple.TN " (espaces). Que se passe-t-il ? Corrigez le DTO pour normaliser l'e-mail (leçon 8.4, @Transform).

Voir le corrigé
@Transform(({ value }) => (typeof value === 'string' ? value.trim().toLowerCase() : value))
@IsEmail()
email: string;

Sans normalisation, @IsEmail() refuse la valeur à cause des espaces. Avec la transformation, l'e-mail est nettoyé avant la validation, et la connexion doit appliquer la même normalisation (même DTO ou même transformation).

Activité 4 @Exclude sur l'entité

Placez @Exclude() sur motDePasse et refreshHache dans l'entité Utilisateur, activez ClassSerializerInterceptor globalement (APP_INTERCEPTOR) et simplifiez UtilisateursService.create. Vérifiez qu'aucune route ne renvoie le hachage.

Voir le corrigé

create peut alors renvoyer directement this.depot.save(…). Vérifiez aussi les routes qui renvoient des objets construits à la main ({ ...utilisateur } donne un objet simple, non filtré) : dans ce cas, renvoyez l'instance ou utilisez plainToInstance.

À retenir

  • UtilisateursModule (entité, données) exporte son service ; AuthModule (inscription, connexion) l'importe.
  • Mot de passe : select: false en base, bcrypt.hash à l'inscription, bcrypt.compare à la connexion.
  • L'inscription publique ne permet jamais de choisir son rôle.
  • Même message pour e-mail inconnu et mot de passe faux, et même durée (hachage factice).
  • Jamais de mot de passe dans une réponse : select: false, DTO de sortie ou @Exclude + ClassSerializerInterceptor.

Cet article vous a-t-il aidé ?