Développement avec l'IA

Les 10 failles de sécurité les plus fréquentes dans le code généré par l'IA

L'IA écrit du code qui fonctionne, pas du code qui résiste. Les failles les plus fréquentes viennent toutes de là : données d'un utilisateur visibles par un autre, base de données ouverte, contrôles faits seulement dans le navigateur, clés secrètes dans le code. Les quatre plus graves se repèrent en une heure, sans être développeur.

Par Adrien Scher · Publié le · 10 min de lecture

Quelles sont les failles les plus fréquentes dans le code généré par l'IA, en bref ?

Presque toutes ont la même origine : l'IA écrit du code qui fonctionne, pas du code qui résiste. Elle fait ce qu'on lui demande, mais elle oublie ce qu'on ne lui demande pas : qui a le droit de voir quoi, ce qui se passe si quelqu'un triche, où ranger une clé secrète.

Les dix failles qu'on retrouve le plus souvent, par ordre de gravité :

  1. un utilisateur peut voir les données d'un autre en changeant un identifiant ;
  2. la base de données est ouverte, faute de règles d'accès ;
  3. les contrôles ne sont faits que dans le navigateur ;
  4. des clés secrètes traînent dans le code ;
  5. les injections SQL ;
  6. les injections de script (XSS) ;
  7. les données reçues ne sont pas vérifiées côté serveur ;
  8. des dépendances inventées ou obsolètes ;
  9. une authentification bricolée ;
  10. des messages d'erreur et des journaux trop bavards.

Les quatre premières sont les plus graves, et ce sont aussi les plus faciles à repérer. Le reste de l'article explique chacune, ce qu'elle peut coûter et comment la détecter.

Pourquoi l'IA produit-elle du code vulnérable ?

Parce qu'elle juge son travail sur ce qui se voit. L'écran s'affiche, le bouton enregistre, la liste se remplit : pour l'IA, la tâche est réussie. Elle ne se demande pas ce qui se passe si l'utilisateur modifie la requête envoyée au serveur, ou si un robot teste toutes les adresses de votre site.

Les chiffres vont dans le même sens :

  • Veracode, 2025. Sur plus de 100 modèles d'IA testés sur 80 tâches de programmation sensibles, le code contenait une faille de sécurité dans 45 % des cas. Sur les injections de script, le code échouait 86 fois sur 100 (rapport GenAI Code Security).
  • GitGuardian, 2025. Parmi environ 20 000 dépôts de code publics où GitHub Copilot était utilisé, 6,4 % laissaient fuiter au moins une clé secrète, soit 40 % de plus que la moyenne des dépôts publics (State of Secrets Sprawl 2025).
  • USENIX Security, 2025. Dans une étude sur 16 modèles d'IA, près de 20 % des bibliothèques recommandées n'existaient pas (We Have a Package for You!).

Ce n'est pas une raison pour ne pas utiliser l'IA. Nous l'utilisons tous les jours pour développer. C'est une raison pour savoir où regarder.

1. Pourquoi un utilisateur voit-il les données d'un autre ?

C'est la faille la plus fréquente et la plus grave. L'application affiche la commande /commande/124 à qui la demande, sans vérifier qu'elle appartient bien à la personne connectée. Un client curieux change 124 en 123 et lit la commande de quelqu'un d'autre : nom, adresse, montant.

L'IA génère facilement ce défaut, car « afficher la commande 124 » et « afficher la commande 124 si elle est à vous » donnent le même écran en démo.

Comment la repérer : créez deux comptes, notez l'adresse d'une page du premier, ouvrez-la avec le second. Il ne doit rien voir.

2. Pourquoi la base de données est-elle accessible à tout le monde ?

Les applications créées avec Lovable, Bolt ou Cursor utilisent souvent Supabase ou Firebase, des bases que le navigateur interroge directement. La seule protection, ce sont les règles d'accès écrites dans la base (les « RLS » chez Supabase). Si elles manquent, ou si elles autorisent tout, n'importe qui peut lire, modifier ou effacer vos tables.

C'est exactement la faille découverte en 2025 sur environ 170 applications Lovable (CVE-2025-48757). Nous en détaillons les conséquences dans notre article Mon app Lovable ou Bolt est-elle prête pour la production ?.

Comment la repérer : dans le tableau de bord de Supabase, chaque table doit avoir la protection RLS activée, avec une règle qui limite l'accès à l'utilisateur concerné.

3. Pourquoi les contrôles faits dans le navigateur ne protègent-ils rien ?

L'IA cache souvent le bouton « Supprimer » aux utilisateurs qui ne sont pas administrateurs, et s'arrête là. Mais le bouton n'est qu'une façade : l'action derrière reste accessible à qui sait l'appeler, ce qui prend deux minutes avec les outils intégrés au navigateur.

Même chose pour un prix calculé dans le navigateur puis envoyé au serveur, ou un rôle « admin » lu dans la mémoire du navigateur. Tout ce qui se passe dans le navigateur peut être modifié par l'utilisateur.

Comment la repérer : demandez à votre développeur, ou à l'IA elle-même, où sont vérifiés les droits de chaque action sensible. La réponse doit toujours être « sur le serveur ».

4. Où les clés secrètes se cachent-elles dans le code ?

Pour brancher un paiement, un envoi de mails ou une IA, l'application a besoin de clés d'accès. Le code généré les colle volontiers directement dans le code, parfois dans la partie envoyée au navigateur, parfois dans un dépôt GitHub public. Une clé de paiement ou d'administration de la base qui fuite, c'est un accès complet à votre compte.

Comment la repérer : ouvrez les outils de développement du navigateur (F12), onglet « Sources », et cherchez secret, sk_live ou service_role. Rien ne doit remonter. Si votre code est sur GitHub, activez l'alerte de détection de secrets, gratuite sur les dépôts publics.

5. Les injections SQL existent-elles encore avec l'IA ?

Oui. C'est une faille ancienne, mais l'IA la reproduit dès qu'elle construit une requête à la base de données en y collant directement ce que l'utilisateur a tapé, au lieu de passer par les mécanismes prévus pour ça. Un attaquant saisit alors, dans un champ de recherche, un morceau de requête qui lui permet de lire ou d'effacer des tables entières.

Comment la repérer : c'est une vérification de code, pas de navigation. Un développeur cherche les requêtes assemblées avec du texte, et un outil d'analyse automatique les signale aussi.

6. Qu'est-ce qu'une injection de script (XSS) ?

Un utilisateur saisit, dans un commentaire ou un nom de profil, un petit programme au lieu d'un texte. Si l'application l'affiche tel quel aux autres utilisateurs, le programme s'exécute dans leur navigateur : il peut voler leur session ou agir à leur place.

C'est le point sur lequel l'IA échoue le plus dans l'étude Veracode : 86 % du code testé ne s'en protégeait pas. Les frameworks modernes protègent par défaut, mais l'IA contourne volontiers cette protection pour afficher du texte mis en forme.

Comment la repérer : saisissez <b>test</b> dans un champ texte. Si le mot s'affiche en gras ailleurs dans l'application, le contenu n'est pas filtré.

7. Pourquoi faut-il vérifier les données sur le serveur ?

Le formulaire refuse un prix négatif ou une date impossible, mais le serveur, lui, accepte tout ce qu'on lui envoie. Un utilisateur peut donc envoyer directement une quantité de -10, une remise de 100 %, ou ajouter "role": "admin" à la modification de son profil, et devenir administrateur.

Comment la repérer : demandez si chaque action du serveur vérifie ses données avec un schéma de validation (Zod, par exemple), et si elle n'enregistre que les champs prévus.

8. Qu'est-ce qu'une dépendance inventée par l'IA ?

Une application s'appuie sur des dizaines de bibliothèques écrites par d'autres. L'IA en recommande parfois qui n'existent pas : près d'une sur cinq dans l'étude présentée à USENIX Security en 2025. Des attaquants publient alors de fausses bibliothèques sous ces noms inventés, pour que le prochain qui suit la même suggestion installe leur code. On appelle cette attaque le « slopsquatting ».

L'IA propose aussi des versions anciennes de bibliothèques réelles, avec des failles connues et corrigées depuis.

Comment la repérer : vérifiez que chaque bibliothèque ajoutée existe depuis un moment et qu'elle est maintenue, et lancez régulièrement l'audit des dépendances (npm audit pour un projet JavaScript).

9. Qu'est-ce qu'une authentification bricolée ?

Quand l'IA écrit elle-même la connexion au lieu d'utiliser une solution éprouvée, on retrouve souvent les mêmes oublis : mots de passe mal protégés en base, sessions qui n'expirent jamais, lien de réinitialisation réutilisable, aucune limite au nombre de tentatives de connexion. Un robot peut alors essayer des milliers de mots de passe sans être bloqué.

Comment la repérer : tentez dix connexions ratées d'affilée. L'application doit finir par ralentir ou bloquer. Et demandez si l'authentification repose sur une solution reconnue (Supabase Auth, Auth.js, better-auth, Clerk) plutôt que sur du code maison.

10. Pourquoi les messages d'erreur peuvent-ils trahir l'application ?

En cas de plantage, le code généré affiche souvent l'erreur technique complète à l'écran : nom des tables, chemin des fichiers, parfois la requête à la base. C'est un plan de l'application offert à qui le cherche.

À l'inverse, les journaux du serveur enregistrent parfois des mots de passe, des données personnelles ou des textes saisis sans les nettoyer, ce que Veracode a relevé dans 88 % du code testé.

Comment la repérer : provoquez une erreur (une adresse qui n'existe pas, un formulaire mal rempli). L'utilisateur doit voir un message simple, jamais du code.

Quelles failles vérifier en premier ?

Toutes ne se valent pas. Si vous n'avez qu'une heure, commencez par celles qui exposent directement vos données :

FailleCe qui peut arriverTest sans être développeur
1. Données d'un autre utilisateurFuite de données clients, obligations RGPDDeux comptes, une même adresse de page
2. Base ouverteLecture, modification ou effacement de toutes les tablesRègles RLS dans Supabase
3. Contrôles dans le navigateurActions d'administration accessibles à tousDemander où sont vérifiés les droits
4. Clés secrètes exposéesAccès complet au paiement, à la base, aux mailsRecherche de secret avec F12
6. Injection de scriptVol de session des autres utilisateursSaisir <b>test</b>
9. AuthentificationComptes piratés par essais répétésDix connexions ratées
10. Erreurs bavardesInformations utiles à un attaquantProvoquer une erreur

Les failles 5, 7 et 8 demandent de lire le code : c'est le travail d'un audit.

Comment développer avec l'IA sans créer ces failles ?

L'IA n'est pas le problème. Le problème, c'est de la laisser seule sur les sujets qu'elle ne voit pas. Quelques habitudes suffisent à éviter l'essentiel :

  • demander explicitement la sécurité : « vérifie que l'utilisateur connecté a le droit d'accéder à cette donnée, côté serveur » donne un code très différent de « affiche la commande » ;
  • utiliser des briques éprouvées pour l'authentification, les paiements et la validation des données, plutôt que de faire écrire du code maison ;
  • relire chaque action du serveur avec une seule question : que se passe-t-il si quelqu'un l'appelle avec d'autres données ?
  • automatiser les contrôles : détection de secrets, audit des dépendances, analyse du code à chaque modification ;
  • faire relire le code par un développeur avant d'y mettre de vraies données, puis à chaque évolution importante.

Comment Le P'tit Logiciel sécurise-t-il une application faite avec l'IA ?

Nous développons nous-mêmes avec l'IA, dans un cadre qui couvre ces dix points dès le départ. Pour une application déjà créée avec Lovable, Bolt, Cursor ou un autre outil, la reprise suit trois étapes :

  1. Un échange de 30 minutes pour comprendre l'application et ce que vous voulez en faire.
  2. Un audit du code, de la base et de l'hébergement, avec la liste des failles classées par gravité et une proposition chiffrée : corriger, restructurer ou reconstruire le socle.
  3. La remise à niveau et la mise en production, sur un hébergement fiable. Le code vous appartient.

Le détail de l'offre est sur notre page développement IA sur mesure.

Questions fréquentes

Les questions qu'on nous pose.

Le code généré par l'IA est-il dangereux ?

Pas plus qu'un code écrit vite par un débutant, mais il contient souvent des failles. Une étude Veracode de 2025 a trouvé une faille de sécurité dans 45 % du code produit par plus de 100 modèles d'IA sur des tâches sensibles. Le code doit donc être relu et testé avant d'y mettre de vraies données.

Quelle est la faille la plus fréquente dans le code généré par l'IA ?

Le contrôle d'accès manquant : un utilisateur peut voir ou modifier les données d'un autre en changeant un identifiant dans l'adresse ou dans la requête. Elle est grave et facile à tester : créez deux comptes et vérifiez que le second ne voit rien du premier.

Comment vérifier la sécurité d'une application générée par l'IA sans être développeur ?

Quatre tests couvrent les failles les plus graves : comparer deux comptes, changer l'identifiant dans l'adresse d'une page, chercher les mots « secret » ou « service_role » dans les sources du navigateur (touche F12), et vérifier que les règles d'accès RLS sont activées sur chaque table de la base.

L'IA peut-elle corriger elle-même les failles de son code ?

En partie, si on lui demande précisément quoi vérifier : les droits côté serveur, la validation des données, les secrets. Mais elle ne repère pas seule ce qu'elle a oublié. Une relecture par un développeur et des outils automatiques (détection de secrets, audit des dépendances) restent nécessaires.

Qu'est-ce que le slopsquatting ?

Une attaque qui exploite les bibliothèques inventées par l'IA. Les modèles recommandent parfois des bibliothèques qui n'existent pas (près de 20 % dans une étude présentée à USENIX Security en 2025) ; des attaquants publient de fausses bibliothèques sous ces noms pour que leur code soit installé par ceux qui suivent la suggestion.

Votre projet mérite un chiffre précis

Décrivez-nous votre besoin en 30 minutes : on vous dit ce qu'il coûterait, et on vous montre une démo avant tout devis.

Réserver 30 min

Pas encore prêt à échanger ? Évaluez d'abord vos opérations avec le diagnostic gratuit.