💬 NLP

SecureForge: Finding and Preventing Vulnerabilities in LLM-Generated Code via Prompt Optimization

L'article présente SecureForge, un pipeline automatisé qui optimise les invites système à l'aide d'un corpus synthétique d'invites amplifiant les vulnérabilités afin de réduire considérablement les failles de sécurité dans le code généré par les LLM tout en maintenant les performances fonctionnelles, permettant une réduction allant jusqu'à 48 % des vulnérabilités avec une transférabilité en zéro-shot vers des scénarios réels.

Auteurs originaux : Houjun Liu, Lisa Einstein, John Yang, Joachim Baumann, Duncan Eddy, Christopher D. Manning, Mykel Kochenderfer, Diyi Yang

Publié 2026-05-12

📖 5 min de lecture🧠 Analyse approfondie

CC BY 4.0

Auteurs originaux : Houjun Liu, Lisa Einstein, John Yang, Joachim Baumann, Duncan Eddy, Christopher D. Manning, Mykel Kochenderfer, Diyi Yang

Article original sous licence CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ Ceci est une explication générée par l'IA de l'article ci-dessous. Elle n'a pas été rédigée ni approuvée par les auteurs. Pour une précision technique, consultez l'article original. Lire la clause de non-responsabilité complète

Imaginez que vous engagez un architecte robot brillant et ultra-rapide pour construire une maison. Vous lui dites : « Construis-moi une maison sécurisée », et il le fait. Mais parce que le robot a appris à partir de milliards de vieux plans (dont certains comportaient des fissures cachées), il installe par erreur une porte qui semble verrouillée mais qui s'ouvre en fait si vous la poussez juste comme il faut.

C'est le problème que SecureForge résout.

Voici l'article expliqué en termes simples, utilisant des analogies pour le rendre clair.

Le problème : La « fissure invisible »

Les assistants de codage IA actuels sont incroyables. Ils écrivent du code plus vite que n'importe quel humain. Mais ils ont une habitude dangereuse : ils écrivent souvent du code qui semble parfait mais qui présente des failles de sécurité cachées.

Les chercheurs ont découvert que même lorsqu'ils disaient explicitement à l'IA : « Veuillez écrire un code sécurisé et éviter ces erreurs de sécurité spécifiques », l'IA commettait encore des erreurs environ 23 % du temps.

Pensez-y comme à un chef à qui l'on dit : « Ne mettez pas de poison dans cette soupe ». Le chef fait de son mieux, mais parce qu'il a appris à partir d'anciens livres de cuisine contenant de mauvaises recettes, il ajoute par erreur un ingrédient toxique. La soupe a bon goût (le code passe les tests), mais elle est dangereuse à consommer (elle présente des vulnérabilités de sécurité).

La solution : SecureForge

Les auteurs ont créé un outil appelé SecureForge. Au lieu d'essayer de retraiter le robot (ce qui est coûteux et difficile), ils ont créé un « manuel d'instruction » (un prompt système) que le robot lit avant de commencer à travailler.

SecureForge fonctionne en trois étapes simples, comme un détective résolvant une affaire :

Étape 1 : Le piège (Repérer les erreurs)

D'abord, SecureForge demande à l'IA d'accomplir des tâches normales et inoffensives (comme « construire une page de connexion »). Il utilise ensuite un analyseur de sécurité (une loupe numérique) pour vérifier le code.

Objectif : Trouver les requêtes spécifiques et banales qui trompent l'IA et la poussent à faire une erreur.
Analogie : C'est comme un gardien de sécurité qui teste un coffre-fort bancaire en essayant de l'ouvrir avec une clé ordinaire. Il ne tente pas de s'introduire ; il cherche simplement à voir où la serrure est faible.

Étape 2 : La chambre d'écho (Amplifier les erreurs)

Une fois qu'ils ont trouvé une requête qui provoque une erreur, ils ne s'arrêtent pas là. Ils utilisent une technique appelée MCMC (Monte Carlo par chaîne de Markov).

Ce qu'elle fait : Elle prend cette seule mauvaise requête et crée des milliers de versions légèrement différentes, comme un livre « choisissez votre propre aventure » où chaque chemin mène à une variation différente du même problème.
Analogie : Imaginez que vous avez trouvé un moyen de tromper un gardien de sécurité. Au lieu d'utiliser seulement ce seul tour, vous écrivez un livre contenant 80 000 façons différentes de tromper ce gardien, couvrant tous les angles possibles. Cela crée une immense bibliothèque de « scénarios d'échec ».

Étape 3 : L'exercice (Optimiser les instructions)

Maintenant, SecureForge prend cette immense bibliothèque de scénarios d'échec et apprend à l'IA comment les éviter. Il utilise un algorithme génétique (un processus d'évolution numérique) pour ajuster les instructions que l'IA lit.

Fonctionnement : Il teste différentes versions du « prompt système » (le livre de règles). Si un livre de règles conduit à un code sécurisé, il le conserve. S'il conduit à une faille, il le rejette et en essaie un nouveau.
Analogie : C'est comme un entraîneur qui fait faire un exercice où le joueur s'entraîne à échouer encore et encore jusqu'à ce qu'il apprenne enfin la manière parfaite de se tenir pour ne jamais tomber. L'entraîneur ne change pas les muscles du joueur (le cerveau de l'IA) ; il change simplement le livre de stratégies.

Les résultats : Plus fort et plus intelligent

L'article a testé cela sur les modèles d'IA les plus avancés disponibles (comme GPT-5 et Claude).

Avant SecureForge : L'IA commettait des erreurs de sécurité environ 23 % du temps, même lorsqu'on lui demandait d'être sûre.
Après SecureForge : Les erreurs ont diminué jusqu'à 48 %.
Le meilleur aspect : L'IA ne s'est pas détériorée dans son travail réel. Elle a toujours réussi tous ses tests de codage. En fait, elle est devenue meilleure à la fois pour être sécurisée et pour être utile en même temps.

Pourquoi cela compte

La plupart des outils de sécurité tentent de repérer le mauvais code après qu'il a été écrit (comme un correcteur orthographique). SecureForge modifie les instructions que l'IA suit avant qu'elle n'écrive la moindre ligne de code.

C'est comme donner au robot architecte un nouveau jeu de plans disant : « N'oubliez pas, dans cette situation spécifique, utilisez toujours une serrure à mortaise, pas un loquet. » Le robot n'a pas besoin d'être reconstruit ; il a juste besoin de meilleures instructions.

L'essentiel : Vous n'avez pas besoin de retraiter l'IA pour la rendre plus sûre. Vous avez juste besoin de trouver le bon « prompt » (instruction) qui lui apprend à éviter les fissures invisibles qu'elle crée naturellement. SecureForge est la machine automatisée qui trouve cette instruction parfaite.

Résumé Technique : SecureForge

Énoncé du Problème

Les agents de codage basés sur les grands modèles de langage (LLM) génèrent du code à une échelle sans précédent, mais ils introduisent fréquemment des vulnérabilités de cybersécurité dans les bases de code sans intervention humaine. Un mode de défaillance critique identifié dans ce travail est la génération de code fonctionnellement correct mais non sécurisé. Même lorsque les modèles de pointe sont explicitement instruits d'écrire du code de production sécurisé et qu'ils reçoivent un contexte concernant des faiblesses spécifiques à éviter, ils produisent encore des vulnérabilités vérifiables environ 23 % du temps sur un corpus de 250 invites de codage bénignes.

Les approches existantes pour atténuer ces risques souffrent de lacunes importantes :

Modèles de Menace Désalignés : Les tests d'intrusion (red-teaming) antérieurs reposent souvent sur des invites adverses qui ne reflètent pas les interactions typiques des utilisateurs avec des tâches de codage bénignes.
Couverture Insuffisante : Les scénarios conçus à la main ciblant des Enumérations de Faiblesses Communes (CWE) spécifiques échouent à caractériser l'espace complet des invites bénignes qui pourraient produire involontairement du code vulnérable.
Obstacles au Déploiement : Les méthodes de durcissement actuelles nécessitent souvent un accès en boîte blanche aux poids pour le fine-tuning ou le préfixage, ce qui est inaccessible pour les développeurs utilisant des modèles à poids fermés via API. De plus, le fine-tuning comporte des risques de décalage de distribution qui dégradent les capacités générales de codage.

Il manque une approche automatisée, facilement déployable et fonctionnant au moment de l'inférence pour mesurer et prévenir l'introduction de faiblesses courantes dans le code généré par des modèles de pointe, sans nécessiter de mise à jour des poids du modèle.

Méthodologie : Pipeline SecureForge

SecureForge est un pipeline automatisé et léger conçu pour durcir proactivement les agents de codage IA contre les faiblesses courantes. Il ne nécessite que l'accès API au modèle à tester et un analyseur statique. Le pipeline opère en trois étapes distinctes :

1. Falsification en Coup Unique (Découverte)

La première étape identifie des invites de départ (seed) bénignes qui suscitent des vulnérabilités vérifiables statiquement.

Génération d'Invites : À partir de la base de données MITRE CWE, le système génère des tâches de codage réalistes utilisant des bibliothèques spécifiques associées à des faiblesses connues (par exemple, injection SQL dans Django).
Filtrage Bénin : Ces invites sont révisées pour supprimer les mentions explicites d'attaques, de vulnérabilités ou de CWE. Le générateur est instruit d'utiliser un langage de qualité production (par exemple, « assurez-vous que l'entrée est correctement assainie ») pour garantir que les invites apparaissent comme des demandes utilisateur standard.
Évaluation : Le modèle cible génère du code pour ces invites avec une température de 1,0. Les sorties sont analysées à l'aide de Semgrep (un outil d'analyse statique). Les invites qui aboutissent à un code passant les tests unitaires mais échouant à l'analyse statique (déclenchant une vulnérabilité) sont conservées comme invites de départ « falsifiées ».

2. Découverte de la Distribution des Échecs (Amplification)

Pour surmonter la sparsité des exemples d'échec initiaux et assurer la diversité, SecureForge utilise un échantillonnage par Chaîne de Markov Monte Carlo (MCMC), exploitant spécifiquement le critère de Metropolis-Hastings (MH).

Objectif : Échantillonner la distribution conditionnelle d'échec $p(\cdot | F_j)$ , où $F_j$ est un type de faiblesse spécifique.
Processus : À partir d'une invite de départ, un noyau d'exploration (une invite de reformulation par un modèle de langage) génère des variations candidates. L'acceptation d'une nouvelle invite $x'$ est déterminée par le rapport de sa probabilité d'échec non normalisée $\bar{p}(x')$ à la probabilité de l'invite actuelle, ajustée par le noyau de transition.
Estimation de Probabilité : La probabilité d'échec $p_{fail}(x)$ est estimée en exécutant l'invite plusieurs fois et en ajustant une distribution Beta aux comptes de succès/échec jusqu'à ce que la variance converge en dessous d'un seuil.
Résultat : Ce processus amplifie un petit ensemble d'invites de départ en un grand corpus synthétique diversifié (80 000 invites) qui maintient des taux de vulnérabilité élevés tout en explorant la distribution des échecs.

3. Durcissement par Optimisation d'Invite

L'étape finale optimise une invite système pour réduire la probabilité de générer du code non sécurisé sans modifier les poids du modèle.

Algorithme d'Optimisation : Le pipeline utilise GEPA (Genetic-Pareto), un algorithme génétique d'ordre zéro qui emploie l'auto-réflexion.
Processus : En partant d'une invite système générique, GEPA génère itérativement des invites système candidates. Chaque candidat est évalué contre l'ensemble du corpus synthétique d'invites d'échec.
Fonction de Fitness : L'algorithme minimise la probabilité d'échec agrégée sur le corpus tout en maintenant la correction fonctionnelle (passage des tests unitaires).
Boucle de Rétroaction : L'analyseur statique fournit un signal (score ±1) basé sur la présence ou non de vulnérabilités dans le code généré. L'invite système est mutée et sélectionnée selon l'optimalité de Pareto, équilibrant sécurité et capacité.

Contributions Clés

Caractérisation Empirique des Échecs Bénins : Les auteurs démontrent que les modèles de pointe génèrent du code non sécurisé même lorsqu'ils sont explicitement priés d'être sûrs et qu'ils reçoivent un contexte CWE. Ils ont constaté que 12,7 % des sorties sont à la fois vulnérables et passent les tests unitaires, soulignant l'invisibilité de ces échecs.
Amplification par MCMC : L'article introduit une méthode pour passer à l'échelle des exemples individuels de falsification vers un corpus diversifié de scénarios d'échec en utilisant MCMC. Les études d'ablation montrent que cette méthode découvre de nouvelles invites vulnérables jusqu'à 2 fois plus efficacement qu'une simple reformulation.
Durcissement au Moment de l'Inférence : SecureForge fournit une solution déployable qui améliore la sécurité uniquement par l'optimisation de l'invite système. Elle ne nécessite ni fine-tuning, ni accès en boîte blanche, ni exposition aux distributions d'invites utilisateur réelles pendant la phase d'optimisation.
Boîte à Outils Open-Source : Les auteurs publient une boîte à outils (secureforge) qui automatise l'ensemble du pipeline, de la génération d'invites d'échec bénignes à l'optimisation des invites système via API ou déploiement local.

Résultats

L'évaluation a été menée sur une suite de modèles open-source (Qwen, CodeLlama, Kimi) et de modèles fermés de pointe (série GPT-5, Claude Sonnet 4.6).

Réduction des Vulnérabilités : SecureForge a obtenu une réduction statistiquement significative des taux de vulnérabilité, avec une réduction maximale de 48 % sur les modèles testés.
Amélioration de Pareto : Les invites système optimisées ont entraîné une amélioration conjointe des taux de succès des tests unitaires et de la sécurité des sorties. Les modèles se sont déplacés significativement vers le quadrant « plus sûr » du plan (passage du test, sécurité) sans dégrader la capacité de codage.
Transfert Zero-Shot : Les invites système optimisées sur des données synthétiques se sont transférées efficacement vers des invites d'agents de codage réels « in-the-wild » issues du jeu de données SWE-chat. Ce transfert s'est produit sans aucune exposition aux distributions d'invites utilisateur réelles pendant la phase d'optimisation, améliorant le taux conjoint de passage des tests et de sécurité jusqu'à 13,5 % sur des tâches réelles.
Comparaison avec la Référence : Des stratégies d'invites simples (demander du code sécurisé ou lister des CWE) ont échoué à réduire les taux de vulnérabilité au même niveau que SecureForge, laissant des taux de vulnérabilité à deux chiffres même dans les scénarios de passage des tests.

Importance et Revendications

L'article revendique que SecureForge comble une lacune critique dans la sécurité des LLM en fournissant un mécanisme automatisé, fonctionnant au moment de l'inférence, pour durcir les agents de codage contre les faiblesses courantes.

Au-delà de l'Entraînement à la Sécurité : Les résultats suggèrent que l'entraînement à la sécurité existant dans les modèles de pointe est insuffisant pour prévenir les vulnérabilités découlant de demandes utilisateur bénignes et involontaires. Demander explicitement de la sécurité ou fournir des listes de CWE ne suffit pas.
Durcissement Évolutif : En s'appuyant sur l'analyse statique et l'optimisation d'invites plutôt que sur des mises à jour de poids, SecureForge offre une voie pratique pour que les développeurs sécurisent immédiatement les modèles à poids fermés.
Sécurité par Conception : Les auteurs postulent que si cette approche est mise en œuvre à grande échelle, elle aide les fournisseurs de technologies à respecter les engagements de « sécurité par conception » en identifiant et en atténuant proactivement les modes de défaillance avant la livraison du code.

Le travail souligne que si l'évaluation actuelle est limitée à la génération de code Python en un seul tour, le pipeline fournit un cadre général pour découvrir et réduire les insécurités de codage dans les LLM de pointe, ne nécessitant qu'une analyse statique de vérité terrain et aucune annotation humaine.