Examiner les failles de sécurité dans le code généré par l'IA

Les grands modèles de langage (LLMs) changent notre façon d'aborder le développement de logiciels et le codage. Les développeurs comptent maintenant sur divers outils pour les aider à créer et à compléter le code. Alors que ces outils alimentés par l'IA gagnent en popularité, il est essentiel de comprendre leur potentiel à introduire des failles de sécurité dans le code qu'ils génèrent. Des études précédentes ont montré que les LLMs peuvent produire un code incorrect ou même contenant des Vulnérabilités. Par exemple, des ingénieurs logiciels utilisant des outils d'IA ont été trouvés à faire plus d'erreurs dans leur code, entraînant des problèmes de sécurité potentiels.

Les chercheurs ont commencé à analyser la sortie de ces modèles de plus près, cherchant à identifier les vulnérabilités dans le code généré. La question se pose : Peut-on faire confiance à ces modèles pour créer du code sécurisé pour des projets réels ?

Pour répondre à cette question, un ensemble de données appelé FormAI a été créé, qui comprenait une grande collection de programmes C générés par l'IA. Cette étude s'appuie sur ce travail en introduisant une nouvelle version du jeu de données, FormAI-v2. Ce nouvel ensemble de données contient encore plus de programmes C compilables générés par divers LLMs avancés. L'objectif est d'analyser la sécurité du code produit et de comprendre à quelle fréquence ces modèles produisent des vulnérabilités.

#Ensemble de données FormAI-v2

L'ensemble de données FormAI-v2 comprend environ 265 000 programmes C compilables réalisés en utilisant différents LLMs. Cela inclut des modèles puissants comme GPT-4, Gemini-pro de Google, et Falcon de TII. Chaque programme de cet ensemble de données a été soigneusement vérifié pour des vulnérabilités à l'aide d'un outil de vérification formelle appelé ESBMC.

Ce processus de vérification rigoureux aide à s'assurer que le nombre de vulnérabilités signalées est précis. Dans cette étude, nous avons découvert qu'au moins 63,47 % des programmes générés contiennent des vulnérabilités. Les différences dans les erreurs de codage entre les modèles sont subtiles, tous les modèles montrant des types d'erreurs similaires.

Cet ensemble de données représente une étape significative vers une meilleure compréhension de l'efficacité de ces modèles à produire un code sécurisé. Les modèles peuvent générer du code qui semble correct mais peut toujours introduire des risques de sécurité. Ainsi, une validation et une évaluation des risques soigneuses sont nécessaires lorsque l'on envisage le code généré par des LLMs pour une utilisation en production.

#Grands modèles de langage et sécurité des logiciels

Les LLMs sont de plus en plus utilisés pour des tâches de codage, aidant les développeurs à créer des programmes simples et à gérer diverses fonctions. Cependant, bien que les LLMs montrent des capacités à produire du code, ils peuvent également générer du code qui est défectueux ou non sécurisé. La recherche sur ce sujet est en pleine expansion, alors que de plus en plus d'ingénieurs logiciels reconnaissent les risques potentiels associés à l'utilisation d'outils d'IA en programmation.

Une étude a indiqué que les LLMs peuvent non seulement produire du code syntaxiquement correct, mais aussi introduire de nouvelles vulnérabilités dans les systèmes sur lesquels ils travaillent. Étant donné que beaucoup de ces modèles sont formés sur des données accessibles au public, il y a un risque qu'ils reproduisent des modèles de codage vulnérables trouvés en ligne.

Cela soulève une question cruciale : Quelle est la sécurité d'utiliser ces modèles pour des tâches de programmation réelles sans protections en place ?

#Recherches antérieures

L'ensemble de données FormAI original a été créé pour examiner le code C généré par l'IA, en catégorisant les vulnérabilités trouvées. Les travaux précédents se concentraient principalement sur un seul modèle (GPT-3.5) sans le comparer à d'autres modèles avancés. Cette nouvelle étude cherche à combler ces lacunes en analysant huit LLMs différents.

De plus, la recherche originale a peut-être manqué certaines vulnérabilités en raison des limitations des méthodes de vérification précédentes. En utilisant une approche de vérification non bornée plus approfondie, nous pouvons mieux évaluer les vulnérabilités présentes dans le code.

La complexité du code généré n'a également pas été analysée dans l'étude originale. Nous calculons maintenant une mesure connue sous le nom de Complexité cyclomatique, qui aide à comprendre la complexité inhérente du code produit par chaque LLM.

#Questions de recherche

Cette étude aborde un ensemble de questions de recherche visant à évaluer les propriétés de sécurité du code généré par des LLMs avancés. Ces questions portent sur la comparaison du code généré par différents modèles, la compréhension des modèles produisant le code le plus vulnérable et l'analyse des caractéristiques des programmes générés.

#Création d'ensemble de données et méthodologie

L'ensemble de données FormAI-v2 se compose de deux parties principales : les programmes C générés par l'IA et leurs classifications de vulnérabilités. Le processus de génération a impliqué la création d'un mélange de programmes en utilisant divers LLMs, assurant une collection variée.

Pour produire un ensemble diversifié de sorties, une méthode de demande dynamique a été utilisée. En variant les invites d'entrée, nous avons pu générer une riche variété de programmes couvrant plusieurs scénarios de codage. Chaque programme généré a ensuite été vérifié pour sa compilabilité, garantissant qu'il pouvait être exécuté sans erreurs.

Pour la classification des vulnérabilités, nous avons utilisé ESBMC pour vérifier chaque échantillon de code. Cet outil puissant détecte non seulement les vulnérabilités, mais minimise également les faux positifs, garantissant que l'ensemble de données reflète des résultats précis.

#Résultats

Après avoir généré et vérifié les programmes, nous avons constaté qu'une part significative du code contenait des vulnérabilités. Le processus de vérification a révélé un large éventail de problèmes, allant des débordements de mémoire à la mauvaise gestion des pointeurs.

Les résultats ont montré que certains types de vulnérabilités étaient répandus dans différents modèles. Par exemple, les débordements de mémoire ont été fréquemment identifiés dans des programmes utilisant la fonction scanf, soulignant les pièges communs dans la gestion des entrées utilisateur.

#Complexité cyclomatique

La complexité cyclomatique est une façon de mesurer la complexité du code en fonction de sa structure. Cette métrique peut indiquer à quel point un morceau de code pourrait être difficile à tester, à maintenir ou à dépanner. Un score plus élevé suggère généralement que le code est plus compliqué et pose plus de défis en matière d'erreurs.

Dans notre analyse, nous avons calculé la complexité cyclomatique pour le code généré par chaque modèle. Il a été noté que des modèles comme GPT-4 produisaient des programmes plus longs tout en maintenant une complexité cyclomatique plus faible. Cela indique que bien qu'ils puissent créer des programmes plus complexes, ils peuvent également le faire de manière structurée et gérable.

#Classification des vulnérabilités

Chaque programme généré a été classé en fonction des vulnérabilités identifiées par ESBMC. La classification aide à comprendre les types communs de vulnérabilités à travers différents modèles. Les problèmes les plus fréquemment détectés incluent :

• Échecs de déréférencement : Souvent associés à des vérifications de pointeur manquantes.
• Débordements de mémoire : Survenant souvent en raison d'une mauvaise gestion de la taille de l'entrée.
• Débordements arithmétiques : Souvent liés à des opérations dépassant les limites de valeur.

Ces résultats soulignent l'importance de pratiques de codage robustes, surtout en ce qui concerne la gestion des pointeurs et des tampons.

#Comparaison des modèles

Nous avons comparé la performance de différents LLMs en matière de génération de code sécurisé. Le code généré par chaque modèle a été soumis au même processus de vérification. Les résultats ont montré que tous les modèles produisaient des vulnérabilités, mais la fréquence et les types variaient.

Bien que certains modèles montrent une performance légèrement meilleure, aucun ne peut être considéré comme totalement sécurisé. Cela souligne la nécessité de méthodes de validation efficaces lors de l'utilisation de code généré par l'IA dans des applications critiques.

#Conclusion

L'ensemble de données FormAI-v2 offre des perspectives précieuses sur les capacités et les limites des grands modèles de langage en programmation. Bien que les LLMs puissent générer des solutions syntaxiquement correctes et parfois créatives, ils posent également des risques considérables en matière de sécurité des logiciels.

Les découvertes révèlent que l'utilisation de code généré par des LLMs dans la pratique peut conduire à d'importantes vulnérabilités si ce code n'est pas soigneusement évalué. Alors que les outils d'IA deviennent intégrés aux pratiques de codage, il est crucial de continuer à rechercher leurs implications en matière de sécurité et de développer des cadres pour assurer une utilisation sûre.

#Directions futures

Les recherches futures devraient se concentrer sur l'expansion de l'ensemble de données FormAI en incluant des modèles plus avancés et en augmentant la taille de l'échantillon pour de meilleures comparaisons. De plus, explorer comment différentes tâches de programmation ou styles impactent les motifs de vulnérabilités pourrait fournir des informations exploitables.

Comprendre les raisons derrière les résultats de vérification réussis peut également conduire à de meilleures pratiques de codage dans les programmes générés par l'IA. En fin de compte, l'objectif est de tirer parti des avantages de l'IA dans le codage tout en minimisant les risques. Le développement continu d'outils pour détecter les vulnérabilités sera essentiel à mesure que la dépendance à l'IA dans le développement logiciel continuera de croître.