Sécurité du code généré par IA, les vérifications à mener avant mise en service

Sécurité du code généré par IA : ce qu’il faut vérifier avant de l’utiliser

Sécurité du code généré par IA, les vérifications à mener avant mise en service

La sécurité du code généré par IA pose un problème que les mesures disponibles décrivent bien : le code produit fonctionne, et c’est précisément ce qui trompe. Un programme qui rend le bon résultat peut exposer des données, accepter des entrées qu’il devrait refuser, ou reposer sur une bibliothèque qui n’existait pas avant que quelqu’un décide de la créer pour en tirer parti. Rien de tout cela ne se voit à l’exécution. Ce guide recense les défaillances les plus fréquentes, donne la méthode de relecture qui les attrape, et précise qui répond de quoi quand le code part en production.

Cet article fait partie de notre guide de l’IA pour coder.

Réponse courte : le code généré par IA est-il sûr ? Pas par défaut. Une étude portant sur plus d’une centaine de modèles a mesuré 45 % d’échantillons en échec aux tests de sécurité, sans amélioration liée à la taille du modèle. Les risques principaux sont les failles classiques du web, les identifiants laissés en clair, les contrôles d’accès absents et les bibliothèques inventées. Du code généré puis relu par quelqu’un de compétent n’a pas ce profil de risque : c’est la relecture qui fait la différence, pas l’origine du code.

En bref

  • Le code fonctionne, et c’est le problème : aucune des défaillances qui comptent ne se voit à l’exécution.
  • 45 % des échantillons échouent aux tests de sécurité, avec de grands écarts selon le langage.
  • Les modèles récents ne font pas mieux : la performance de sécurité reste stable quels que soient la taille et le raffinement du modèle.
  • Le risque le plus ignoré : près d’un paquet recommandé sur cinq n’existe pas, et les mêmes noms fictifs reviennent, ce qui ouvre une attaque de chaîne d’approvisionnement.
  • Une parade simple et mesurée : les modèles repèrent 80 % de leurs propres inventions quand on leur demande de vérifier.
  • Sept points de relecture suffisent à attraper la majorité des problèmes courants.
  • La responsabilité ne se délègue pas : au regard du RGPD, l’origine du code est sans effet sur vos obligations.
  • Pour outiller vos équipes sur ces vérifications, notre formation à la relecture du code produit par IA part de vos projets.

Sécurité du code généré par IA : pourquoi les tests échouent

Le rapport Veracode sur la sécurité du code généré par IA, publié le 30 juillet 2025, a soumis plus d’une centaine de modèles à des tests portant sur les failles de la liste OWASP Top 10. 45 % des échantillons ont échoué.

LangageTaux d’échec
Java72 %
C#45 %
JavaScript43 %
Python38 %

Le constat qui compte le plus tient dans une phrase de l’éditeur : la performance de sécurité reste stable quels que soient la taille du modèle et le raffinement de son entraînement. Autrement dit, attendre la génération suivante de modèles n’est pas une stratégie.

Une faille domine. Sur les échantillons concernés par le risque d’injection de code dans une page web, 86 % ne s’en protégeaient pas. C’est une faille nommée en janvier 2000, documentée depuis, et pour laquelle chaque langage propose des parades intégrées.

Pourquoi les modèles se trompent ainsi. Ils reproduisent ce qu’ils ont vu, et ce qu’ils ont vu est l’ensemble du code public, exemples pédagogiques simplifiés compris, qui écartent volontairement les protections pour rester lisibles. Un modèle optimisé pour produire du code qui fonctionne n’a aucune raison structurelle de produire du code qui résiste.

La nuance à garder en tête. Ces tests mesurent la sortie brute des modèles, sans relecture humaine. Ils décrivent donc ce que vous obtenez si vous acceptez sans vérifier, ce que notre article sur le vibe coding examine en détail. Un code relu par quelqu’un de compétent n’a pas ce profil.

Le risque le plus sous-estimé : les dépendances inventées

C’est la défaillance la moins connue et la plus vicieuse, parce qu’elle transforme une erreur du modèle en porte d’entrée.

Le mécanisme. Quand un modèle propose d’installer une bibliothèque, il lui arrive d’en inventer le nom. Une équipe de chercheurs des universités du Texas à San Antonio, de l’Oklahoma et de Virginia Tech a mesuré le phénomène sur 16 modèles et environ 19 000 requêtes, en Python et en JavaScript (étude publiée par USENIX).

Les chiffres :

  • 19,6 % de paquets inventés en moyenne sur l’ensemble des modèles testés.
  • Environ 5 % pour les modèles commerciaux, contre 21 % pour les modèles ouverts : l’écart est considérable.
  • 205 474 noms de paquets inexistants produits au total.

Le détail qui crée le danger. Ces inventions ne sont pas aléatoires. 45 % des noms fictifs reviennent systématiquement pour une même requête, et 60 % réapparaissent au moins une fois sur dix tentatives. Un nom inventé est donc prévisible.

D’où l’attaque. Un attaquant interroge les modèles, relève les noms de bibliothèques qu’ils inventent le plus souvent, puis enregistre réellement ces noms sur les dépôts publics, avec du code malveillant à l’intérieur. La prochaine personne qui suit docilement l’instruction d’installation télécharge le piège. Cette technique porte un nom, le slopsquatting, calqué sur le typosquattage qui exploite les fautes de frappe.

La parade, mesurée par la même étude. Interrogés à nouveau sur leur propre réponse, ChatGPT et DeepSeek identifient 80 % de leurs hallucinations. Une simple demande de vérification élimine donc l’essentiel du risque.

Voici la liste des bibliothèques que tu m'as recommandé d'installer. Pour chacune, confirme qu'elle existe réellement, donne son dépôt officiel et sa dernière version publiée. Signale celles dont tu n'es pas certain.

La vérification qui ne coûte rien. Avant toute installation, cherchez le nom sur le dépôt officiel du langage. Une bibliothèque légitime a un historique de versions, des mainteneurs identifiables et des téléchargements réguliers. Un paquet publié il y a trois semaines, sans historique, qui porte exactement le nom que l’IA vous a soufflé, mérite votre méfiance.

De l’invention à l’attaque 1. L’IA invente un nom de bibliothèque qui n’existe pas 19,6 % 2. Elle recommence le même nom revient pour la même demande 45 % 3. L’attaquant enregistre ce nom avec du code piégé 4. Vous installez la commande donnée par l’IA fonctionne La parade : redemander au modèle de vérifier sa propre liste il repère 80 % de ses inventions, puis vous contrôlez le dépôt officiel avant d’installer

Les quatre autres défaillances à connaître

Les identifiants laissés en clair. Les modèles produisent volontiers du code avec la clé d’accès écrite directement dedans, parce que c’est ainsi que les exemples pédagogiques sont rédigés. Le problème survient quand ce code part dans un dépôt partagé. Une clé publiée reste compromise même après suppression, car l’historique la conserve.

Les contrôles d’accès absents. C’est la défaillance la plus discrète : le programme fonctionne parfaitement pour l’utilisateur légitime, et tout aussi bien pour celui qui ne devrait pas y avoir accès. Aucun message d’erreur ne vous préviendra. La vulnérabilité de la plateforme Lovable évoquée plus loin relève exactement de cette catégorie.

La validation des entrées. Un modèle suppose que les données reçues ressemblent à celles de votre exemple. Il ne prévoit pas ce qui se passe avec un champ vide, un fichier de mauvais format, une valeur négative ou une saisie malveillante.

Les bibliothèques obsolètes. Les modèles s’appuient sur ce qu’ils ont appris, donc sur un état du monde daté. Une bibliothèque recommandée peut avoir été abandonnée, ou corrigée depuis pour une faille que la version suggérée contient encore.

Le point commun de ces quatre cas : ils sont invisibles en exécution. Un programme affecté par les quatre à la fois peut passer tous vos essais fonctionnels sans broncher.

Un exemple : la faille qu’on ne voit pas en testant

Prenons le cas le plus banal, un formulaire interne qui affiche les commentaires laissés par les collègues.

Ce que vous demandez. « Fais-moi une page qui enregistre un commentaire et affiche la liste des commentaires précédents. »

Ce que vous recevez. Un code d’une vingtaine de lignes qui fonctionne du premier coup. Vous saisissez « Très bien, merci », le commentaire s’affiche. Vous en saisissez un deuxième, il s’affiche aussi. Le test est concluant.

Ce que le test ne montre pas. Le code réaffiche le texte reçu tel quel. Tant que les gens écrivent des phrases, tout va bien. Le jour où quelqu’un saisit à la place une instruction destinée au navigateur, elle est exécutée chez toutes les personnes qui consultent ensuite la page. Selon ce que fait cette instruction, elle peut récupérer des sessions ouvertes ou rediriger vers un site piégé.

Pourquoi le modèle a produit cela. Parce que les exemples pédagogiques dont il s’inspire écartent volontairement l’échappement des données affichées, qui alourdit le code sans rien apporter à la démonstration. Le modèle a bien reproduit ce qu’il a vu.

Ce qui aurait suffi. Une ligne, celle qui échappe le texte avant de l’afficher. Le langage la fournit, il faut seulement penser à la demander. C’est l’objet de la première des trois demandes formulées plus loin.

La leçon générale. Cette faille est la plus fréquente des mesures disponibles, avec 86 % d’échec sur les échantillons concernés. Elle est identifiée et nommée depuis plus de vingt-cinq ans. Et elle reste invisible tant que personne n’essaie autre chose que les données auxquelles on s’attend, ce qui est précisément l’objet du point 4 de la liste qui suit.

Sept points de relecture qui attrapent l’essentiel

Cette liste ne remplace pas un audit. Elle attrape ce qui revient le plus souvent, et elle est à la portée d’un profil technique qui n’est pas spécialiste de sécurité.

1. Cherchez les identifiants dans le code. Mots de passe, clés d’accès, jetons, chaînes de connexion. Tout doit sortir du code et vivre dans un fichier de configuration exclu du dépôt.

2. Vérifiez chaque bibliothèque installée. Existence réelle, dépôt officiel, mainteneur, date de dernière publication. Les noms proposés par l’IA passent tous par ce contrôle.

3. Demandez-vous qui peut appeler quoi. Pour chaque fonction accessible de l’extérieur, posez la question : que se passe-t-il si une personne non autorisée l’appelle ? Si la réponse est « ça marche », vous avez trouvé un problème.

4. Essayez les entrées absurdes. Champ vide, texte à la place d’un nombre, valeur négative, fichier de 200 Mo, caractères inattendus. Un programme correct refuse proprement.

5. Regardez ce qui est enregistré et où. Beaucoup d’outils conservent les fichiers reçus ou écrivent des journaux contenant des données personnelles, sans que personne l’ait demandé.

6. Vérifiez le comportement en cas d’erreur. Un message d’erreur technique affiché à l’utilisateur renseigne un attaquant sur votre infrastructure. L’arrêt doit être propre et silencieux sur les détails.

7. Relisez ce qui touche à l’argent et à l’identité. Paiement, authentification, réinitialisation de mot de passe, gestion des droits. Ces quatre zones justifient toujours un regard qualifié, quelle que soit la taille du projet.

Comment s’organiser. Ces sept points tiennent dans une liste partagée que l’on coche avant toute mise en service. C’est ce que couvre notre atelier de sécurisation de vos pratiques de développement assisté, construit sur vos propres projets plutôt que sur des exemples génériques.

Demander du code plus sûr dès le départ

La relecture rattrape, la formulation prévient. Trois demandes changent sensiblement ce que vous recevez.

Exiger les protections explicitement. Les modèles ne les ajoutent pas spontanément, mais les produisent correctement quand on les réclame.

Écris ce code en appliquant les protections suivantes : validation de toutes les entrées, échappement des données affichées, aucun identifiant en dur (utilise des variables d'environnement), et gestion explicite des erreurs. Commente chaque protection pour que je puisse la vérifier.

Faire expliciter les hypothèses. C’est la demande la plus rentable, parce qu’elle révèle ce que le modèle a supposé sans le dire.

Avant de me donner le code, liste les hypothèses que tu fais sur les données d'entrée, les droits d'accès et l'environnement d'exécution. Indique lesquelles sont risquées si elles se révèlent fausses.

Demander une relecture adverse. Un modèle critique correctement un code qu’on lui soumet, y compris le sien.

Relis ce code du point de vue d'un attaquant. Liste les failles par ordre de gravité, avec pour chacune un scénario d'exploitation concret et la correction à apporter.

La limite de l’exercice. Cette relecture par l’IA attrape beaucoup de choses, mais elle partage les angles morts du modèle qui a produit le code. Elle ne remplace ni un outil d’analyse ni un humain compétent sur les zones sensibles.

Les outils qui travaillent à votre place

Trois catégories d’outils automatisent une partie du contrôle, et la plupart sont gratuits pour un usage modeste.

L’analyse statique examine le code sans l’exécuter et signale les motifs dangereux connus. C’est le filet le plus large et le moins coûteux à mettre en place.

L’analyse des dépendances compare vos bibliothèques à des bases de vulnérabilités publiées et vous alerte quand l’une d’elles devient problématique. Elle traite le risque des versions obsolètes, pas celui des paquets inventés, qui demande le contrôle manuel décrit plus haut.

La détection d’identifiants bloque l’envoi de clés et de mots de passe vers un dépôt, avant que la publication soit irréversible.

Ce qu’il faut en attendre. Ces outils attrapent les failles connues et documentées, ce qui représente une grande part des défaillances du code généré. Ils ne jugent ni la logique métier, ni la pertinence des contrôles d’accès, qui restent du ressort de la relecture humaine.

Ce qui change quand un agent écrit le code

Tout ce qui précède suppose que quelqu’un relit avant de mettre en service. Cette hypothèse tombe dès qu’un outil agit seul.

Le déplacement du problème. Un assistant propose un texte que vous examinez. Un agent modifie des fichiers, installe des dépendances et exécute des commandes. Les sept points de relecture restent valables, mais ils ne peuvent plus s’appliquer au même moment : il n’y a plus d’instant où le code attend votre accord.

Les trois questions qui remplacent la relecture ponctuelle. À quoi l’outil a-t-il accès, et pouvez-vous le restreindre ? Que reste-t-il comme trace de ce qu’il a fait ? Et quelles actions exigent une validation humaine avant exécution, en particulier les suppressions et les installations ?

Le risque des dépendances devient plus aigu. Un agent qui installe lui-même ce qu’il juge nécessaire supprime l’étape où vous auriez vérifié le nom du paquet. C’est la conjonction la plus défavorable : une invention répétable du modèle, et plus personne entre l’invention et l’installation.

💡 Où s’arrête cet article : nous traitons ici la vérification du code produit, dans un cadre où un humain valide. Les outils qui exécutent des tâches en autonomie, leurs droits d’accès et leurs garde-fous relèvent de nos contenus sur les agents IA.

Reprendre du code qu’on n’a pas écrit

La situation la plus courante en entreprise n’est pas de sécuriser du code neuf, mais de devoir juger un outil déjà en service que personne ne comprend.

1. Commencez par les données. L’outil manipule-t-il des données personnelles, en conserve-t-il une trace, et où ? Cette réponse décide de l’urgence, avant toute considération technique.

2. Faites produire une explication fonctionnelle. Un assistant décrit correctement un programme existant : ce qu’il fait, ce qu’il suppose, ce qui casserait. En quelques minutes, vous savez de quoi vous parlez.

3. Passez les sept points de relecture. Dans l’ordre, sur le code tel qu’il est.

4. Cherchez l’historique des identifiants. Si le code a vécu dans un dépôt partagé, une clé a pu y être publiée puis retirée. Elle reste compromise et doit être remplacée.

5. Décidez, et écrivez la décision. Garder avec une réserve, reprendre, ou remplacer par une fonction d’un logiciel que vous payez déjà. Cette dernière issue est plus fréquente qu’on ne l’imagine. Notre article sur le vibe coding détaille cette démarche de reprise.

Qui répond de la sécurité du code généré par IA ?

La question arrive tard dans les projets, et toujours au mauvais moment.

Le RGPD ne s’intéresse pas à l’origine du code. Si un traitement expose des données personnelles, le responsable de traitement répond du manquement. Que le code ait été écrit par un salarié, un prestataire ou un modèle de langage ne change rien à l’obligation de sécurité qui pèse sur vous.

Les conditions d’utilisation des outils ne vous couvrent pas. Les fournisseurs d’assistants de code n’assument pas la sécurité de ce qu’ils produisent. L’épisode de la plateforme Lovable l’illustre : une vulnérabilité référencée CVE-2025-48757, évaluée au niveau critique avec un score de 9,3 sur 10, permettait à un attaquant non authentifié de lire et modifier les bases de données des sites produits. L’éditeur a contesté la vulnérabilité, en faisant valoir qu’il revient à chaque client de protéger les données de son application.

En interne, la responsabilité suit la validation. Celui qui met en service répond de ce qu’il met en service. C’est pourquoi le point de validation doit être nommé plutôt que supposé : sans nom, personne ne se sent tenu de relire.

Sur le plan réglementaire. L’article 4 de l’AI Act, dans sa version modifiée par le règlement « Digital Omnibus » en vigueur depuis le 27 juillet 2026, demande aux organisations qui utilisent l’IA de prendre des mesures pour développer la maîtrise de l’IA de leur personnel (lawandtechnology.eu). Savoir relire ce qu’un modèle produit fait partie de cette maîtrise, au même titre que savoir le solliciter.

Le code généré par IA est-il moins sûr que le code humain ?

Les mesures disponibles vont dans ce sens sans le trancher définitivement. Une étude portant sur 470 demandes de fusion issues de projets ouverts conclut que le code écrit par IA produit environ 1,7 fois plus de problèmes que le code humain. Cette étude émane d’un éditeur d’outils de relecture, ce qui invite à la prudence sur l’interprétation. Le constat plus solide reste celui de Veracode : 45 % d’échantillons en échec aux tests de sécurité, avec une performance qui ne progresse pas d’une génération de modèles à l’autre.

Qu’est-ce que le slopsquatting ?

C’est une attaque qui exploite les bibliothèques inventées par les modèles. Un attaquant repère les noms fictifs que les modèles produisent régulièrement, les enregistre pour de bon sur les dépôts publics avec du code malveillant, et attend que quelqu’un suive l’instruction d’installation. La technique est viable parce que les inventions se répètent : 45 % des noms fictifs reviennent systématiquement pour une même demande.

Comment vérifier qu’une bibliothèque proposée existe vraiment ?

Cherchez son nom sur le dépôt officiel du langage et regardez trois choses : l’historique des versions, l’identité des mainteneurs et le volume de téléchargements. Une bibliothèque légitime a un passé. Demandez aussi au modèle de vérifier sa propre liste : l’étude de référence montre qu’il repère alors 80 % de ses inventions.

Les modèles récents produisent-ils du code plus sûr ?

Non, et c’est le résultat le plus contre-intuitif des mesures disponibles. La performance de sécurité reste stable quels que soient la taille du modèle et le raffinement de son entraînement, alors que les autres capacités progressent. Attendre le modèle suivant ne règle donc pas la question.

Peut-on demander à l’IA de relire son propre code ?

Oui, et c’est utile, en particulier pour vérifier les dépendances et repérer les failles courantes. Mais cette relecture partage les angles morts du modèle qui a écrit le code. Elle complète l’analyse automatique et la relecture humaine, elle ne les remplace pas, surtout sur les contrôles d’accès et la logique métier.

Quels outils mettre en place en premier ?

La détection d’identifiants avant envoi vers un dépôt, parce qu’une clé publiée est compromise de façon irréversible. Ensuite l’analyse statique, qui offre le plus large filet pour le moins d’effort. L’analyse des dépendances vient en troisième, utile mais partielle puisqu’elle ne détecte pas les paquets inventés.

Sommes-nous responsables d’une fuite causée par du code généré ?

Au regard du RGPD, oui : l’obligation de sécurité pèse sur le responsable de traitement, et l’origine du code n’y change rien. Les conditions des fournisseurs d’outils n’assument pas la sécurité du code produit, et l’un d’eux a explicitement renvoyé cette charge à ses clients lors d’une vulnérabilité critique. En interne, désignez nommément qui valide avant mise en service.

Faut-il interdire le code généré par IA en entreprise ?

L’interdiction déplace la pratique hors de votre vue sans la faire disparaître. Ce qui fonctionne : autoriser explicitement, définir les zones où une relecture qualifiée est obligatoire (données personnelles, paiement, authentification, accès), outiller la vérification, et former les équipes à relire. Le risque se gère, il ne se décrète pas.

Au final

La sécurité du code généré par IA se résume à un déplacement de l’effort : le temps gagné sur l’écriture doit être réinvesti dans la vérification, faute de quoi il n’est pas gagné mais emprunté. Les chiffres sont stables et convergents, près d’un échantillon sur deux échoue aux tests de sécurité et les modèles récents n’y changent rien, ce qui fait de la relecture une compétence durable plutôt qu’une précaution transitoire. Les sept points de contrôle de cet article attrapent l’essentiel de ce qui se produit réellement, et le contrôle des bibliothèques proposées mérite d’entrer dans les réflexes avant les autres, parce qu’il est le moins connu et le plus directement exploitable par un attaquant. Pour installer ces réflexes dans vos équipes, notre parcours IA générative pour sécuriser vos usages techniques, certifié Qualiopi et finançable par votre OPCO, part de votre code et de vos outils.

Laisser un commentaire

Votre adresse e-mail ne sera pas publiée. Les champs obligatoires sont indiqués avec *

Sommaire

S’inscrire à la newsletter

Recevez nos actualités et conseils sur les sujets qui vous intéressent.


Partagez sur

Qu’est-ce qui vous intéresse ?

Recevez les nouveautés Proactive Academy sur les sujets de votre choix, directement dans votre navigateur. Sans e-mail, et modifiable à tout moment.

Vos thèmes