Améliorer les LLM pour corriger les vulnérabilités de code

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.