Investigating the application of differential fuzzing to support the identification and suppression of equivalent mutants: An experimental study
Cette étude expérimentale démontre que le fuzzing différentiel est une approche pratique et indépendante du langage pour identifier et supprimer efficacement les mutants équivalents à travers divers projets logiciels réels, atteignant des scores de mutation quasi parfaits tout en générant des entrées exploitables pour renforcer les suites de tests traditionnelles.
Article original sous licence CC BY 4.0 (https://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
Les tests de logiciels sont le processus de vérification qu'un programme informatique fonctionne correctement, mais trouver chaque erreur possible est presque impossible car les programmes sont complexes et les entrées sont infinies. Pour remédier à cela, les chercheurs utilisent une technique appelée test de mutation, qui consiste à introduire intentionnellement de minuscules erreurs réalistes dans le code pour voir si les tests existants peuvent les détecter. Si un test ne parvient pas à repérer l'erreur, cela signifie que la suite de tests n'est pas assez robuste. Cependant, cette méthode fait face à un obstacle tenace : certaines de ces fausses erreurs sont si subtiles qu'elles ne modifient pas du tout le comportement du programme, les rendant impossibles à détecter. Ce sont ce que l'on appelle des mutants équivalents, et leur identification nécessite généralement qu'un expert humain passe un temps considérable à lire le code ligne par ligne, un processus lent et coûteux qui a longtemps freiné l'utilisation généralisée de cette méthode de test.
Parallèlement, une autre méthode de test appelée « fuzzing » (ou test par injection de données aléatoires) est devenue un outil standard pour trouver des failles de sécurité. Le fuzzing consiste à injecter dans un programme des quantités massives de données aléatoires ou malformées pour voir s'il plante. Bien qu'efficace pour trouver des bugs qui provoquent l'arrêt d'un programme, le fuzzing traditionnel passe souvent à côté du type d'erreurs subtiles qui modifient la façon dont un programme calcule ou se comporte sans provoquer de plantage. Une nouvelle étude menée par des chercheurs de l'Université de São Paulo explore une manière de combiner ces deux mondes. Ils ont étudié une technique appelée fuzzing différentiel, qui exécute le programme original et une version avec une petite erreur côte à côte, en injectant exactement les mêmes données et en comparant les résultats. Si les deux versions produisent des sorties différentes, l'erreur est détectée. Les chercheurs voulaient voir si cette approche pouvait identifier automatiquement ces insaisissables mutants équivalents et le faire bien plus rapidement qu'un humain.
Pour tester cette idée, l'équipe a sélectionné six fonctions spécifiques issues de quatre projets de logiciels open-source bien connus, écrits dans quatre langages de programmation différents : C++, C, Go et Python. Ces projets comprenaient Bitcoin Core, un protocole de cryptomonnaie ; OpenSSL, une bibliothèque de cryptographie ; LND, un réseau de canaux de paiement ; et Arrow, une bibliothèque de gestion de dates et d'heures. À l'aide d'un outil capable de générer des erreurs pour n'importe quel langage de programmation, ils ont créé 1 090 variations valides de ces fonctions. Avant le début des tests automatisés, les chercheurs ont inspecté manuellement les erreurs pour éliminer celles qui étaient manifestement équivalentes, laissant ainsi un ensemble de cas difficiles pour voir si le système automatisé pouvait distinguer les autres. Ils ont ensuite exécuté cinq scénarios de test différents sur ces erreurs, allant de tests unitaires standards à des sessions de fuzzing limitées dans le temps à cinq minutes par erreur.
Les résultats ont montré que le fuzzing traditionnel, qui ne recherche que les plantages, était la méthode la moins efficace, ne détectant que très peu d'erreurs. En revanche, l'approche de fuzzing différentiel s'est révélée remarquablement puissante. Lorsqu'on lui donnait une limite de cinq minutes pour tester chaque erreur, cette méthode a réussi à identifier et à confirmer le comportement des erreurs dans cinq des six fonctions, atteignant un taux de réussite compris entre 98 et 100 %. Pour la fonction où elle a initialement éprouvé des difficultés, les chercheurs ont découvert qu'ajouter une simple liste de mots-clés attendus aidait le système à mieux comprendre l'entrée, permettant finalement d'atteindre un score parfait. L'étude a également révélé que le temps nécessaire pour trouver ces erreurs était étonnamment court ; en moyenne, le système trouvait les différences en environ 30 secondes, bien plus vite que les 15 minutes qu'il faut typiquement à un humain pour analyser manuellement un seul cas.
Au-delà de la simple détection des erreurs, les chercheurs ont découvert que les données utilisées pendant le processus de fuzzing possédaient une valeur cachée. La collection d'entrées générées par l'outil de fuzzing, appelée corpus de graines (seed corpus), contenait des cas de test spécifiques que les tests unitaires standards avaient manqués. Ces entrées ont pu éliminer des mutants que les suites de tests traditionnelles ne pouvaient pas détecter. Cela suggère que les données déjà générées par les équipes de sécurité peuvent être réutilisées pour renforcer les suites de tests régulières, transformant un sous-produit des tests de sécurité en une ressource pour la qualité logicielle générale. L'étude a également analysé le temps nécessaire pour trouver les erreurs les plus difficiles à détecter, constatant que si la plupart étaient trouvées rapidement, quelques-unes nécessitaient nettement plus de temps et présentaient un schéma où la difficulté variait considérablement, de la même manière que certaines tâches prennent un peu plus de temps tandis que d'autres prennent très longtemps.
Les chercheurs ont conclu que le fuzzing différentiel offre une manière pratique et indépendante du langage pour soutenir la classification de ces erreurs difficiles. Il ne nécessite pas de nouveaux outils complexes ni de configurations spécifiques au langage, car il se contente de comparer le code original à la version modifiée. En traitant les erreurs survivantes comme des candidats à une revue manuelle plutôt qu'en essayant de classifier chaque erreur, la méthode réduit considérablement l'effort humain nécessaire. L'étude suggère que cette approche peut être intégrée aux flux de travail existants pour filtrer efficacement les erreurs qui sont réellement équivalentes, laissant les experts humains se concentrer uniquement sur le petit nombre de cas qui restent incertains. Cette conclusion indique qu'une simple comparaison automatisée des comportements de programmes peut résoudre un problème qui a longtemps été considéré comme trop coûteux et chronophage pour une adoption industrielle généralisée.
Noyé(e) sous les articles dans votre domaine ?
Recevez des digests quotidiens des articles les plus récents correspondant à vos mots-clés de recherche — avec des résumés techniques, dans votre langue.