Évaluer l'apprentissage automatique pour la détection des vulnérabilités logicielles

Des travaux récents ont montré que l'Apprentissage automatique peut aider à détecter des problèmes de sécurité dans les logiciels. En examinant le code source d'une fonction, les modèles d'apprentissage automatique peuvent identifier s'il y a une faille avec un bon niveau de précision. Cependant, il y a des inquiétudes sur la fiabilité de ces résultats à travers différents ensembles de données.

Pour évaluer la capacité générale de ces modèles, des chercheurs ont essayé d'ajouter de petites modifications aux Données de test tout en gardant le même sens. Ce test a révélé que les modèles s'appuyaient souvent sur des caractéristiques non liées aux Vulnérabilités réelles, et leur précision chutait considérablement. En réponse, une stratégie a été suggérée où le modèle serait formé sur ces données modifiées, ce qui améliorerait les performances.

Dans cette étude, nous approfondissons cette investigation. Nous proposons une façon simple de benchmarker ces modèles, ce qui peut aider les chercheurs à mieux évaluer comment l'apprentissage automatique fonctionne pour trouver des vulnérabilités dans le code. Plus précisément, nous suggérons deux approches : une où nous transformons les données d'entraînement et de test tout en gardant leur sens intact, et une autre où nous testons le modèle avec des données contenant des vulnérabilités corrigées.

En utilisant une variété de Transformations, techniques d'apprentissage automatique et ensembles de données, nous avons découvert qu même avec un entraînement sur des données modifiées, les modèles s'appuient toujours sur des caractéristiques non pertinentes lorsqu'il s'agit de prédire des vulnérabilités. Ils ont également eu du mal à bien performer en distinguant les fonctions vulnérables de leurs versions corrigées.

De nombreuses études récentes ont rapporté des résultats impressionnants dans la détection de vulnérabilités à l'aide de méthodes d'apprentissage automatique. Ces modèles semblent meilleurs que ceux utilisant d'autres techniques, comme l'analyse statique, même s'ils ne nécessitent pas de connaissances profondes sur le fonctionnement des programmes. Cela soulève la question : le problème de la détection des vulnérabilités de sécurité dans les logiciels est-il déjà résolu ? Ces modèles peuvent-ils vraiment repérer des vulnérabilités ou ces scores élevés sont-ils simplement trompeurs ?

Pour que les méthodes d'apprentissage automatique soient utilisées en toute sécurité dans de vraies applications logicielles, elles doivent être fiables et dignes de confiance. Ainsi, les chercheurs essaient d'explorer ce que ces modèles peuvent et ne peuvent pas faire, au-delà de leur performance sur des tests standard.

Une façon de tester les limites de ces modèles est de voir où ils échouent. Par exemple, nous pouvons apporter de petits changements significatifs à l'entrée du code et observer comment les modèles réagissent. Cela inclut le renommage de variables, l'ajout de lignes qui ne s'exécutent pas, ou l'échange de morceaux de code avec des équivalents. Des études précédentes ont montré que les modèles d'apprentissage automatique manquent souvent de fiabilité face à des changements qui conservent le sens.

Une façon courante de résoudre les problèmes de fiabilité est de former le modèle avec des données modifiées. De nombreux chercheurs ont découvert que cela peut aider à restaurer des performances perdues. Cependant, des questions subsistent quant à savoir si les améliorations proviennent d'améliorations réelles dans la capacité du modèle à identifier des vulnérabilités, ou si les modèles s'ajustent simplement pour s'adapter à un autre type de données.

Pour répondre à ces questions, nous présentons une méthode qui peut aider à évaluer les modèles d'apprentissage automatique pour la détection de vulnérabilités à travers des modifications de données. La première méthode implique d'appliquer certaines modifications aux ensembles de données d'entraînement et de test. Lorsqu'elle est répétée pour diverses paires de transformations, les scores obtenus peuvent indiquer si les modèles s'adaptent trop étroitement aux modifications spécifiques appliquées pendant l'entraînement. La deuxième méthode évalue la performance d'un modèle formé sur des données modifiées sur un ensemble de test qui inclut des fonctions vulnérables et leurs versions corrigées.

En plus de nos méthodes proposées, nous partageons également ce que nous avons trouvé dans nos expériences. Nous avons mis en œuvre ces méthodes sur trois techniques d'apprentissage automatique de pointe utilisées pour la détection de vulnérabilités. Pour la première méthode, nous avons utilisé 11 changements qui conservent le sens du code intact et les avons testés sur deux ensembles de données. Comme prévu, l'entraînement sur des données modifiées a aidé à restaurer les performances, mais seulement lorsque les mêmes changements étaient utilisés à la fois dans l'entraînement et le test. Si des changements différents étaient appliqués, les performances chutaient considérablement.

Pour la deuxième méthode, nous avons créé un nouvel ensemble de données appelé VulnPatchPairs, qui inclut des fonctions vulnérables accompagnées de leurs versions corrigées. Malgré l'utilisation de trois techniques d'apprentissage automatique de pointe, aucun modèle n'a pu efficacement faire la différence entre les fonctions vulnérables et leurs homologues corrigés. Leur performance n'était que légèrement meilleure que celle d'un simple tirage au sort.

En résumé, nos contributions incluent :

1. Une méthode claire pour évaluer les modèles d'apprentissage automatique visant à détecter des vulnérabilités à l'aide de données modifiées.
2. Des preuves montrant que les améliorations issues de l'utilisation de données d'entraînement modifiées ne s'appliquent qu'à des changements spécifiques utilisés lors de l'entraînement et que les modèles s'adaptent trop à des caractéristiques non pertinentes introduites par ces changements.
3. Introduction de VulnPatchPairs, un nouvel ensemble de données contenant des fonctions vulnérables et leurs versions corrigées correspondantes.
4. Démonstration que les techniques d'apprentissage automatique de pointe ont du mal à distinguer entre les fonctions vulnérables et leurs corrections, et que l'entraînement sur des données modifiées ne conduit pas à une amélioration significative des performances.
5. Disponibilité de tous les ensembles de données, du code et des résultats pour garantir la transparence et la reproductibilité.

#Travaux Connexes

Une façon majeure d'étudier la fiabilité des méthodes d'apprentissage automatique pour détecter des vulnérabilités est à travers des changements qui maintiennent le sens du code. Des études précédentes ont introduit des méthodes pour générer ces types de changements dans les ensembles de données de code source. Les effets de l'utilisation de données modifiées pour l'entraînement ont été explorés dans de nombreuses tâches d'ingénierie logicielle, comme résumer du code, prédire des types, classifier des fonctionnalités de code, et identifier des vulnérabilités. Un résultat commun de ces études est que l'utilisation des mêmes changements pour l'entraînement et le test peut améliorer les performances.

Certaines études ont été plus loin en testant comment des données d'entraînement amplifiées avec un type de changement se comportent lorsqu'elles sont évaluées sur des données amplifiées avec un autre changement, mais connexe. Par exemple, dans une étude, des auteurs ont utilisé une méthode pour renommer des variables pendant l'entraînement puis ont évalué sur des données où les variables étaient renommées de manière aléatoire. D'autres études ont également constaté que l'utilisation de différentes méthodes pour l'entraînement et le test conduit généralement à des performances inférieures. Cependant, il reste incertain si ces résultats sont spécifiques aux méthodes de transformation étudiées ou s'ils s'appliquent à différentes méthodes, modèles et ensembles de données. Notre recherche vise à répondre à ces questions en ouvrant une méthodologie générale et une étude empirique approfondie.

Certaines transformations utilisées dans les études existantes sont calculées pendant l'entraînement du modèle dans le but de rendre le modèle plus robuste. La distinction entre cette approche et l'amplification des données d'entraînement standard est que les transformations pour l'entraînement adversarial sont réalisées pendant le processus d'entraînement pour maximiser la perte du modèle sur les échantillons d'entrée. Nous avons utilisé à la fois des transformations simples et un entraînement adversarial dans nos expériences.

Pour explorer davantage l'efficacité des techniques d'apprentissage automatique pour identifier des vulnérabilités et comment l'amplification des données les affecte, nous avons compilé un nouvel ensemble de données appelé VulnPatchPairs. Cet ensemble de données contient des paires de fonctions vulnérables et leurs corrections respectives. Des travaux précédents ont suggéré de tels ensembles de données basés sur des paires pour des études de correction automatisée, mais nous sommes les premiers à utiliser ce type d'ensemble de données pour évaluer l'efficacité des modèles d'apprentissage automatique dans la détection de vulnérabilités.

Nous proposons une nouvelle méthode de benchmarking pour aider les chercheurs à évaluer les techniques d'apprentissage automatique pour détecter des vulnérabilités. La méthode est divisée en deux parties.

#Transformations de Code Sensibles aux Étiquettes

Une partie essentielle de nos méthodes implique des transformations de code sensibles aux étiquettes, ainsi que ce que nous attendons des modèles de détection de vulnérabilités.

Une transformation de code est une fonction qui change un morceau de code sans altérer son sens. Une situation idéale est lorsque l'application d'une transformation à un extrait de code ne change pas son étiquette de vulnérabilité. Nous appelons ce type de transformation une préservation sémantique. À l'inverse, une transformation inversant l'étiquette change un extrait d'une manière telle que son statut de vulnérabilité change, c'est-à-dire qu'elle ajoute ou supprime une vulnérabilité.

En général, nous espérons qu'un modèle de détection des vulnérabilités puisse prédire avec précision si un extrait de code contient un défaut de sécurité, quelle que soit les transformations précédemment appliquées. Plus précisément, nous nous attendons à ce que :

• Si nous transformons le code sans changer son statut de vulnérabilité, l'outil de détection devrait toujours produire le bon résultat.
• Si nous modifions un extrait de code pour ajouter ou supprimer une vulnérabilité, nous nous attendons à ce que le modèle change sa prédiction pour s'aligner sur ce nouveau statut.

#Méthodologie : Détecter le Surajustement aux Changements de Code

L'objectif de notre première méthode est de vérifier si les améliorations issues de l'amplification des données peuvent s'appliquer de manière cohérente au-delà des modifications spécifiques effectuées pendant l'entraînement. Nous voulons également voir si les techniques d'apprentissage automatique continuent de surajuster à des changements non liés dans leurs ensembles de données d'entraînement.

Entrées : Les entrées pour cette méthode comprennent un ensemble de transformations de préservation sémantique, un ensemble de données d'entraînement, un ensemble de données de test, une technique d'apprentissage automatique pour la détection des vulnérabilités, et une métrique de performance qui mesure à quel point le modèle performe.

Calculs : Cette méthode calcule les résultats moyens de l'amplification uniquement des données de test, en utilisant les mêmes transformations pour les ensembles de données d'entraînement et de test, et en utilisant différentes transformations pour les données d'entraînement.

Utilisation des Résultats : Les chercheurs peuvent utiliser cette méthode pour évaluer de nouvelles techniques d'apprentissage automatique pour détecter des vulnérabilités. Plus précisément, ils peuvent répondre à des questions sur la façon dont les performances changent avec des données de test modifiées, à quel point la performance peut être restaurée avec des transformations similaires pour les données d'entraînement, et si le modèle surajuste à des changements spécifiques.

#Distinguer entre Vulnérabilité et Correction

Le but de notre deuxième méthode est de voir si les techniques d'apprentissage automatique peuvent se généraliser à partir d'ensembles de données d'entraînement standard à un scénario modifié où elles doivent différencier les vulnérabilités de leurs formes corrigées.

Entrées : En plus des entrées requises pour la première méthode, cette deuxième méthode inclut également un ensemble de données de test spécialisé VulnPatch pour la comparaison.

Calculs : Cette méthode utilise l'ensemble de données de test VulnPatch pour quantifier la capacité du modèle à se généraliser dans un cadre modifié. Elle examine à la fois un modèle formé sur des ensembles de données standard et un autre formé sur des données amplifiées.

Utilisation des Résultats : En utilisant cette méthode, les chercheurs peuvent évaluer si la performance de leurs modèles peut être appliquée à un cadre modifié. Ils peuvent également déterminer si l'amplification des données améliore la capacité du modèle à se généraliser.

#Configuration Expérimentale et Questions de Recherche

Notre objectif est de vérifier si nos deux méthodes proposées peuvent évaluer efficacement les techniques d'apprentissage automatique de pointe pour la détection des vulnérabilités. Nous visons à répondre à plusieurs questions clés :

1. Que se passe-t-il avec la performance des modèles d'apprentissage automatique lorsque nous amplifions des extraits de code d'entrée sans altérer leur statut de vulnérabilité ?
2. Ces techniques surajustent-elles à des modifications spécifiques qui ne changent pas le statut de vulnérabilité ?
3. Les scores de performance élevés peuvent-ils être généralisés à un scénario modifié où les modèles doivent distinguer des vulnérabilités de leurs corrections ?

#Transformations de Préservation Sémantique

Une partie clé de nos méthodes implique l'utilisation de transformations de préservation sémantique. Les transformations couramment utilisées dans les travaux connexes incluent le renommage d'identificateurs, l'insertion de lignes qui n'exécutent pas, le remplacement d'instructions de code par des équivalents, le déplacement d'instructions et la suppression de lignes inutiles.

#Ensembles de Données de Détection de Vulnérabilités

Pour nos expériences, nous avons utilisé deux ensembles de données disponibles publiquement spécifiquement conçus pour la détection de vulnérabilités.

1. CodeXGLUE/Devign : Cet ensemble de données inclut 26 400 fonctions C, dont environ 45,6 % contiennent des vulnérabilités.

2. VulDeePecker : Cet ensemble de données est constitué de 61 600 exemples de code C/C++, environ 28,7 % d'entre eux contenant des vulnérabilités.

#Nouvel Ensemble de Données : VulnPatchPairs

Nous avons développé un nouvel ensemble de données appelé VulnPatchPairs pour enquêter sur la manière dont les techniques d'apprentissage automatique peuvent identifier des vulnérabilités par rapport à leurs corrections. Cet ensemble de données, qui comprend des fonctions C provenant de grands projets open-source, se compose de paires de fonctions vulnérables et de leurs versions corrigées.

#Techniques d'Apprentissage Automatique

Pour nos expériences, nous avons sélectionné trois techniques d'apprentissage automatique de pointe reconnues pour leurs performances dans la détection de vulnérabilités. Ces techniques ont été choisies en fonction de leurs classements dans les benchmarks les plus célèbres pour évaluer de telles approches.

#Pipeline d'Entraînement du Modèle

Nous avons maintenu une configuration d'entraînement cohérente à travers tous les modèles pendant nos expériences. Les ensembles de données que nous avons utilisés étaient déjà divisés en ensembles d'entraînement, de validation et de test, et nous avons appliqué des étapes de prétraitement pour nettoyer les données.

#Résultats Expérimentaux

Nous avons commencé notre analyse en examinant comment l'amplification des données affecte la performance des modèles d'apprentissage automatique. Nos résultats ont montré que l'amplification de l'ensemble de données de test tend à diminuer les performances des modèles. Cependant, lorsque nous avons amplifié l'ensemble de données d'entraînement de manière similaire, nous avons généralement vu des améliorations.

#Surajustement à des Transformations Spécifiques

Nous avons enquêté sur la possibilité que la performance puisse encore être restaurée lorsque des transformations différentes étaient appliquées à l'ensemble de données d'entraînement par rapport à l'ensemble de données de test. Nos résultats ont indiqué que l'utilisation de transformations différentes n'a pas contribué à restaurer la performance ; en fait, les performances chutaient souvent encore davantage.

#Généralisation à VulnPatchPairs

Notre dernier ensemble d'expériences a porté sur la détermination si les techniques d'apprentissage automatique pouvaient se généraliser à partir d'ensembles de données standard à un scénario nécessitant de faire la distinction entre des vulnérabilités et leurs corrections correspondantes. Nous avons constaté que les modèles avaient généralement du mal à faire cette distinction et ne montraient pas d'amélioration significative grâce à l'amplification des données d'entraînement.

#Menaces à la Validité

Nous reconnaissons diverses menaces potentielles à la validité de nos résultats, y compris les choix faits concernant la sélection des hyperparamètres et les répartitions d'ensembles de données. De plus, nous reconnaissons que nos résultats peuvent ne pas s'appliquer à d'autres techniques d'apprentissage automatique, ensembles de données et transformations au-delà de ceux que nous avons évalués.

#Discussion et Travaux Futurs

En résumé, nos résultats confirment que les améliorations tirées de l'amplification des données s'appliquent uniquement à des transformations spécifiques utilisées lors de l'entraînement. L'incapacité des techniques d'apprentissage automatique de pointe à se généraliser dans de nouveaux contextes présente des défis significatifs pour leur application dans des environnements logiciels réels. Nos méthodes proposées offrent une nouvelle approche pour mesurer et aborder ces problèmes, et nous espérons qu'elles inspireront d'autres recherches pour améliorer la robustesse des techniques d'apprentissage automatique pour la détection de vulnérabilités.