Vibe coding et sécurité : la checklist qui compte vraiment
Le vibe coding sécurise l'essentiel par défaut. Cette checklist cible les seuls endroits où l'IA a quitté le chemin balisé du framework.

Un développeur demande à un agent IA comme Claude Code de lui construire une petite appli de réservation en une après-midi. Il décrit ce qu’il veut en français courant, et laisse l’agent écrire le code lui-même : c’est ce qu’on appelle désormais le vibe coding. La sécurité n’est presque jamais mentionnée dans la demande. Pourtant l’agent choisit un framework web classique, branche une base de données, ajoute un formulaire de connexion, et livre un produit qui fonctionne avant midi. La plupart des erreurs de sécurité qui pourrissaient autrefois le code écrit à la main n’apparaissent jamais, parce que le framework s’en occupe tout seul : il neutralise le texte affiché à l’écran, il construit ses requêtes à la base de données sans risque, il chiffre les mots de passe sans qu’on le lui demande. Le risque de cette appli n’est pas réparti uniformément dans le code. Il se concentre dans la poignée d’endroits où l’agent, en suivant les instructions du développeur ou ses propres raccourcis, est sorti du chemin balisé par le framework.
C’est la vraie nature du problème posé par la mise en production d’applications générées par IA, différente du sempiternel avertissement comme quoi « l’IA écrit du code non sécurisé ». Une checklist utile pour le vibe coding ne récite pas la liste des vulnérabilités connues par cœur. Elle propose plutôt une méthode pour repérer les endroits précis où l’agent a quitté la route balisée, parce que c’est exactement là que se produisent les vrais dégâts.
Là où les secrets fuitent vraiment
La façon la plus courante de compromettre une appli vibe-codée n’a rien d’un exploit sophistiqué. C’est un mot de passe, une clé d’API ou un identifiant de base de données tapé directement dans le code au lieu d’être stocké ailleurs, protégé, puis poussé sur un dépôt de code public sans que personne ne s’en aperçoive. Un identifiant qui fuite de cette façon est d’ailleurs une porte d’entrée classique pour les attaques de la chaîne d’approvisionnement logicielle, où une seule clé exposée ouvre bien plus que l’accès à l’appli d’origine.
Ce n’est pas une supposition, c’est un phénomène documenté. La société de sécurité GitGuardian surveille chaque année la fuite de secrets sur GitHub public, et son rapport State of Secrets Sprawl 2026 a recensé 28,65 millions de secrets (comprendre identifiants, jetons et clés) ajoutés à des commits publics en 2025, soit un bond de 34 % sur un an, la plus forte hausse annuelle jamais mesurée par l’entreprise. Plus parlant encore pour notre sujet : les commits réalisés avec l’aide de Claude Code, l’un des agents de codage IA les plus utilisés, affichaient un taux de fuite de secrets de 3,2 %, contre 1,5 % en moyenne sur l’ensemble de GitHub public, soit grosso modo le double. Les secrets liés spécifiquement à des services d’IA ont bondi de 81 % sur l’année.
Rien de tout cela ne veut dire que les agents sont négligents par construction. Cela veut dire que lorsque la consigne est simplement « fais que ça marche vite », le chemin le plus court consiste souvent à coller une vraie clé dans un fichier de configuration plutôt qu’à mettre en place un vrai gestionnaire de secrets, et l’agent, optimisé pour produire une démo fonctionnelle, prendra ce chemin sauf consigne contraire. Le correctif ne coûte rien : garder les identifiants dans des variables d’environnement ou un coffre-fort à secrets dédié, jamais dans le code, et vérifier tout dépôt avant de le rendre public.

Les failles d’injection apparaissent exactement là où le framework a été contourné
L’injection SQL, une technique où un attaquant glisse ses propres commandes de base de données dans un champ de formulaire ou une barre de recherche parce que l’appli construit ses requêtes en assemblant du texte brut, reste l’un des bugs les plus destructeurs et les plus évitables du web. Elle occupe la troisième place du CWE Top 25 des failles logicielles les plus dangereuses, la liste annuelle que MITRE et l’agence américaine de cybersécurité CISA compilent à partir d’environ 31 770 signalements de vulnérabilités réelles.
Les frameworks modernes règlent ce problème par défaut grâce à ce qu’on appelle un query builder, une couche de code qui assemble les requêtes à la base de données sans danger, en traitant ce que tape l’utilisateur comme une donnée et jamais comme une commande, sans que le développeur ait à y penser. Un agent de codage qui travaille dans un framework classique utilisera normalement ce query builder automatiquement. Le cas de figure qui échoue est étroit, mais prévisible : quelqu’un demande une fonction de recherche personnalisée ou une optimisation de performance, et l’agent, pour satisfaire la demande, écrit une requête SQL brute à la main plutôt que de passer par le query builder. C’est cette seule requête écrite à la main qui devient la porte d’entrée de l’attaquant.
La différence se voit dans le code lui-même. Le chemin balisé ressemble à ceci, dans une application Node.js typique :
// The framework's query builder treats orderId as data, never as a command
const order = await db("orders").where({ id: orderId, userId: currentUser.id }).first();
Le contournement ressemble à ceci :
// A hand-written query splices orderId directly into the SQL text
const order = await db.raw(`SELECT * FROM orders WHERE id = ${orderId}`);
Les deux renvoient la même commande dans une requête normale. Seule la deuxième laisse un attaquant taper des commandes de base de données directement dans le champ orderId.
Le même schéma s’applique à la façon dont une page affiche le contenu soumis par les utilisateurs, comme un commentaire ou une bio de profil. Les frameworks neutralisent automatiquement ce texte, c’est-à-dire qu’ils le convertissent en caractères inertes avant de l’afficher, si bien qu’un commentaire contenant un bout de code s’affiche comme du texte inoffensif au lieu de s’exécuter. Dès que la demande devient « affiche ceci en HTML » pour permettre une mise en forme quelconque, cette neutralisation automatique se désactive, et n’importe quel visiteur capable de soumettre du texte peut potentiellement y glisser du code qui s’exécutera dans le navigateur d’un autre utilisateur.
Auditer les failles d’injection revient à chercher les exceptions dans le code, pas la règle : toute requête écrite à la main, tout affichage HTML explicitement activé, tout endroit où un commentaire dans le code dit quelque chose comme « j’ai dû le faire à la main ici ». Ces lignes méritent un second regard précisément parce qu’elles sont rares.
Les trous de contrôle d’accès : qui peut voir les données de qui
Un problème plus subtil, et en pratique plus fréquent, survient quand l’appli vérifie correctement qu’un visiteur est connecté, mais oublie de vérifier que la donnée précise qu’il demande lui appartient réellement. Cette faille porte un nom officiel, Broken Object Level Authorization, dans le OWASP API Security Top 10, où elle occupe la première place, plus connue sous son abréviation IDOR, pour insecure direct object reference : le cas où changer un simple chiffre dans une adresse web, comme un numéro de commande ou de facture, permet de consulter ou modifier un enregistrement qui n’est pas le sien. C’est exactement le genre de méfiance systématique que défend l’approche Zero Trust : vérifier chaque requête individuellement, plutôt que de supposer qu’une session connectée prouve déjà que le visiteur a le droit de voir cet enregistrement précis.
Ce trou apparaît typiquement quand un agent IA construit une fonctionnalité rapidement en copiant la forme d’une fonctionnalité existante. Il réussit la vérification de connexion, parce que ce schéma est partout dans le code et dans ses données d’entraînement, mais la vérification de propriété passe facilement à la trappe parce qu’elle dépend de la logique métier propre à cette fonctionnalité précise, à savoir confirmer que le numéro de commande de la requête appartient bel et bien à l’utilisateur connecté. Elle doit être écrite intentionnellement pour chaque action sensible ; un framework ne peut pas l’inventer tout seul comme il invente des requêtes sans danger.

Un problème connexe, plus ancien, porte le nom de CSRF, ou falsification de requête intersite : un site malveillant piège le navigateur d’un visiteur pour lui faire soumettre une action, comme changer une adresse e-mail ou valider un achat, sur un site où ce visiteur se trouve justement connecté ailleurs, à son insu. Le CSRF occupe la quatrième place de ce même Top 25 du CWE cité plus haut. La plupart des frameworks modernes intègrent une protection native contre ce risque, généralement un jeton caché qui doit correspondre à chaque soumission de formulaire, actif par défaut. Il ne cesse de compter que lorsqu’un développeur désactive cette protection pour rendre une API plus facile à appeler depuis un autre programme, un arbitrage délibéré qui mérite d’être réexaminé avant la mise en ligne, pas un bug.
L’entrée qui n’existait pas il y a cinq ans : l’injection de prompt
Toutes les failles vues jusqu’ici précèdent les agents de codage IA. L’injection de prompt est différente : elle vise les applications qui utilisent elles-mêmes un modèle d’IA comme fonctionnalité, par exemple un chatbot de support client intégré au produit, et elle n’exploite pas une erreur de code mais une faiblesse structurelle du fonctionnement de ces modèles. Un attaquant cache des instructions dans un contenu que le modèle d’IA va lire, comme un document qu’on lui demande de résumer ou un message auquel on lui demande de répondre, et le modèle, incapable de distinguer de façon fiable les instructions d’origine du développeur du texte qu’il ne fait que traiter, suit les instructions cachées à la place.
Le OWASP Top 10 pour les applications de grands modèles de langage classe l’injection de prompt en position LLM01, la toute première, pour la deuxième édition consécutive. Elle figure aux côtés de catalogues similaires publiés par MITRE et par l’agence américaine NIST, comparés en détail ailleurs, qui tentent tous de nommer des risques propres à l’IA que les checklists de sécurité classiques n’avaient jamais eu à couvrir. Ce classement compte ici pour une raison précise : c’est le seul point de cette liste que les réglages sûrs d’un framework ne peuvent pas absorber discrètement, parce qu’il n’existe pas encore d’équivalent du query builder pour ce risque-là. Si l’appli en cours de revue comporte une fonctionnalité propulsée par l’IA au-delà du simple processus de codage, cette fonctionnalité a besoin d’une vérification délibérée qui ne vient pas automatiquement avec le framework.
Comment auditer réellement une appli générée par IA avant sa mise en ligne
Cocher une checklist point par point donne une confiance trompeuse, parce qu’une case peut être techniquement vraie (l’appli « a » une authentification, « a » une validation des entrées) tout en cachant l’unique exception qui compte vraiment. La méthode la plus utile consiste à aller chercher directement ces exceptions.
Commencez par chercher dans le code tout endroit où une requête brute à la base de données a été écrite au lieu d’utiliser les méthodes standard du framework, et tout endroit où un contenu est affiché en HTML directement plutôt que via la sortie normale et automatiquement neutralisée du framework. Les deux cas sont généralement assez rares pour être relus un par un dans une appli petite ou moyenne, et les deux ont tendance à apparaître dans des commentaires ou du code ajouté par l’agent après une demande précise et inhabituelle. Ensuite, examinez chaque fonctionnalité qui permet à un utilisateur connecté d’agir sur un enregistrement précis, une commande, un document, un message, et vérifiez qu’il existe une ligne de code explicite confirmant que cet enregistrement lui appartient, pas seulement qu’il est connecté. Vérifiez ensuite si la protection CSRF du framework est restée activée, et si elle a été désactivée quelque part, si ce choix a été délibéré et documenté. Enfin, si l’appli comporte une fonctionnalité qui repose elle-même sur l’IA, assurez-vous que le texte non fiable qu’elle traite, documents téléversés, pages web aspirées, messages d’inconnus, ne peut pas discrètement prendre le pas sur ses instructions.

Cette approche fonctionne aussi bien pour un développeur solo qui relit son projet de week-end que pour une équipe qui prépare le lancement d’un produit payant, parce qu’elle ne demande pas de lire chaque ligne d’un code généré par IA. Elle demande de savoir quelle poignée de lignes mérite la méfiance.
Questions fréquentes
Utiliser un agent de codage IA rend-il une application moins sûre qu’une application écrite par un humain ?
Pas en soi. Une checklist de vibe coding existe précisément parce que le code généré par IA suit les mêmes réflexes de sécurité que le framework sur lequel il s’appuie, souvent plus sûr que le code écrit à la main moyen, sauf dans la poignée d’endroits où une demande du développeur a poussé l’agent à contourner ces réglages par défaut. Ce sont ces endroits-là qui méritent une attention particulière.
Quel est le tout premier point à vérifier avant de mettre en ligne une appli générée par IA ?
Les secrets exposés, c’est-à-dire les mots de passe, clés d’API ou identifiants de base de données commités directement dans le code, restent le problème le plus courant et le moins coûteux à corriger. Le rapport 2026 de GitGuardian a mesuré des taux de fuite environ deux fois supérieurs à la moyenne publique dans les commits assistés par IA, et le correctif, déplacer les identifiants vers des variables d’environnement, prend quelques minutes.
Qu’est-ce que l’IDOR, et pourquoi un agent IA a-t-il tendance à le manquer ?
L’IDOR, pour insecure direct object reference, survient quand une appli laisse un utilisateur connecté accéder aux données d’un autre utilisateur simplement en changeant un identifiant, comme un numéro de commande, dans une requête. Les agents de codage ajoutent généralement correctement la vérification de connexion, un schéma très répandu, mais oublient la vérification de propriété d’un enregistrement précis, qui dépend d’une logique métier propre à chaque fonctionnalité.
L’injection de prompt concerne-t-elle une appli qui n’a pas de chatbot ?
L’injection de prompt, classée LLM01 par l’OWASP Top 10 pour les applications LLM, ne s’applique qu’aux fonctionnalités où l’application elle-même transmet du texte non fiable à un modèle d’IA dans le cadre de sa propre logique. Une appli sans aucune fonctionnalité propulsée par l’IA au-delà du processus de codage qui l’a construite n’est pas exposée à ce risque précis.
Combien de temps prend une revue de sécurité de ce type pour une petite appli générée par IA ?
Pour une application petite à moyenne, chercher dans le code les requêtes écrites à la main, l’affichage HTML non neutralisé, les vérifications de propriété manquantes et la protection CSRF désactivée prend généralement quelques heures, pas des jours, parce que la revue cible des exceptions précises et identifiables plutôt que l’ensemble du code.