KI-Agenten und Secret-Leaks: Scanning vs. Containment
Secret-Leaks durch KI-Coding-Agenten über „Nicht mehr fragen“-Allowlists: Secret Scanning und Containment im Vergleich, mit Leitplanken gegen committete Zugangsdaten.

Sicherheitsforscher haben gerade Passwörter, API-Tokens und Cloud-Zugangsdaten in mehr als tausend öffentlichen GitHub-Dateien gefunden – nicht in schlampigen .env-Dateien, sondern in den Einstellungen von KI-Coding-Agenten. Verantwortlich ist ein stilles Muster rund um Secret-Leaks durch KI-Coding-Agenten: Entwickler genehmigen einen Befehl wie curl -H "Authorization: Bearer sk-...", klicken auf „Nicht mehr fragen“, und der komplette Befehl – inklusive Token – landet in einer lokalen Einstellungsdatei. Committet man diese Datei, ist das Secret öffentlich. Ich beschäftige mich seit Jahren mit Infrastruktursicherheit, und das ist eine der vermeidbarsten Leak-Klassen, die ich gesehen habe. Außerdem ist sie wirklich neu, denn die Datei, die das Secret leakt, gab es vor zwei Jahren noch nicht.
Die beiden Verteidigungsansätze, zu denen Teams greifen, sind Secret Scanning (Leak erkennen, dann aufräumen) und Containment (sicherstellen, dass das Secret gar nicht erst zum Agenten oder ins Repo gelangt). Beide sind nötig. Keiner reicht allein aus. Dieser Beitrag vergleicht sie direkt miteinander – wann welcher gewinnt und wo welcher scheitert – und endet mit dem, was ich in einem Team mit Claude Code, Cursor oder jedem Agenten mit Permission-Allowlist tatsächlich ausrollen würde.
Vorab eine Klarstellung: Das ist kein Argument gegen agentische Coding-Tools. Ich nutze sie täglich und würde nicht zurückwollen. Der Permission-Prompt – der Agent, der fragt „Darf ich das ausführen?“ – ist wirklich einer der besseren Sicherheitsmechanismen, die diese Tools mitbringen. Das Problem liegt ausschließlich in dem, was nach dem Ja passiert: wo dieses „Ja“ gespeichert wird und was es enthält.
Wie die Allowlist zum Secret-Speicher wird
Um den Fehlermodus zu verstehen, muss man sich ansehen, was „Nicht mehr fragen“ eigentlich speichert. Wenn ein agentisches CLI einen Befehl ausführen will, speichert die naive Implementierung den vollständigen Befehlsstring in der Permission-Regel. Kein Muster. Kein Hash. Den wörtlichen String, den du genehmigt hast.
Wenn ein Entwickler aws s3 cp s3://bucket/backup.sql . --profile prod genehmigt, ist das harmlos. Genehmigt er aber psql postgresql://admin:hunter2@db.internal/myapp oder curl -u deploy:APIKEY123 https://.../deploy, liegen die Zugangsdaten danach in .claude/settings.local.json oder der entsprechenden Konfiguration. Die Settings-Datei ist zum lokalen Bleiben gedacht – Claude Code ignoriert sie sogar automatisch per gitignore, wenn das Tool die Datei selbst anlegt. Hat der Entwickler die Datei aber manuell erstellt, mit force-add hinzugefügt oder sein globales gitignore deckt sie nicht ab, landet sie nach einem git add . und einem Push auf GitHub. Genau diese Kette steckt hinter den 1.122 Dateien, die die Forscher gefunden haben.
Auffällig ist, wie viele Glieder dieser Kette für sich genommen vernünftig sind. Einen Befehl mit einem eingebetteten Zugangsdatum zu genehmigen, haben Entwickler jahrzehntelang interaktiv getan, ohne Folgen – der Befehl läuft, die Shell-History hält ihn lokal fest, und niemand kümmert sich darum. „Nicht mehr fragen“ zu klicken ist rational; die Prompt-Müdigkeit ist real, und das zentrale Verkaufsargument dieser Agenten ist weniger Unterbrechung. Selbst git add . ist vertretbar, wenn das Tool dir gesagt hat, die Datei sei lokal. Der Vorfall entsteht nicht durch eine einzelne unachtsame Handlung. Er entsteht, weil fünf harmlose Handlungen in einem System zu einem öffentlichen Zugangsdatum zusammenwirken. Das sind die schwersten Sicherheitsfehler überhaupt zu beheben, denn niemand sieht bei sich selbst, dass er etwas falsch macht.
Diesen genauen Fehler habe ich schon vor der Zeit der Agenten gesehen. Ein Teamleiter bei einem Fintech, für das ich beratend tätig war, hatte eine allowed_commands.sh für einen CI-Hilfsbot – dieselbe Idee, selbst gebaut. Jemand hatte einen einmaligen Datenbank-Migrationsbefehl mit dem DSN inline genehmigt. Sechs Monate später wurde das Repo quelloffen veröffentlicht, und der DSN steckte in der Git-History einer Datei, die niemand prüfte, weil sie „keine Konfiguration“ war. Die Datei war aber Konfiguration. Sie sah nur nicht danach aus.
Das ist der Kern: Permission-Allowlists sind Konfigurationsdateien, die nebenbei operative Secrets erfassen. Niemand prüft sie auf Secrets, weil niemand sie als geheimnishaltig betrachtet. Deine Secret-Management-Richtlinie deckt .env, credentials.yml und vielleicht Terraform-State ab. Sie deckt mit ziemlicher Sicherheit nicht .claude/settings.local.json oder .cursor/-Konfigurationen ab. Über einen ähnlichen blinden Fleck haben wir in dem Beitrag zur Prüfung von API-Clients als Credential-Tresore geschrieben – die Tools, die du täglich nutzt, sammeln Secrets an Orten, die deine Richtlinie nicht benennt.
Und die Kategorie wächst. Jedes agentische Tool, das in den letzten Jahren auf den Markt kam, hat eine Variante davon: Allowlists, vertrauenswürdige Verzeichnisse, gemerkte Freigaben, MCP-Server-Konfigurationen mit eingebetteten Tokens. Jede davon ist ein neuer Dateipfad, den deine bestehenden Richtlinien, gitignores und Scanner-Konfigurationen nicht erwähnen. Die nächste Version dieses Vorfalls ist derselbe Fehler in einer Datei mit anderem Namen.
Secret Scanning vs. Containment: Die beiden Verteidigungslinien
Hier ist der Vergleich, den ich im restlichen Beitrag durchgehe:
- Erkennung zuerst (Secret Scanning): Pre-Commit-Hooks, Repo-Scanner wie gitleaks und trufflehog, Push-Protection von GitHub oder GitLab sowie regelmäßige History-Scans. Man geht davon aus, dass Secrets leaken; man fängt sie schnell ab und rotiert.
- Containment zuerst (Secrets draußen halten): Secrets gelangen nur über Umgebungsvariablen, CLIs von Passwort-Managern oder kurzlebige Zugangsdaten in Befehle; Agenten laufen in Sandboxes oder ephemeren VMs; lokale Settings-Dateien sind global per gitignore ausgeschlossen. Das System wird so entworfen, dass es nichts gibt, das leaken könnte.
Erkennung ist eine Aufräumoperation. Containment ist eine Designeigenschaft. Beide scheitern in entgegengesetzte Richtungen: Scanning hat False Negatives und läuft immer nachträglich; Containment hat Einführungskosten und kollidiert mit der Reibung für Entwickler. Welcher Ansatz gewinnt, hängt davon ab, welchen Fehlermodus du tolerieren kannst.
Die beiden verschlechtern sich außerdem auf unterschiedliche Weise über die Zeit. Scanning altert sanft – ein verpasstes Secret ist schlimm, aber die gefundenen werden trotzdem gefunden, und die Regelsätze werden besser. Containment verschlechtert sich über Ausnahmen. Jedes Mal, wenn ein Entwickler die Reibung umgeht – „nur dieses eine Mal füge ich das Token direkt ein“ –, wird die Eigenschaft schwächer, und es gibt kein Protokoll dieser Schwächung. Du merkst, dass das Containment versagt hat, so wie du merkst, dass ein Schloss offen stand: wenn jemand nachschaut. Deshalb gehören beide zusammen statt gegeneinander, aber ich gewichte sie unterschiedlich. Der folgende Abschnitt erklärt, warum Scanning, obwohl es die Standardantwort der Branche ist, für diese Leak-Klasse der schwächere der beiden Ansätze ist.
Secret Scanning: Stärken und harte Grenzen
Secret Scanning gewinnt, wenn der Leak bereits passiert ist oder gleich passiert – was angesichts der menschlichen Natur oft der Fall ist. Die Push-Protection von GitHub blockiert bekannte Token-Formate beim Push. gitleaks in einem Pre-Commit-Hook fängt erstaunlich viel ab, bevor es den Laptop verlässt. Wenn du aus diesem Artikel nur eine Sache mitnimmst, dann diese:
# .pre-commit-config.yaml
repos:
- repo: https://github.com/gitleaks/gitleaks
rev: v8.18.4
hooks:
- id: gitleaks
Zehn Minuten Einrichtung, und die konkrete Leak-Klasse aus dieser Geschichte – ein Token in einer committeten Settings-Datei – verschwindet größtenteils, denn gitleaks kümmert sich nicht darum, dass es sich um eine JSON-Settings-Datei handelt. Es scannt Inhalte, keine Dateinamen. Wenn du interne Token-Präfixe hast, füg einen Regex dafür hinzu.
Es gibt noch eine Scanning-Ebene, die Teams gern vergessen und die sich lohnt: die eigene lokale Maschine regelmäßig auf nicht committete Secrets prüfen. Die Hooks auf Repo-Ebene greifen nur bei Commit oder Push. Eine Settings-Datei, die drei Monate auf der Festplatte liegt, bis jemand git add . ausführt, ist ein dreimonatiges Fenster, in dem das Secret nur einen Befehl von der Veröffentlichung entfernt ist. Ein geplanter Job – selbst ein wöchentlicher Cron, der gitleaks über die Dotfiles im Home-Verzeichnis laufen lässt – verkürzt dieses Fenster auf Tage. Das ist unschön, funktioniert aber.
Scanning hat jedoch drei harte Grenzen, die die Claude-Code-Geschichte schön offenlegt. Erstens: Entropie-basierte Detektoren übersehen Secrets mit niedriger Entropie. Ein Passwort wie Winter2024! in einem psql-Connection-String löst keinen Entropie-Check aus, und wenn es kein bekanntes Anbieterformat ist, greift keine Regel. Die Forscher fanden viele einfache Passwörter, nicht nur AWS-artige Schlüssel. Zweitens: Scanning greift nachträglich auf der Push-Ebene. Push-Protection stoppt den Push, was großartig ist – aber wenn sie nicht anschlägt, steht das Secret in der History, und die History vergisst nie. Eine Rotation nach einem Leak bedeutet, jede Stelle zu finden, an der das Zugangsdatum verwendet wurde, und ich habe diese Aufräumarbeit noch nie in weniger als einem Tag erledigt gesehen. Drittens erzeugt Scanning ein falsches Gefühl von Vollständigkeit. Teams sehen den grünen Haken und hören auf, darüber nachzudenken, wie Secrets fließen. Wie wir schon in unserem Beitrag über KI-Sicherheitsscanner argumentiert haben: Ein Scanner ist ein Sicherheitsnetz, kein Ersatz dafür, nicht zu fallen.
Zum zweiten Punkt: Es lohnt sich, genau zu benennen, was „Aufräumen“ tatsächlich bedeutet, wenn ein Zugangsdatum in einem öffentlichen Repo landet – Teams unterschätzen das chronisch. Die Rotation ist der einfache Teil: Token widerrufen, neues ausstellen, Secret-Store aktualisieren. Der schwierige Teil ist die Archäologie: Jede Deploy-Pipeline, jeder Cron-Job, jeder Entwickler-Laptop und jede Drittanbieter-Integration, die das alte Zugangsdatum verwendet hat, muss gefunden und aktualisiert werden, und wer eine davon übersieht, verursacht im ungünstigsten Moment einen Ausfall. Dazu kommt das Spiegelproblem: Ist das Repo öffentlich, musst du davon ausgehen, dass das Secret innerhalb von Minuten abgegriffen wurde. Bots, die Zugangsdaten abgreifen, beobachten den GitHub-Event-Stream dauerhaft. Bis dein Scanner Alarm schlägt, wurde das Secret wahrscheinlich bereits geklont, indexiert und vielleicht gegen deine Produktions-Endpunkte getestet. Die Erkennung hat dir Bewusstsein verschafft. Sicherheit hat sie dir nicht gebracht.
Trotzdem möchte ich dem Scanning gerecht werden, denn in diesen Debatten wird es zu schnell abgetan. Für große Organisationen mit Hunderten Repos und Tausenden Entwicklern ist Scanning die einzige Schicht, die ohne Verhaltensänderung skaliert. Mit dieser Größe kannst du einen Leak nicht wegtrainieren, aber du kannst die meisten mit Push-Protection abfangen. Wenn du als Platform-Team entscheiden musst, wo du die erste Woche Aufwand investierst, lautet die Antwort Scanning – es ist günstig, zentralisiert und fängt die hochentropischen Anbieter-Token ab, die den meisten Schaden anrichten. Halte es nur nicht für die ganze Lösung.

Containment: Env-Variablen, Sandboxes und kurzlebige Zugangsdaten
Containment gewinnt überall dort, wo das Secret sonst niedergeschrieben würde – und genau dort spielt dieser Vorfall. Erscheint das Zugangsdatum nie als wörtlicher String in einem Befehl, hat die Allowlist nichts Gefährliches zu speichern. Der genehmigte Befehl wird zu curl -H "Authorization: Bearer $DEPLOY_TOKEN" ..., und die Settings-Datei enthält einen harmlosen Variablennamen. Zwei Regeln decken das meiste ab:
- Secrets gelangen nur über Umgebungsvariablen oder Indirektion in Befehle (
$TOKEN,$(op read ...), eine Konfigurationsdatei, die der Agent zur Laufzeit liest) – niemals als literale Werte. - Agentenspezifische Konfigurationsverzeichnisse (
.claude/,.cursor/,.aider*) gehören in dein maschinenweites globales gitignore (~/.config/git/ignore), nicht nur pro Repo, damit kein Projekt sie jemals committen kann.
# Global gitignore covers every repo on this machine
git config --global core.excludesFile ~/.config/git/ignore
cat >> ~/.config/git/ignore <<'EOF'
.claude/
.cursor/
.aider*
.env*
EOF
Warum global statt pro Repo? Aus zwei Gründen. Erstens existieren Repo-gitignores nur, wenn jemand daran denkt, sie in jedes neue Repository aufzunehmen – und neue Repositories entstehen genau dann, wenn niemand an Sicherheitshygiene denkt. Zweitens ist ein globales gitignore Maschinenrichtlinie, keine Projektrichtlinie – es kann nicht versehentlich in einem Pull Request entfernt werden, der „die gitignore aufräumt“, was ich tatsächlich schon erlebt habe. Die Repo-Variante schützt ein Repo. Die globale Variante schützt einen Entwickler, und der Entwickler ist hier die leckanfällige Einheit.
Die Env-Var-Regel verdient dieselbe Prüfung, weil sie einen subtilen Fehlermodus hat: Shell-Profile. Wenn der Entwickler die Anforderung an Env-Variablen „löst“, indem er DEPLOY_TOKEN=sk-... in seiner .bashrc exportiert, hast du das Secret nur von einer ungeprüften Dotfile in eine andere verschoben. Die Regel muss an einem echten Secrets-Backend enden – 1Password CLI, direnv, das aus einem verschlüsselten Store liest, oder ein Cloud-Secrets-Manager mit aws ssm oder op inject beim Sitzungsstart. Der Agent bekommt die Variable; die Festplatte bekommt nie den Wert. Das ist eine zusätzliche Indirektion, und sie unterscheidet Containment von Kosmetik.
Die stärkere Form von Containment nenne ich echtes Sandboxing: Den Agenten pro Aufgabe in einer ephemeren VM oder einem Container laufen lassen, in einem isolierten Netzwerk, mit einem Proxy vor externen APIs. Ein Setup aus der Praxis, das ich bewundere, schiebt einen API-Proxy zwischen den Agenten und einen allmächtigen SaaS-Schlüssel: Lesezugriffe laufen durch, Schreibzugriffe brauchen eine Bestätigung am Telefon. Das ist Defense in Depth richtig gemacht – selbst ein vollständig kompromittierter Agent mit --dangerously-skip-permissions kann nur das anfassen, was der Proxy erlaubt. Den breiteren Zielkonflikt haben wir in Containment vs. Monitoring bei KI-Agenten behandelt; dieser Vorfall spricht für Containment.
Kurzlebige Zugangsdaten sind die andere Hälfte der starken Variante, und sie werden unterschätzt, weil sie den Wirkungsradius selbst dann verkleinern, wenn alle anderen Schichten versagen. Ein statischer AWS-Zugangsschlüssel, der auf GitHub landet, ist gültig, bis ihn jemand bemerkt. Ein per OIDC ausgestelltes Zugangsdatum mit einer TTL von einer Stunde, das auf GitHub landet, ist ein Logeintrag. Unterstützt dein Cloud-Anbieter Workload Identity Federation – und alle großen tun das –, sollten die Zugangsdaten des Agenten schneller ablaufen, als dein Incident-Response-Prozess überhaupt ein Meeting einberufen kann.
Die ehrlichen Kosten von Containment sind Reibung. Passwort-Manager-CLIs bedeuten Fingerabdruck-Abfragen mitten in der Aufgabe. Ephemere VMs bedeuten Einrichtungszeit und Kaltstart-Latenz bei jedem Lauf. Scoped Proxies bedeuten, dass jemand den Proxy bauen und pflegen muss. Für einen Solo-Entwickler bei einem Side-Projekt ist volles Sandboxing übertrieben, und die Variante mit globalem gitignore plus Env-Variablen ist die richtige Wahl. Für ein Team, dessen Agenten auf Produktions-Zugangsdaten zugreifen, ist die Reibung der Preis dafür, nicht der nächste gemeldete Breach zu sein.
Die mittlere Schicht: Die Allowlist selbst reparieren
Es gibt eine dritte Option, die die Tool-Anbieter besitzen, nicht du: Den wörtlichen Befehl gar nicht erst speichern. Eine Berechtigungsregel, die curl -H "Authorization: Bearer *" als Muster speichert – mit geschwärzten Argumentwerten –, ist zum Abgleich genauso brauchbar und enthält kein Secret. Das Team hinter Claude Code hat gesagt, dass sie genau diese Klasse verhindern wollen, und ihre empfohlene Richtung ist ein automatischer Berechtigungsmodus, der überhaupt keine Allow- und Deny-Listen pflegen muss. Das ist der richtige Instinkt. Jede manuell gepflegte Allowlist ist ein zukünftiger Vorfall mit einem Zeitstempel, den du noch nicht sehen kannst.
Musterabgleich ist allerdings kein Gratismittagessen. Ein Glob wie curl * passt gleichermaßen zum harmlosen Deploy-Befehl wie zum bösartigen Exfiltrationsbefehl; aggressives Schwärzen tauscht also das Leak-Risiko gegen das Risiko zu breiter Freigaben. Das richtige Design ist wahrscheinlich eher strukturell als textuell: Gespeichert wird, welches Binary und welche Flags genehmigt wurden – niemals die Argumentwerte. So bleibt der Abgleich präzise (ja zu curl mit Headern, nein zu curl, das an eine neue Domain pipt), ohne dass irgendetwas gespeichert wird, in dem ein Zugangsdatum stecken könnte. Die Anbieter werden dort ankommen; der Anreiz besteht inzwischen aus über tausend öffentlichen Dateien als Beleg.
Bis die Anbieter das ausliefern, kannst du es mit Hygiene annähern: Lass regelmäßig einen Scanner über die lokalen Settings-Dateien selbst laufen. Ein Einzeiler wie gitleaks detect --no-git --source ~/.claude .claude prüft genau die Dateien, um die es in dieser Geschichte geht, bevor sie in die Nähe eines Repos kommen. Füg es deinem Dotfiles-Setup-Skript hinzu, dann kostet es nichts.
Meine Empfehlung: Containment als Standard, Scanning als Netz
Wenn ich mich für eines entscheiden müsste, würde ich Containment wählen. Ein Leak, der nie passiert, schlägt jedes schnell entdeckte Leak – immer. Scanning ist das, worauf du dich verlässt, wenn Containment versagt – und das wird es, denn irgendjemand wird um 1 Uhr nachts einen Connection-String in einen Chat einfügen –, aber es sollte der Ausnahmebehandler sein, nicht die Richtlinie.
Konkret, für ein Team, das agentische Coding-Tools in diesem Quartal ausrollt, in dieser Reihenfolge nach Aufwand:
- Globales gitignore für Agenten-Konfigurationsverzeichnisse auf jedem Entwickler-Rechner – fünf Minuten, und das Leak über committete Settings-Dateien ist komplett erledigt.
- Regel: Secrets nur über Env-Variablen oder eine CLI des Passwort-Managers, niemals inline in Befehlen. Gehört ins Onboarding, nicht in ein Wiki, das niemand liest.
- gitleaks als Pre-Commit-Hook plus Push-Protection auf der Forge – das Sicherheitsnetz für alles oben Genannte.
- Kurzlebige, eng gefasste Zugangsdaten für alles, was der Agent anfasst (per OIDC ausgestellte Cloud-Zugangsdaten statt statischer Schlüssel), damit ein Leak innerhalb von Stunden abläuft.
- Für Agenten mit Produktionszugriff: eine ephemere Sandbox plus ein API-Proxy, der festlegt, was die Zugangsdaten des Agenten tun dürfen.
Beachte die Reihenfolge. Die beiden günstigsten Punkte sind Containment, und sie eliminieren die gesamte Vorfallklasse, statt nur ihre Wahrscheinlichkeit zu verringern. Die Scanning-Punkte kommen erst an dritter Stelle – nicht weil sie unwichtig wären, sondern weil sie das Netz unter dem Trapez sind, und man spannt das Netz erst, nachdem man die Seile geprüft hat. Die Punkte vier und fünf sind der Moment, in dem du nicht mehr nur gegen Unfälle, sondern gegen Kompromittierung verteidigst – und genau dorthin entwickeln sich agentische Tools, ob wir es einplanen oder nicht.

Allein die ersten beiden Punkte hätten praktisch jede Datei im Datensatz der Forscher verhindert. Das ist das Frustrierende an diesem Vorfall: Es ist kein raffinierter Angriff. Es ist ein neuer Dateityp, der einen alten Fehler transportiert, und die Lösung ist dieselbe Hygiene, die wir seit der ersten committeten .env predigen – angewendet auf ein Verzeichnis, das in keiner Richtlinie bisher vorkommt.
Aktualisiere deine Richtlinie. Die Agenten verschwinden nicht, und der Button „Nicht mehr fragen“ auch nicht.


