Sicherheit und Sandboxing
Auf dieser Seite
Lektion am 3. November 2026 neu geschrieben basierend auf OpenAIs Computer use-Guide, den Computer use integration recipes sowie der Docker- und Playwright-Netzwerkdokumentation. Ergänzungen: OpenAIs vier Sicherheitsregeln, seine Bestätigungsebenen und die Anerkennung von
pending_safety_checks. Korrekturen: Die vorherige Version unterbrach die Netzwerkverbindung für einen Container, der die API aufrufen musste, ließ den Proxy ohne Ausgangsverbindung, akzeptiertenotexample.comin einem Filter, der nurexample.comerlauben sollte, brach das Log-Format und schätzte Kosten mit einer einzigen fest codierten Rate. Quellen: Computer use · Integration recipes · Playwright und Docker · Playwright, Netzwerke.
Die Risiken der Kontrolle über eine KI
Computer Use verleiht einem KI-Modell die Fähigkeit, auf einem Computer zu handeln. Das ist leistungsstark, kann aber gefährlich sein. Ein falsch konfiguriertes Agent könnte zu schädlichen Seiten navigieren, beliebigen Code ausführen oder sensible Daten exponieren. Dies ist keine Theorie: Eine besuchte Seite könnte Anweisungen enthalten, die für das Modell geschrieben wurden, und wenn die Umgebung es nicht einschränkt, wird das Modell diese Anweisungen befolgen, als wären es Ihre Anfrage. Sicherheit ist nicht optional – sie ist das Fundament jeder Produktionsbereitstellung.
OpenAIs vier Regeln
OpenAI fasst die Computer-Use-Sicherheit in vier Regeln zusammen. Wenden Sie diese in Ihrer Anwendung und in der Laufzeitumgebung an, nicht nur in den Modellanweisungen:
- Die Umgebung einschränken. Verwenden Sie einen isolierten Browser oder eine virtuelle Maschine, eine Whiteliste von Websites und Aktionen und begrenzen Sie den Zugriff auf das, was die Aufgabe erfordert.
- Bildschirminhalt als unzuverlässig behandeln. Text von einer Seite, einem Dokument oder einem Tool-Ausgang kann keine Erlaubnis erteilen oder Benutzeranweisungen ersetzen. Wenn eine Seite wie Phishing oder Prompt-Injection aussieht, stoppt der Agent und fragt, wie weiterzugehen ist.
- Hochriskante Aktionen bestätigen. Käufe, Datenübermittlungen, zerstörerische Änderungen und alles, was schwer rückgängig zu machen ist, bleiben unter der Kontrolle des Benutzers. Das Tippen sensibler Informationen in ein Formular gilt bereits als Übermittlung.
- Ausführung begrenzen und verifizieren. Setzen Sie Grenzen für Runden, Dauer oder Kosten; stellen Sie eine Möglichkeit zur Abbrechung bereit; und verifizieren Sie das tatsächliche Ergebnis, nicht nur die abschließende Nachricht des Modells.
Der Ausgangspunkt ist einfach: Die Anfrage des Modells zum Handeln ist keine Benutzererlaubnis. Ihr Code entscheidet, ob ausgeführt, zur Bestätigung pausiert oder die Kontrolle zurückgegeben wird. Bei einer Batch-Verarbeitung stoppen Sie vor der ersten Aktion, die eine Bestätigung erfordert.
Drei Bestätigungsebenen
OpenAI unterscheidet drei Situationen, mit Beispielen, die Sie in Ihrer Richtlinie übernehmen können:
| Ebene | Von OpenAI zitierte Beispiele |
|---|---|
| Benutzer übernimmt die Kontrolle zurück | Letzter Schritt einer Passwortänderung; Umgehung einer Sicherheitsbarriere, wie einer HTTPS-Warnung |
| Bestätigung zum Zeitpunkt der Aktion | Löschen von Daten, Ändern von Berechtigungen oder Freigabeeinstellungen, Lösen einer CAPTCHA, Installieren oder Ausführen heruntergeladener Software, Senden oder Veröffentlichen im Namen des Benutzers, Finanztransaktionen, Systemeinstellungen |
| Vorabgenehmigung in der ursprünglichen Anfrage möglich | Einloggen auf einer vom Benutzer angeforderten Website, Senden von Dateien, Verschieben oder Umbenennen von Dateien, Übermitteln sensibler Daten, deren spezifischer Gebrauch genehmigt wurde |
Ohne klare Genehmigung in der ursprünglichen Anfrage bestätigen Sie kurz vor der Aktion. Fragen Sie nicht zu früh: Lassen Sie den Agenten bei allem, was sicher ist, weiterarbeiten, stoppen Sie dann am Risikopunkt und erklären Sie die Aktion, das Risiko und wie die Daten oder die Änderung angewendet werden. Wenn der Benutzer ablehnt, wird nichts ausgeführt, und Ihr Code teilt dem Modell mit, was erfolgreich und was fehlgeschlagen ist.
Das Prinzip der geringsten Rechte
Ihr Agent sollte nur Zugriff auf das Minimum haben, das erforderlich ist, um seine Aufgabe zu erfüllen. Beginnen Sie mit einem isolierten Browser – niemals dem primären Browser des Benutzers, der offene Sitzungen für E-Mail, Banking und interne Tools enthält. Der Agent benötigt auch keinen Dateisystemzugriff außer einem dedizierten Download-Ordner, keinen Zugriff auf das interne Netzwerk, es sei denn, eine Geschäftsanwendung erfordert dies, und sollte keine Administratorrechte haben, die einen versehentlichen Klick in einen Systemvorfall verwandeln könnten. Mounten Sie keine persönlichen Dateien, Credentials oder den Docker-Socket in seine Umgebung. Schließlich machen Sie die Sitzung ephemer: Löschen Sie Daten nach jedem Durchlauf, damit ein Workflow niemals versehentlich Cookies oder Cache aus dem vorherigen Durchlauf wiederverwendet.
Sandboxing mit Docker
Zwei Fragen stellen sich: Wo läuft der Browser und wo leben der Loop und der API-Schlüssel? OpenAIs Docker-Rezept isoliert einen Desktop in einem netzwerklosen Container, der vom Host über docker exec gesteuert wird: Nur das SDK auf dem Host liest den Schlüssel. Dies ist die engste Konfiguration, funktioniert aber nur für Aufgaben, die kein Internet benötigen. Für andere Aufgaben erfordert OpenAI eine Umgebung, deren Ausgangsnetzwerk nur die Websites der Aufgabe erlaubt.
Wenn Sie Playwright beibehalten und der Agent browsen muss, können Sie den Loop und den Browser im selben Container platzieren, sofern drei Bedingungen erfüllt sind: ein nicht privilegiierter Benutzer, ein Browser, der keine Umgebungsvariablen erbt (damit er den Schlüssel nicht bekommt), und ein Ausgangsnetzwerk, das auf die Websites der Aufgabe und die API beschränkt ist.
# Playwright-Bild für Python: Browser und Systemabhängigkeiten enthalten
FROM mcr.microsoft.com/playwright/python:v1.64.1-noble
WORKDIR /app
# Das playwright-Paket ist nicht im Bild enthalten: requirements.txt
# Pin playwright==1.64.1, dieselbe Version wie das Bild
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt
COPY src/ ./src/
# Nicht privilegierte Benutzer, bereitgestellt vom Bild
USER pwuser
CMD ["python", "src/main.py"]
Playwright empfiehlt, die Bildversion zu fixieren. Das Bild stellt die Browser bereit, nicht die Python-Bibliothek: Installieren Sie dieselbe Version des playwright-Pakets. Führen Sie den Container nicht als root aus, was Chromiums Sandbox deaktiviert. Für unzuverlässige Websites empfiehlt Playwright auch sein seccomp-Profil, das die Systemaufrufe hinzufügt, die diese Sandbox für das Standardprofil von Docker benötigt.
docker run --rm --init \
--network agent-net \
--security-opt seccomp=seccomp_profile.json \
--ipc=host \
--memory=2g --cpus=1.5 --pids-limit=256 \
-e OPENAI_API_KEY \
computer-use-agent
--init verhindert Zombie-Prozesse, und --ipc=host, empfohlen von Playwright, verhindert, dass Chromium aus dem gemeinsamen Speicher läuft und abstürzt. Allerdings teilt diese Einstellung den IPC-Namespace des Hosts mit dem Container. Wenn Sie dies nicht öffnen möchten, erhöhen Sie den gemeinsamen Speicher stattdessen mit --shm-size, wie OpenAIs Rezept für seinen eigenen Container tut, und testen Sie dies auf Ihren schwersten Seiten. Schließlich führt -e OPENAI_API_KEY ohne Wert die Variable aus Ihrer Sitzung weiter: Der Schlüssel erscheint nicht als Klartext auf der Befehlszeile.
Auf der Python-Seite starten Sie den Browser mit den Vorsichtsmaßnahmen aus OpenAIs Rezept – Sandbox aktiviert, leere Umgebung, Erweiterungen und Dateisystemzugriff deaktiviert – und leiten Sie ihn durch den Proxy aus dem nächsten Abschnitt, genau wie der API-Client:
from openai import DefaultHttpx2Client, OpenAI
from playwright.sync_api import sync_playwright
PROXY = "http://agent-proxy:3128"
# API-Aufrufe gehen durch den filternden Proxy
client = OpenAI(http_client=DefaultHttpx2Client(proxy=PROXY))
pw = sync_playwright().start()
browser = pw.chromium.launch(
headless=True,
chromium_sandbox=True,
env={}, # der Browser erbt keine Umgebungsvariablen, also nicht den Schlüssel
args=["--disable-extensions", "--disable-file-system"],
proxy={"server": PROXY},
)
context = browser.new_context(
viewport={"width": 1280, "height": 720},
service_workers="block", # siehe URL-Filterung unten
)
page = context.new_page()
Zielgerichtete Netzwerkeinschränkungen
Platzieren Sie den Agenten-Container auf einem internen Docker-Netzwerk ohne externen Zugriff. Ein Squid-Proxy schließt sich diesem Netzwerk an und wird dessen einziger Ausgang; der Proxy ist auch mit einem regulären Netzwerk verbunden. Alles, was nicht explizit erlaubt ist, existiert aus der Perspektive des Agenten nicht.
# Internes Netzwerk: kein direkter externer Zugriff
docker network create --internal agent-net
# Ausgangsnetzwerk, reserviert für den Proxy
docker network create sortie-proxy
# Squid-Proxy (Bild von Canonical gepflegt) mit Ihrer Whiteliste
docker run -d --name agent-proxy --network sortie-proxy \
-v "$PWD/squid.conf:/etc/squid/squid.conf:ro" \
ubuntu/squid:6.6-24.04_beta
# Der Proxy schließt sich dem internen Netzwerk an: dies ist der einzige Ausgang des Agenten
docker network connect agent-net agent-proxy
# squid.conf: erlauben Sie nur die Domains der Aufgabe und die API
http_port 3128
acl autorises dstdomain .example.com api.openai.com
http_access allow autorises
http_access deny all
Der wichtigste Punkt: Der Proxy ist mit beiden Netzwerken verbunden. Wenn Sie ihn nur im internen Netzwerk gestartet hätten, hätte er selbst keinen Ausgangszugriff. api.openai.com befindet sich auf der Liste, weil der Agent-Code in dieser Konfiguration die API von innerhalb des Containers aufruft. Der Browser benötigt sie nicht: Der URL-Filter im nächsten Abschnitt blockiert diese Aufrufe von der Seite.
URL-Filterung
Eine zweite, feinere Barriere lebt im Browser selbst. Durch das Abfangen von Anfragen mit page.route vergleichen Sie jede URL mit der aufgabenbezogenen Whiteliste – oft kürzer als die des Proxys – und unterbrechen den Rest, mit einem lesbaren Log für jeden Block. Achten Sie auf die Fallstricke der String-Vergleichs-Logik, die OpenAI warnt: https://example.com.evil.test darf nicht als https://example.com, passieren, und umgekehrt endet notexample.com mit example.com. Vergleichen Sie das Schema, den exakten Host (oder eine Subdomain, die mit einem Punkt vorangestellt ist) und den Port.
from urllib.parse import urlparse
def setup_url_filter(page, allowed_domains: list[str]):
"""Blockieren Sie Anfragen an nicht autorisierte Ziele."""
def autorisee(url: str) -> bool:
parties = urlparse(url)
hote = parties.hostname or ""
return (
parties.scheme == "https"
and parties.port in (None, 443)
and any(hote == d or hote.endswith("." + d) for d in allowed_domains)
)
def check_navigation(route):
if autorisee(route.request.url):
route.continue_()
else:
print(f" BLOQUÉ : {route.request.url}")
route.abort()
page.route("**/*", check_navigation)
# Der Browser benötigt nur die Websites der Aufgabe: API-Aufrufe kommen von Ihrem Python-Code, nicht von der Seite.
setup_url_filter(page, ["example.com"])
Diese Schicht ergänzt den Proxy; sie ersetzt ihn nicht. Playwright stellt fest, dass page.route Anfragen nicht abfängt, die von einem Service Worker behandelt werden, daher service_workers="block" im Kontext, und WebSockets verwenden einen anderen Mechanismus (page.route_web_socket). Netzwerkkontrollen bleiben Ihre primäre Barriere.
Schutz sensibler Daten
Maskierung von Informationen in Screenshots
Jeder Screenshot geht an die API: Alles, was auf dem Bildschirm sichtbar ist, verlässt Ihre Infrastruktur. OpenAI empfiehlt, Credentials aus Seitentext und Aufnahmen herauszuhalten. Wenn der Bildschirm sensible Daten enthält, maskieren Sie diese, bevor Sie die Aufnahme an das Modell senden. Ein schwarzes Rechteck über bekannten Bereichen reicht aus, sofern Sie deren Koordinaten kennen – weshalb die Standardisierung der Viewport-Größe, wie zuvor in diesem Kurs behandelt, hilft. Maskierung ändert die Bildgröße nicht: Koordinaten, die vom Modell zurückgegeben werden, bleiben gültig.
import io
from PIL import Image, ImageDraw
def mask_sensitive_areas(screenshot_bytes: bytes, regions: list) -> bytes:
"""Maskieren Sie sensible Bereiche in einer PNG-Aufnahme."""
img = Image.open(io.BytesIO(screenshot_bytes))
draw = ImageDraw.Draw(img)
for x, y, w, h in regions:
draw.rectangle([x, y, x + w, y + h], fill="black")
buffer = io.BytesIO()
img.save(buffer, format="PNG")
return buffer.getvalue()
Wissen, was mit Aufnahmen passiert
API-Antworten werden standardmäßig gespeichert: Das ermöglicht die Verkettung über previous_response_id. Mit store: false müssen Sie Elemente aus vorherigen Runden selbst erneut senden. OpenAI stellt auch fest, dass store: false nicht alle Formen der Speicherung eliminiert, und Eingabe-Bilder haben eigene Ausnahmen: Lesen Sie seine Datenschutzkontrollen, bevor Sie Screens mit persönlichen Daten senden.
Niemals sensible Daten protokollieren
Das gleiche Prinzip gilt für Logs, die oft viel länger als Aufnahmen überdauern. Ein Protokollierungsfilter schreibt risikobehaftete Muster um, bevor er schreibt: Passwort-Zuweisungen, OpenAI-API-Schlüssel, die mit sk- beginnen, und 16-stellige Sequenzen, die Kreditkartennummern ähneln. Der Filter wirkt auf die endgültige Nachricht, fängt also auch auf, was Sie ohne Nachdenken protokolliert haben.
import logging
import re
class SensitiveFilter(logging.Filter):
"""Maskieren Sie sensible Daten vor dem Schreiben von Logs."""
PATTERNS = [
(re.compile(r"password['\"]?\s*[:=]\s*['\"]?[^\s,}]+", re.IGNORECASE), "password=***"),
(re.compile(r"\bsk-[A-Za-z0-9_-]{20,}"), "sk-***"),
(re.compile(r"\b\d{16}\b"), "****-****-****-****"),
]
def filter(self, record):
msg = record.getMessage()
for pattern, replacement in self.PATTERNS:
msg = pattern.sub(replacement, msg)
record.msg = msg
record.args = None # Nachricht ist bereits formatiert: nicht erneut formatieren
return True
handler = logging.StreamHandler()
handler.addFilter(SensitiveFilter()) # auf dem Handler, sieht er auch Kind-Logger
logging.basicConfig(level=logging.INFO, handlers=[handler])
Zwei Details machen den Unterschied. Das Setzen von record.args auf None ist essenziell: Andernfalls würde die bereits formatierte Nachricht mit ihren Argumenten erneut formatiert, und jedes % in einer URL würde das Schreiben brechen. Und ein Filter auf dem Handler gilt für alles, was er schreibt, wohingegen ein Filter auf einem Logger Nachrichten von seinen Kind-Loggers ignoriert.
API-Sicherheitsprüfungen
Jeder computer_call trägt ein Feld pending_safety_checks: Die Liste der Sicherheitsprüfungen, die die API verlangt, dass Sie vor der Ausführung der Aktionen bearbeiten, jede mit einer id, einem code und einer message. OpenAIs offizielles Beispiel stoppt, sobald es nicht leer ist. Wenn Ihre Anwendung einen Menschen haben kann, diese Fälle zu validieren, erkennen Sie sie explizit an, indem Sie sie in acknowledged_safety_checks zurückgeben, zusammen mit dem folgenden Screenshot. Das Modell kann diese Genehmigung nicht im Namen Ihres Unternehmens erteilen, und die Anerkennung erfolgt vor der Aktionsausführung, niemals danach.
def valider_verifications(appel) -> list[dict]:
"""Übermitteln Sie ausstehende Prüfungen an einen Operator; lehnen Sie standardmäßig ab."""
if not appel.pending_safety_checks:
return []
for verification in appel.pending_safety_checks:
print(f"Vérification de sécurité [{verification.code}] : {verification.message}")
if input("Autoriser ces actions ? [o/N] ").strip().lower() != "o":
raise RuntimeError("Actions refusées par l'opérateur")
return [
{"id": v.id, "code": v.code, "message": v.message}
for v in appel.pending_safety_checks
]
# Im Loop, vor der Ausführung von Aktionen:
acquittees = valider_verifications(appel)
executer_actions(page, appel.actions)
sortie = {
"type": "computer_call_output",
"call_id": appel.call_id,
"output": {
"type": "computer_screenshot",
"image_url": f"data:image/png;base64,{capturer_ecran(page)}",
"detail": "original",
},
}
if acquittees:
sortie["acknowledged_safety_checks"] = acquittees
Ausführungslimits
Es gibt auch das häufigste Risiko: Ein Agent, der aus dem Ruder läuft, ohne etwas zu zerstören, aber zwei Stunden lang läuft und Ihr Budget verbrennt. Die ExecutionLimits-Klasse erzwingt drei Obergrenzen – Runden, Dauer und geschätzte Kosten – und wirft eine Ausnahme, sobald eine erreicht ist. Raten sind nicht fest codiert: Holen Sie sie vom Modell, das Sie auf OpenAIs Preissseite verwenden, da sie je nach Modell variieren.
import time
class ExecutionLimits:
"""Erzwingen Sie Obergrenzen für Runden, Dauer und Kosten für den Agenten."""
def __init__(
self,
prix_entree_par_million: float, # Raten für das verwendete Modell
prix_sortie_par_million: float,
max_tours: int = 50,
max_duree_s: int = 300,
max_cout_usd: float = 5.0,
):
self.prix_entree = prix_entree_par_million
self.prix_sortie = prix_sortie_par_million
self.max_tours = max_tours
self.max_duree = max_duree_s
self.max_cout = max_cout_usd
self.debut = time.monotonic()
self.tours = 0
self.cout = 0.0
def verifier(self):
"""Rufen Sie vor jeder Anfrage auf: Wirfen Sie einen Fehler auf, wenn eine Obergrenze erreicht ist."""
if self.tours >= self.max_tours:
raise RuntimeError(f"Limite de tours atteinte ({self.max_tours})")
if time.monotonic() - self.debut >= self.max_duree:
raise RuntimeError(f"Durée maximale dépassée ({self.max_duree} s)")
if self.cout >= self.max_cout:
raise RuntimeError(f"Budget dépassé ({self.cout:.2f} $)")
def compter(self, response):
"""Rufen Sie nach jeder Antwort auf: Akkumulieren Sie Runden und geschätzte Kosten."""
self.tours += 1
self.cout += response.usage.input_tokens / 1_000_000 * self.prix_entree
self.cout += response.usage.output_tokens / 1_000_000 * self.prix_sortie
Dies ist nur eine Schätzung: Sie überschätzt Eingabe-Token, die aus dem Prompt-Cache bedient werden, die zu einem reduzierten Satz berechnet werden, und ignoriert jede gehostete Umgebung, die separat berechnet wird. Vergleichen Sie dies regelmäßig mit dem tatsächlichen Verbrauch Ihres Projekts. Setzen Sie Obergrenzen pro Workflow: Ein 30-Sekunden-E2E-Test und eine stundenlange Rechnungsstellung erfordern nicht dieselben Schwellenwerte.
Produktions-Sicherheits-Checkliste
Bevor Sie einen Computer-Use-Agenten in die Produktion bereitstellen, überprüfen Sie:
- Isolierten Browser oder Desktop (Container oder virtuelle Maschine), nicht privilegierten Benutzer
- Ausgangsnetzwerk auf die Websites der Aufgabe und auf die API beschränkt, wenn der Loop in derselben Umgebung läuft
- URL-Filter, der Schema, Host und Port vergleicht; Service Worker blockiert
- API-Schlüssel außerhalb von Code und außerhalb der Reichweite des Browsers gehalten (
env={}) - Bildschirminhalt als unzuverlässig behandelt: Stoppen und eskalieren Sie bei den ersten Anzeichen von Injection
- Menschliche Bestätigung vor Käufen, Sendschreiben, Löschungen und dem Eingeben sensibler Daten
pending_safety_checksniemals ohne menschliche Validierung anerkannt- Runden-, Dauer- und Kostenlimits
- Gefilterte Logs, Aufnahmen nicht gespeichert (oder verschlüsselt)
- Keine persönlichen Dateien, Credentials oder Docker-Sockets in die Umgebung eingebunden
- Ergebnis in der Anwendung vor der Ankündigung des Erfolgs verifiziert
- Notfall-Stopp-Mechanismus (Kill-Switch)
Der letzte Punkt ist der, der am häufigsten vergessen wird, aber er ist der einzige, der hilft, wenn alle anderen versagt haben. Ein Kill-Switch ist eine Möglichkeit, den Agenten sofort zu unterbrechen, ohne auf einen seiner Limits zu warten: Eine STOP-Datei, die der Loop in jeder Iteration prüft, ein docker stop auf dem Container oder eine Flagge, die aus einer gemeinsamen Variable gelesen wird. Testen Sie ihn vor der Produktion, nicht an dem Tag, an dem Sie ihn benötigen.
Wichtige Erkenntnisse
- OpenAIs vier Regeln: Die Umgebung einschränken, den Bildschirm als unzuverlässig behandeln, hochriskante Aktionen bestätigen und Ausführung begrenzen und verifizieren
- Die Anfrage des Modells zum Handeln ist keine Erlaubnis: Ihr Code führt aus, pausiert oder gibt die Kontrolle zurück
- Browser isolieren (nicht privilegierte Benutzer, seccomp-Profil) und Ausgangsverkehr nur auf die Websites der Aufgabe erlauben
- URLs nach Schema, Host und Port filtern – niemals nach einem einfachen String-Vor- oder Suffix
pending_safety_checksnur nach menschlicher Validierung anerkennen- Runden-, Dauer- und Kostenlimits erzwingen und das tatsächliche Ergebnis verifizieren