Entwicklerwerkzeuge

Gemini und Z3 zur Erkennung von Go-Bugs, die Fuzzing übersieht

Ein Google-Ingenieur kombinierte Gemini 4 Argon und den Z3-Constraint-Solver, um Laufzeit-Panics in Go-Code zu erkennen, die vom Standard-Fuzzing übersehen wurden. Dabei wurden blinde Flecken bei der Behandlung der Slice-Kapazität aufgedeckt.

Illustration der Code-Analyse mit einem Glaswürfel und markierten Papieren
Für diesen Artikel generierte Illustration

Automatisch aus dem englischen Original übersetzt.

Ein Google-Ingenieur, der das Agent Skills-Programm leitet, entwickelte eine hybride Test-Pipeline, die große Sprachmodelle mit formaler Constraint-Lösung kombiniert, um subtile Fehler in Go-Anwendungen aufzudecken. Dieser Ansatz wurde Mitte November 2026 veröffentlicht und nutzt Gemini 4 Argon, um kompilierten Assembler-Code in logische Constraints für den Z3-Solver zu übersetzen. So konnten Abstürze identifiziert werden, die von Standard-Fuzzing-Tools aufgrund von Besonderheiten der Laufzeitumgebung übersehen wurden.

Was passiert ist

Der Entwickler erstellte skill-lint, eine in Go geschriebene Befehlszeilenschnittstelle (CLI), die dazu dient, SKILL.md-Dateien für KI-Agenten zu validieren und zu bearbeiten. Trotz einer umfassenden Suite aus Unit- und Fuzz-Tests blieb das Tool anfällig für Laufzeit-Panics, die durch Off-by-one-Fehler oder inkorrekte Slice-Operationen in seinen Markdown-Parsern verursacht wurden. Diese Bugs blieben oft latent, bis spezifische, ungewöhnliche Eingabemuster sie in der Produktion auslösten. Dies verdeutlichte die Grenzen herkömmlicher Testmethoden für komplexe Parsing-Logik.

Um dieses Problem anzugehen, baute der Ingenieur einen Workflow, der Schlüssel-Funktionen in RISC-V-Assembler kompiliert und Gemini 4 Argon nutzt, um die verbleibenden Bounds-Checks zu analysieren. Das Modell übersetzt diese Checks in Regeln für den Z3-Constraint-Solver, der dann bestimmt, ob irgendeine Eingabe die Bedingungen für einen Crash erfüllen kann. Dieser Prozess identifizierte drei latente Bugs in skill-lint und detektierte erfolgreich alle drei künstlich eingebauten Bugs für Testzwecke. Dazu gehörten Fälle, in denen der Standard-Go-Fuzzer selbst nach längeren Läufen nicht in der Lage war, das Problem zu finden.

Die Untersuchung ergab, dass Go’s Fuzzer häufig Out-of-Bounds-Fehler übersieht, weil er typischerweise Slices mit Reservekapazität übergibt. Wenn ein Slice eine zusätzliche Kapazität über seine Länge hinaus hat, führt der Zugriff auf Indizes jenseits der Länge, aber innerhalb der Kapazität, nicht zu einem Panic, was den Bug maskiert. Durch das Beschneiden der Slice-Kapazität auf ihre Länge während des Tests konnte der Fuzzer dieselben Abstürze sofort erkennen. Der Solver-Ansatz bot jedoch eine systematischere Methode, um diese Probleme zu finden, ohne sich auf Zufallstreffer verlassen zu müssen.

Wie es funktioniert

Der Go-Compiler enthält eine Optimierungspass namens SSA prove, die Bounds-Checks eliminiert, deren Sicherheit mathematisch bewiesen werden kann. Einige Checks verbleiben jedoch im kompilierten Maschinencode als explizite Traps, die einen Laufzeit-Panic auslösen, wenn sie verletzt werden. Der neue Workflow zielt auf diese verbleibenden Traps ab, indem er den Go-Code mit spezifischen Flags kompiliert, um Assembler-Listings und Debug-Logs für die Elimination von Bounds-Checks zu generieren. Dies liefert eine präzise Karte der Stellen, an denen der Compiler die Sicherheit nicht garantieren konnte.

Gemini 4 Argon analysiert sowohl den ursprünglichen Go-Quellcode als auch den generierten RISC-V-Assembler. Es identifiziert den Pfad zu jedem verbleibenden Bounds-Check-Trap und übersetzt die logischen Bedingungen in ein Skript für den Z3-Constraint-Solver. Z3 versucht dann, diese Constraints zu lösen, um spezifische Eingabewerte zu finden, die den Panic auslösen würden. Wenn Z3 eine Lösung findet, generiert der Workflow einen konkreten Go-Testfall, der den Crash reproduziert und damit bestätigt, dass der Bug existiert.

Diese Methode nutzt die Fähigkeit des LLMs, Code-Strukturen zu verstehen, sowie die Präzision des Solvers bei der logischen Deduktion. Während das LLM die komplexe Aufgabe der Übersetzung von Assembler-Anweisungen in Solver-Constraints übernimmt, erledigt Z3 die schwere Arbeit der Prüfung der Erfüllbarkeit. Der gesamte Prozess dauert etwa eine Minute pro Funktion. Die LLM-Übersetzung stellt dabei den Engpass dar, während Z3 die Constraints in Millisekunden löst, was eine gezielte Analyse kritischer Funktionen praktikabel macht.

Wichtige Details

  • Der Workflow nutzt Gemini 4 Argon, um Go-Assembler in Z3-Constraints zu übersetzen, wobei der Fokus auf den Bounds-Checks liegt, die nach der Compiler-Optimierung übrig bleiben.
  • Standard-Go-Fuzzing verpasste zwei eingebaute Bugs, da es selten Slices erzeugt, bei denen Kapazität gleich Länge ist, wodurch Out-of-Bounds-Lesezugriffe stillschweigend erfolgreich waren.
  • Das Beschneiden der Slice-Kapazität auf die Länge in Fuzz-Tests (data[:len(data):len(data)]) ermöglichte es dem Fuzzer, dieselben Abstürze in weniger als einer Sekunde zu erkennen.
  • Der Solver identifizierte drei latente Bugs in skill-lint, darunter überlappende Chunk-Bearbeitungen und falsche Zeilennummern-Zählungen nach Löschungen.
  • Z3 gibt "sat" zurück, wenn eine zum Absturz führende Eingabe existiert, und "unsat", wenn keine solche Eingabe gefunden wird. Dies bietet ein klares Signal für potenzielle Bugs.
  • Der Ansatz ist auf reine Funktionen beschränkt und erkennt keine Data Races oder Deadlocks. Für diese ist weiterhin der Go Race Detector erforderlich.

Warum es wichtig ist

Für Entwickler, die robuste Go-Anwendungen erstellen, insbesondere solche, die Parser oder Datentransformationen beinhalten, hebt dieser Ansatz einen erheblichen blinden Fleck in standardmäßigen Testpraktiken hervor. Wenn man sich ausschließlich auf Fuzzing verlässt, können kritische Edge Cases ungetestet bleiben, falls die Strategie zur Eingabeerzeugung des Fuzzers nicht mit den spezifischen Speicherlayout-Anforderungen des Bugs übereinstimmt. Das Verständnis, wie Slice-Kapazität mit Bounds-Checking interagiert, ist entscheidend für das Schreiben sicherer und stabiler Codes.

Die Integration von LLMs mit formalen Verifikationswerkzeugen bietet einen praktischen Mittelweg zwischen manueller Code-Review und vollständigem Theorem-Proving. Sie ermöglicht es Ingenieuren, rigorose logische Analysen auf spezifische Hochrisiko-Funktionen anzuwenden, ohne den Overhead der Modellierung einer gesamten Anwendung. Diese Hybrid-Methode kann subtile Integer-Overflows und Logikfehler erfassen, die im Quellcode allein schwer zu erkennen sind, und verbessert so die Gesamtzuverlässigkeit von Softwaresystemen.

Die Fallstudie demonstriert zudem die Bedeutung des Verständnisses des zugrunde liegenden Maschinencodes beim Debugging von Problemen in höheren Programmiersprachen. Durch die Untersuchung der Assembler-Ausgabe können Entwickler genau sehen, wie der Compiler ihren Code interpretiert, einschließlich impliziter Typkonvertierungen oder Optimierungen, die Schwachstellen einführen könnten. Diese tiefere Einsicht kann zu besseren Coding-Praktiken und effektiveren Teststrategien führen.

Was Sie tun können

  • Schneiden Sie die Slice-Kapazität in Ihren Fuzz-Tests auf die Länge zu (data[:len(data):len(data)]), um sicherzustellen, dass Out-of-Bounds-Zugriffe Panics auslösen.
  • Verwenden Sie go build -gcflags="-S -d=ssa/check_bce/debug=1", um zu identifizieren, welche Bounds-Checks in kritischen Funktionen die Compiler-Optimierung überleben.
  • Extrahieren Sie reine Funktionen aus Ihrer Anwendungslogik für eine gezielte Analyse und überlassen Sie I/O- und Netzwerkaufrufe den Standard-Integrationstests.
  • Erwägen Sie die Verwendung von Constraint-Solvern wie Z3 zur Überprüfung komplexer Logik in Parsern oder mathematischen Operationen, wo zufälliges Fuzzing ineffizient ist.
  • Überprüfen Sie die Assembler-Ausgabe auf unerwartete Typ-Trunkierungen oder Registerbewegungen, die die Bounds-Checking-Logik beeinflussen könnten.
  • Kombinieren Sie statische Analysetools mit dynamischem Testing, um sowohl logische Korrektheit als auch Laufzeitverhalten umfassend abzudecken.
  • #go
  • #testing
  • #ai
  • #security
  • #debugging

Tools aus dem Bytechap-Shop

Weiterlesen

Alle Artikel