Latest / KI Espresso / Claude Code unter Verdacht: Wer prüft den Agenten?

Transcript

Claude Code unter Verdacht: Wer prüft den Agenten? · KI Espresso

• 0:00
  SPEAKER_01: Die chinesische Cybersicherheitsbehörde CNVDB hat gerade Claude Code, spezifisch die Version 2.1.98 bis 2.1.196, als handfestes Sicherheitsrisiko mit integriertem Backdoor-Code eingestuft.
• 0:16
  SPEAKER_00: Und das völlig zu Recht.
• 0:18
  SPEAKER_00: Wir reden hier halt nicht mehr über einen simplen Spellchecker.
• 0:21
  SPEAKER_00: Das ist ein autonomer Akteur, der, naja, der direkt in der kritischen Softwarelieferkette sitzt.
• 0:27
  SPEAKER_01: Aber Anthropic hat doch sofort reagiert.
• 0:29
  SPEAKER_01: Die meinten, das war ein Anti-Distillation-Experiment.
• 0:33
  SPEAKER_01: Das war keine Spionage.
• 0:35
  SPEAKER_00: Ja, dass dann in Version 2.1.198 ganz schnell wieder verschwunden ist.
• 0:40
  SPEAKER_00: Richtig?
• 0:40
  SPEAKER_00: Erklär das mal einem Auditor.
• 0:42
  SPEAKER_00: Ob Experiment oder Vector das Tool hat, versteckte Netzwerksignale gesendet.
• 0:47
  SPEAKER_01: Genau, und also Antidistillation heißt ja nur, die wollten verhindern, dass Nutzer massenhaft Code abgreifen, um damit fremde Modelle zu trainieren.
• 0:56
  SPEAKER_01: Das ist reiner IP-Schutz.
• 0:58
  SPEAKER_01: Für mich zeigt das, dass das Risiko in mangelhaften Policies liegt, nicht im Agenten selbst.
• 1:05
  SPEAKER_01: Wer denn sauber isoliert, gewinnt massiv an Produktivität.
• 1:08
  SPEAKER_00: Da muss ich, naja, da muss ich echt hart widersprechen.
• 1:12
  SPEAKER_00: Du tust so, als wäre das eine reine Konfigurationsfrage.
• 1:15
  SPEAKER_00: Aber ein Coding-Agent ist kein normales Dev-Tool.
• 1:19
  SPEAKER_00: Stell dir vor, es läuft doch in der Sandbox.
• 1:22
  SPEAKER_00: Theoretisch, ja.
• 1:23
  SPEAKER_00: Aber stell dir vor, du hast eine Bohrmaschine, die dreht sich nur, wenn du drückst.
• 1:27
  SPEAKER_00: Der Agent ist eher wie ein externer Bauarbeiter, dem du den Schlüssel gibst und der nachts allein entscheidet, welche Wende er einreißt.
• 1:36
  SPEAKER_00: Wenn der Unbemerkt Daten funkt, ist das eine völlig neue Vertrauensebene.
• 1:40
  SPEAKER_01: Der Bauarbeiter trägt aber quasi eine Bodycam.
• 1:43
  SPEAKER_01: Die Architektur von Cloud Code ist konzeptionell extrem restriktiv.
• 1:47
  SPEAKER_01: Du hast diese zentrale Punkt Cloud Settings.json und sensible Netzwerkbefehle brauchen, also die brauchen explizite Zustimmung.
• 1:55
  SPEAKER_00: Auf dem Papier, ja.
• 1:57
  SPEAKER_01: Nicht nur auf dem Papier.
• 1:58
  SPEAKER_01: Du hast den simplen Befehl Permissions, du hast Open Telemetrie-Metriken, wir haben die volle Kontrolle darüber, was unter der Haube passiert.
• 2:06
  SPEAKER_00: Okay, aber denk das mal in der Praxis durch.
• 2:08
  SPEAKER_00: Nimm einen Zürcher FinTech oder ein SARS-Team in Berlin.
• 2:12
  SPEAKER_00: Der Agent durchforstet lokale Dateien, Bildskripte, unverschlüsselte Secrets.
• 2:18
  SPEAKER_00: Und dann kommen diese MCP-Server ins Spiel.
• 2:20
  SPEAKER_01: Das Model-Context-Protokoll, ja.
• 2:22
  SPEAKER_01: Die dienen ja bewusst als Brücke.
• 2:24
  SPEAKER_00: Genau, als Brücke in externe Systeme.
• 2:28
  SPEAKER_00: Zu Datenbanken oder Fremdentools.
• 2:30
  SPEAKER_00: Und sobald ein Entwickler, was ja ständig passiert, sich eine.cloudSettings.localjSON anlegt, um, naja, um schneller arbeiten zu können, wird dein ganzer zentraler Workspace-Trust ausgehebelt.
• 2:43
  SPEAKER_00: Aber Moment.
• 2:44
  SPEAKER_00: Der Entwickler öffnet dem Agenten quasi die Hintertür.
• 2:48
  SPEAKER_00: Dein zentrales Audit läuft völlig ins Leere.
• 2:51
  SPEAKER_01: Aber genau das ist doch der springende Punkt.
• 2:54
  SPEAKER_01: Diese lokalen Overrides braucht man für die Flexibilität.
• 2:57
  SPEAKER_01: Wir klemmen Entwicklern ja auch nicht das Internet ab, nur weil sie theoretisch Firmencode leaken könnten.
• 3:04
  SPEAKER_01: Das ist menschliches Versagen, wenn diese lokalen Daten nicht ins zentrale Monitoring fließen.
• 3:08
  SPEAKER_00: Ein Mensch kann aber nicht in Millisekunden tausende Zeilen Code im Kontextfenster sammeln und an eine externe API schicken.
• 3:18
  SPEAKER_00: Die Skalierung der Gefahr ist eine ganz andere.
• 3:20
  SPEAKER_00: Puh, okay.
• 3:22
  SPEAKER_00: Wenn morgen ein Auditor fragt, beweisen Sie mir wasserdicht, dass kein Kundencode abgeflossen ist.
• 3:29
  SPEAKER_00: Und du musst auf lokale Entwickler-Settings verweisen dann.
• 3:32
  SPEAKER_00: Ganz ehrlich, dann hast du das Audit in der Sekunde krachen verloren.
• 3:37
  SPEAKER_00: Das ist ein starker Punkt.
• 3:38
  SPEAKER_01: Das zwingt uns schlichtweg zu einer professionelleren Handhabung.
• 3:41
  SPEAKER_01: Wenn der Agent faktisch zu kritischer Infrastruktur wird, müssen wir.
• 3:45
  SPEAKER_00: Ein Punkt fehlt noch.
• 3:46
  SPEAKER_00: Also, wenn wir über die Sicherheit von autonomen KI-Agenten sprechen, müssen wir uns unbedingt diesen ganz spezifischen Fall ansehen.
• 3:55
  SPEAKER_01: Ja, du meinst die Cloud-Code-Version, oder?
• 3:58
  SPEAKER_01: Also 2.1.99 bis 2.1.196.
• 4:03
  SPEAKER_00: Genau die ja, weil da eskaliert die Situation gerade enorm.
• 4:08
  SPEAKER_00: Ich meine, China hat da ja eine offizielle Warnung herausgegeben.
• 4:11
  SPEAKER_01: Hm, und das nicht ohne Grund.
• 4:13
  SPEAKER_01: Sie bezeichnen diesen fest eingebauten Monitoring-Mechanismus von Anthropic explizit als, ja, als Backdoor-Code.
• 4:21
  SPEAKER_00: Richtig, was Enthropic natürlich vehement bestreitet.
• 4:24
  SPEAKER_00: Die verweisen auf ihre offizielle Dokumentation, ne?
• 4:28
  SPEAKER_00: Und ich muss sagen, ich vertrete hier eher die Seite, dass es sich höchstwahrscheinlich einfach um Standardtelemetrie handelt.
• 4:35
  SPEAKER_00: Echt jetzt?
• 4:35
  SPEAKER_00: Du sagst Standardtelemetrie?
• 4:37
  SPEAKER_00: Ja, also Fehlerdiagnostik, die ist für die Weiterentwicklung von so komplexen Systemen halt absolut unerlässlich.
• 4:44
  SPEAKER_01: Okay, da betrachte ich das aber aus einer deutlich skeptischeren Perspektive.
• 4:49
  SPEAKER_01: Ich meine, ein intransparenter Monitoringmechanismus, der so tief in der Architektur verankert ist, das stellt völlig unabhängig von der eigentlichen Intention der Entwickler per Definition ein ungelöstes Kontrollrisiko dar.
• 5:04
  SPEAKER_00: Ich sehe schon, warum du das so kritisch siehst.
• 5:08
  SPEAKER_00: Aber lass mich dir das mal kurz pragmatisch aufschlüsseln.
• 5:11
  SPEAKER_00: Schieß los.
• 5:12
  SPEAKER_00: Wenn wir wollen, dass diese autonomen Systeme wirklich verlässlich und sicher laufen, dann brauchen die Entwickler doch dieses kontinuierliche Feedback, oder?
• 5:21
  SPEAKER_00: Ja, bis zu einem gewissen Grad.
• 5:22
  SPEAKER_00: Eben.
• 5:23
  SPEAKER_00: Wenn wir jetzt jede Form von Systemtelemetrie sofort als Backdoor-Framen, naja, framen ist gut, das ist ja.
• 5:29
  SPEAKER_00: Ähnlich wie bei automatischen Absturzberichten von modernen Betriebssystemen.
• 5:35
  SPEAKER_00: Wie sollen die Entwickler dann überhaupt noch Sicherheit garantieren?
• 5:38
  SPEAKER_00: Ich meine, ohne diese Daten fliegen die beim Debugging doch völlig blind.
• 5:43
  SPEAKER_01: Tut mir leid, aber den Vergleich, den kaufe ich dir einfach nicht ab.
• 5:46
  SPEAKER_01: Wieso nicht?
• 5:47
  SPEAKER_01: Lass mich dir sagen, warum deine Analogie da mechanisch völlig hinkt.
• 5:51
  SPEAKER_01: Der fundamentale Unterschied zwischen legitimer Telemetrie und, sagen wir mal, einer potenziellen Backdoor, der liegt in der informationellen Autonomie des Nutzers.
• 6:00
  SPEAKER_01: Okay, du meinst die Transparenz.
• 6:03
  SPEAKER_01: Genau.
• 6:03
  SPEAKER_01: Bei einem normalen Absturzbericht wird ein statisches Protokoll erstellt, richtig?
• 6:08
  SPEAKER_01: Ich sehe exakt, was gesendet wird und ich habe die Wahl.
• 6:12
  SPEAKER_01: Ich kann aktiv auf Senden oder eben auf Abbrechen klicken.
• 6:15
  SPEAKER_00: Ja, das stimmt schon.
• 6:16
  SPEAKER_01: Aber.
• 6:17
  SPEAKER_01: Warte, bei diesen spezifischen Cloud-Code-Versionen ist das anders.
• 6:21
  SPEAKER_01: Da operiert das Monitoring fest verdrahtet im Hintergrund.
• 6:24
  SPEAKER_01: Das Ding liest kontinuierlich den ganzen Kontext aus.
• 6:27
  SPEAKER_01: Und der Entwickler kann diesen Datenstrom nicht einfach mal auf Kommandozeilen-Ebene kappen.
• 6:33
  SPEAKER_00: Die Architektur zwingt dem Nutzer da quasi einen blinden Fleck auf.
• 6:37
  SPEAKER_01: Okay, das ist ein interessanter Punkt.
• 6:38
  SPEAKER_01: Du bemängelst also primär die fehlende Granularität beim Opt-out.
• 6:42
  SPEAKER_01: Exakt.
• 6:43
  SPEAKER_01: Aber wir reden hier ja nicht von einem starren Betriebssystem, wir reden von einem iterativen KI-Agenten, der eigenständig Code schreibt und ausführt.
• 6:52
  SPEAKER_01: Wenn das System jetzt in eine Endlosschleife gerät oder fehlerhaften, vielleicht sogar schädlichen Code generiert, dann muss der Mechanismus das doch während der Laufzeit erkennen, oder?
• 7:01
  SPEAKER_00: Ja, aber zu welchem Preis?
• 7:03
  SPEAKER_00: Naja, wenn du den Nutzern die Möglichkeit gibst, das Monitoring komplett abzuschalten, dann riskierst du, dass diese Agenten unbemerkt massiven Schaden anrichten, einfach weil Entropic eben nicht mehr eingreifen oder aus den Fehlern lernen kann.
• 7:18
  SPEAKER_01: Da stellt sich mir aber sofort die Frage, wer profitiert am Ende wirklich davon, wenn das System Entscheidungen auf Basis dieses Monitorings trifft?
• 7:27
  SPEAKER_01: Die Sicherheit der Nutzer.
• 7:28
  SPEAKER_01: Dient das wirklich nur der lokalen Sicherheit?
• 7:31
  SPEAKER_01: Oder, und das ist ja die große Befürchtung, werden hier kontinuierlich spezifische Entwicklungsdaten abtransportiert?
• 7:38
  SPEAKER_01: Daten, die Enthropic dann einen asymmetrischen Vorteil beim Training zukünftiger Modelle verschaffen.
• 7:44
  SPEAKER_00: Puh, das ist jetzt aber schon ein bisschen spekulativ.
• 7:47
  SPEAKER_00: Ich.
• 7:47
  SPEAKER_00: Also ich würde das Wort Hintertür trotzdem vermeiden.
• 7:51
  SPEAKER_00: Warum?
• 7:52
  SPEAKER_00: Weil es eine versteckte, böswillige Zugriffsabsicht impliziert.
• 7:56
  SPEAKER_00: Und Anthropic verteidigt diesen Datenfluss ja ganz offen.
• 8:00
  SPEAKER_00: Aber du hast recht, wir müssen das pragmatisch für die Anwender betrachten.
• 8:04
  SPEAKER_00: Absolut.
• 8:05
  SPEAKER_00: Für Unternehmen, die jetzt überlegen, Cloud Code in ihre, sagen wir mal, kritische Infrastruktur zu integrieren, da geht es nicht um Begrifflichkeiten.
• 8:13
  SPEAKER_00: Da geht es um harte Prüffragen.
• 8:15
  SPEAKER_01: Genau.
• 8:15
  SPEAKER_01: Wie zum Beispiel hat der Nutzer die technische Möglichkeit, Empfehlungen oder Aktionen des Systems manuell zu überschreiben.
• 8:22
  SPEAKER_00: Richtig.
• 8:23
  SPEAKER_00: Und zwar bevor sensible Unternehmensdaten erfasst und nach außen gesendet werden.
• 8:28
  SPEAKER_01: Exakt, das ist der Knackpunkt.
• 8:30
  SPEAKER_01: Und solange diese Autonomie nicht glasklar gegeben ist, ist das System für Sicherheitsverantwortliche einfach ein rotes Tuch.
• 8:38
  SPEAKER_00: Auch wenn Anthropic argumentiert, die Architektur sei sicher und diene reinen diagnostischen Zwecken.
• 8:44
  SPEAKER_01: Reine Versprechungen reichen in der Cybersicherheit einfach nicht aus.
• 8:48
  SPEAKER_01: Die gleichen kein Architekturrisiko aus.
• 8:51
  SPEAKER_00: Dann liegt die Beweislast jetzt wohl ganz klar bei Anthropic.
• 8:54
  SPEAKER_00: Ganz genau.
• 8:55
  SPEAKER_00: Um dieses theoretische Vertrauen irgendwie in die Praxis zu übersetzen, brauchen wir handfeste Belege.
• 9:00
  SPEAKER_00: Seien es unabhängige Audits oder kryptografisch überprüfbare Datenprotokolle.
• 9:06
  SPEAKER_01: Ja, die exakt belegen, was da eigentlich abfließt.
• 9:09
  SPEAKER_01: Solange diese Beweise nicht lückenlos vorliegen, bleibt das Misstrauen absolut berechtigt.
• 9:14
  SPEAKER_01: Es läuft am Ende auf einen ganz konkreten Praxistest hinaus.
• 9:18
  SPEAKER_00: Was muss also bewiesenermaßen wahr sein, bevor ein einzelner Entwickler, ein Unternehmen oder eine ganze Institution diesem System in der Praxis wirklich vertrauen sollte?
• 9:28
  SPEAKER_01: Claude Code Versionen 2.191 bis 2.1196 vom Anfang zurück.
• 9:35
  SPEAKER_01: Das sind nicht einfach nur Nummern in einer Release-Note.
• 9:38
  SPEAKER_01: Sie stellen die fundamentale Frage, ob ihr wirklich wisst und kontrolliert, wer oder was da gerade aktiv an eurer Codebasis mitarbeitet.
• 9:48
  SPEAKER_00: Wenn euch diese Debatte zum Nachdenken gebracht hat, abonniert KI Espresso.
• 9:53
  SPEAKER_00: Jeden Tag eine neue KI-Debatte in sechs Minuten.