KI-Programmieragenten entwickeln sich zu einem Risiko für die Software-Lieferkette
Softwareentwickler importieren schon seit langem Code, den sie nicht selbst geschrieben haben. Open-Source-Bibliotheken, Paket-Repositorys und Frameworks von Drittanbietern ermöglichen es Teams, Anwendungen zu entwickeln, ohne jede Komponente von Grund auf neu erstellen zu müssen, während Sicherheitsprogramme nach und nach Verfahren entwickelt haben, um Abhängigkeiten zu scannen und zu reagieren, wenn ein weit verbreitetes Paket eine Sicherheitslücke enthält. KI-Codierungsagenten fügen eine weitere Ebene hinzu, da Software nun im Rahmen eines weitgehend automatisierten Entwicklungsprozesses externe Komponenten erkennen, auswählen und integrieren kann.
Der Produktivitätsvorteil ist leicht nachvollziehbar. Ein Mitarbeiter, der mit der Entwicklung einer neuen Funktion beauftragt wird, kann den Quellcode einsehen, neue Funktionen schreiben, Tests durchführen und alle Abhängigkeiten installieren, die er für notwendig erachtet. Ein Entwickler, der zuvor einen ganzen Nachmittag damit verbracht hat, Bibliotheken zu prüfen, erhält so innerhalb weniger Minuten funktionsfähigen Code.
Diese Geschwindigkeit verändert die Sicherheitsgrenze, da das Ziel des Agenten in der Regel darin besteht, die Software zum Laufen zu bringen. Sofern Organisationen keine Sicherheitsbeschränkungen explizit festlegen, kann das System ein Paket auswählen, dessen Dokumentation zur Aufgabe passt, ohne zu prüfen, ob der Betreuer noch aktiv ist, ob das Paket eine verdächtige Vorgeschichte hat oder ob eine ähnlich benannte Abhängigkeit einem Angreifer gehört.
Verwechslungen bei Paketnamen bieten Angreifern bereits eine Möglichkeit, automatisierte Prozesse auszunutzen. Ein System, das nach einer Abhängigkeit sucht, könnte auf ein bösartiges Paket stoßen, dessen Name einer legitimen internen oder öffentlichen Bibliothek sehr ähnlich ist, während ein KI-Agent, der Anweisungen aus der Dokumentation auswertet, mit großer Sicherheit die falsche Auswahl treffen kann.
Auch generierter Code selbst kann unsichere Muster reproduzieren. Modelle lernen aus umfangreichen Beständen bestehender Software, die neben modernen Praktiken auch veraltete Ansätze enthalten. Eine Funktion kann trotz schwacher Authentifizierung, unsicherer Eingabeverarbeitung oder einer anfälligen Abhängigkeit korrekt laufen, sodass das Entwicklungsteam am Ende eine Software erhält, die zwar gewöhnliche Funktionstests besteht, bei einer Sicherheitsüberprüfung jedoch durchfällt.
Auch menschliche Entwickler können genau dieselben Fehler machen, auch wenn die Automatisierung deren Häufigkeit und Ausmaß verändert. Wenn ein Entwickler zwanzig Zeilen Code schreibt, kann ein Kollege diese vor der Bereitstellung noch angemessen überprüfen. Wenn Agenten jedoch Tausende von Zeilen über mehrere Repositorys hinweg generieren, wird die manuelle Überprüfung zum Engpass, und die Teams beginnen, sich stärker auf automatisierte Kontrollen zu verlassen.
Die Entwicklungspipeline muss daher zum Kontrollpunkt werden. Abhängigkeitsprüfungen, die Erkennung vertraulicher Daten, statische Analysen und Lizenzprüfungen können automatisch durchgeführt werden, sobald ein Entwickler den Code ändert. So wird verhindert, dass die Geschwindigkeit in der Programmierphase dazu führt, dass Sicherheitsvorkehrungen umgangen werden, die normalerweise vor der Produktionsfreigabe greifen würden.
Besondere Aufmerksamkeit verdienen die Zugriffsrechte, da Programmierer zunehmend Zugriff auf Repositorys, Entwicklungsumgebungen und Bereitstellungstools benötigen. Wenn man einem Programmierer weitreichende Zugriffsrechte gewährt, weil er Aufgaben schnell erledigen muss, kann ein kompromittierter Arbeitsablauf weitaus größere Auswirkungen haben als bei einem herkömmlichen Code-Assistenten, der lediglich Textvorschläge innerhalb eines Editors unterbreitet.
Unternehmen können dieses Risiko durch zeitlich begrenzte Zugangsdaten und aufgabenspezifische Berechtigungen verringern. Ein Mitarbeiter, der eine Frontend-Komponente ändert, benötigt selten dauerhaften Zugriff auf Produktionsdatenbanken, während ein System, das Tests durchführt, nicht automatisch die Berechtigung erhalten sollte, eine Anwendung öffentlich bereitzustellen.
Externe Anweisungen schaffen eine weitere Angriffsfläche. Programmieragenten lesen Problembeschreibungen, Dokumentationen, Webseiten und Repository-Dateien als Kontext, was bedeutet, dass bösartiger Text versuchen kann, ihr Verhalten zu beeinflussen – genauso wie eine Prompt-Injektion andere KI-Agenten manipulieren kann. Eine kompromittierte Dokumentationsdatei kann daher Teil der Software-Lieferkette werden, selbst wenn sie selbst keine ausführbare Malware enthält.
Die Herkunftsnachverfolgung gewinnt zunehmend an Bedeutung, da Teams wissen müssen, welcher Agent den Code geändert hat, welches Modell dabei verwendet wurde, welche Abhängigkeiten hinzugefügt wurden und welche Tests vor dem Merge ausgeführt wurden. Herkömmliche Versionskontrollsysteme erfassen zwar die Codeänderung, doch die KI-Entwicklung erfordert zusätzliche Kontextinformationen darüber, wie die Änderung zustande gekommen ist.
Im Rahmen des Überprüfungsprozesses muss zudem zwischen Arbeiten mit geringem und hohem Risiko unterschieden werden. Ein Mitarbeiter, der Formatierungen korrigiert, benötigt nicht dieselbe Überwachung wie einer, der die Authentifizierungs- oder Zahlungslogik ändert. Auf diese Weise können Unternehmen einen Großteil des Produktivitätsvorteils erhalten und gleichzeitig eine eingehendere manuelle Überprüfung für Änderungen vorbehalten, die zu ernsthaften Risiken führen können.
Privater Code wirft ein weiteres Problem auf, da Agenten je nach ihrer Architektur Inhalte aus dem Repository an externe Modelle senden können. Unternehmen benötigen Klarheit darüber, welcher Code ihre Umgebung verlässt, wie Anbieter diesen speichern und ob vertrauliche Informationen in Protokollierungs- oder Trainingssystemen auftauchen können.
Softwareteams gehen daher zunehmend dazu über, Richtlinien zu entwickeln, die Agenten als Teilnehmer an der Entwicklungsumgebung regeln, anstatt sie als erweiterte Autovervollständigungsfunktion zu behandeln. Der Agent verfügt über eine Identität, Berechtigungen, Aktionen und Ausgaben, die mit den bestehenden Sicherheitskontrollen des Unternehmens vereinbar sein müssen.
Das Programmieren mit KI kann die Entwicklungszeit dennoch drastisch verkürzen, da ein Großteil der Softwarearbeit aus sich wiederholenden Aufgaben besteht Implementierung, die Maschinen gut damit umgehen. Sicherheitsteams müssen diese Automatisierung nicht verhindern; sie müssen vielmehr sicherstellen, dass die Geschwindigkeit der Code-Generierung nicht die Fähigkeit des Unternehmens übersteigt, nachzuvollziehen, was in das Produkt einfließt.
Die Software-Lieferkette wurde erweitert, als Entwickler aufhörten, jede Komponente selbst zu programmieren. Programmierassistenten erweitern sie erneut, da die Auswahl und Zusammenstellung dieser Komponenten nun automatisch erfolgen kann, wodurch die Kontrolle über Herkunft, Abhängigkeiten und Berechtigungen zum Preis für schnellere Software wird.
