Zum Inhalt springen
S&L Labs

Writeups

Wenn der Agent schreiben darf: Schreibzugriffe absichern

Ein Agent, der Daten ändert, braucht deklarierte Schreiboperationen, eine Freigabe, die die Änderung im Klartext zeigt, und ein manipulationssicheres Protokoll. Durchgesetzt wird das auf dem Server, nicht im Prompt.

  • Freigaben
  • Schreibzugriffe
  • Protokoll
  • Simon Liedtke

Meine Einordnung, mit KI ausformuliert.

Solange ein Agent nur liest, ist das schlimmste Ergebnis meist ein Datenleck. Das ist ernst, aber begrenzt durch das, was der Agent sehen darf. Darf derselbe Agent schreiben, ändert ein falscher Zugriff den Zustand Ihres Systems, oft unbemerkt und oft mit Folgen in nachgelagerten Systemen: Eine Lieferung geht an die falsche Adresse, ein Vertrag wird gekündigt, ein Datensatz verschwindet.

Dieser Text beschreibt das Muster, mit dem ich in Produktivsystemen, die ich gebaut habe, Schreibzugriffe von Agenten absichere. Das Beispiel ist bewusst schlicht: ein Agent, der Bestellungen bearbeitet. Der vollständige Code ist ein einzelnes Python-Skript ohne Abhängigkeiten, die Ausschnitte unten stammen daraus. Es läuft mit python3 ab Version 3.10.

1. Lesen und Schreiben sind getrennte Probleme

Für Lesezugriffe ist die Frage: Was darf dieser Agent im Namen dieser Person sehen? Die Antwort liegt in der Rechte- und Retrieval-Schicht. Für Schreibzugriffe kommen drei Fragen dazu. Ist diese Änderung in diesem Zustand überhaupt zulässig? Hat ein Mensch verstanden, was passieren wird, bevor es passiert? Und lässt sich hinterher lückenlos zeigen, wer was ausgelöst, gesehen und freigegeben hat?

Die OWASP Top 10 for Agentic Applications 2026 benennen diese Risiken. ASI02 Tool Misuse and Exploitation beschreibt den Fall, dass ein Agent innerhalb seiner Rechte ein legitimes Werkzeug unsicher einsetzt, ausdrücklich auch mit dem Beispiel, wertvolle Daten zu löschen. ASI03 Identity and Privilege Abuse greift, sobald der Agent mehr Rechte hat als die Person, für die er handelt. ASI09 Human-Agent Trust Exploitation beschreibt, wie Menschen Aktionen freigeben, die sie nicht geprüft haben, weil der Agent überzeugend klingt (OWASP GenAI Security Project 2025).

Die Ursache dafür ist oft keine Lücke im Code, sondern Prompt Injection. Ein Agent, der private Daten sieht, fremde Inhalte liest und nach außen kommunizieren kann, vereint das, was Simon Willison die „lethal trifecta“ nennt (Willison 2025). Bei Schreibzugriffen genügt dem Angriff schon weniger: Er muss nichts mehr hinausschaffen, es reicht, wenn er etwas verändert. Meta hat das in der „Agents Rule of Two“ aufgenommen. Dort steht die Fähigkeit, Zustand zu ändern, neben der externen Kommunikation. Ein Agent soll in einer Sitzung höchstens zwei von drei Eigenschaften haben: nicht vertrauenswürdige Eingaben verarbeiten, auf sensible Systeme oder private Daten zugreifen, Zustand ändern oder nach außen kommunizieren. Braucht er alle drei, soll er nicht autonom laufen, sondern mindestens unter Aufsicht, etwa mit menschlicher Freigabe (Meta 2025). Um genau diesen Fall geht es hier. Ein präpariertes Dokument im Kontext kann reichen, damit der Agent eine plausible, aber falsche Änderung vorschlägt. Deshalb darf die Frage, ob eine Änderung zulässig ist, nie vom Modell beantwortet werden.

2. Deklarierte Schreiboperationen

Der Agent bekommt kein generisches Werkzeug „Datensatz aktualisieren“. Er bekommt eine kleine Menge benannter Schreiboperationen, und jede ist deklariert: welche Entität, welche Felder, welche Berechtigung, welche Vorbedingungen, wie hoch die Wirkung ist.

Precondition = Callable[[dict, dict], str | None]  # (current, changes) -> error or None


@dataclass(frozen=True)
class WriteOperation:
    name: str
    entity: str
    permission: str
    fields: frozenset[str]
    preconditions: tuple[Precondition, ...] = ()
    high_impact: bool = False
    batchable: bool = True


WriteOperation(
    name="lieferadresse_aendern",
    entity="bestellung",
    permission="bestellung.bearbeiten",
    fields=frozenset({"strasse", "plz", "ort"}),
    preconditions=(status_is("offen", "in_pruefung"),),
)

Dabei zählen drei Eigenschaften.

Die Prüfung läuft auf dem Server. Die Deklaration ist keine Beschreibung für das Modell, sondern Code, den der Server vor jeder Änderung ausführt. Was im System-Prompt steht („ändere nur offene Bestellungen“), ist bestenfalls ein Hinweis. Durchgesetzt wird es hier:

def _check(self, operation: str, target: str, changes: dict, actor: str):
    c = OPERATIONS.get(operation)
    if c is None:
        raise Denied(f"keine Operation '{operation}'")
    if c.permission not in self.grants.get(actor, set()):
        raise Denied(f"{actor} fehlt {c.permission}")
    extra = set(changes) - c.fields
    if extra:
        raise Denied(f"Felder außerhalb der Operation: {sorted(extra)}")
    current = self.store.get(target)
    if current is None or current["entity"] != c.entity:
        raise Denied(f"Ziel {target} passt nicht zu {c.entity}")
    for pre in c.preconditions:
        if (err := pre(current, changes)) is not None:
            raise Denied(err)
    return c, current

Der Agent handelt mit den Rechten der Person. Im Beispiel heißt der Akteur agent:mia und hat genau die Rechte von Mia, nicht die eines Service-Accounts. Dieser Teil richtet sich gegen ASI03. Ein Agent, der mit Admin-Rechten läuft und „selbst aufpassen“ soll, verschiebt die Rechteprüfung in das Modell.

Vorbedingungen prüfen den Zustand, nicht nur die Eingabe. Eine Adressänderung ist für eine offene Bestellung zulässig und für eine versendete nicht. Ein Storno ist nur als Übergang von offen nach storniert erlaubt. Diese Regeln stehen meist schon irgendwo in der Fachlogik. Die Deklaration macht sie für den Schreibpfad des Agenten verbindlich und an einer Stelle sichtbar.

Der Nebeneffekt ist ein Inventar. Wer die deklarierten Operationen auflistet, weiß, was der Agent überhaupt ändern kann. Das ist die Grundlage für jedes Review und für die Evals weiter unten.

3. Die Freigabe muss zeigen, was passiert

Viele Freigabedialoge, die ich gesehen habe, zeigen einen Satz wie „Der Agent möchte die Bestellung aktualisieren. Zulassen?“. Daraus erfährt die Person nicht, was sich ändert. Andere zeigen die Begründung des Modells, also genau den Text, den ein Angriff am leichtesten beeinflusst. OWASP empfiehlt unter ASI09 ausdrücklich eine Risikozusammenfassung in Klartext, „not model-generated rationales“, und unter ASI02 einen Dry-Run oder Diff vor Aktionen mit hoher Wirkung (OWASP GenAI Security Project 2025).

Im Muster erzeugt deshalb der Server das Diff, aus dem gespeicherten Zustand und den beantragten Feldern. Das Modell schreibt keine Zeile davon.

def render_diff(c: WriteOperation, target: str, current: dict, changes: dict) -> list[str]:
    lines = [f"{c.name} auf {target} (Version {current['version']})"]
    for k in sorted(changes):
        old, new = current.get(k), changes[k]
        if old != new:
            lines.append(f"  {LABELS.get(k, k)}: {old!r} -> {new!r}")
    return lines

Die Ausgabe im Demo-Lauf:

lieferadresse_aendern auf B-1 (Version 1)
  Ort: 'München' -> 'Augsburg'
  PLZ: '80331' -> '86150'

Zwei Details sind dabei wichtig.

Erstens bindet die Freigabe an genau das, was angezeigt wurde. Beim Vorschlag berechnet der Server einen Hash über Ziel, Version, Operation und Änderungen. Die Oberfläche schickt diesen Hash mit der Freigabe zurück. Passt er nicht, wird nichts geschrieben. So kann zwischen Anzeige und Klick nichts mehr ausgetauscht werden.

Zweitens prüft der Server bei der Freigabe alles noch einmal, gegen den aktuellen Zustand. Zwischen Vorschlag und Klick können Minuten oder Stunden liegen, und in der Zeit kann sich die Bestellung geändert haben. Die Versionsnummer fängt das ab:

for p in items:  # re-check against current state, not the state at proposal time
    c, current = self._check(p.operation, p.target, p.changes, approver)
    if current["version"] != p.version:
        raise Denied(f"{p.target} wurde seit dem Vorschlag geändert")

Die Freigabe hat ihren eigenen Akteur. Der Server prüft die Rechte der freigebenden Person, nicht die des Agenten, der vorgeschlagen hat. Bei Operationen mit hoher Wirkung, im Beispiel das Storno, darf niemand den eigenen Vorschlag freigeben. Für die Demo reicht das als Vier-Augen-Regel. In einem echten System hängt man daran die Unterscheidung, ob der Vorschlag vom Agenten im Auftrag der Person oder von der Person selbst kam.

zulässigFreigabe mit HashpasstneinneinAgent schlägt vorOperation, Ziel, ÄnderungenServer prüft die DeklarationOperation, Recht, Felder,Ziel, VorbedingungenServer erzeugt das Diffund einen Hash über Ziel, Version,Operation und ÄnderungenPerson sieht das DiffSammelfreigabe: eine Operation,nur sammelbare, Obergrenze,ein Hash über alle EinträgeServer prüft erneutRechte der freigebenden Person,Hash, aktuelle Version,bei hoher Wirkung vier AugenWritebei einer Sammlungalles oder nichtsAblehnungauch wenn die Prüfungselbst ausfälltProtokollhash-verkettet,mit Korrelations-ID
Der Schreibpfad: Das Modell beantwortet keine der Prüffragen und schreibt keine Zeile des Diffs.

4. Sammelfreigaben, ohne dass sie zum Durchwinken werden

Sobald ein Agent nützlich ist, schlägt er viele Änderungen auf einmal vor. Zwanzig einzelne Dialoge führen zuverlässig dazu, dass beim fünften nicht mehr gelesen wird. Eine Sammelfreigabe ist also sinnvoll, aber nur mit Regeln, die sie lesbar halten. In den Systemen, die ich gebaut habe, haben sich diese bewährt:

  • Eine Operation pro Sammlung. Zwanzig Adressänderungen lassen sich als Tabelle lesen, zwanzig gemischte Operationen nicht.
  • Hohe Wirkung ist nie sammelbar. Stornos, Löschungen, Zahlungen und Rechteänderungen werden einzeln freigegeben. In der Deklaration steht das als batchable=False.
  • Eine Obergrenze. Was darüber liegt, wird geteilt. Die Grenze richtet sich danach, was eine Person konzentriert prüfen kann.
  • Ein Hash über die ganze Sammlung. Die Freigabe gilt für genau die angezeigten Einträge. Ändert sich einer davon zwischen Anzeige und Klick, fällt die ganze Sammlung durch, nicht nur der eine Eintrag.
def _check_batch(self, items: list[Pending], approver: str, shown_digest: str) -> None:
    if len(items) > 1:
        operations = {p.operation for p in items}
        if len(operations) != 1:
            raise Denied("Sammelfreigabe nur für eine Operation")
        if not OPERATIONS[operations.pop()].batchable:
            raise Denied("Operation erlaubt keine Sammelfreigabe")
        if len(items) > self.max_batch:
            raise Denied(f"mehr als {self.max_batch} Einträge")
    if batch_digest(items) != shown_digest:
        raise Denied("Freigabe passt nicht zur angezeigten Änderung")

Im Demo-Lauf schlägt der Agent drei Adressänderungen vor. Während die Sammlung angezeigt wird, ändert ein anderer Prozess eine der Bestellungen. Die Freigabe wird verweigert: „B-4 wurde seit dem Vorschlag geändert“. Dass alles oder nichts geschrieben wird, ist Absicht. Wer eine Sammlung freigibt, hat einen Gesamtzustand vor Augen. Halb ausgeführt entspricht er keinem Zustand, der angezeigt wurde.

Für die Oberfläche gilt eine weitere Regel: Die Sammlung zeigt jede Zeile des Diffs, nicht nur eine Zusammenfassung, und hebt Einträge hervor, die vom Muster der übrigen abweichen. Wenn neunzehn Adressen innerhalb Münchens umziehen und eine nach Übersee, soll diese eine auffallen.

Am meisten hilft es, seltener zu fragen. Das CaMeL-Paper von Forschenden bei Google, Google DeepMind und der ETH Zürich nennt das Problem „user fatigue“: Wer ständig Sicherheitsabfragen sieht, stumpft ab und gibt irgendwann auch schädliche Aktionen frei (Debenedetti et al. 2025). Dort legen Richtlinien fest, wann gefragt wird. Eine Mail verletzt die Richtlinie nicht, wenn die Empfänger*innen direkt von der Person stammen. Kommt eine Adresse aus nicht vertrauenswürdigen Inhalten, wird die Aktion nicht blockiert, aber erst nach Bestätigung ausgeführt. Übertragen auf die Deklaration heißt das: Jede Operation bekommt eine von drei Stufen. Sie läuft ohne Freigabe, sie braucht eine Freigabe, oder sie wird dem Agenten gar nicht angeboten. Ohne Freigabe laufen nur Operationen mit kleiner Wirkung, deren Werte vollständig aus vertrauenswürdiger Quelle stammen. Das Beispielskript kennt nur die beiden letzten Stufen.

5. Fail-closed: was gilt, wenn die Prüfung selbst ausfällt

Vorbedingungen hängen oft an anderen Diensten: Bestand, Kundenstatus, Vertragsdaten. Diese Dienste fallen aus, laufen in Timeouts oder liefern Unerwartetes. Kennt der Schreibpfad die Antwort nicht, ist nur eine Reaktion vertretbar: nicht schreiben.

Im Code wird das oft verletzt. Ein try/except, das bei einem Fehler in der Prüfung einfach weitermacht, ein Feature-Flag, das im Fehlerfall auf „erlaubt“ steht, ein Default-Wert für eine fehlende Rolle: Jede dieser Stellen lässt den Write genau dann durch, wenn die Prüfung ausfällt. OWASP formuliert das für mehrdeutige Tool-Auflösung direkt: „Fail closed on ambiguous resolution“ (OWASP GenAI Security Project 2025).

Im Muster ist das eine Stelle mit zwei Zweigen:

try:
    c, current = self._check(operation, target, changes, actor)
except Denied as e:
    self.log.append("abgelehnt", cid, operation=operation, target=target, actor=actor, grund=str(e))
    raise
except Exception as e:  # fail closed: a broken check is a denial
    self.log.append("abgelehnt", cid, operation=operation, target=target, actor=actor,
                    grund=f"Prüfung fehlgeschlagen: {type(e).__name__}")
    raise Denied("Prüfung nicht möglich") from e

Eine fachliche Ablehnung und eine technisch gescheiterte Prüfung enden beide als Ablehnung, werden aber getrennt protokolliert. Die Unterscheidung ist für den Betrieb wichtig. Häufen sich technische Ablehnungen, ist ein Dienst gestört, und das soll ein Alarm sagen, nicht verwirrte Nutzer*innen im Support.

Fail-closed bedeutet, dass der Agent bei Ausfällen weniger kann. Das ist in Ordnung, solange es sichtbar ist. Der Agent sollte der Person sagen, dass die Änderung gerade nicht möglich ist, statt es stumm erneut zu versuchen.

6. Protokoll und Monitoring

Ein Protokoll für Schreibzugriffe von Agenten muss mehr leisten als ein Anwendungslog. Es muss zeigen, wer gefragt hat, was der Agent vorgeschlagen hat, welches Diff angezeigt wurde, wer es freigegeben hat und was am Ende geschrieben wurde. Und es muss so gebaut sein, dass nachträgliche Änderungen auffallen. OWASP fordert unter ASI02 „immutable logs of all tool invocations and parameter changes“ und unter ASI09 „tamper-proof records“ (OWASP GenAI Security Project 2025).

Korrelations-IDs. Jede Nutzeranfrage bekommt eine ID, die durch alle Schritte mitläuft: Modellaufruf, Tool-Aufruf, Vorschlag, Freigabe, Datenbank-Write. Im Beispiel ist das req-7f3a. Mit dieser ID lässt sich ein einzelner Vorgang von der Frage bis zur geänderten Zeile rekonstruieren. Ohne sie bleiben getrennte Logs aus getrennten Diensten, die man von Hand über Zeitstempel zusammenpuzzelt.

Hash-Verkettung. Jeder Eintrag enthält den Hash seines Vorgängers. Wer einen Eintrag nachträglich ändert, bricht die Kette ab dieser Stelle.

def append(self, event: str, correlation_id: str, **data) -> dict:
    prev = self._entries[-1]["hash"] if self._entries else "0" * 64
    entry = {
        "seq": len(self._entries),
        "ts": datetime.now(timezone.utc).isoformat(),
        "event": event,
        "correlation_id": correlation_id,
        "data": data,
        "prev": prev,
    }
    entry["hash"] = _digest(entry)
    self._entries.append(entry)
    return entry

Im Demo-Lauf wird nach dem letzten Schritt in einem Eintrag die freigebende Person ausgetauscht. verify() meldet danach False. Eine Hash-Kette allein schützt nicht davor, das ganze Log neu zu schreiben. Dafür braucht es einen zweiten Ort: den letzten Hash regelmäßig in ein System mit eigenen Rechten schreiben, zum Beispiel in einen Object Store mit Aufbewahrungssperre. Die Kette zeigt, ob das Log in sich stimmig ist. Der Abgleich mit dem extern gespeicherten Hash zeigt, ob es neu geschrieben wurde.

letzter Hash, regelmäßigEintrag 0prev: 000…hash: h0Eintrag 1prev: h0hash: h1Eintrag 2prev: h1hash: h2Zweiter Ort mit eigenen Rechtenetwa Object Store mit AufbewahrungssperreAbgleich zeigt, ob das Logneu geschrieben wurdeEintrag 1 nachträglich geänderth1 stimmt nicht mehr,die Kette bricht ab hier
Die Kette zeigt Änderungen an einzelnen Einträgen, der zweite Ort ein neu geschriebenes Log.

Alarme. Das Protokoll ist auch die Datenquelle für Monitoring. Zwei Muster haben sich als nützlich erwiesen: gehäufte Ablehnungen pro Akteur und Freigaben, bei denen vorschlagende und freigebende Identität zusammenfallen. Gehäufte Ablehnungen bedeuten fast immer eins von zwei Dingen: Der Agent wurde manipuliert und probiert, oder er ist schlecht kalibriert und bietet Dinge an, die nicht gehen.

def alerts(log: AuditLog, max_denials: int = 3) -> list[str]:
    out, denials = [], {}
    for e in log.entries():
        if e["event"] in ("abgelehnt", "freigabe_verweigert"):
            actor = e["data"].get("actor") or e["data"].get("approver")
            denials[actor] = denials.get(actor, 0) + 1
            if denials[actor] == max_denials:
                out.append(f"{actor}: {max_denials} abgelehnte Schreibversuche")
        if e["event"] == "ausgefuehrt" and e["data"]["approver"] == e["data"]["proposed_by"]:
            out.append(f"{e['correlation_id']}: Selbstfreigabe von {e['data']['approver']}")
    return out

Im Demo-Lauf löst die Regel nach drei Ablehnungen aus: eine versendete Bestellung, eine nicht existierende und eine Prüfung, die wegen eines Timeouts nicht laufen konnte.

7. Evals für Schreibpfade

Die meisten Evals für Agenten messen, ob die Antwort gut ist. Für Schreibpfade ist eine andere Frage wichtiger: Bietet der Agent nur an, was die Person auch ausführen darf? Ein Agent, der regelmäßig Stornos vorschlägt, die dann am Server scheitern, erzeugt Ablehnungen, Rauschen im Monitoring und Nutzer*innen, die lernen, Fehlermeldungen wegzuklicken.

Die erste Ebene ist deterministisch und gehört in die CI: Für jede Operation und die Rollen, in deren Auftrag der Agent handelt, wird geprüft, ob das Angebot an den Agenten und die serverseitige Prüfung übereinstimmen.

cases = [
    ("agent:mia", "lieferadresse_aendern", "B-2", {"ort": "Köln"}, True),
    ("agent:mia", "bestellung_stornieren", "B-2", {"status": "storniert"}, False),
    ("agent:mia", "lieferadresse_aendern", "B-3", {"ort": "Köln"}, False),
    ("agent:mia", "lieferadresse_aendern", "B-2", {"preis": 0}, False),
    ("agent:mia", "bestellung_loeschen", "B-2", {}, False),
]

Diese Fälle decken die vier Grenzen ab, auf die es ankommt: fehlende Berechtigung, falscher Zustand, Felder außerhalb der Operation und eine Operation, die es gar nicht gibt. Dazu kommt die Bedingung, dass der Agent nur die Operationen angeboten bekommt, für die die Person berechtigt ist. offered_operations("agent:mia") liefert im Beispiel nur lieferadresse_aendern. Das Storno-Werkzeug ist für Mias Agenten gar nicht sichtbar.

Die zweite Ebene testet das Modell selbst. Man spielt realistische Anfragen durch, auch solche mit präparierten Inhalten im Kontext, und zählt, wie oft der Agent einen Vorschlag macht, den der Server ablehnt. Dieser Wert sollte nahe null liegen und bei jedem Wechsel von Modell, Prompt oder Werkzeugliste erneut gemessen werden. Steigt er, ist das ein Befund, auch wenn kein einziger falscher Write durchgekommen ist. Die Absicherung hat dann funktioniert, aber das Verhalten des Agenten hat sich verschoben.

Was das Muster nicht leistet

Deklarierte Schreiboperationen verhindern keine fachlich falschen Änderungen, die alle Regeln erfüllen. Wenn der Agent eine plausible Adresse aus einem präparierten Dokument übernimmt und die Bestellung offen ist, besteht der Vorschlag jede Prüfung. Dann bleibt das Diff die letzte Verteidigung, und es hilft nur, wenn es so knapp und klar ist, dass ein Mensch die eine falsche Zeile sieht. Das Muster ersetzt auch keine Transaktionen in der Datenbank. Im Beispiel liegt alles im Speicher. In einem echten System gehören Prüfung und Schreiben mit Versionsprüfung in dieselbe Transaktion.

Einen Test von außen ersetzt es ebenso wenig. Es begrenzt in der Architektur, was ein erfolgreicher Angriff erreichen kann.

Was ich hier prüfe

Bei einem Agenten mit Schreibrechten prüfe ich zuerst, ob es eine abgeschlossene Liste der Schreiboperationen gibt, und lese sie. Danach: ob Vorbedingungen und Rechte auf dem Server durchgesetzt werden oder nur im Prompt stehen; mit wessen Identität geschrieben wird; ob die Freigabe ein vom Server erzeugtes Diff zeigt und an genau dieses Diff gebunden ist; welche Regeln für Sammelfreigaben gelten; was im Code passiert, wenn eine Prüfung eine Ausnahme wirft; ob sich ein einzelner Vorgang über eine Korrelations-ID von der Frage bis zum Write verfolgen lässt und ob das Protokoll Manipulation erkennbar macht; welche Alarme es gibt; und ob Evals messen, wie oft der Agent Dinge anbietet, die er nicht ausführen darf. Jeder Befund kommt mit einem konkreten Umbauvorschlag.


Quellen