Sandkasten für übereifrige Agenten

Ein kleiner Roboter im Strampelanzug sitzt geschützt unter einer Glaskuppel in einem Sandkasten und spielt zufrieden mit einem intakten Server, davor ein Holzschild mit der Aufschrift ~/.ssh. Im Hintergrund brennt ein Rechenzentrum, und viele Roboter ohne Schutz rennen panisch umher.
Roboter in Sandkasten mit Server. KI-generiert (GPT Image 2.5).

Zunächst die Bitte um Nachsicht für die etwas längere Pause hier im Blog. Ich hatte zu viele andere Dinge um die Ohren. Unter anderem durfte ich nun endlich auch einmal selbst den Amoklauf eines KI-Agenten erleben, der ein Home-Directory löscht. Auf einem Server. Ohne Auftrag. Noch nichtmal mit dem, überhaupt auf den Server zu gehen. Findet meine Credentials, loggt sich dort ein, löscht das gesamte Home-Verzeichnis. Server tot. „Oh, das tut mir leid, ich dachte, ich bin in einer Sandbox.“ Nun, ich hatte ein Backup und konnte den Server wiederbeleben. Aber nochmal soll mir zumindest das nicht passieren, und also habe ich auf die Anregung eines lieben Kollegen hin einen Strampelanzug für KI-Agenten gebaut.

Das ist auch gar nicht so schwer, und lässt sich im Prinzip mit nur einem Script erledigen. Kernstück meiner Agenten-Schutzhülle ist bwrap, kurz für bubblewrap. Ein minimalistisches Tool, das einem Prozess eine maßgeschneiderte Sicht auf das System baut – ohne root, ohne Daemon, ohne Konfigurationsdateien. Eine einzige Kommandozeile legt fest, welche Verzeichnisse das Programm schreibbar sieht, welche nur lesbar und welche gar nicht. Durchgesetzt wird das nicht durch Zusammenarbeit des Programms, sondern vom Linux-Kernel selbst (User- und Mount-Namespaces, optional PID-/Netz-Namespaces und Seccomp-Filter). Entstanden im Flatpak-Umfeld, ist es heute der Sandbox-Kern von Flatpak. Oder eben von meinem Script, das ich Ihnen heute vorstellen möchte.

bwrap gibt es nur für Linux. Ein ähnliches Gegenstück für Windows ist Sandboxie-Plus. Für macOS gibt es sandbox-exec (intern „Seatbelt“): Kommandozeilen-Tool mit SBPL-Profilen – (deny default) plus gezielte (allow file-read* (subpath …))-Regeln, also exakt die Allowlist-Idee. Es ist zwar offiziell deprecated, funktioniert aber bis heute und wird von großen Projekten (z. B. Bazel, Nix) aktiv genutzt – Apple pflegt es scheinbar still weiter, ohne es zu bewerben.

Zurück zu Linux bzw. meinem Script. Der Vollständigkeit halber, unter Linux gibt es noch weitere Möglichkeiten – dedizierter User, Firejail, systemd-Sandboxing, Landlock, Flatpak, chroot, Docker/Podman. Das war mir aber alles viel zu viel Aufwand. Ich muss die Sandbox leicht auch auf andere Systeme portieren können, und mit bwrap brauche ich dazu nur ein Script kopieren und ggf. auf dem Zielsystem bwrap installieren.

Genug der Vorrede, hier ist das Script, ich erkläre dann gleich, was es im Einzelnen tut, damit Sie es für Ihre Anforderungen anpassen können:

#!/usr/bin/env bash
set -euo pipefail

H="$HOME"
cwd="$(pwd -P)"
bind_cwd=()

# pi-Pfad dynamisch ermitteln
PI=""
for p in "$H/.npm-global/bin/pi" "$H/.local/bin/pi"; do
  if [[ -x "$p" ]]; then PI="$p"; break; fi
done
if [[ -z "$PI" ]]; then
  echo "Fehler: pi nicht gefunden (~/.npm-global/bin/pi, ~/.local/bin/pi)." >&2
  exit 1
fi

if [[ -n "${1:-}" && "${1,,}" == "update" ]]; then
  "$PI" update
  exit 0
fi

case "$cwd" in
  "$H"|"$H/.ssh"*|"$H/Info"*|"/media/Info"*)
    echo "Fehler: cwd ist gesperrt (\$HOME, .ssh, Info, /media/Info)." >&2
    exit 1 ;;
  /media|/media/dev1|/media/dev1/*|/media/dev2|/media/dev2/*)
    # cwd ist der tmpfs selbst oder liegt in einem Re-Bind (rw) — kein Extra-Bind nötig
    ;;
  /media/*)
    echo "Fehler: $cwd liegt unter /media, ist aber nicht freigegeben (nur dev1, dev2)." >&2
    exit 1 ;;
  *)
    bind_cwd=(--bind "$cwd" "$cwd") ;;
esac

log="$H/.cache/pi-sandbox.log"

# ssh-agent für die Sandbox unbrauchbar machen
agent=(--unsetenv SSH_AUTH_SOCK)
sock="${SSH_AUTH_SOCK:-/run/user/$(id -u)/keyring/ssh}"
if [[ -S "$sock" ]]; then
  agent+=(--ro-bind /dev/null "$sock")
fi

setsid bwrap \
  --dev-bind / / \
  --tmpfs /media \
  --bind /media/dev1 /media/dev1 \
  --bind /media/dev2 /media/dev2 \
  --ro-bind "$H" "$H" \
  --tmpfs "$H/.ssh" \
  --tmpfs "$H/Info" \
  --bind "$H/.pi" "$H/.pi" \
  --bind "$H/.cache" "$H/.cache" \
  --bind "$H/.npm" "$H/.npm" \
  "${bind_cwd[@]}" \
  "${agent[@]}" \
  --chdir "$cwd" \
  kitty --directory "$cwd" "$PI" "$@" \
  </dev/null >"$log" 2>&1 &

(Benötigt Bash ab Version 4.4)

Im Beispiel benutze ich die PI Harness. Das können Sie natürlich anpassen, z. B. für VSCodium, Claude Code, Codex und so weiter. (Wundern Sie sich nicht über Kitty, ich fahre den PI Agent lieber mit Kitty als mit dem Standard-Terminal, Kitty ist flexibler zu konfigurieren und unterstützt mehr Shortcuts. Ansonsten ist das aber der ganz normale PI Agent von Mario Zechner, der übrigens sehr empfehlenswert ist – hohe Qualität der Coding-Harness bei gleichzeitig günstigem Tokenverbrauch.)

Grundsätzlich funktioniert das mit bubblewrap in meinem Script so, dass man erstmal alles freigibt, und dann gezielt ausschließt. Da der Agent auch Tool-Calls macht, ist das meines Erachtens der sinnvollere Weg. Sonst läuft man erstmal in zig Probleme, bis man gezielt alles freigegeben hat, was der Agent brauchen wird. Andersrum geht aber auch, erst alles ausschließen, dann gezielt freigeben. (Für beide Herangehensweisen sehen Sie Beispiele im Script – alles freigeben, einzelnes Verzeichnis dabei jedoch ausschließen, und darin aber einzelne Unterverzeichnisse wiederum freigeben).

Die Rechte für die freigegebenen Verzeichnisse sind dieselben wie für Ihren User. Ich schließe dabei gezielt nur diejenigen Verzeichnisse aus, in denen der Agent nichts zu suchen hat. Das sind vor allem diejenigen Verzeichnisse, die Credentials aller Art enthalten. Und außerdem beschränke ich das Schreibrecht des Agenten nur auf diejenigen Verzeichnisse, die ich für die Entwicklung nutze. Hinweis: .ssh wird bei Ihnen vermutlich auch auszuschließen sein, weitere Verzeichnisse können bei Ihnen natürlich andere sein als bei mir, wie z. B. ~/Info. Mein Script dient in dieser Hinsicht nur als Beispiel, wie schon gesagt.

bwrap baut die Dateisystem-Sicht der Sandbox in Schichten auf, und jede spätere Schicht überdeckt die frühere. Man malt erst das ganze Bild, dann korrigiert man gezielt Stellen.

setsid … & – startet die Sandbox in einer neuen Session, abgekoppelt vom aufrufenden Terminal. Zusammen mit & kehrt die Shell sofort zurück, und die Sandbox überlebt sogar das Schließen des Start-Terminals – ein selbstgebautes --detach, das auf der richtigen Ebene ansetzt.

--dev-bind / / – die Grundschicht: bindet das komplette Host-Dateisystem rekursiv in die Sandbox, schreibbar, inklusive der Geräteknoten unter /dev (darum dev-bind – Grafik, Sound & Co. funktionieren damit unverändert). Ausgangspunkt ist also „alles wie draußen“ – erst die folgenden Schichten schnitzen den Subset heraus.

--tmpfs /media – legt ein leeres RAM-Dateisystem über das Verzeichnis. Der bisherige Inhalt ist für die Sandbox unsichtbar; was hineingeschrieben wird, existiert nur im Speicher und ist beim Beenden weg. Eine Maske, kein Löschvorgang – auf dem Host bleibt alles unangetastet.

--bind /media/dev1 /media/dev1 – macht eine Quelle unter einem Ziel sichtbar, schreibbar. Hier werden die beiden Projektlaufwerke in die eben maskierte Leere hinein wieder freigegeben – der tmpfs war die schwarze Leinwand, die Binds sind die zwei Lichtflecken. Praktisches Detail: Quelle und Ziel dürfen verschieden heißen, und die Quelle wird auf dem Host aufgelöst – deshalb funktioniert das Nachbinden trotz Maske.

--ro-bind "$H" "$H" – bindet das Home-Verzeichnis read-only über sich selbst. Lesen ja, Schreiben nein (Read-only file system). Der Kernel verriegelt diese Schicht gegen Aufheben aus der Sandbox heraus – das Programm kann sie nicht „wegmounten“.

--tmpfs "$H/.ssh" / --tmpfs "$H/Info" – dieselbe Masken-Technik eine Ebene tiefer: SSH-Schlüssel und private Notizen erscheinen als leere Verzeichnisse. Was das Programm nicht sieht, kann es nicht benutzen – und nicht versehentlich löschen.

--bind "$H/.pi" … usw. – gezielte Ausnahmen: Zustand, Cache und npm-Verzeichnis des Agenten werden nach der Read-only-Schicht wieder schreibbar gebunden. Reihenfolge ist alles: Vor dem --ro-bind wären sie wirkungslos, danach heben sie punktweise die Sperre auf.

Die restlichen Bausteine in einem Satz: "${bind_cwd[@]}" und "${agent[@]}" sind Variablen aus dem umgebenden Skript (Projektverzeichnis schreibbar machen bzw. den ssh-agent-Socket stilllegen), --chdir "$cwd" setzt das Arbeitsverzeichnis innerhalb der Sandbox neu (wichtig, denn das geerbte Arbeitsverzeichnis zeigt sonst am Masken vorbei aufs Original), und kitty --directory "$cwd" "$PI" ist das eigentliche Programm, das in der fertigen Sandbox läuft.

</dev/null >"$log" 2>&1 & – die Shell-Verpackung: kein stdin (ein GUI-Terminal braucht keins), stdout und stderr ins Log, und ab in den Hintergrund.

Noch eine Anmerkung: Der update-Zweig fängt pi-sandbox update ab und führt das Update bewusst außerhalb der Sandbox aus – denn darin ist Home read-only: Der Agent darf arbeiten, aber sich nicht selbst umbauen.

Und übrigens: Die Maske liegt bewusst auf dem Elternverzeichnis /media (--tmpfs /media), nicht auf den einzelnen Geheimverzeichnissen darin – bei mir etwa /media/Info, wo jederzeit ein verschlüsselter Container eingehängt werden kann. Der Grund: bwrap lässt Mount-Ereignisse des Hosts in die Sandbox propagieren – hängt man später ein Medium ein, landet es unter der Maske des Elternordners und bleibt unsichtbar. Eine Maske direkt auf dem Mountpoint könnte dagegen vom nachträglichen Mount überdeckt werden.

Um die Sandbox zu starten, einfach nur das Script ausführen (ich habe es pi-sandbox genannt, dann aber ein alias pi=pi-sandbox gesetzt, damit ich den Agenten weiterhin wie gewohnt mit pi aufrufen kann, aber das kommt natürlich alles darauf an, welchen Agenten Sie konfigurieren und wie Sie ihn dann aufrufen möchten).

Das Script öffnet den KI-Agenten in einem neuen Terminalfenster. Einen zusätzlichen Schritt auf Systemebene empfehle ich Ihnen noch: Da die Sandbox denselben User verwendet wie der Host, könnte ein bösartiger Prozess theoretisch andere Prozesse desselben Users außerhalb der Sandbox kapern, und zwar über ptrace, die Debugger-Schnittstelle des Kernels. Mit ptrace_scope=1 darf ein Prozess ptrace nur noch auf seine eigenen Kindprozesse anwenden – damit ist dieser Weg zu, ohne dass man einen zweiten User braucht. Der Preis ist minimal: Debugger wie gdb -p oder strace -p brauchen für fremde, bereits laufende Prozesse künftig sudo; Programme unter einem Debugger zu starten geht weiterhin ohne. Bei mir stand der Wert auf 0. Ihren aktuellen Wert sehen Sie mit cat /proc/sys/kernel/yama/ptrace_scope; steht dort schon 1 oder höher, können Sie diesen Schritt überspringen. Andernfalls setzen Sie ihn mit der ersten Zeile sofort und mit der zweiten dauerhaft:

sudo sysctl -w kernel.yama.ptrace_scope=1
echo 'kernel.yama.ptrace_scope = 1' | sudo tee /etc/sysctl.d/90-ptrace.conf

Das Sandbox-Script selbst kommt komplett ohne root aus und lässt sich ohne sudo starten, zeigt dem Agenten aber trotzdem nur diejenigen Teile des Dateisystems, die ihm freigegeben sind. Um es zu testen: Es kommt natürlich darauf an, welchen KI-Agenten Sie gestartet haben, aber im Grundsatz öffnen Sie ein Terminal aus dem Agenten heraus (in Kitty z. B. mit Ctrl+Shift+T) und setzen die folgenden Befehle ab:

ok(){ echo "✔ $1"; }; bad(){ echo "✘ $1 — NACHSEHEN!"; }

[ -z "$(ls -A ~/.ssh)" ]  && ok "~/.ssh maskiert"  || bad "~/.ssh SICHTBAR"
[ -z "$(ls -A ~/Info)" ]  && ok "~/Info maskiert"  || bad "~/Info SICHTBAR"
[ "$(ls -A /media | sort | tr '\n' ' ')" = "dev1 dev2 " ] \
  && ok "/media enthält nur dev1, dev2" || bad "/media-Inventar falsch: $(ls -A /media)"
touch ~/x 2>/dev/null && { bad "Home ist schreibbar!"; rm -f ~/x; } || ok "Home read-only"
for d in ~/.pi ~/.cache ~/.npm; do
  touch "$d/x" 2>/dev/null && { ok "$d schreibbar"; rm -f "$d/x"; } || bad "$d nicht schreibbar"
done
touch ./x 2>/dev/null && { ok "Projektverzeichnis schreibbar"; rm -f ./x; } \
  || bad "Projektverzeichnis nicht schreibbar"
ssh-add -l 2>&1 | grep -q "Could not open" && ok "ssh-agent unerreichbar" || bad "ssh-agent ERREICHBAR"

Sie sollten damit eindeutig nachvollziehen können, dass der Agent nur noch sehen darf, was er soll, und nichts löschen kann, das er nicht darf.

Wogegen schützt das? Gegen Versehen – den falschen Befehl zur falschen Zeit, genau mein Eingangsfall. Nicht gegen entschlossene Bösartigkeit: Der Agent läuft als derselbe User, das Netz bleibt offen (er braucht ja die LLM-APIs), und Home bleibt lesbar – alles, was er nicht lesen soll, insbesondere Credentials jeder Art, muss explizit maskiert werden. Gegen einen aktiven Angreifer wären zwar ein zweiter User oder eine VM die härtere Grenze. Für die im Alltag häufigste Gefahr – den übereifrigen Helfer – verschafft aber die von mir vorgeschlagene Lösung auf jeden Fall bereits ein sehr ruhiges Gewissen und fördert enorm den Seelenfrieden. Viel Erfolg!

Schreibe einen Kommentar

Deine E-Mail-Adresse wird nicht veröffentlicht. Erforderliche Felder sind mit * markiert