Outils de développement

Utiliser Gemini et Z3 pour détecter les bugs Go que le fuzzing manque

Un ingénieur de Google a combiné Gemini 4 Argon et le solveur de contraintes Z3 pour détecter des paniques d'exécution dans le code Go que le fuzzing standard avait négligées, révélant des angles morts dans la gestion de la capacité des slices.

Illustration de l'analyse de code avec un cube en verre et des documents annotés
Illustration générée pour cet article

Traduit automatiquement depuis l'original anglais.

Un ingénieur de Google dirigeant le programme de compétences des agents a développé un pipeline de test hybride qui combine les grands modèles de langage avec la résolution formelle de contraintes pour découvrir des bugs subtils dans les applications Go. Publiée à la mi-novembre 2026, cette approche utilise Gemini 4 Argon pour traduire l'assemblage compilé en contraintes logiques destinées au solveur Z3, identifiant avec succès des plantages que les outils de fuzzing standards avaient manqués en raison de particularités de l'environnement d'exécution.

Ce qui s'est passé

Le développeur a créé skill-lint, une interface en ligne de commande écrite en Go conçue pour valider et modifier les fichiers SKILL.md des agents IA. Malgré une suite complète de tests unitaires et de fuzzing, l'outil restait vulnérable aux paniques d'exécution causées par des erreurs off-by-one ou des opérations incorrectes sur les slices dans ses analyseurs Markdown. Ces bugs restaient souvent dormants jusqu'à ce que des motifs d'entrée spécifiques et inhabituels ne les déclenchent en production, soulignant les limites des méthodes de test traditionnelles pour les logiques d'analyse complexes.

Pour remédier à cela, l'ingénieur a construit un workflow qui compile les fonctions clés en assemblage RISC-V et utilise Gemini 4 Argon pour analyser les vérifications de limites survivantes. Le modèle traduit ces vérifications en règles pour le solveur de contraintes Z3, qui détermine ensuite si une entrée quelconque peut satisfaire les conditions menant à un plantage. Ce processus a identifié trois bugs latents dans skill-lint et a réussi à détecter les trois bugs artificiels implantés pour les tests, y compris les cas où le fuzzer Go standard n'avait pas trouvé le problème même après des exécutions prolongées.

L'investigation a révélé que le fuzzer de Go manque souvent les erreurs hors limites car il passe généralement des slices avec une capacité excédentaire. Lorsqu'une slice possède une capacité supplémentaire au-delà de sa longueur, l'accès aux indices dépassant la longueur mais restant dans la capacité ne provoque pas de panique, masquant ainsi le bug. En réduisant la capacité de la slice pour qu'elle corresponde à sa longueur lors des tests, le fuzzer a pu détecter les mêmes plantages immédiatement, mais l'approche par solveur a fourni un moyen plus systématique de trouver ces problèmes sans compter sur le hasard.

Comment ça fonctionne

Le compilateur Go inclut une passe d'optimisation appelée SSA prove qui élimine les vérifications de limites dont il peut prouver mathématiquement qu'elles sont sûres. Cependant, certaines vérifications restent dans le code machine compilé sous forme de pièges explicites qui déclenchent une panique d'exécution si elles sont violées. Le nouveau workflow cible ces pièges survivants en compilant le code Go avec des drapeaux spécifiques pour générer des listes d'assemblage et des journaux de débogage pour l'élimination des vérifications de limites (BCE). Cela fournit une carte précise des endroits où le compilateur ne pouvait pas garantir la sécurité.

Gemini 4 Argon analyse à la fois le code source Go original et l'assemblage RISC-V généré. Il identifie le chemin vers chaque piège de vérification de limites restant et traduit les conditions logiques en script pour le solveur de contraintes Z3. Z3 tente ensuite de résoudre ces contraintes pour trouver des valeurs d'entrée spécifiques qui déclencheraient la panique. Si Z3 trouve une solution, le workflow génère un cas de test Go concret qui reproduit le plantage, confirmant l'existence du bug.

Cette méthode tire parti de la capacité du LLM à comprendre la structure du code et de la précision du solveur dans le raisonnement logique. Alors que le LLM gère la tâche complexe de traduction des instructions d'assemblage en contraintes de solveur, Z3 effectue le travail lourd de vérification de la satisfaisabilité. L'ensemble du processus prend environ une minute par fonction, la traduction par le LLM étant le goulot d'étranglement et Z3 résolvant les contraintes en millisecondes, rendant cela faisable pour une analyse ciblée des fonctions critiques.

Détails clés

  • Le workflow utilise Gemini 4 Argon pour traduire l'assemblage Go en contraintes Z3, se concentrant sur les vérifications de limites survivantes après l'optimisation du compilateur.
  • Le fuzzing Go standard a manqué deux bugs implantés car il crée rarement des slices où la capacité égale la longueur, permettant aux lectures hors limites de réussir silencieusement.
  • La réduction de la capacité de la slice à la longueur dans les tests de fuzzing (data[:len(data):len(data)]) a permis au fuzzer de détecter les mêmes plantages en moins d'une seconde.
  • Le solveur a identifié trois bugs latents dans skill-lint, y compris des modifications de blocs superposés et un comptage incorrect des numéros de ligne après des suppressions.
  • Z3 renvoie "sat" lorsqu'une entrée provoquant un plantage existe et "unsat" lorsqu'une telle entrée n'est pas trouvée, fournissant un signal clair pour les bugs potentiels.
  • Cette approche est limitée aux fonctions pures et ne détecte pas les data races ni les deadlocks, qui nécessitent toujours le détecteur de race Go.

Pourquoi c'est important

Pour les développeurs construisant des applications Go robustes, en particulier celles impliquant des analyseurs ou des transformations de données, cette approche met en évidence un angle mort significatif dans les pratiques de test standard. Se fier uniquement au fuzzing peut laisser des cas limites critiques non testés si la stratégie de génération d'entrées du fuzzer ne correspond pas aux exigences spécifiques de disposition mémoire du bug. Comprendre comment la capacité des slices interagit avec la vérification des limites est essentiel pour écrire du code sécurisé et stable.

L'intégration des LLM avec des outils de vérification formelle offre un compromis pratique entre la revue de code manuelle et la preuve de théorème complète. Elle permet aux ingénieurs d'appliquer une analyse logique rigoureuse à des fonctions à haut risque spécifiques sans la surcharge de modélisation d'une application entière. Cette méthode hybride peut attraper des dépassements d'entiers subtils et des erreurs logiques difficiles à repérer dans le seul code source, améliorant la fiabilité globale des systèmes logiciels.

L'étude de cas démontre également l'importance de comprendre le code machine sous-jacent lors du débogage de problèmes de langages de haut niveau. En examinant la sortie d'assemblage, les développeurs peuvent voir exactement comment le compilateur interprète leur code, y compris toute conversion implicite de types ou optimisation susceptible d'introduire des vulnérabilités. Cette compréhension plus profonde peut conduire à de meilleures pratiques de codage et à des stratégies de test plus efficaces.

Ce que vous pouvez faire

  • Réduisez la capacité de la slice à la longueur dans vos tests de fuzzing en utilisant data[:len(data):len(data)] pour vous assurer que les accès hors limites déclenchent des paniques.
  • Utilisez go build -gcflags="-S -d=ssa/check_bce/debug=1" pour identifier quelles vérifications de limites survivent à l'optimisation du compilateur dans les fonctions critiques.
  • Extrayez les fonctions pures de la logique de votre application pour une analyse ciblée, laissant les entrées/sorties et les appels réseau aux tests d'intégration standard.
  • Envisagez d'utiliser des solveurs de contraintes comme Z3 pour vérifier la logique complexe dans les analyseurs ou les opérations mathématiques où le fuzzing aléatoire est inefficace.
  • Examinez la sortie d'assemblage pour détecter les troncatures de types inattendues ou les mouvements de registres qui pourraient affecter la logique de vérification des limites.
  • Combinez les outils d'analyse statique avec les tests dynamiques pour couvrir à la fois la correction logique et le comportement d'exécution de manière exhaustive.
  • #go
  • #testing
  • #ai
  • #security
  • #debugging

Outils de la Boutique Bytechap

Continuer la lecture

Tous les articles