Essayez Salt Code. Obtenez votre jeton gratuit

Industrie

Comment sécuriser le code généré par l'IA

November 19, 2026

Danielle Duhon
Directrice de la croissance

Les assistants de codage IA rédigent une part importante du code déployé par les équipes. Rapport 2026 de Veracode sur la sécurité du code généré par IA estime que l'IA rédige environ la moitié de tout le code soumis par les équipes ayant adopté ces outils. Cette rapidité est précieuse, mais ces assistants sont conçus pour produire du code fonctionnel, pas du code sécurisé, et aucun d'entre eux ne connaît vos normes de sécurité internes. Ce guide présente un flux de travail pratique pour sécuriser le code généré par IA : comment rédiger des prompts, l'analyser, vérifier ses dépendances, examiner les changements les plus risqués, définir des politiques et automatiser leur application afin que la sécurité suive le rythme du développement automatisé.

Quels sont les risques de sécurité liés au code généré par IA ?

Le code généré par IA a tendance à présenter quatre types de défaillances identifiables :

  • Paquets hallucinés. Les modèles font parfois référence à des bibliothèques qui n'existent pas. Des attaquants peuvent enregistrer ces noms et les remplir de code malveillant.
  • Secrets codés en dur. Le code d'exemple contient souvent des identifiants fictifs, et de vraies clés finissent par être soumises avec lui.
  • Modèles de codage non sécurisés. Les failles d'injection, telles que le cross-site scripting et l'injection de logs, apparaissent car le modèle ne peut pas voir comment les données non fiables circulent dans l'ensemble de l'application.
  • Défauts de conception et de logique. Une autorisation défaillante, des données exposées dans les chaînes de requête et l'absence de limitation de débit peuvent compiler sans erreur et passer une analyse de base.

Les recherches sont cohérentes. Rapport 2026 de Veracode sur la sécurité du code généré par IA a testé plus de 100 modèles sur quatre instantanés. Les taux de réussite syntaxique ont atteint 99,9 %, mais le taux de réussite moyen en matière de sécurité est resté autour de 56 %. Dans environ 44 % des tâches, les modèles ont introduit une vulnérabilité détectable du Top 10 de l'OWASP. Les résultats variaient considérablement selon le type de faille : les modèles ont bien géré l'injection SQL (taux de réussite de 83 %) mais ont obtenu de mauvais résultats sur le cross-site scripting (15 %) et l'injection de logs (12 %).

Les secrets suivent le même schéma. Le rapport 2026 de GitGuardian sur la prolifération des secrets, tel que couvert par SC Media, a révélé que les commits publics co-rédigés par Claude Code fuitaient des secrets à hauteur de 3,2 %, soit environ deux fois plus que la référence de 1,5 % observée sur l'ensemble des commits GitHub publics. Il a également révélé plus de 24 000 secrets exposés dans des fichiers de configuration MCP publics.

Concernant les dépendances, une Étude USENIX Security 2025 sur 16 modèles de langage (LLM) générateurs de code et 576 000 échantillons de code a révélé des taux d'hallucination de paquets d'au moins 5,2 % pour les modèles commerciaux et 21,7 % pour les modèles open source, avec 205 474 noms de paquets hallucinés uniques.

La bonne nouvelle est que ces risques suivent des modèles prévisibles. Vous pouvez gérer les risques prévisibles grâce à un flux de travail reproductible, ce que le reste de ce guide aborde.

Guider l'IA avec des prompts axés sur la sécurité

Les prompts vagues ont tendance à produire du code présentant des failles de sécurité. Les tests de Veracode n'ont délibérément fourni aux modèles aucune consigne spécifique en matière de sécurité, car les développeurs se concentrent généralement sur la fonctionnalité et ne savent pas toujours quand une requête a des implications sécuritaires. Dans ces conditions, les modèles ont choisi une implémentation non sécurisée dans près de la moitié des tâches. Énoncer les exigences de sécurité dès le départ permet de combler une partie de cette lacune.

Un prompt plus efficace nomme les contrôles attendus, et pas seulement la fonctionnalité :

  • Faible : « Crée un point de terminaison d'API qui supprime un utilisateur. »
  • Plus efficace : « Crée un point de terminaison d'API qui supprime un utilisateur. Exige une authentification par jeton bearer dans l'en-tête Authorization, et non dans la chaîne de requête. Transmets l'ID utilisateur dans le corps de la requête et vérifie que l'appelant est autorisé à supprimer cet utilisateur spécifique. Valide toutes les entrées, utilise des requêtes paramétrées, limite le débit du point de terminaison et ne code aucune information d'identification en dur. »

La version plus efficace cible précisément les failles que Salt Code signale dans sa propre démo: autorisation au niveau de l'objet rompue (OWASP API1), jetons d'authentification dans la chaîne de requête (API2) et fuites d'ID utilisateur via les URL (API3).

Maintenez une bibliothèque partagée de prompts de codage sécurisé approuvés afin que toute l'équipe parte de la même base. Même ainsi, la discipline des prompts dépend du fait que chaque développeur se souvienne de chaque exigence à chaque requête. C'est pourquoi les étapes ultérieures, ainsi que l'application automatisée, sont essentielles.

Analyser chaque changement avec des outils de sécurité automatisés

Exécutez trois types de contrôles automatisés sur chaque changement suggéré par l'IA, et pas seulement avant une mise en production :

  • Tests de sécurité des applications statiques (SAST) pour détecter les modèles de code non sécurisés tels que les failles par injection.
  • Analyse de la composition logicielle (SCA) pour signaler les paquets tiers vulnérables ou suspects.
  • Détection de secrets pour bloquer les identifiants avant qu'ils ne soient validés. GitGuardian recommande lui-même d'analyser les modifications de code à la recherche de secrets avant de les valider.

Placez ces contrôles à deux endroits. Dans l'IDE, ils fournissent aux développeurs un retour immédiat pendant que le code est encore frais. Dans l'intégration continue (CI), ils agissent comme un verrou qui bloque une fusion lorsqu'un contrôle échoue.

L'analyse a une limite qui mérite d'être soulignée. Comme Salt Code l'explique, les outils SAST et DAST détectent les problèmes en aval, une fois le code validé, révisé et mis en file d'attente pour le déploiement ; chaque correction devient alors une réécriture. Les données de Veracode montrent également pourquoi les scanners seuls ne suffisent pas pour certaines catégories de failles : la détection des failles XSS (cross-site scripting) et des injections de logs nécessite de suivre la manière dont les entrées utilisateur circulent entre les fichiers et les fonctions, ce qu'un modèle générant une fonction isolée ne peut pas voir. Ajustez vos scanners pour détecter les modèles produits par les outils d'IA et associez-les à des mesures de prévention plus en amont dans le flux de travail.

Vérifiez chaque dépendance avant qu'elle n'intègre votre base de code

Les outils de codage par IA suggèrent parfois des paquets qui n'existent pas. Le Étude USENIX Security 2025 décrit cela comme une nouvelle forme d'attaque par confusion de paquets : un attaquant enregistre le nom halluciné sur un registre public tel que PyPI ou npm, y publie du code malveillant et attend qu'un développeur exécute la commande d'installation suggérée par l'IA. Les chercheurs ont constaté que le problème était persistant et systémique à travers les différents modèles.

Avant d'installer un paquet suggéré par un outil d'IA, confirmez trois points :

  1. Il est réel. Vérifiez que le paquet existe sur le registre officiel sous son nom exact et soyez vigilant face aux noms proches de bibliothèques populaires.
  2. Il est activement maintenu. Examinez l'historique des versions, l'activité du mainteneur et le volume de téléchargements. Un paquet flambant neuf sans historique mérite une attention particulière.
  3. Il est exempt de vulnérabilités connues. Passez-le au crible de votre outil d'analyse de composition logicielle (SCA) avant qu'il n'atteigne un fichier de verrouillage (lockfile).

Ensuite, tenez à jour une nomenclature logicielle (SBOM). Un SBOM est une liste des composants open source et tiers présents dans votre code, avec leurs versions, leurs licences et leur état de correctif, comme le Programme de sécurité et de confidentialité des informations du CMS l'explique. Le générer lors de l'intégration continue vous donne un registre permanent de chaque composant introduit par un outil d'IA, vous permettant ainsi de réagir rapidement lorsqu'une nouvelle vulnérabilité est divulguée.

Réservez la révision humaine aux changements à haut risque

Les outils automatisés ne peuvent pas détecter toutes les failles de logique métier, et les relecteurs ne peuvent pas analyser chaque ligne générée par l'IA à la vitesse d'une machine. Concentrez la relecture humaine là où une erreur coûte le plus cher :

  • Authentification et autorisation. Le contrôle d'accès mérite une attention particulière. Le rapport de Gartner How to Secure Custom-Built AI Agents indique que les problèmes de contrôle d'accès seront à l'origine de la plupart des failles de sécurité liées aux agents.
  • Cryptographie. Choix des algorithmes, gestion des clés et génération de nombres aléatoires.
  • Traitement des données sensibles. Tout ce qui touche aux données personnelles (PII), aux données de paiement ou aux données de santé, y compris les endroits où ces données sont journalisées.
  • Nouveaux points de terminaison externes, outils d'agent et serveurs MCP. Chaque nouvelle intégration d'API ou de MCP élargit votre surface d'attaque. Gartner note également que la plupart des serveurs MCP publiés manquent de désinfection de contenu, faisant des serveurs MCP publics un vecteur d'attaque important et sous-estimé.

Séparez la personne qui a demandé une modification risquée de celle qui l'approuve. Un développeur ayant itéré avec un assistant IA jusqu'à ce que le code fonctionne est le moins susceptible de repérer les erreurs commises par l'assistant.

La relecture ne s'arrête pas non plus à la fusion. Comme l'explique Nick Rago de Salt dans Votre transformation par l'IA nécessite une protection à l'exécution pour l'ensemble de votre écosystème d'agents, une seule requête peut transiter d'un agent via un LLM et des serveurs MCP jusqu'aux API qui font tourner votre entreprise. Un attaquant qui découvre un outil exposé peut contourner l'agent et appeler directement l'API sous-jacente. Le code écrit par vos assistants IA fait partie de ce chemin ; validez-le donc à l'exécution tout comme lors de la relecture.

Établissez une politique de gouvernance légère pour les outils de codage par IA

Rédigez une politique courte et pratique plutôt qu'un long document de conformité. Une politique que les gens peuvent lire en cinq minutes est une politique qu'ils respectent. Salt Code nomme l'alternative clairement : lorsque les politiques résident dans des PDF, des wikis et des connaissances tacites, l'IA qui construit votre logiciel n'en a lu aucune.

Au minimum, la politique doit préciser :

  • Où les outils d'IA sont autorisés. Quels assistants sont approuvés, pour quels dépôts, et si certains codes (tels que les modules cryptographiques ou de paiement) sont interdits.
  • Ce qui doit être analysé. Les contrôles SAST, SCA et de secrets que chaque modification assistée par IA doit réussir, ainsi que leur lieu d'exécution.
  • Ce qui nécessite une révision humaine. Les catégories à haut risque mentionnées dans la section précédente.
  • Qui est responsable des exceptions. Un responsable désigné capable d'approuver une dérogation et d'en justifier la raison.

Étiquetez les commits générés par l'IA afin que les équipes puissent retracer l'origine d'un problème jusqu'à la création du code. Les métadonnées des commits sont précisément ce qui a rendu possibles les découvertes de Claude Code par GitGuardian : les chercheurs n'ont pu comparer les taux de fuites que parce que ces commits comportaient une étiquette de co-auteur. Ce même étiquetage permet à votre équipe de mesurer si son code assisté par IA devient plus sûr au fil du temps.

Automatisez l'application des règles avec une plateforme de gouvernance du code IA

Chaque étape ci-dessus ne fonctionne que si les développeurs y pensent, à chaque requête et sous la pression des délais. Une plateforme de gouvernance dédiée applique ces étapes automatiquement. Lors de l'évaluation d'une solution, recherchez les points suivants :

  • Prévention au moment de la génération. Les politiques doivent façonner le code pendant que l'IA l'écrit, et ne pas se contenter de signaler les problèmes après le commit.
  • Couverture de tous vos assistants. Les développeurs utilisent plusieurs outils ; un modèle de politique unique doit les régir tous.
  • Application des règles dans le pipeline et à l'exécution. Des contrôles en CI/CD qui bloquent les violations avant la mise en production, ainsi qu'une surveillance du comportement réel des API, des serveurs MCP et des agents une fois déployés.
  • Priorisation basée sur l'exposition réelle. Résultats classés par accessibilité et exploitabilité, afin que les équipes traitent en priorité ce qui compte vraiment.
  • Pistes d'audit claires. Registres indiquant quelles politiques ont été appliquées à quel code, pour la conformité et la réponse aux incidents.

Salt Code est conçu pour ce flux de travail. Son objectif est de rendre le code généré par l'IA conforme dès sa création, et non a posteriori. Salt Code connecte le moteur de gouvernance de posture de Salt aux outils déjà utilisés par les développeurs et assure l'application des règles, de l'invite à la production :

  1. Découvrir chaque API, serveur MCP et intégration d'agent IA dans les dépôts de code et les environnements cloud.
  2. Appliquer pendant la génération de code en traduisant les politiques de sécurité en règles qui guident les assistants de codage IA en temps réel.
  3. Gouverner dans le pipeline en validant les politiques dans le CI/CD et les pull requests, et en bloquant les violations avant la mise en production.
  4. Valider à l'exécution en surveillant les API, les intégrations MCP et les agents pour détecter les violations de politique, les failles de posture et les activités anormales.
  5. Remédier et améliorer en réinjectant les résultats obtenus à l'exécution dans les flux de travail des développeurs et dans les assistants IA eux-mêmes.

Salt Code est fourni avec plus de 140 politiques prédéfinies, couvrant des cadres allant de l'OWASP API Security Top 10 au MCP Security Top 10, ainsi que vos propres règles personnalisées. Il fonctionne avec Claude Code, Cursor, GitHub Copilot, Windsurf, Kiro, Codex, Gemini CLI, JetBrains et tout assistant de codage IA prenant en charge la configuration de serveur MCP.

Les équipes souhaitant démarrer immédiatement peuvent utiliser la version gratuite de Salt Code. Elle s'installe en environ 60 secondes, ajoute 40 politiques de sécurité couvrant la sécurité des API, la sécurité MCP, la sécurité LLM et la conformité OpenAPI, et est active dès l'invite suivante. Selon Salt, elle injecte un contexte de sécurité dans la fenêtre de contexte de l'agent, de sorte que votre code ne quitte jamais votre machine. Le plan entreprise ajoute des packs de politiques personnalisés, une gestion à l'échelle de l'organisation, des rapports de sécurité au moment de l'invite, ainsi que le SSO/SCIM.

Pour le voir en action, regardez le webinaire à la demande Sécurisez le code généré par l'IA avant sa mise en production : Salt Code, qui inclut une démonstration en direct de Salt Code appliquant des politiques en temps réel au sein des assistants de codage IA.

Foire aux questions

Comment inciter l'IA à écrire du code plus sécurisé ?

Précisez les exigences de sécurité dans votre prompt plutôt que de demander uniquement la fonctionnalité. Exigez explicitement la validation des entrées, les requêtes paramétrées, les contrôles d'authentification et d'autorisation, la gestion sécurisée des jetons et des identifiants, et l'absence de secrets codés en dur. Maintenez une bibliothèque partagée de prompts éprouvés pour que toute l'équipe parte sur une base commune, et utilisez un outil qui injecte automatiquement les politiques de sécurité afin que la protection ne dépende pas de la mémoire humaine.

Une relecture humaine du code généré par l'IA est-elle toujours nécessaire ?

Oui, mais de manière ciblée. Veracode a constaté que même le modèle le plus performant lors de ses tests de 2026 échouait encore à environ une tâche de sécurité sur trois. Concentrez la relecture humaine sur l'authentification et l'autorisation, la cryptographie, la gestion des données sensibles, ainsi que sur les nouveaux points de terminaison, les outils d'agent ou les serveurs MCP, et laissez l'automatisation gérer le reste.

Quels outils permettent de sécuriser le code généré par l'IA ?

Une approche multicouche : l'analyse statique (SAST) pour détecter les modèles non sécurisés, l'analyse de composition logicielle (SCA) pour identifier les paquets vulnérables ou inexistants, la détection de secrets avant le commit, la génération de SBOM pour le suivi des composants, et une plateforme de gouvernance du code IA telle que Salt Code, qui applique les politiques directement au sein de l'assistant de codage.

Comment éviter que des secrets ne se retrouvent dans le code généré par l'IA ?

Ne collez jamais de véritables identifiants dans des prompts ou des exemples de code. Référencez les secrets à partir d'un coffre-fort ou d'un gestionnaire de secrets, exécutez une détection de secrets dans l'IDE ainsi qu'en tant que vérification pré-commit et CI, et auditez les fichiers de configuration MCP, que GitGuardian a identifiés comme une source croissante de fuites d'identifiants. Si un secret fuit, révoquez-le immédiatement plutôt que de simplement le supprimer du dernier commit.

Le code généré par l'IA doit-il suivre un processus de revue distinct du code écrit par des humains ?

Il doit répondre aux mêmes exigences de sécurité, avec des contrôles supplémentaires adaptés aux types d'erreurs de l'IA : vérification des paquets, analyse des secrets et examen plus approfondi des catégories à haut risque. Étiqueter les commits assistés par l'IA rend cette démarche pratique, car cela permet d'orienter ces modifications vers les contrôles appropriés et de mesurer les résultats au fil du temps.

Nos derniers articles