Security and Quality in LLM-Generated Code: A Multi-Language, Multi-Model Analysis

Diese Studie analysiert die Sicherheit und Qualität von Code, der von großen Sprachmodellen (LLMs) in verschiedenen Programmiersprachen generiert wurde, und stellt fest, dass die Modelle oft veraltete Methoden verwenden und moderne Sicherheitsfeatures nicht nutzen, was eine Weiterentwicklung zur Integration aktueller Best Practices erforderlich macht.

Das Wesentliche

Stellen Sie sich vor, Sie haben einen extrem talentierten, aber noch sehr jungen Koch namens KI. Dieser Koch kann Rezepte für die köstlichsten Gerichte (also Computerprogramme) aus dem Nichts zaubern. Er liest Millionen von Kochbüchern (Trainingsdaten) und kann Ihnen sofort sagen, wie man eine Pizza oder einen Salat macht.

Aber hier ist das Problem: Ist das Essen auch sicher zu essen? Enthält es versehentlich giftige Zutaten? Ist es gut zubereitet, oder fällt es beim ersten Bissen auseinander?

Genau diese Frage haben die Autoren dieses Papers untersucht. Sie haben nicht nur geschaut, ob der KI-Koch das Essen schmecken lässt (funktioniert der Code?), sondern vor allem, ob es gesund und sicher ist.

Hier ist die Geschichte ihrer Forschung, einfach erklärt:

1. Der große Kochwettbewerb

Die Forscher haben fünf verschiedene Versionen dieses KI-Kochs eingeladen (bekannte Modelle wie GPT-4o, Claude, Gemini, Llama und Codestral). Jeder Koch sollte 200 verschiedene Aufgaben lösen.

Um fair zu bleiben, haben sie vier verschiedene Küchenarten (Programmiersprachen) gewählt:

• Python & Java: Das sind wie moderne, gut organisierte Küchen mit Sicherheitsgurten und automatischen Herden. Hier ist es schwer, sich zu verbrennen.
• C & C++: Das sind wie alte, wilde Küchen ohne Sicherheitsgurte. Hier muss man selbst aufpassen, dass man nicht in die offene Flamme greift oder das Messer fallen lässt. Ein kleiner Fehler kann hier katastrophal sein.

2. Der Test: "Ist das Essen fertig?"

Zuerst haben sie geprüft, ob der Koch überhaupt ein Gericht auf den Tisch stellen kann.

• Das Ergebnis: Bei den modernen Küchen (Python und Java) haben fast alle KIs ein perfektes Gericht hingelegt. Es hat funktioniert.
• Das Problem: Bei den wilden Küchen (C und C++) haben viele KIs das Messer fallen lassen. Sie haben Zutaten vergessen (fehlende Bibliotheken) oder die Anweisungen falsch verstanden. Die Gerichte waren oft unvollständig oder konnten gar nicht serviert werden.

3. Der Geschmackscheck: "Schmeckt es richtig?"

Dann haben sie geprüft, ob das Gericht auch so schmeckt, wie bestellt (semantische Korrektheit).

• Python & Java: Hier waren die KIs sehr gut. Sie haben die Rezepte fast immer genau befolgt.
• C & C++: Hier gab es mehr "Geschmacksfehler". Die KIs haben manchmal die falsche Menge Salz genommen oder den Ofen zu heiß eingestellt. Besonders bei C++ (der komplexesten Küche) hatten die KIs große Schwierigkeiten.

4. Der Sicherheitscheck: "Ist das Gift?"

Das war der wichtigste Teil. Die Forscher haben mit speziellen Sicherheits-Scannern (wie SonarQube und CodeQL) geprüft, ob die Gerichte gefährliche Zutaten enthalten.

Was haben sie gefunden?

• Die "Vergessenen" Zutaten: In den C- und C++-Gerichten steckten oft "unsichtbare Gifte". Das sind Dinge wie Speicherfehler (der Koch vergisst, den Teller wegzuräumen, bis er platzt) oder harte Geheimnisse (der Koch schreibt sein Passwort direkt auf den Teller).
• Die veralteten Rezepte: Viele KIs nutzen alte, unsichere Methoden für Verschlüsselung (wie einen alten, durchlöcherten Tresor), obwohl es moderne, sichere Tresore gibt. Sie wissen nicht, dass es bessere Werkzeuge gibt.
• Die Unterschiede:
  • Java & Python: Hier waren die Gerichte meist sicherer, aber es gab immer noch Fehler bei Passwörtern oder falschen Zertifikaten.
  • C & C++: Hier war die Gefahr am größten. Da diese Sprachen dem Koch mehr Freiheit geben, machen sie auch mehr Fehler, die zu Sicherheitslücken führen können.

5. Die große Erkenntnis

Die Studie zeigt uns drei wichtige Dinge:

1. Die Sprache macht den Unterschied: Wenn Sie einem KI-Koch eine einfache, moderne Sprache (wie Python) geben, macht er weniger Fehler als bei einer komplexen, alten Sprache (wie C++).
2. KI ist nicht perfekt: Auch die besten KIs nutzen manchmal veraltete oder unsichere Methoden, weil sie in ihren alten Kochbüchern gelernt haben, wie man Dinge früher gemacht hat, nicht wie man es heute sicher macht.
3. Wir müssen aufpassen: Wir können den KI-Koch nicht blind vertrauen. Wir müssen seine Gerichte immer noch selbst prüfen, bevor wir sie unseren Gästen (den Nutzern) servieren.

Fazit

Die KI ist ein mächtiger Assistent, der uns beim Kochen (Programmieren) viel Zeit spart. Aber sie ist noch kein Meisterkoch, der jede Gefahr erkennt. Besonders bei komplexen Aufgaben (wie C++) braucht sie noch viel Hilfe und Aufsicht, damit am Ende kein "giftiges" Programm auf dem Tisch steht.

Die Forscher sagen: "Wir müssen die KIs weiter trainieren, damit sie nicht nur schnell kochen, sondern auch sicher und moderne Rezepte verwenden."

Technische Zusammenfassung

Hier ist eine detaillierte technische Zusammenfassung des Papers „Security and Quality in LLM-Generated Code: A Multi-Language, Multi-Model Analysis" auf Deutsch:

1. Problemstellung

Die rasante Entwicklung von Large Language Models (LLMs) hat deren Einsatz zur automatisierten Code-Generierung im Softwareentwicklungslebenszyklus massiv vorangetrieben. Obwohl diese Tools die Produktivität steigern, bleibt die Sicherheit und Qualität des von ihnen generierten Codes unterbeleuchtet. Bisherige Studien haben oft nur einzelne Programmiersprachen oder Modelle betrachtet und zeigen, dass LLMs sowohl funktionale als auch sicherheitskritische Fehler produzieren können. Es fehlt jedoch an einer umfassenden, vergleichenden Analyse, wie sich die Wahl der Programmiersprache (z. B. Python vs. C) und des spezifischen Modells auf die Sicherheit, Korrektheit und Wartbarkeit des generierten Codes auswirkt. Insbesondere die Interaktion zwischen sprachspezifischen Merkmalen (wie Speicherverwaltung) und den Fähigkeiten der LLMs ist noch nicht ausreichend quantifiziert.

2. Methodik

Die Autoren führten eine umfassende Messstudie durch, die auf einem neu erstellten, manuell kuratierten Datensatz basiert.

• Datensatz: Es wurden 200 Programmieraufgaben definiert, die in sieben Kategorien unterteilt sind (u. a. Secure Coding, Datenstrukturen, Netzwerke, Concurrency). Die Aufgaben sind sprachneutral formuliert, um faire Vergleiche zu ermöglichen.
• Bewertete Sprachen: Python, Java, C++ und C.
• Bewertete Modelle: Fünf weit verbreitete LLM-Familien: GPT-4o, Claude-3.5, Gemini-1.5, Codestral und Llama-3.
• Generierung: Für jede Kombination aus Aufgabe, Sprache und Modell wurde Code generiert (insgesamt 4.000 Code-Dateien).
• Evaluierungs-Pipeline:
  1. Syntaktische Validität: Prüfung auf Kompilierbarkeit (für Java, C++, C) oder Syntaxfehler (Python).
  2. Semantische Korrektheit: Da die LLMs oft unterschiedliche Schnittstellen generierten, wurden pro Programm und Sprache individuelle Unit-Tests erstellt (insgesamt 4.000 Testdateien), um die Logik gegen eine Referenzimplementierung zu prüfen.
  3. Qualitäts- und Sicherheitsanalyse: Einsatz von statischen Analyse-Tools (SonarQube und CodeQL) zur Identifizierung von Schwachstellen (CWE-Kategorien), Sicherheits-Hotspots, Zuverlässigkeitsproblemen und Wartbarkeitsmängeln.
  4. Manuelle Überprüfung: Ein Teil der Ergebnisse (ca. 20%) wurde von menschlichen Experten manuell validiert, um False Positives der Tools auszuschließen.
  5. Komplexitätsmetriken: Analyse von Lines of Code (LoC), zyklomatischer Komplexität (CyC) und kognitiver Komplexität (CoC).

3. Wichtige Beiträge

1. Neuer Benchmark-Datensatz: Vorstellung eines manuell geprüften Datensatzes mit 200 Aufgaben, der für die Evaluierung von LLMs in verschiedenen Domänen und Sprachen verfügbar ist.
2. Vergleichende Evaluation: Eine der ersten Studien, die vier Programmiersprachen und fünf führende LLMs unter einheitlichen Bedingungen vergleicht. Dies ermöglicht direkte Schlussfolgerungen über sprach- und modellabhängige Unterschiede, die in Einzelstudien oft übersehen werden.
3. Tiefgehende Sicherheitsanalyse: Quantifizierung der Verteilung bekannter Schwachstellenklassen (CWEs) in LLM-generiertem Code und Identifizierung von Mustern, wie diese Schwachstellen in verschiedenen Sprachen auftreten.
4. Multidimensionale Qualitätsbewertung: Die Studie betrachtet Sicherheit nicht isoliert, sondern in Kombination mit Korrektheit, Wartbarkeit und „Clean Code"-Eigenschaften (Konsistenz, Intentionalität, Anpassbarkeit).

4. Ergebnisse

Die Studie liefert klare Erkenntnisse über die Leistungsfähigkeit und Grenzen aktueller LLMs:

• Spracheinfluss:
  • Python und Java: Erzielten die höchsten Raten bei der Kompilierung und semantischen Korrektheit. Sie generierten weniger Sicherheitsprobleme, da sie automatische Speicherverwaltung bieten.
  • C und C++: Wiesen signifikant mehr Kompilierungsfehler und semantische Mängel auf. Hier traten häufiger Probleme mit Speichersicherheit (Buffer Overflows), hartkodierte Geheimnisse und falsche kryptografische Implementierungen auf.
• Modellleistung:
  • Claude-3.5 und GPT-4o schnitten im Allgemeinen am besten ab, insbesondere bei Java und C++.
  • Llama-3 zeigte in komplexeren Sprachen (C++, Java) die schwächsten Leistungen.
  • Gemini-1.5 hatte in Java die höchste Anzahl an Sicherheitslücken.
• Sicherheitsmängel:
  • Häufige Fehler umfassen die Verwendung veralteter kryptografischer Methoden (z. B. RSA ohne OAEP-Padding, CWE-780), hartkodierte Passwörter (CWE-259) und unsichere Eingabevalidierung.
  • Viele Modelle nutzen keine modernen Sicherheitsfeatures aktueller Compiler oder Frameworks (z. B. in Java 17), sondern greifen auf veraltete Praktiken zurück.
• Komplexität:
  • Claude-3.5 neigte dazu, sehr ausführlichen und komplexen Code zu generieren (hohe LoC und CoC), was die Wartbarkeit erschwert.
  • Codestral und GPT-4o generierten tendenziell einfacheren und wartbareren Code.
• Clean Code:
  • Intentionalität (Klarheit des Zwecks) und Konsistenz waren bei allen Modellen und Sprachen Schwachstellen, besonders in C und C++.

5. Bedeutung und Fazit

Die Studie unterstreicht, dass die Sicherheit von KI-generiertem Code stark von der gewählten Programmiersprache und dem spezifischen Modell abhängt. Während LLMs in höheren Sprachen wie Python und Java bereits gute Ergebnisse liefern, bestehen in systemnahen Sprachen wie C und C++ erhebliche Risiken, insbesondere im Bereich der Speichersicherheit.

Kernaussagen:

• LLMs sind noch nicht vollständig mit modernen Sicherheitsbest Practices oder sprachspezifischen Best Practices abgestimmt.
• Die reine funktionale Korrektheit (Semantik) garantiert keine Sicherheit; Sicherheitslücken bleiben auch in syntaktisch korrektem Code häufig.
• Es besteht ein dringender Bedarf an Weiterentwicklungen der LLMs, um diese besser auf sichere Codierungsstandards und die Nuancen verschiedener Programmiersprachen auszurichten.

Die Autoren stellen den gesamten Datensatz, die Prompts und die Analyse-Skripte als Open Source zur Verfügung, um die Reproduzierbarkeit zu gewährleisten und zukünftige Forschung zu ermöglichen. Die Studie dient als wichtiger Referenzpunkt (Baseline) für die Bewertung zukünftiger Generationen von Code-Generierungs-Modellen.