Sandboxing für KI-Agenten

IRC-Mania Die Seite rund um Sicherheit und Programmierung

Internet, Sicherheit , Internet Relay Chat

Gesponsert

Was dieser Artikel über Sandboxing für KI-Agenten behandelt

• Wie Du KI-Agenten in Sandbox-Umgebungen betreibst.
• Welche Sandbox-Technologien es gibt: Docker, Firejail, gVisor, nsjail.
• Wie Du Code-Ausführung, Dateisystem-Zugriff und Netzwerk isolierst.
• Praxisbeispiele für Code-Agenten, Datei-Agenten und Web-Agenten.
• Best Practices für Sicherheit, Performance und Wartung.

Einleitung: Sandboxing für KI-Agenten verständlich erklärt

KI-Agenten, die Code ausführen, Dateien verändern oder Netzwerk-Anfragen senden, sind gefährlich. Ein manipulierter Agent (Prompt Injection) kann Schadcode ausführen, Dateien löschen oder Daten nach außen senden. Sandboxing ist die Isolation des Agenten in einer Umgebung, die keinen Zugriff auf das Host-System hat. Wenn der Agent etwas Schädliches tut, betrifft das nur die Sandbox, nicht den Server.

Dieser Artikel richtet sich an Entwicklerinnen und Entwickler, die KI-Agenten mit Code-Ausführung oder System-Zugriff bauen. Du solltest verstehen, was KI-Agenten sind und wie Docker funktioniert. Grundlagen der Python-Programmierung findest Du auf IRC-Coding.de.

Warum brauche ich Sandboxing?

Stell Dir vor, Du baust einen Code-Agenten, der Python-Code schreibt und ausführt. Der Agent bekommt einen Task, schreibt Code und führt ihn aus. Was passiert, wenn der Agent (durch Prompt Injection) Schadcode schreibt? os.system("rm -rf /") würde Dein gesamtes System löschen. In einer Sandbox passiert nichts: Der Code wird isoliert ausgeführt, das Host-System ist sicher.

Sandboxing für KI-Agenten kurz erklärt

Sandboxing ist die Isolation des Agenten in einer Umgebung mit eingeschränktem Zugriff. Der Agent kann Code ausführen, aber nur innerhalb der Sandbox. Dateisystem, Netzwerk und Prozesse sind isoliert. Wenn der Agent etwas Schädliches tut, betrifft das nur die Sandbox.

Der Kerngedanke lautet: Der Agent darf alles in der Sandbox, aber nichts außerhalb.

Für wen ist dieser Artikel gedacht?

• Entwicklerinnen und Entwickler, die Code-Agenten bauen.
• Sicherheits-Verantwortliche, die Agenten absichern.
• Systemadministratoren, die Agenten in Produktion betreuen.
• Teams, die Agenten mit System-Zugriff einführen.

Vorkenntnisse in Docker, KI-Agenten und Sicherheit sind erforderlich.

Wichtige Begriffe

• Sandbox - Isolierte Ausführungsumgebung. Wann nützlich: für sichere Code-Ausführung.
• Docker - Container-Plattform. Wann nützlich: beliebteste Sandbox.
• Firejail - Linux-Sandbox-Tool. Wann nützlich: leichtgewichtige Isolation.
• gVisor - Google-Sandbox für Container. Wann nützlich: zusätzliche Sicherheitsschicht.
• nsjail - Google-Sandbox-Tool. Wann nützlich: prozessbasierte Isolation.
• Isolation - Trennung von Agent und Host. Wann nützlich: das Sicherheitsprinzip.
• KI-Agenten - Was isoliert wird. Wann nützlich: der Untersuchungsgegenstand.
• Prompt Injection - Manipulation des Agenten. Wann nützlich: warum Sandboxing nötig ist.
• Tool-Berechtigungen - Rechte-Verwaltung. Wann nützlich: ergänzt Sandboxing.

Sandbox-Technologien im Vergleich

Docker als Sandbox

Docker ist die beliebteste Sandbox für KI-Agenten. Du erstellst ein Image mit Python und Abhängigkeiten, führst den Agenten-Code im Container aus.

Dockerfile für Code-Agent

FROM python:3.12-slim

# Python-Abhängigkeiten
RUN pip install --no-cache-dir ollama requests

# Arbeitsverzeichnis
WORKDIR /workspace

# Kein Root-User
RUN useradd -m agent
USER agent

# Code kopieren
COPY --chown=agent:agent agent.py .

# Kein Netzwerk (optional)
# CMD ["python", "agent.py"]

Agent in Docker ausführen

# Image bauen
docker build -t code-agent .

# Container starten mit eingeschränkten Rechten
docker run --rm \
  --network none \                    # Kein Netzwerk
  --memory 512m \                     # Speicher-Limit
  --cpus 1 \                          # CPU-Limit
  --read-only \                       # Read-Only Filesystem
  --tmpfs /tmp:size=100m \            # Temp-Verzeichnis
  --cap-drop ALL \                    # Alle Capabilities entfernen
  --security-opt no-new-privileges \  # Keine Privilegieneskalation
  -v ./workspace:/workspace:ro \      # Workspace read-only mounten
  code-agent

Python-Code in Docker ausführen

import subprocess
import tempfile

def execute_in_docker(code, timeout=30):
    # Code in temporärer Datei speichern
    with tempfile.NamedTemporaryFile(mode="w", suffix=".py", delete=False) as f:
        f.write(code)
        code_file = f.name

    # In Docker ausführen
    result = subprocess.run([
        "docker", "run", "--rm",
        "--network", "none",
        "--memory", "512m",
        "--cpus", "1",
        "--read-only",
        "--tmpfs", "/tmp:size=100m",
        "--cap-drop", "ALL",
        "--security-opt", "no-new-privileges",
        "-v", f"{code_file}:/code.py:ro",
        "python:3.12-slim",
        "python", "/code.py"
    ], capture_output=True, text=True, timeout=timeout)

    return {
        "stdout": result.stdout,
        "stderr": result.stderr,
        "returncode": result.returncode
    }

Firejail als Sandbox

Firejail ist eine leichtgewichtige Sandbox für Linux, die Prozesse isoliert.

Installation

sudo apt install firejail

Agent mit Firejail ausführen

# Agent isoliert ausführen
firejail --noprofile --private-tmp --nosound --no3d \
  --net=none \
  --private=/tmp/agent-workspace \
  --rlimit-fsize=10485760 \    # 10MB Datei-Limit
  --rlimit-nproc=10 \          # Max 10 Prozesse
  python agent.py

Python-Code mit Firejail ausführen

import subprocess
import tempfile

def execute_in_firejail(code, timeout=30):
    with tempfile.NamedTemporaryFile(mode="w", suffix=".py", delete=False) as f:
        f.write(code)
        code_file = f.name

    result = subprocess.run([
        "firejail", "--noprofile",
        "--private-tmp",
        "--net=none",
        "--rlimit-fsize=10485760",
        "--rlimit-nproc=10",
        "python", code_file
    ], capture_output=True, text=True, timeout=timeout)

    return {
        "stdout": result.stdout,
        "stderr": result.stderr,
        "returncode": result.returncode
    }

gVisor als zusätzliche Sicherheit

gVisor ist eine Sandbox von Google, die den Systemaufruf-Filter implementiert. Es bietet zusätzliche Sicherheitsschicht über Docker.

Installation

# gVisor installieren
sudo apt install runsc

# Docker für gVisor konfigurieren
sudo tee /etc/docker/daemon.json <<EOF
{
  "runtimes": {
    "runsc": {
      "path": "/usr/bin/runsc"
    }
  }
}
EOF
sudo systemctl restart docker

Agent mit gVisor ausführen

docker run --rm \
  --runtime=runsc \
  --network none \
  --memory 512m \
  code-agent

Praxisbeispiel 1: Code-Agent mit Docker

class DockerCodeAgent:
    def __init__(self, model="llama3.1"):
        self.model = model

    def execute_code(self, code, timeout=30):
        # Code in Docker ausführen
        result = execute_in_docker(code, timeout)
        return result

    def run(self, task):
        # Modell bittet, Code zu schreiben
        code = call_ollama([
            {"role": "system", "content": "Schreibe Python-Code für die Aufgabe."},
            {"role": "user", "content": task}
        ])

        # Code in Sandbox ausführen
        result = self.execute_code(code)

        # Ergebnis an Modell zurückgeben
        if result["returncode"] == 0:
            return result["stdout"]
        else:
            return f"Fehler: {result['stderr']}"

Praxisbeispiel 2: Datei-Agent mit eingeschränktem Dateisystem

# Agent mit read-only Zugriff auf /data
docker run --rm \
  --network none \
  -v /data:/data:ro \           # Read-only
  --tmpfs /tmp:size=100m \       # Schreibbar nur in /tmp
  file-agent

Praxisbeispiel 3: Web-Agent mit eingeschränktem Netzwerk

# Agent darf nur zu Ollama, nicht ins Internet
docker run --rm \
  --network agent-network \      # Eigenes Netzwerk
  --network-alias agent \
  web-agent

# Netzwerk so konfigurieren, dass nur Ollama erreichbar ist
docker network create --internal agent-network
# Ollama im selben Netzwerk
docker run --network agent-network -d ollama

Sicherheitshinweise

• Kein Root: Führe den Agenten nie als Root aus. Erstelle einen eigenen User.
• Netzwerk isolieren: Gib dem Agenten nur Netzwerkzugriff, wenn nötig. Nutze --network none oder interne Netzwerke.
• Ressourcen-Limits: Setze Memory- und CPU-Limits, um Ressourcenexzess zu verhindern.
• Read-Only Filesystem: Nutze --read-only, damit der Agent keine Dateien verändern kann.
• Capabilities entfernen: Nutze --cap-drop ALL, um alle Linux-Capabilities zu entfernen.
• No New Privileges: Nutze --security-opt no-new-privileges, um Privilegieneskalation zu verhindern.
• Timeouts: Setze Timeouts, um Endlosschleifen zu verhindern.
• Audit Logging: Protokolliere alle Sandbox-Aufrufe. Siehe Protokollierung.
• Siehe: Sandbox-Umgebungen, Tool-Berechtigungen.

Typische Stolpersteine

• Keine Sandbox genutzt: Code direkt auf Host ausgeführt. Hohes Risiko.
• Root-User: Agent läuft als Root. Kann alles tun.
• Kein Netzwerk-Limit: Agent kann Daten nach außen senden.
• Keine Ressourcen-Limits: Agent kann Host überlasten.
• Kein Timeout: Endlosschleifen blockieren Sandbox.
• Sandbox nicht geprüft: Sandbox kann Lücken haben. Teste mit Schadcode.

Weiterführende Links

• KI-Agenten Grundlagen - Was KI-Agenten sind.
• Docker Grundlagen - Docker verstehen.
• Docker Sicherheit - Docker absichern.
• Docker Netzwerk-Isolation - Netzwerke isolieren.
• Docker Ressourcenlimits - Limits setzen.
• Tool-Berechtigungen - Rechte verwalten.
• Sandbox-Umgebungen - Sicherheit.
• Prompt Injection Schutz - Warum Sandboxing nötig.

Key Takeaways:

• Sandboxing isoliert Agenten vom Host-System.
• Docker ist die beliebteste Sandbox, Firejail leichtgewichtig, gVisor zusätzliche Sicherheit.
• Wichtig: Kein Root, Netzwerk isolieren, Ressourcen-Limits, Read-Only, Timeouts.
• Code-Agenten müssen immer in Sandbox ausgeführt werden.
• Sandbox allein reicht nicht: kombiniere mit Tool-Berechtigungen und Prompt Injection Schutz.

FAQ

Quellen und weiterführende Literatur

• Docker Sicherheit - Docker-Sicherheit.
• Firejail - Linux-Sandbox.
• gVisor - Google-Sandbox.
• nsjail - Prozess-Sandbox.

Premium VPS Hosting

Schnelle und sichere VPS Server

Gesponsert