Ausführen von nicht vertrauenswürdigem Agentencode ohne Sandbox

Ausführung von nicht vertrauenswürdigem Agentencode ohne Sandbox

Die Ausführung von nicht vertrauenswürdigem Agentencode – Code von externen oder benutzergestellten KI-Agenten – ist eine wachsende Herausforderung in modernen KI-Bereitstellungen. Traditionelle Sandbox-Ansätze (z. B. Docker-Container, gVisor oder Firecracker) bieten zwar eine starke Isolierung, führen aber zu erheblichem Overhead, Latenz und Komplexität. Dieser Artikel untersucht praktische Techniken zur Ausführung von nicht vertrauenswürdigem Agentencode ohne vollständige Sandbox, unter Nutzung von leichtgewichtiger Isolierung, statischer Analyse und Laufzeitüberwachung. Wir stützen uns auf Erkenntnisse aus aktuellen Branchendiskussionen, einschließlich der Untersuchung von Agentensicherheit im LangChain-Blog und OpenAIs laufender Arbeit an sicheren Ausführungsumgebungen. Ziel ist es, einen praktischen, einsatzbereiten Ansatz für Entwickler zu bieten, die Geschwindigkeit und Einfachheit benötigen, ohne die Sicherheit zu beeinträchtigen.

Voraussetzungen

Stellen Sie vor Beginn sicher, dass Ihr System die folgenden Anforderungen erfüllt:

• **Linux-basiertes System** (Ubuntu 22.04+ oder ähnlich) – die meisten leichtgewichtigen Isolierungswerkzeuge sind Linux-nativ.
• **Python 3.10+** – zum Ausführen von Agentencode und unseren Beispielskripten.
• **`seccomp`-Unterstützung** – Systemaufruffilterung auf Kernel-Ebene (standardmäßig auf modernem Linux aktiviert).
• **`nsjail`** – eine leichtgewichtige, sicherheitsorientierte Sandbox zum Ausführen von nicht vertrauenswürdigem Code. Installation über den Paketmanager.
• **`cgroups` v2** – für Ressourcenlimits (CPU, Arbeitsspeicher). Überprüfung mit `mount | grep cgroup`.
• **`apparmor` oder `selinux`** – optional, aber empfohlen für zusätzliche MAC-Durchsetzung (Mandatory Access Control).

Schritt-für-Schritt-Installation

Wir installieren und konfigurieren `nsjail` als unser primäres Werkzeug. `nsjail` verwendet Linux-Namespaces, seccomp-bpf und cgroups, um nicht vertrauenswürdigen Code mit minimalem Overhead einzuschränken.

1. nsjail installieren

Aktualisieren Sie zunächst Ihre Paketliste und installieren Sie `nsjail`:

sudo apt-get update
sudo apt-get install -y nsjail

Überprüfen Sie die Installation:

nsjail --version

Wenn Sie die neueste Version benötigen, kompilieren Sie aus dem Quellcode (Anweisungen finden Sie im `nsjail` GitHub-Repository). Für die meisten Anwendungsfälle reicht die Paketversion aus.

2. Python und Abhängigkeiten installieren

Stellen Sie sicher, dass Python 3.10+ installiert ist:

python3 --version

Installieren Sie die erforderlichen Python-Bibliotheken für unser Beispiel:

pip install requests pyyaml

3. Seccomp-Profile konfigurieren

Erstellen Sie ein benutzerdefiniertes Seccomp-Profil, um Systemaufrufe einzuschränken. Speichern Sie Folgendes als `agent_seccomp.policy`:

# Grundlegendes Seccomp-Profil für nicht vertrauenswürdigen Agentencode
# Nur sichere Syscalls erlauben
[whitelist]
read
write
open
close
mmap
munmap
brk
exit_group
clone
execve
stat
fstat
lseek
getdents64

Diese Richtlinie blockiert gefährliche Syscalls wie `ptrace`, `socket` (Netzwerk), `mount` und `process_vm_writev`. Sie können sie basierend auf den Anforderungen Ihres Agenten erweitern.

4. Cgroups für Ressourcenlimits einrichten

Erstellen Sie eine Cgroup für Ressourcensisolierung:

sudo mkdir -p /sys/fs/cgroup/agent_limits
echo "100000" | sudo tee /sys/fs/cgroup/agent_limits/memory.max  # 100 MB Speicherlimit
echo "50000" | sudo tee /sys/fs/cgroup/agent_limits/cpu.max      # 50% CPU-Limit

Diese Limits verhindern, dass außer Kontrolle geratene Agenten Systemressourcen erschöpfen.

Verwendungsbeispiele

Wir werden nun nicht vertrauenswürdigen Agentencode mit `nsjail`, unserer Seccomp-Richtlinie und Cgroup-Limits ausführen.

Beispiel 1: Ausführen eines einfachen Python-Skripts

Erstellen Sie ein Testskript `agent_code.py`, das nicht vertrauenswürdiges Agentenverhalten simuliert:

# agent_code.py - Beispiel für nicht vertrauenswürdigen Agentencode
import os

def run_agent():
    print("Agent: Hallo, ich bin ein nicht vertrauenswürdiger Agent!")
    # Versuch einer gefährlichen Operation (wird blockiert)
    try:
        os.system("rm -rf /")  # Dies wird aufgrund von Seccomp fehlschlagen
    except Exception as e:
        print(f"Gefährliche Operation blockiert: {e}")
    return "Agent sicher abgeschlossen"

if __name__ == "__main__":
    result = run_agent()
    print(f"Ergebnis: {result}")

Führen Sie es innerhalb von `nsjail` aus:

nsjail --config /dev/stdin <<EOF
{
  "chroot": "/",
  "cwd": "/tmp",
  "seccomp_policy_file": "/pfad/zu/agent_seccomp.policy",
  "cgroup_memory_max": 104857600,  # 100 MB
  "cgroup_cpu_max": 50000,          # 50%
  "exec_bin": "/usr/bin/python3",
  "exec_args": ["/tmp/agent_code.py"]
}
EOF

Erklärung der einzelnen Parameter:

• `chroot`: Beschränkt den Dateisystemzugriff auf ein bestimmtes Verzeichnis.
• `cwd`: Arbeitsverzeichnis innerhalb des Jails.
• `seccomp_policy_file`: Pfad zu unserer benutzerdefinierten Richtlinie.
• `cgroup_memory_max` und `cgroup_cpu_max`: Ressourcenlimits.
• `exec_bin` und `exec_args`: Der auszuführende Befehl.

Das Skript wird ausgeführt, aber jeder Versuch, Shell-Befehle auszuführen (wie `os.system`), wird durch Seccomp blockiert, und der Agent wird ordnungsgemäß fehlschlagen.

Beispiel 2: Ausführen von Agentencode mit Netzwerkeinschränkungen

Netzwerkzugriff ist für nicht vertrauenswürdige Agenten oft unnötig. Wir können die Netzwerkfunktionalität mit der Netzwerk-Namespace-Isolierung von `nsjail` vollständig deaktivieren.

Erstellen Sie ein Skript, das versucht, Daten abzurufen:

# network_agent.py
import requests

def fetch_data():
    try:
        response = requests.get("https://api.example.com/data")
        return response.text
    except Exception as e:
        return f"Netzwerk blockiert: {e}"

if __name__ == "__main__":
    print(fetch_data())

Führen Sie es mit deaktiviertem Netzwerk aus:

nsjail --config /dev/stdin <<EOF
{
  "chroot": "/",
  "cwd": "/tmp",
  "seccomp_policy_file": "/pfad/zu/agent_seccomp.policy",
  "cgroup_memory_max": 104857600,
  "cgroup_cpu_max": 50000,
  "disable_network": true,  # Netzwerk vollständig deaktivieren
  "exec_bin": "/usr/bin/python3",
  "exec_args": ["/tmp/network_agent.py"]
}
EOF

Der Parameter `disable_network` erstellt einen Netzwerk-Namespace ohne Schnittstellen. Der Agent kann keine Verbindung herstellen, was Datenexfiltration oder externe Aufrufe verhindert.

Beispiel 3: Begrenzung der Ausführungszeit

Agenten können in Endlosschleifen laufen. Verwenden Sie das Zeitlimit von `nsjail`:

nsjail --config /dev/stdin <<EOF
{
  "chroot": "/",
  "cwd": "/tmp",
  "seccomp_policy_file": "/pfad/zu/agent_seccomp.policy",
  "cgroup_memory_max": 104857600,
  "cgroup_cpu_max": 50000,
  "time_limit": 5,  # Maximal 5 Sekunden Ausführungszeit
  "exec_bin": "/usr/bin/python3",
  "exec_args": ["/tmp/agent_code.py"]
}
EOF

Wenn der Agent 5 Sekunden überschreitet, beendet `nsjail` ihn und gibt einen Timeout-Fehler zurück.

Beispiel 4: Überwachung des Agentenverhaltens

Für den Produktionseinsatz protokollieren Sie alle Aktionen des Agenten. Ändern Sie die Seccomp-Richtlinie, um blockierte Syscalls zu protokollieren:

# agent_seccomp_log.policy
[whitelist]
read
write
open
close
mmap
munmap
brk
exit_group
clone
execve
stat
fstat
lseek
getdents64

[audit]
ptrace
socket
connect

Führen Sie dann mit Protokollierung aus:

nsjail --config /dev/stdin <<EOF
{
  "chroot": "/",
  "cwd": "/tmp",
  "seccomp_policy_file": "/pfad/zu/agent_seccomp_log.policy",
  "seccomp_log": true,  # Blockierte Syscalls protokollieren
  "cgroup_memory_max": 104857600,
  "cgroup_cpu_max": 50000,
  "exec_bin": "/usr/bin/python3",
  "exec_args": ["/tmp/agent_code.py"]
}
EOF

Überprüfen Sie die Protokolle mit `dmesg | tail -20` oder `journalctl -xe`. Dies hilft, bösartiges oder fehlerhaftes Agentenverhalten zu identifizieren.

Best Practices und Einschränkungen

Die Ausführung von nicht vertrauenswürdigem Code ohne vollständige Sandbox ist ein Kompromiss zwischen Leistung und Sicherheit. Hier sind wichtige Überlegungen:

• **Verwenden Sie einen mehrschichtigen Ansatz**: Kombinieren Sie `nsjail` mit AppArmor-Profilen und schreibgeschützten Dateisystemen für eine abgestufte Verteidigung. Der KI-Blog von Microsoft betont die Bedeutung mehrerer Isolierungsschichten.
• **Vermeiden Sie die Gewährung unnötiger Berechtigungen**: Entfernen Sie `CAP_NET_ADMIN`, `CAP_SYS_ADMIN` und andere Fähigkeiten. `nsjail` macht dies standardmäßig.
• **Aktualisieren Sie regelmäßig Seccomp-Richtlinien**: Wenn sich Agentencode weiterentwickelt, können neue Syscalls erforderlich sein. Überprüfen Sie Protokolle und passen Sie die Whitelist an.
• **Berücksichtigen Sie Timeouts**: Legen Sie immer eine maximale Ausführungszeit fest, um Denial-of-Service zu verhindern.
• **Testen Sie mit realen Agenten-Workloads**: Die Forschung von Anthropic zur KI-Sicherheit legt nahe, dass Tests mit adversarischen Eingaben helfen, Isolierungslücken aufzudecken.
• **Überwachen Sie die Ressourcennutzung**: Verwenden Sie Cgroups, um Speicher, CPU und E/A zu verfolgen. Plötzliche Spitzen können auf bösartige Aktivitäten hinweisen.

Einschränkungen

Dieser Ansatz ist nicht für alle Szenarien geeignet:

• **Kernel-Exploits**: Wenn der Agentencode eine Kernel-Sicherheitslücke ausnutzt, können Namespaces und Seccomp den Host möglicherweise nicht schützen. Vollständige Sandboxing (z. B. gVisor) bietet eine stärkere Isolierung.
• **Seitenkanalangriffe**: Ressourcennutzungsmuster können Informationen preisgeben. Für sicherheitskritische Anwendungen sollten Sie hardwaregestützte Isolierung in Betracht ziehen.
• **Komplexe Agentenabhängigkeiten**: Einige Agenten benötigen gemeinsam genutzte Bibliotheken, Datenbanken oder GPU-Zugriff. Diese können benutzerdefinierte Richtlinien oder teilweise Sandboxing erfordern.

Fazit

Die Ausführung von nicht vertrauenswürdigem Agentencode ohne vollständige Sandbox ist mit leichtgewichtigen Linux-Primitiven wie `nsjail`, Seccomp und Cgroups machbar. Dieser Ansatz bietet einen geringen Overhead (typischerweise <5% Leistungseinbuße) und blockiert gleichzeitig gefährliche Systemaufrufe, Netzwerkzugriff und Ressourcenerschöpfung. Durch Befolgen der Installationsschritte und obigen Beispiele können Sie KI-Agentencode sicher in Produktionsumgebungen ausführen, unter Nutzung von Branchenerkenntnissen von LangChain, OpenAI, Microsoft und Anthropic. Beginnen Sie mit einer restriktiven Richtlinie, überwachen Sie Protokolle und erweitern Sie schrittweise die Berechtigungen nach Bedarf. Der Schlüssel ist, standardmäßig zu verweigern: Geben Sie Agenten nur die minimalen Fähigkeiten, die für ihre Aufgabe erforderlich sind. Diese pragmatische Strategie balanciert Sicherheit, Geschwindigkeit und Einfachheit für moderne KI-Bereitstellungen aus.