Améliorer les LLM pour corriger les vulnérabilités de code
Améliorer la capacité des LLM à réparer les vulnérabilités de dépassement de buffer avec des techniques sensibles au contexte.
Arshiya Khan, Guannan Liu, Xing Gao
― 7 min lire
Table des matières
Les grands modèles de langage (LLM) sont des programmes informatiques capables de comprendre et de générer du langage humain. Ils sont devenus populaires pour plein de tâches, y compris pour aider les programmeurs à écrire et corriger du code. Cependant, ces modèles rencontrent souvent des problèmes lorsqu'il s'agit de gérer des questions de sécurité, surtout pour corriger du code vulnérable.
Dans cet article, on se concentre sur les Vulnérabilités de débordement de tampon, qui peuvent survenir lorsqu'un programme essaie de stocker plus de données dans un tampon que ce qu'il peut contenir. Cela peut entraîner un comportement imprévisible et des risques de sécurité. On explore comment améliorer la capacité des LLM à identifier et corriger ce genre de vulnérabilités en leur donnant plus de contexte sur le code et les enjeux de sécurité liés.
Le problème avec les LLM
Des LLM comme GitHub Copilot peuvent analyser du code et détecter des vulnérabilités, mais ils ont souvent du mal à corriger ces problèmes efficacement. Nos recherches montrent que Copilot peut détecter des vulnérabilités dans environ 76 % des cas, mais il ne peut les réparer avec succès que dans 15 % des cas. Cet écart montre que même si Copilot peut identifier des problèmes, il a du mal à générer le code correct pour les corriger.
Pour améliorer ça, on explore l'utilisation de l'ajustement de prompt sensible au contexte. Cette technique consiste à fournir aux LLM des informations supplémentaires sur les vulnérabilités dans le code. En faisant cela, on vise à renforcer leur capacité à réparer du code vulnérable.
Mise en place de l'expérience
On a mené des expériences pour tester les performances de Copilot dans la Détection et la réparation des vulnérabilités de débordement de tampon. On a commencé par analyser 156 morceaux de code contenant différents types de problèmes de débordement de tampon. Le but était de voir combien de vulnérabilités Copilot pouvait détecter et combien il pouvait réellement réparer.
Nos résultats étaient inquiétants. Copilot avait un taux de détection de vulnérabilités de 76 %, ce qui est pas mal. Cependant, pour ce qui est de la réparation des vulnérabilités, le taux est tombé à seulement 15 %. Cela nous dit que même si Copilot peut reconnaître un problème, il peine à le corriger.
Test avec le contexte de sécurité
Pour voir si on pouvait améliorer le taux de réparation de Copilot, on l'a testé en lui fournissant un contexte de sécurité supplémentaire dans les prompts. D'abord, on a mentionné calmement dans le prompt qu'il y avait une vulnérabilité dans le code sans donner de détails précis. Ça a mené à une légère amélioration du taux de réparation, augmentant de 15 % à 20 %. Bien que ce soit une petite amélioration, ça a montré que fournir plus d'infos pouvait aider.
Ensuite, on a ajouté encore plus de détails spécifiques sur le type de vulnérabilité – en mentionnant spécifiquement le débordement de tampon. Ça a encore augmenté le taux de succès de réparation, atteignant 31 %. Ces résultats suggèrent que donner à Copilot des instructions plus claires sur la nature des vulnérabilités peut booster sa capacité à les corriger.
Ajustement de prompt sensible au contexte
En se basant sur ces découvertes, on a développé un processus d'ajustement de prompt sensible au contexte qui inclut à la fois le contexte de sécurité et le contexte de code dans les prompts. Le contexte de code fait référence aux éléments spécifiques dans le code qui peuvent contribuer à la vulnérabilité, et comprendre cela est crucial pour des Réparations efficaces.
Pour tester cette méthode, on a mis en œuvre une approche étape par étape où on a guidé Copilot à travers le processus de réparation. À chaque étape, on lui a fourni des informations pertinentes sur les vulnérabilités de débordement de tampon dans le code. Si Copilot identifiait incorrectement une vulnérabilité, on la corrigeait et fournissait un contexte supplémentaire.
Au fur et à mesure que Copilot avançait dans ces étapes, on a vu que sa capacité à générer du code correct augmentait. À la fin de ce processus, le taux de réparation de Copilot avait bondi à 63 %. Cela signifie qu'en lui donnant à la fois un contexte de sécurité et un contexte de code, on pouvait augmenter la probabilité que Copilot produise des réparations précises.
Comparaison des taux de succès de réparation
On a comparé les performances de Copilot sur des vulnérabilités dépendantes du code, comme le débordement de tampon, par rapport à ses performances sur des vulnérabilités indépendantes du code, qui ne dépendent pas d'éléments de code spécifiques. Quand on l'a testé, on a trouvé que Copilot avait un taux de succès de 53 % pour réparer les vulnérabilités indépendantes du code mais seulement 13 % pour celles dépendantes du code.
Cette différence significative met en lumière à quel point il est plus difficile pour Copilot de réparer des vulnérabilités dépendantes du code. Notre objectif était d'améliorer ses performances sur ces types de vulnérabilités grâce à l'ajustement de prompt sensible au contexte. Les exemples de débordement de tampon ont fourni un axe clair pour nos expériences et nous ont permis d'affiner les performances du modèle.
Approche en cascade pour l'ajustement de prompt sensible au contexte
Le processus d'ajustement de prompt sensible au contexte qu'on a développé peut être visualisé comme un modèle en cascade. Ça veut dire qu'on commence par des infos basiques et on ajoute progressivement plus de détails au fur et à mesure que le processus avance. À chaque étape, on pose une question à Copilot sur la détection de vulnérabilités, suivi d'un prompt pour réparer les problèmes identifiés.
Si Copilot ne répare pas le code correctement, on lui donne un coup de main supplémentaire en clarifiant le problème. En le guidant à travers ces étapes, on construit sur les connaissances liées au domaine en rapport avec le contexte de sécurité et le contexte de code.
Les résultats de cette méthode ont montré qu'au fur et à mesure qu'on introduisait plus d'infos à chaque étape, la probabilité que Copilot répare avec succès les vulnérabilités augmentait significativement.
Conclusion
Pour conclure, nos recherches montrent que réparer du code vulnérable est un vrai défi pour des LLM comme GitHub Copilot, surtout quand il s'agit de vulnérabilités dépendantes du code comme le débordement de tampon. Cependant, en fournissant le bon contexte grâce à l'ajustement de prompt, on peut vraiment améliorer la capacité du modèle à corriger ces problèmes.
En testant diverses méthodes pour ajouter du contexte de sécurité et de code, on a découvert qu'une approche structurée pouvait augmenter le taux de succès de réparation de 15 % à 63 %. Cette amélioration claire met en évidence la nécessité pour les programmeurs de fournir le plus d'infos pertinentes possible quand ils utilisent des LLM pour des tâches de réparation de code.
Les aperçus tirés de cette étude contribuent au développement continu et à l'amélioration des LLM, les rendant plus efficaces comme outils pour la sécurité logicielle. À mesure qu'ils évoluent, ils peuvent mieux soutenir les programmeurs dans l'identification et la réparation des vulnérabilités, menant finalement à des systèmes logiciels plus sûrs et plus fiables.
Titre: Code Vulnerability Repair with Large Language Model using Context-Aware Prompt Tuning
Résumé: Large Language Models (LLMs) have shown significant challenges in detecting and repairing vulnerable code, particularly when dealing with vulnerabilities involving multiple aspects, such as variables, code flows, and code structures. In this study, we utilize GitHub Copilot as the LLM and focus on buffer overflow vulnerabilities. Our experiments reveal a notable gap in Copilot's abilities when dealing with buffer overflow vulnerabilities, with a 76% vulnerability detection rate but only a 15% vulnerability repair rate. To address this issue, we propose context-aware prompt tuning techniques designed to enhance LLM performance in repairing buffer overflow. By injecting a sequence of domain knowledge about the vulnerability, including various security and code contexts, we demonstrate that Copilot's successful repair rate increases to 63%, representing more than four times the improvement compared to repairs without domain knowledge.
Auteurs: Arshiya Khan, Guannan Liu, Xing Gao
Dernière mise à jour: 2024-09-26 00:00:00
Langue: English
Source URL: https://arxiv.org/abs/2409.18395
Source PDF: https://arxiv.org/pdf/2409.18395
Licence: https://creativecommons.org/licenses/by/4.0/
Changements: Ce résumé a été créé avec l'aide de l'IA et peut contenir des inexactitudes. Pour obtenir des informations précises, veuillez vous référer aux documents sources originaux dont les liens figurent ici.
Merci à arxiv pour l'utilisation de son interopérabilité en libre accès.