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

Les failles courantes des API (OWASP) et comment s'en protéger

Cette leçon présente l'OWASP et ses deux listes de référence, l'OWASP Top 10:2025 et l'OWASP API Security Top 10 (édition 2023). Sur une vraie API NestJS, chaque faille principale est réellement explo...

0 chapitres 0 QCM Accès gratuit
Les failles courantes des API (OWASP) et comment s'en protéger

À propos de ce cours

Cette leçon présente l'OWASP et ses deux listes de référence, l'OWASP Top 10:2025 et l'OWASP API Security Top 10 (édition 2023). Sur une vraie API NestJS, chaque faille principale est réellement exploitée puis corrigée : accès aux données d'un autre utilisateur (BOLA), affectation de masse d'un rôle administrateur, fuite du hachage du mot de passe, injection SQL dans le Query Builder TypeORM, consommation de ressources sans limite, action réservée aux administrateurs et erreur 500 qui révèle des détails internes. Les autres risques de la liste sont expliqués avec la défense NestJS correspondante. Activités corrigées.

Objectifs de la leçon

  • Connaître l'OWASP et ses listes de risques (Top 10:2025, API Security Top 10).
  • Reconnaître les failles les plus fréquentes d'une API dans du code NestJS.
  • Exploiter chaque faille sur un vrai projet pour en mesurer la gravité.
  • Appliquer la correction NestJS adaptée et la vérifier.

Versions: NestJS 12.5 (projet CommonJS créé avec nest new), TypeScript 6, Node.js 24, MariaDB 10.11, helmet 8.3, @nestjs/throttler 6.7. Tout le code de ce chapitre provient d'un vrai projet, api-securisee, et toutes les sorties ont réellement été obtenues en l'exécutant. Les mêmes notions s'appliquent à NestJS 10 et 11.

Le projet du chapitre : api-securisee

Une API de demandes administratives: chaque stagiaire dépose ses demandes (attestation, relevé de notes…) et ne doit voir que les siennes ; l'administration voit tout et peut supprimer. Trois comptes de démonstration sont créés au premier démarrage : admin@exemple.tn / Admin2026!, sami@exemple.tn et lina@exemple.tn / Stagiaire2026!. Sami possède les demandes 1 et 2, Lina les demandes 3 et 4.

Il reprend ce que vous connaissez déjà : TypeORM et MySQL (chapitres 11-12), DTO et validation (chapitre 07), JWT et rôles (chapitre 13), Swagger (chapitre 14). Chaque leçon du chapitre y ajoute une protection.

L'OWASP et ses listes

L'OWASP (Open Worldwide Application Security Project) est une fondation à but non lucratif qui publie des ressources libres sur la sécurité des applications. Ses listes « Top 10 » servent de référence commune aux développeurs, aux auditeurs et aux entreprises :

  • l'OWASP Top 10:2025, pour les applications web en général. Le contrôle d'accès défaillant (A01) reste en tête ; on y trouve aussi la mauvaise configuration (A02), la chaîne d'approvisionnement logicielle (A03, les dépendances npm), l'injection (A05), les défauts de journalisation et d'alerte (A09) et la mauvaise gestion des situations exceptionnelles (A10) ;
  • l'OWASP API Security Top 10, propre aux API. Son édition 2023 est toujours la plus récente : c'est celle que nous suivons.

OWASP API Security Top 10

Les dix risques des API (édition 2023) et la défense correspondante dans NestJS.

Pour chaque faille démontrée ci-dessous, le projet a été modifié pour la réintroduire, compilé, démarré, puis attaqué avec curl; la correction est le code du projet final. Les jetons de Sami (stagiaire, id 2) et de l'administratrice sont obtenus par POST /api/auth/connexion et placés dans les variables $SAMI et $ADMIN.

API1 Autorisation au niveau objet défaillante (BOLA)

C'est la faille n° 1 des API. L'utilisateur est bien connecté, mais l'API ne vérifie pas que l'objet demandé lui appartient. Il suffit de changer l'identifiant dans l'URL.

Code vulnérable (il « marche » : les tests du propriétaire passent) :

📄 src/demandes/demandes.service.ts (vulnérable)

async une(id: number, moi: UtilisateurConnecte) {
  const demande = await this.repo.findOneBy({ id });
  if (!demande) throw new NotFoundException('Demande introuvable');
  return demande;
}

Attaque réelle :

$ # Sami (id 2) demande la demande n° 3, qui appartient à Lina
curl -s http://localhost:3000/api/demandes/3 -H "Authorization: Bearer $SAMI" | jq
{
  "id": 3,
  "objet": "Attestation de présence (dossier médical joint)",
  "statut": "en_attente",
  "creeLe": "2026-11-15T16:58:07.913Z"
}

Sami lit la demande de Lina, avec une information médicale. Les identifiants étant des nombres qui se suivent, une boucle de 1 à 10 000 aspire toute la base.

Correction: le filtre sur le propriétaire fait partie de la requête.

📄 src/demandes/demandes.service.ts (extrait)

  async une(id: number, moi: UtilisateurConnecte) {
    // un stagiaire ne voit que SES demandes : sinon 404 (ne pas révéler qu'elle existe)
    const filtre = moi.role === 'admin' ? { id } : { id, proprietaire: { id: moi.id } };
    const demande = await this.repo.findOneBy(filtre);
    if (!demande) throw new NotFoundException('Demande introuvable');
    return demande;
  }

Après correction :

$ # Sami (id 2) demande la demande n° 3, qui appartient à Lina
curl -s http://localhost:3000/api/demandes/3 -H "Authorization: Bearer $SAMI"
{"message":"Demande introuvable","error":"Not Found","statusCode":404}
$ curl -s http://localhost:3000/api/demandes/1 -H "Authorization: Bearer $SAMI"
{"id":1,"objet":"Attestation de stage","statut":"en_attente","creeLe":"2026-11-15T16:58:20.047Z"}

On répond 404 et non 403 : un 403 confirmerait que la demande n° 3 existe. Le même filtre est appliqué à la liste (rechercher()), et devra l'être à toute modification ou suppression ouverte aux stagiaires. Pensez « quel utilisateur a le droit de voir CET objet ? » pour chaque route qui reçoit un identifiant. Utiliser des UUID au lieu d'entiers rend les identifiants difficiles à deviner, mais ne remplace pas ce contrôle.

API3 Affectation de masse (mass assignment)

L'API recopie dans l'entité toutes les propriétés reçues, y compris celles que le client ne devrait pas pouvoir choisir : role, statut, proprietaire…

📄 Code vulnérable

// main.ts
app.useGlobalPipes(new ValidationPipe({ transform: true })); // sans whitelist

// utilisateurs.service.ts
const u = this.repo.create({ ...dto, motDePasseHash: await bcrypt.hash(dto.motDePasse, 12) });

Attaque réelle : inscription avec un champ role ajouté :

$ curl -s -X POST http://localhost:3000/api/auth/inscription -H 'Content-Type: application/json' \
  -d '{"email":"pirate@exemple.tn","nom":"Pirate","motDePasse":"Pirate2026x","role":"admin"}'
{"id":4,"email":"pirate@exemple.tn","nom":"Pirate","role":"admin","creeLe":"2026-11-15T16:58:38.238Z"}

Le compte créé par une inscription publique est administrateur. Le DTO ne déclare pas role, mais sans whitelist, le ValidationPipe laisse passer les propriétés inconnues, et l'opérateur ...dto les recopie.

Correction, en deux protections indépendantes:

📄 src/configurer-app.ts (extrait)

  // 19.3 : rejeter les propriétés inconnues (affectation de masse)
  app.useGlobalPipes(new ValidationPipe({ whitelist: true, forbidNonWhitelisted: true, transform: true }));

📄 src/utilisateurs/utilisateurs.service.ts (extrait)

    const u = this.repo.create({
      email: dto.email.toLowerCase(),
      nom: dto.nom,
      motDePasseHash: await bcrypt.hash(dto.motDePasse, 12),
      role: 'stagiaire', // jamais lu depuis la requête
    });

Après correction :

$ curl -s -X POST http://localhost:3000/api/auth/inscription -H 'Content-Type: application/json' \
  -d '{"email":"pirate@exemple.tn","nom":"Pirate","motDePasse":"Pirate2026x","role":"admin"}'
{"message":["property role should not exist"],"error":"Bad Request","statusCode":400}

whitelist: true retire les propriétés non décorées ; forbidNonWhitelisted: true refuse carrément la requête (400), ce qui aide aussi le développeur Angular à repérer une faute de frappe. Et le service construit l'entité champ par champ, sans ...dto.

API3 Exposition excessive de données

L'autre moitié de API3 : l'API renvoie plus de propriétés que nécessaire, en comptant sur Angular pour ne pas les afficher. Ici, l'entité Utilisateur est renvoyée telle quelle :

Réponse réelle sans @Exclude() :

$ curl -s http://localhost:3000/api/utilisateurs/moi -H "Authorization: Bearer $SAMI" | jq
{
  "id": 2,
  "email": "sami@exemple.tn",
  "nom": "Sami Ben Ali",
  "motDePasseHash": "$2b$12$AewkDeaNWXuvkGmy/.GUYOtrnKNTq.XUNUWKCfVxGSS6aCKR9vze2",
  "role": "stagiaire",
  "creeLe": "2026-11-15T16:58:55.175Z"
}

Le hachage bcrypt du mot de passe est visible dans l'onglet Réseau du navigateur : il peut être attaqué hors ligne, sans limite de débit.

Correction: @Exclude() sur la propriété, et l'intercepteur ClassSerializerInterceptor global (déjà dans configurerApp) qui applique ces règles à chaque réponse :

📄 src/utilisateurs/utilisateur.entity.ts (extrait)

export class Utilisateur {
  @PrimaryGeneratedColumn() id: number;
  @Column({ length: 120, unique: true }) email: string;
  @Column({ length: 80 }) nom: string;
  @Exclude() @Column({ name: 'mot_de_passe_hash', length: 100 }) motDePasseHash: string;
  @Column({ type: 'varchar', length: 20, default: 'stagiaire' }) role: Role;
  @CreateDateColumn({ name: 'cree_le' }) creeLe: Date;

Après correction :

$ curl -s http://localhost:3000/api/utilisateurs/moi -H "Authorization: Bearer $SAMI"
{"id":2,"email":"sami@exemple.tn","nom":"Sami Ben Ali","role":"stagiaire","creeLe":"2026-11-15T16:59:07.459Z"}

Attention: ClassSerializerInterceptor ne fonctionne que sur des instances de classe. Une entité chargée par TypeORM en est une ; un objet littéral ({ ...utilisateur }, résultat de getRawMany()) ne l'est pas, et @Exclude() est alors ignoré. Pour les réponses importantes, des DTO de sortie explicites, ou select: false sur la colonne, sont encore plus sûrs.

A05:2025 Injection SQL

L'injection n'est plus dans le Top 10 des API parce que les ORM l'empêchent… quand on les utilise correctement. Le Query Builder de TypeORM (chapitre 12) accepte du SQL brut dans where: une concaténation suffit à ouvrir la faille.

📄 src/demandes/demandes.service.ts (vulnérable)

if (recherche) qb.andWhere(`d.objet LIKE '%${recherche}%'`);

Attaque réelle :

$ curl -s -G http://localhost:3000/api/demandes --data-urlencode "recherche=attestation" -H "Authorization: Bearer $SAMI" | jq
{
  "donnees": [
    {
      "id": 1,
      "objet": "Attestation de stage",
      "statut": "en_attente",
      "creeLe": "2026-11-15T16:59:19.832Z"
    }
  ],
  "total": 1,
  "page": 1,
  "limite": 10
}
$ curl -s -G http://localhost:3000/api/demandes --data-urlencode "recherche=%' OR 1=1 -- " -H "Authorization: Bearer $SAMI" | jq
{
  "donnees": [
    {
      "id": 1,
      "objet": "Attestation de stage",
      "statut": "en_attente",
      "creeLe": "2026-11-15T16:59:19.832Z"
    },
    {
      "id": 2,
      "objet": "Relevé de notes du semestre 1",
      "statut": "en_attente",
      "creeLe": "2026-11-15T16:59:19.834Z"
    },
    {
      "id": 3,
      "objet": "Attestation de présence (dossier médical joint)",
      "statut": "en_attente",
      "creeLe": "2026-11-15T16:59:19.836Z"
    },
    {
      "id": 4,
      "objet": "Changement de groupe",
      "statut": "en_attente",
      "creeLe": "2026-11-15T16:59:19.837Z"
    }
  ],
  "total": 4,
  "page": 1,
  "limite": 10
}

La recherche normale fonctionne. Mais avec %' OR 1=1 -- , la requête devient WHERE d.proprietaireId = 2 AND d.objet LIKE '%%' OR 1=1 -- %': la condition est toujours vraie et -- transforme la fin en commentaire. Sami obtient les demandes de tout le monde. Avec d'autres charges, on peut lire d'autres tables (UNION SELECT), voire modifier la base.

Correction: un paramètre lié. La valeur est envoyée à MySQL séparément de la requête : elle ne peut jamais être interprétée comme du SQL.

📄 src/demandes/demandes.service.ts (extrait)

    // la valeur est envoyée séparément de la requête SQL (paramètre lié)
    if (recherche) qb.andWhere('d.objet LIKE :motif', { motif: `%${recherche}%` });

Après correction :

$ curl -s -G http://localhost:3000/api/demandes --data-urlencode "recherche=attestation" -H "Authorization: Bearer $SAMI" | jq
{
  "donnees": [
    {
      "id": 1,
      "objet": "Attestation de stage",
      "statut": "en_attente",
      "creeLe": "2026-11-15T16:59:32.084Z"
    }
  ],
  "total": 1,
  "page": 1,
  "limite": 10
}
$ curl -s -G http://localhost:3000/api/demandes --data-urlencode "recherche=%' OR 1=1 -- " -H "Authorization: Bearer $SAMI"
{"donnees":[],"total":0,"page":1,"limite":10}

La charge est maintenant cherchée comme un simple texte : aucun résultat. Règle : jamais de ${...} dans une chaîne SQL (Query Builder, query(), orderBy construit à partir de la requête…). Pour un tri choisi par le client, utilisez une liste blanche de colonnes (chapitre 12). Avec find(), findOneBy() et les paramètres :nom, TypeORM lie toujours les valeurs.

API4 Consommation de ressources illimitée

Une seule requête peut coûter très cher : une page de 100 000 lignes, un corps JSON de plusieurs mégaoctets, un fichier énorme, ou des milliers de requêtes (leçon 19.2). Le projet pose trois bornes : @Max(50) sur la taille de page, la limite de débit, et une taille maximale du corps des requêtes JSON :

📄 src/demandes/dto/rechercher-demandes.dto.ts

import { Type } from 'class-transformer';
import { IsInt, IsOptional, IsString, Max, MaxLength, Min } from 'class-validator';

export class RechercherDemandesDto {
  @IsOptional() @IsString() @MaxLength(50) recherche?: string;
  @IsOptional() @Type(() => Number) @IsInt() @Min(1) page = 1;
  @IsOptional() @Type(() => Number) @IsInt() @Min(1) @Max(50) limite = 10; // jamais « tout » d'un coup
}

📄 src/configurer-app.ts (extrait)

  // 19.3 : corps de requête limité (consommation de ressources)
  app.useBodyParser('json', { limit: '10kb' });

Résultats réels :

$ curl -s "http://localhost:3000/api/demandes?limite=100000" -H "Authorization: Bearer $SAMI"
{"message":["limite must not be greater than 50"],"error":"Bad Request","statusCode":400}
$ # un corps JSON de 50 ko
head -c 50000 /dev/zero | tr "\0" "a" | jq -Rc '{objet: .}' | curl -s -X POST http://localhost:3000/api/demandes \
  -H "Authorization: Bearer $SAMI" -H "Content-Type: application/json" --data-binary @-
{"statusCode":413,"message":"request entity too large"}

Le corps de 50 ko est refusé (413) par Express avant même d'être analysé. La limite par défaut d'Express est de 100 ko : ajustez-la à vos besoins réels (10 ko suffit largement pour des formulaires ; l'upload de fichiers passe par Multer, avec sa propre limite, chapitre 15).

@Type(() => Number) est nécessaire : dans une URL, limite=100000 est une chaîne ; sans conversion, @IsInt() la refuserait toujours.

API5 Autorisation au niveau fonction défaillante

Une fonction réservée (supprimer, valider, exporter, administrer) est accessible à un simple utilisateur, souvent parce que le bouton est caché dans Angular mais la route n'est pas protégée. Dans le projet, le guard global vérifie les rôles déclarés par @Roles() (chapitre 13) :

📄 src/demandes/demandes.controller.ts (extrait)

  @Roles('admin')
  @Delete(':id')
  @HttpCode(204)
  supprimer(@Param('id', ParseIntPipe) id: number) {
    return this.service.supprimer(id);
  }

Sami tente de supprimer une demande :

$ curl -s -X DELETE http://localhost:3000/api/demandes/3 -H "Authorization: Bearer $SAMI"
{"message":"Action non autorisée pour votre rôle","error":"Forbidden","statusCode":403}

Le guard étant global (APP_GUARD), une route ajoutée sans décorateur exige au moins une connexion : on « oublie » une protection dans le sens sûr. Les routes publiques sont marquées explicitement avec @Public().

A10:2025 Erreurs mal gérées

Une erreur imprévue (base indisponible, bogue) ne doit révéler au client ni la pile d'appels, ni la requête SQL, ni des adresses ou des noms d'utilisateur internes. NestJS s'en charge par défaut : toute erreur qui n'est pas une HttpException devient un 500 générique, et les détails ne vont que dans le journal du serveur :

Ce que reçoit le client :

$ curl -s http://localhost:3000/api/sante/panne
{"statusCode":500,"message":"Internal server error"}

Ce que contient le journal du serveur :

[API] 4773  - 11/15/2026, 6:00:01 PM   ERROR [ExceptionsHandler] Error: connect ECONNREFUSED 10.0.0.12:3306 (utilisateur 'api')
    at SanteController.panne (/projet/dist/sante/sante.controller.js:18:15)
[API] 4773  - 11/15/2026, 6:00:01 PM   ERROR [HTTP] GET /api/sante/panne 500 10ms { requete: '420a21c9', ip: '127.0.0.1', utilisateur: null }

Ne cassez pas cette protection : pas de catch (e) { throw new BadRequestException(e.message) }, pas de filtre d'exception qui renvoie exception.stack. Traduisez les erreurs attendues en codes précis (doublon d'e-mail → 409, chapitre 18) et laissez les autres devenir des 500 journalisés.

Les autres risques de la liste
RisqueExempleDéfense dans un projet NestJS
API2 Authentification défaillantemots de passe faibles, jetons sans expiration, connexion sans limite, message « e-mail inconnu » qui confirme l'existence des comptesbcrypt (chapitre 13), @IsStrongPassword, JWT court (expiresIn: '1h'), limite de débit (19.2), même message « Identifiants incorrects » et même durée de calcul dans les deux cas (hachage factice dans AuthService)
API6 Flux métier sensiblesun script réserve toutes les places d'une formation en une secondelimites propres au flux, règles métier (une réservation par stagiaire), captcha ou validation manuelle si nécessaire
API7 SSRF« importer une photo depuis une URL » : l'attaquant donne http://169.254.169.254/ ou http://localhost:3306 et fait parler le serveur à sa placene télécharger que depuis une liste de domaines autorisés, refuser les adresses internes, délai court
API8 Mauvaise configurationSwagger ouvert en production, CORS origin: '*' avec jetons, synchronize: true en production, secrets par défautHelmet (19.1), CORS précis (chapitre 18), Swagger seulement hors production, configuration validée au démarrage (19.5)
API9 Inventaireune ancienne version /api/v1 oubliée et non corrigée, une route de test restée en ligneSwagger à jour, versionnement explicite, suppression des anciennes routes
API10 API tiercesfaire confiance aveuglément à la réponse d'un service de paiement ou de géolocalisationvalider les réponses reçues comme des entrées utilisateur (DTO), HTTPS, délais et gestion des erreurs
A03:2025 Chaîne d'approvisionnementune dépendance npm vulnérable ou piégéenpm audit, mises à jour régulières, package-lock.json versionné (19.5)
Activités

Activité 1 Trouver la faille

Pour chaque extrait, nommez le risque OWASP et corrigez : (a) @Patch(':id') modifier(@Param('id') id: number, @Body() dto) { return this.repo.update(id, dto); } dans une API où chaque stagiaire gère son profil ; (b) return this.repo.query(`SELECT * FROM stagiaires ORDER BY ${tri}`); (c) @Get('export') exporter() { return this.service.toutExporter(); } sans décorateur, dans une API sans guard global ; (d) catch (e) { throw new InternalServerErrorException(e.message); }.

Voir le corrigé

(a) API1 (n'importe quel id) et API3 (dto non typé : n'importe quelle colonne) : filtrer par moi.id, typer dto avec une classe DTO validée, whitelist. (b) Injection SQL : liste blanche const colonnes = { nom: 's.nom', date: 's.creeLe' } et orderBy(colonnes[tri] ?? 's.id'). (c) API5 (et API4) : @Roles('admin') avec un guard, idéalement global, et une limite de débit stricte. (d) A10 : le message interne part chez le client ; laisser l'erreur remonter (500 générique) ou journaliser puis lancer une exception sans détail.

Activité 2 Audit BOLA de votre projet

Dans le projet de votre TP 8, 9 ou 12 : listez dans un tableau toutes les routes qui reçoivent un identifiant (:id). Pour chacune, indiquez qui doit y avoir accès et testez avec curl le jeton d'un autre utilisateur. Corrigez et ajoutez un test e2e pour chaque cas (chapitre 17).

Voir le corrigé

Exemple de test e2e : connecter deux stagiaires, créer une ressource avec le premier, puis await request(app.getHttpServer()).get(`/api/demandes/${id}`).set('Authorization', `Bearer ${jetonDeuxieme}`).expect(404);. Ces tests empêchent la faille de revenir lors d'une modification future. Commit : fix(securite): contrôle du propriétaire sur les ressources.

Activité 3 SSRF

Une route POST /api/profil/photo-depuis-url reçoit { url } et télécharge l'image avec fetch(url). Donnez deux URL dangereuses et écrivez les vérifications à faire avant le fetch.

Voir le corrigé

Dangereuses : http://localhost:3000/api/... (contourne les contrôles réseau), http://127.0.0.1:6379 (Redis), http://169.254.169.254/latest/meta-data/ (secrets d'un serveur cloud), file:///etc/passwd. Vérifications : const u = new URL(url); protocole https: uniquement ; nom d'hôte dans une liste autorisée ; refus des adresses privées et locales ; délai (AbortSignal.timeout(5000)), taille maximale et type de contenu vérifiés. Le plus sûr reste de ne pas proposer cette fonctionnalité et de faire téléverser le fichier.

Activité 4 Checklist de revue

Rédigez dans le README de votre dépôt une checklist « sécurité » de 8 à 10 questions à se poser avant de fusionner une Pull Request qui ajoute une route.

Voir le corrigé

Par exemple : la route est-elle publique volontairement (@Public()) ? Qui a le droit d'y accéder (@Roles) ? Les objets sont-ils filtrés par propriétaire ? Le corps est-il un DTO validé ? La réponse contient-elle uniquement les champs nécessaires ? Les listes sont-elles paginées avec un maximum ? Pas de SQL concaténé ? Les erreurs attendues ont-elles un code précis ? La route coûteuse a-t-elle une limite de débit ? Un test e2e vérifie-t-il un accès refusé ?

À retenir

  • OWASP : Top 10:2025 (applications web) et API Security Top 10 (édition 2023), les références communes.
  • API1 BOLA : filtrer chaque objet par propriétaire, répondre 404.
  • API3 : whitelist + forbidNonWhitelisted à l'entrée, @Exclude() ou DTO de sortie à la sortie.
  • Injection : toujours des paramètres liés (:nom), jamais ${} dans du SQL.
  • API4 et API5 : pages bornées, corps limité, limite de débit ; @Roles avec un guard global.
  • Erreurs : 500 générique pour le client, détails seulement dans le journal.

Cet article vous a-t-il aidé ?