ARQ: Agentic CodeQL Query Refinement for C/C++ Vulnerability Detection
ARQ est un cadre agentique qui affine automatiquement les requêtes CodeQL pour C/C++ en utilisant des preuves ancrées dans l'exécution provenant de programmes synthétisés et de LLM afin de réduire considérablement les faux positifs et les faux négatifs sans nécessiter de jeux de données étiquetés, atteignant jusqu'à 119,8 % de détections de vrais positifs supplémentaires et résolvant des problèmes de longue date dans les dépôts officiels.
Article original placé dans le domaine public sous CC0 1.0 (http://creativecommons.org/publicdomain/zero/1.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 logiciels qui font fonctionner nos ordinateurs, nos téléphones et nos voitures sont souvent construits avec des langages comme le C et le C++. Ces outils offrent aux programmeurs un contrôle précis sur la manière dont une machine utilise sa mémoire, mais ce même pouvoir facilite l'erreur. Une petite faute dans la gestion de la mémoire d'un programme peut laisser une porte ouverte aux attaquants pour faire planter des systèmes ou voler des données. Pour détecter ces erreurs avant qu'elles ne causent de dommages, les experts en sécurité utilisent des scanners automatisés qui lisent le code et recherchent des schémas dangereux. Ces scanners s'appuient sur un ensemble de règles, écrites par des humains, qui leur indiquent précisément à quoi ressemble un morceau de code vulnérable. Si les règles sont trop strictes, le scanner manque de vrais dangers ; si elles sont trop lâches, il s'alarme pour des problèmes qui n'existent pas, gaspillant ainsi du temps et de la confiance.
Pendant des années, l'amélioration de ces règles a été un travail manuel et lent. Les experts doivent lire le code, deviner là où le scanner pourrait échouer et réécrire les règles à la main. Ce processus est difficile car les règles doivent être parfaites, et le code qu'elles scannent est vaste et complexe. Une nouvelle approche appelée ARQ change la manière dont ce travail est effectué. Au lieu de compter uniquement sur l'intuition humaine, ARQ utilise l'intelligence artificielle pour tester et corriger ces règles automatiquement. Elle ne se contente pas de deviner ; elle exécute le code qu'elle crée pour voir si les règles fonctionnent réellement. En construisant une boucle où le système génère des programmes de test, les exécute, puis utilise les résultats pour améliorer les règles, ARQ trouve et corrige des erreurs que les humains ont manquées pendant des années.
Les chercheurs derrière ARQ sont partis d'une idée simple mais puissante : une règle n'est aussi bonne que sa capacité à distinguer le code sûr du code dangereux. Ils ont donné à une intelligence artificielle une règle spécifique provenant d'un scanner de sécurité populaire et lui ont demandé de créer deux programmes très similaires. L'un des programmes était conçu pour être sûr, et l'autre pour être dangereux. L'IA a ensuite observé la réaction du scanner face aux deux. Si le scanner marquait le programme sûr comme dangereux, la règle était trop lâche. S'il manquait le programme dangereux, la règle était trop stricte. Ce décalage entre ce que le scanner disait et ce qui se passait réellement lors de l'exécution du code est devenu la preuve dont l'IA avait besoin pour corriger la règle.
Pour s'assurer que l'IA ne faisait pas que deviner, le système utilisait un outil spécial appelé « sanitizer » (assainisseur). Cet outil agit comme un capteur de haute précision qui surveille un programme pendant son exécution. Si le programme tente de faire quelque chose d'incorrect, comme utiliser une mémoire qui a déjà été libérée, le sanitizer arrête le programme et signale l'erreur immédiatement. Cela a fourni aux chercheurs une vérité de terrain. Ils pouvaient comparer le verdict du scanner avec le rapport du sanitizer. Si le scanner disait qu'un programme était sûr, mais que le sanitizer détectait un plantage, les chercheurs savaient que le scanner avait commis une erreur. L'IA utilisait alors cette erreur confirmée pour réécrire la règle, la rendant plus intelligente.
Ce processus se déroulait en une boucle continue. L'IA générait une nouvelle paire de programmes de test, les exécutait, vérifiait les résultats et affinait à nouveau la règle. Crucialement, chaque fois que la règle changeait, le système la testait à nouveau contre tous les exemples précédents pour s'assurer que la correction ne brisait rien de ce qui fonctionnait déjà. Cela empêchait l'IA de surcorriger et de créer de nouveaux problèmes tout en résolvant les anciens. L'équipe a testé cette méthode sur douze règles de sécurité différentes utilisées dans des logiciels réels. Ils ont soumis ces règles à deux grandes collections de codes conçues pour tester les outils de sécurité. Les résultats ont montré que les règles affinées par l'IA détectaient nettement plus de vulnérabilités réelles que les règles originales écrites par l'homme. Dans certains cas, le nombre de menaces détectées a plus que doublé, tandis que le taux de fausses alertes est resté extrêmement bas, maintenant une précision supérieure à quatre-vingt-dix-huit pour cent.
L'impact de ce travail a dépassé les données de test. Les chercheurs ont appliqué leurs règles affinées à des bibliothèques logicielles réelles et largement utilisées qui alimentent une grande partie d'Internet, telles que des outils de compression de données et d'affichage d'images. Les règles améliorées ont mis au jour deux bugs qui se cachaient dans ces bibliothèques depuis des années, attendant d'être trouvés. De plus, le système a réussi à corriger trois problèmes spécifiques qui avaient été signalés sur un dépôt de logiciels public mais qui étaient restés non résolus pendant aussi longtemps que vingt-sept mois. Ces problèmes avaient dérouté les experts humains pendant plus de deux ans, pourtant le système automatisé les a résolus en testant et en ajustant systématiquement les règles de détection.
Cette approche suggère une nouvelle façon de maintenir la sécurité de notre infrastructure numérique. Au lieu d'attendre que les humains trouvent une faille et écrivent manuellement un correctif, les systèmes peuvent désormais tester continuellement leurs propres règles par rapport à une exécution réelle. La méthode ne nécessite pas de bases de données massives d'erreurs étiquetées ou des années de données historiques pour fonctionner. Elle a simplement besoin de la capacité d'exécuter du code et de vérifier les résultats. En ancrant l'intelligence artificielle dans la réalité du comportement des programmes, plutôt que dans leur simple apparence théorique, les chercheurs ont créé un outil capable de maintenir les scanners de sécurité aiguisés et efficaces à mesure que le logiciel évolue. Ce travail démontre que lorsque l'intelligence artificielle est couplée à des preuves concrètes issues de l'exécution du code, elle peut résoudre des problèmes d'ingénierie complexes qui ont longtemps résisté à l'effort humain.
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.