Ein Blick in die Codex-Sandbox
Wie Codex Befehle auf deinem Rechner innerhalb der von dir festgelegten Grenzen ausführt.
Bei OpenAI setzen wir zur Absicherung von Agenten auf mehrschichtige Sicherheit(wird in einem neuen Fenster geöffnet). Unsere Investitionen in Training und Alignment bilden dafür die Grundlage. Zusätzlich implementieren wir Schutzfunktionen in unserem Agenten-Harness Codex(wird in einem neuen Fenster geöffnet). Eine der häufigsten und potenziell riskanten Aufgaben von Codex ist das Ausführen von Befehlen auf deinem Computer. Deshalb haben wir die Codex-Sandbox entwickelt: Damit kann Codex in deiner bestehenden Umgebung arbeiten, innerhalb der von dir festgelegten Grenzen für Datei- und Netzwerkzugriffe.
Eine (wird in einem neuen Fenster geöffnet)Sandbox(wird in einem neuen Fenster geöffnet) begrenzt, worauf ein Programm während seiner Ausführung zugreifen kann. Zum Organisieren von Fotos könntest du die Codex-Sandbox so konfigurieren, dass Befehle Dateien in ~/Pictures lesen und ändern dürfen, während der Netzwerkzugriff gesperrt ist, um Uploads zu verhindern. Für eine Codeprüfung könntest du den Zugriff auf Onlinedokumentation erlauben und Quelldateien zugleich schreibgeschützt lassen. Du konfigurierst die Codex-Sandbox über (wird in einem neuen Fenster geöffnet)Berechtigungsprofile(wird in einem neuen Fenster geöffnet). Sie legen die Dateisystem- und Netzwerkbeschränkungen für eine Codex-Sitzung fest.
In diesem Artikel erläutern wir zunächst die Abwägungen hinter den Standardeinstellungen der Codex-Sandbox. Anschließend erklären wir ihren Aufbau und wie der Harness sie zur Ausführung von Befehlen nutzt. Wir zeigen, wie einzelne Nutzer:innen und Unternehmen die Berechtigungen an ihre Anforderungen anpassen und wie Entwicklungsteams die Sandbox in eigenen Tools wiederverwenden können. Abschließend betrachten wir, wie diese Beschränkungen unter macOS, Linux und Windows durchgesetzt werden.
Bei Codex setzen wir auf restriktive Standardeinstellungen für die Sandbox, die dennoch sinnvolles Arbeiten ermöglichen. Dient beispielsweise ein Git-Repository als Stammverzeichnis des Arbeitsbereichs, gilt für das integrierte Berechtigungsprofil :workspace:
Es erlaubt Schreibzugriffe im Arbeitsbereich, lässt Verzeichnisse wie
.gitund.codexaber schreibgeschützt. So kann Codex Quellcode bearbeiten, ohne für jede Änderung um Erlaubnis zu fragen. Direkte Änderungen an.codex/config.tomloder Git-Hooks unter.git/hookswerden hingegen verhindert.Es erlaubt weitreichende Lesezugriffe auf das Dateisystem im Rahmen der bestehenden Nutzer-Betriebssystemberechtigungen. Compiler, Laufzeitumgebungen und Build-Tools benötigen SDKs, Bibliotheken und Konfigurationen außerhalb des Repositorys. Eine Beschränkung der Lesezugriffe auf den Arbeitsbereich würde viele übliche Abläufe beeinträchtigen. Der Nachteil: Auch sensible Dateien an anderen Stellen des Rechners können lesbar bleiben, etwa Konfigurationsdateien mit API-Schlüsseln.
Es deaktiviert den Netzwerkzugriff. Das blockiert direkte Uploads zu externen Diensten, einschließlich Versuchen, Daten auszuschleusen, die der Befehl lesen kann. Es verhindert aber auch legitime Vorgänge wie das Herunterladen von Abhängigkeiten, für die zusätzliche Zugriffsrechte nötig sind.
Diese Beschränkungen verhindern viele Arten unerwünschten Verhaltens. Schädliche Aktionen bleiben jedoch möglich. So könnte der Agent beispielsweise Schadcode in ein lokal installiertes Paket wie node_modules/prettier einschleusen. Eine solche Änderung erscheint möglicherweise nicht in git status, da Git node_modules häufig ignoriert. Führt dein Editor diese Kopie von Prettier beim Speichern aus, könnte schon das Speichern einer Datei den Schadcode außerhalb der Codex-Sandbox ausführen. Deshalb setzen wir auf mehrschichtige Sicherheit: Die Sandbox begrenzt den Zugriff von Befehlen. Training und Alignment helfen dem Modell, diesen Zugriff im Sinne der nutzenden Person zu verwenden.
Hinweise dazu, wie du Sandbox-Berechtigungen anpasst und in einer Unternehmensumgebung mit weiteren Schutzmaßnahmen kombinierst, findest du im Sicherheitsleitfaden für Codex(wird in einem neuen Fenster geöffnet).
Virtuelle Maschinen und Container(wird in einem neuen Fenster geöffnet) sind zwei verbreitete Mechanismen für Sandboxing. Bei der Codex-Sandbox verfolgen wir jedoch einen anderen Ansatz. Statt Berechnungen zur Isolierung in eine separate Umgebung zu verlagern, nutzt Codex die Sandboxing-Funktionen der jeweiligen Plattform. Sie beschränken Befehle, die in der bestehenden Nutzerumgebung ausgeführt werden.
Für viele Entwickler:innen ist ihr Laptop eine maßgeschneiderte Entwicklungsumgebung, die sie jederzeit nach Bedarf ändern können. Diese Umgebung in einem Docker-Container nachzubilden, kann aufwendig sein. Manche Abläufe benötigen zudem weiterhin Tools, die auf dem Host laufen.
Nehmen wir als Beispiel die Entwicklung einer iOS-App mit Codex auf einem Mac. Würdest du Codex zur Isolierung in Docker ausführen, könnte Codex weder die iOS-Build-Toolchain aus nativen Mac-Programmen ausführen noch den iPhone-Simulator starten, um den Code auszuführen. Ein Docker-basierter Ablauf könnte Builds und Simulatorvorgänge an den Mac-Host delegieren. Diese Vorgänge würden jedoch außerhalb der Container-Sandbox ausgeführt und bräuchten eigene Beschränkungen. Bei Codex halten wir es lieber einfach und investieren gezielt in betriebssystemspezifisches Sandboxing. So kann Codex in der Umgebung laufen, die für die jeweilige Aufgabe am besten geeignet ist.
Der Harness stellt diese betriebssystemspezifischen Sandboxing-Mechanismen über eine gemeinsame API für macOS, Windows und Linux bereit. Diese API nimmt einen Befehl und ein Berechtigungsprofil entgegen. Erlaubt das Berechtigungsprofil eingeschränkten Netzwerkzugriff, muss die aufrufende Komponente einen Netzwerk-Proxy bereitstellen, der diese Grenzen durchsetzt:
Diese Funktion startet den Prozess in einer Sandbox und gibt ein Child-Handle zurück. Damit kann der Harness auf das Ende des Prozesses warten. Jeder untergeordnete Prozess erbt die Sandbox-Beschränkungen seines übergeordneten Prozesses. Sie gelten somit im gesamten vom Befehl gestarteten Prozessbaum, auch für Nachfolgeprozesse, die länger laufen als der ursprüngliche Prozess.
Das folgende Diagramm zeigt, wie diese Komponenten zusammenspielen: von der Konfiguration bis zur Ausführung eines Befehls in der Sandbox. Die folgenden Abschnitte erläutern die einzelnen Schritte.

Wie im Artikel Die Codex-Agent-Schleife entpackt erläutert, führt der Codex-Harness die vom Modell erzeugten Tool-Aufrufe aus. Bei Programmieraufgaben kommt am häufigsten ein Shell-Tool zum Einsatz. Es führt Befehle ähnlich aus wie Nutzer:innen es in einer interaktiven Shell wie Bash tun würden. Hier betrachten wir das One-Shot-Shell-Tool (wird in einem neuen Fenster geöffnet)exec_command(wird in einem neuen Fenster geöffnet) zur Befehlsausführung(wird in einem neuen Fenster geöffnet). Daran zeigen wir, wie der Harness mit der Sandbox die gewünschten Schutzmaßnahmen umsetzt.
Dies ist eine vereinfachte Darstellung davon, wie der Codex-Harness den Tool-Aufruf exec_command ohne Sandboxing ausführen würde:
Um den Befehl in einer Sandbox auszuführen, ersetzt der Harness den Aufruf von subprocess.Popen() durch spawn_command_under_sandbox(). Der Harness stellt das Berechtigungsprofil und bei Bedarf den Netzwerk-Proxy bereit:
Mit dem Tool exec_command kann das Modell auch andere Berechtigungen für einen einzelnen Befehl anfordern. Ob die Anfrage genehmigt wird, entscheidet jedoch der Harness:
Ist use_default angegeben, verwendet der Harness die Standard-Sandbox-Konfiguration für den aktuellen Dialogschritt. with_additional_permissions fordert erweiterten Zugriff innerhalb der Sandbox an, require_escalated hingegen die Ausführung außerhalb der Sandbox. Der Harness bewertet die Anfrage anhand der Benutzereinstellungen, bevor er den Befehl ausführt. (Codex kann beispielsweise die nutzende Person direkt fragen oder die Anfrage an die automatische Prüfung(wird in einem neuen Fenster geöffnet) weiterleiten.) Wird die Ausführung genehmigt, übergibt Codex die passenden Werte für permission_profile und network_proxy zusammen mit den Befehlsargumenten aus dem ursprünglichen ExecCommandToolCall an perform_exec_command_with_sandboxing().
Das Shell-Tool nutzt spawn_command_under_sandbox() am häufigsten. Der Harness verwendet seine Sandboxing-Infrastruktur außerdem für Vorgänge wie das Lesen und Ändern lokaler Dateien. Die Wiederverwendung reicht über den Harness hinaus: Mit dem Befehl codex sandbox kannst du die Befehlsausführung in einer Sandbox in deine eigenen Tools integrieren, wie wir später zeigen. Als Nächstes betrachten wir, wie Berechtigungsprofile definiert werden.
Mit einem benannten Berechtigungsprofil kannst du dieselben Dateisystem- und Netzwerkbeschränkungen projektübergreifend wiederverwenden. Du kannst eigene Profile unter [permissions] in config.toml definieren. Das folgende Beispiel definiert ein Profil namens dev, das das integrierte Profil :workspace erweitert(wird in einem neuen Fenster geöffnet):
Das Profil dev gewährt zusätzlich Schreibzugriff auf ~/build-cache und schränkt den Zugriff auf Dateien im Arbeitsbereich weiter ein. Dateisystemeinträge können reinen Lesezugriff (read) oder Lese- und Schreibzugriff (write) gewähren oder den Zugriff vollständig sperren (deny).
Mit der Tabelle :workspace_roots definierst du Regeln für Pfade relativ zu den Stammverzeichnissen des Projektarbeitsbereichs. Die Codex CLI verwendet standardmäßig ihr Arbeitsverzeichnis als einziges Stammverzeichnis des Arbeitsbereichs. Die ChatGPT‑Desktop‑App nutzt dagegen die Quellordner des Projekts. Codex wendet jede Regel auf jedes Stammverzeichnis an. Der Eintrag .vscode in dev macht somit das Verzeichnis .vscode unter jedem Stammverzeichnis schreibgeschützt.
Zusätzlich zu seinen eigenen Regeln erbt dev die folgenden Schutzmaßnahmen von :workspace:
Für die Netzwerkkonfiguration der Codex-Sandbox gibt es im Wesentlichen drei Möglichkeiten:
Jeglichen Netzwerkzugriff deaktivieren (Standard im Profil
:workspace)Vollständigen, direkten Netzwerkzugriff aktivieren (Standard im Profil
:danger-full-access)Den Netzwerkzugriff auf einen Proxy beschränken, der anhand des Berechtigungsprofils entscheidet, was er durchlässt
Um dev direkten Netzwerkzugriff zu geben, setze permissions.dev.network.enabled = true auf der obersten Ebene von config.toml. Das gewährt vollständigen Netzwerkzugriff, wenn der Netzwerk-Proxy deaktiviert ist.
Um dev auf bestimmte Domains zu beschränken, aktiviere den Netzwerk-Proxy und konfiguriere seine Domainregeln:
Domainregeln unterstützen exakte Namen und Platzhaltermuster. Explizite Sperrregeln haben Vorrang vor Freigaberegeln. Anfragen an andere Domains benötigen eine Genehmigung oder werden blockiert, wie weiter unten im Abschnitt Netzwerk-Proxy beschrieben.
Einzelne Nutzer:innen können projektübergreifende Standardeinstellungen konfigurieren und sie für ein bestimmtes vertrauenswürdiges Projekt überschreiben. Auch die IT-Administration eines Unternehmens kann Standardeinstellungen für Nutzer:innen festlegen und begrenzen wollen, welche Einstellungen diese ändern dürfen. Codex unterstützt beides durch mehrschichtige Konfiguration und verwaltete Vorgaben.
Wie im Abschnitt Priorität der Konfiguration(wird in einem neuen Fenster geöffnet) beschrieben, führt Codex Einstellungen aus mehreren config.toml-Dateien zusammen. Tabellen werden rekursiv zusammengeführt. Bei widersprüchlichen Werten hat die Quelle mit der höheren Priorität Vorrang. Arrays werden als Ganzes ersetzt.
Deshalb verwenden Berechtigungsprofile Tabellen für Dateisystempfade und Netzwerkdomains. Ein Team kann einzelne Einträge in seiner eigenen Konfiguration hinzufügen oder überschreiben und Änderungen an allen anderen Einträgen der Basiskonfiguration der Organisation automatisch übernehmen:
Die IT-Administration kann außerdem über requirements.toml verwaltete Vorgaben(wird in einem neuen Fenster geöffnet) bereitstellen, um die Konfigurationsmöglichkeiten der Nutzer:innen einzuschränken. Diese Vorgaben können aus mehreren Quellen stammen, darunter Systemdateien und über die Cloud bereitgestellte Richtlinien. Ein häufiger Anwendungsfall ist die Angabe von allowed_permission_profiles, um einzuschränken, welche Berechtigungsprofile Personen im Unternehmen auswählen können. Die IT-Administration könnte beispielsweise diese Cloud-Vorgaben festlegen:
Die Cloud-Vorgaben hätten Vorrang vor der systemweiten Vorgabendatei unter /etc/codex/requirements.toml. Ein Eintrag in dieser Datei kann daher die obige explizite Einstellung ":danger-full-access" = false nicht überschreiben. Bleibt :workspace undefiniert, kann eine andere Vorgabenebene diesen Eintrag liefern. Profile, deren Einträge false sind oder in der endgültigen zusammengeführten Tabelle fehlen, stehen nicht zur Verfügung.
Durch diese Trennung können Organisationen Grenzen durchsetzen, während Nutzer:innen ihre Konfiguration innerhalb dieser Grenzen anpassen. Die daraus entstehenden Berechtigungsprofile kann der Harness verwenden oder direkt auf einen Befehl anwenden, wie wir im Folgenden zeigen.
Die Codex CLI bietet den Befehl sandbox, mit dem sich beliebige Befehle unter einem in der Codex-Konfiguration definierten Berechtigungsprofil ausführen lassen. Häufig dient er dazu, das Profil zu testen und zu prüfen, ob die Sandbox das Verhalten verhindert, das sie blockieren soll.
Der folgende Befehl versucht beispielsweise, VS Code so zu konfigurieren, dass beim Speichern ein schädlicher automatischer Formatierer ausgeführt wird. Wenn .vscode bereits existiert, sollte das oben definierte Profil dev diesen Schreibzugriff blockieren, da das Verzeichnis schreibgeschützt ist. (codex sandbox behandelt cwd standardmäßig als Stammverzeichnis eines Arbeitsbereichs.)
Tatsächlich schlägt dies unter macOS mit folgender Meldung fehl:
Der Befehl codex sandbox macht den Sandboxing-Mechanismus von Codex unabhängig von einer Agentensitzung verfügbar. Du kannst dieselbe Konfigurationssprache und plattformspezifische Durchsetzung nutzen, um Befehle einzuschränken, die deine eigenen Tools starten.
Bei einem in config.toml konfigurierten stdio-MCP-Server versucht der Codex-Harness nicht, den Startbefehl des Servers in einer Sandbox auszuführen. Codex kann nicht zuverlässig ableiten, welche Dateien oder Netzwerkdienste der Server benötigt. Ein Standard-Sandbox-Profil könnte daher eine ansonsten gültige Konfiguration unbrauchbar machen.
Der MCP-Server @modelcontextprotocol/server-memory(wird in einem neuen Fenster geöffnet) wird beispielsweise üblicherweise wie folgt für die Nutzung mit Codex konfiguriert:
Da dieser npx-Befehl ohne Sandbox läuft, kann er mit denselben Nutzerberechtigungen wie Codex, Dateien schreiben und Netzwerkanfragen senden. Das gewährt zu weitreichende Rechte. Um den Zugriff einzuschränken, können wir ein Berechtigungsprofil namens memory-mcp definieren und den ursprünglichen npx-Befehl über codex sandbox --permission-profile memory-mcp aufrufen. So begrenzen wir, wohin der Server schreiben darf, und verhindern seinen Netzwerkzugriff:
Erstelle vor dem Start des Servers dessen Datenverzeichnis und lade das Paket in der festgelegten Version in den npm-Cache. Dadurch kann npx --offline den Server unter einem Profil starten, das den Netzwerkzugriff deaktiviert:
Sobald das Paket im Cache liegt, kann Codex den Memory-Server ohne Netzwerkzugriff starten. Schreibzugriffe sind dann auf den npm-Cache und das Datenverzeichnis des Servers beschränkt.
Die Sandbox-Implementierung setzt ein Berechtigungsprofil in Beschränkungen um, die das Betriebssystem durchsetzt. Die Kernlogik des Netzwerk-Proxys zur Anfrageverarbeitung und Richtlinienprüfung ist für alle drei großen Betriebssysteme gleich. Die Einrichtung des Proxys und seine Integration in die Sandbox sind dagegen betriebssystemspezifisch. Wir betrachten zuerst den gemeinsamen Proxy und anschließend die Implementierungen für macOS, Linux und Windows.
Um die Netzwerkbeschränkungen eines Berechtigungsprofils durchzusetzen, startet der Harness einen Netzwerk-Proxy. Er konfiguriert die Sandbox so, dass sie Verbindungen zu diesem Proxy erlaubt, direkte Verbindungen zu externen Hosts jedoch blockiert. Der Proxy prüft jede Anfrage anhand der Domainregeln des Profils und entscheidet, ob er sie weiterleitet.
Im Codex-Repository ist der Netzwerk-Proxy in der Crate codex-network-proxy(wird in einem neuen Fenster geöffnet) implementiert. Der Harness nutzt sie als Bibliothek, sie lässt sich aber auch als eigenständige CLI(wird in einem neuen Fenster geöffnet) kompilieren. Wenn aktiviert, startet codex-network-proxy standardmäßig sowohl einen HTTP-Proxy als auch einen SOCKS5-Proxy. Diese Proxy-Adressen werden dem von der Sandbox gestarteten Prozess über Umgebungsvariablen mitgeteilt. Neben Standard-Umgebungsvariablen wie HTTP_PROXY, HTTPS_PROXY und ALL_PROXY werden auch mehrere bekannte anwendungsspezifische Umgebungsvariablen(wird in einem neuen Fenster geöffnet) wie PIP_PROXY gesetzt. Allerdings beachten nicht alle Programme diese Umgebungsvariablen. Versucht ein Programm, sich direkt mit einem externen Host zu verbinden, blockieren die Sandbox-Beschränkungen des Betriebssystems die Verbindung. Das beschreiben die plattformspezifischen Abschnitte weiter unten.
Der Netzwerk-Proxy setzt die in einem Berechtigungsprofil definierten Netzwerkbeschränkungen um. Das zuvor gezeigte Profil dev erlaubt beispielsweise Anfragen an *.openai.com und sperrt Anfragen an evil.example ausdrücklich. Richtet sich eine Anfrage an eine Domain, die keiner Freigabe- oder Sperrregel entspricht, kann der Proxy die Anfrage aussetzen und dem Harness zur Genehmigung vorlegen. Wie im Beispiel mit dem Shell-Befehl kann Codex die nutzende Person direkt fragen oder die Anfrage an die automatische Prüfung(wird in einem neuen Fenster geöffnet) weiterleiten. Nach Erhalt der Entscheidung lässt der Proxy die Anfrage entweder passieren oder weist sie mit einer Fehlermeldung zurück.
Die Reihenfolge ist dabei wichtig, denn schon durch eine DNS-Abfrage können Informationen unbefugt bekannt werden, die in einem Hostnamen codiert sind. Der Proxy löst den angefragten Hostnamen daher erst auf, nachdem feststeht, dass er erlaubt oder genehmigt ist. Beachte, dass weit gefasste Platzhalterregeln oder der Zugriff auf DNS-Dienste weiterhin eine DNS-basierte Datenexfiltration ermöglichen können.
Unter macOS verwendet Codex Seatbelt(wird in einem neuen Fenster geöffnet), Apples vom Kernel durchgesetzten Sandboxing-Mechanismus. Seatbelt-Richtlinien werden in der Sandbox Profile Language (SBPL) geschrieben, einer auf Scheme basierenden Sprache zur Beschreibung von Sandbox-Beschränkungen. Codex ruft Seatbelt über den macOS-Befehl /usr/bin/sandbox-exec auf. Wie codex sandbox nimmt er Optionen zur Beschreibung der Sandbox entgegen, gefolgt vom auszuführenden Befehl:
PROFILE ist eine SBPL-Zeichenfolge mit Einträgen, die die Sandbox konfigurieren. Der folgende SBPL-Ausschnitt macht beispielsweise /dev/null und /dev/zero gemäß der Sandbox-Richtlinie lesbar und beschreibbar:
Wird der Netzwerk-Proxy bei einem Sandbox-Aufruf aktiviert, werden Regeln wie die folgenden in das Profil eingefügt. Sie beschränken Verbindungen auf die entsprechenden lokalen Ports:
Das Basisprofil von Codex beginnt mit (deny default). Ausgehende Verbindungen bleiben daher blockiert, sofern sie nicht ausdrücklich erlaubt sind.
Außerdem kann SBPL Platzhalter mit (param) enthalten:
Diese werden durch die an sandbox-exec übergebenen Optionen -Dkey=value gefüllt.
Für seine eigene Sandbox-API erstellt Codex die Argumentliste(wird in einem neuen Fenster geöffnet) für sandbox-exec ausgehend von einer Basisrichtlinie(wird in einem neuen Fenster geöffnet). Anschließend ergänzt Codex diese anhand von permission_profile und weiterem Kontext zum vollständigen Seatbelt-Profil. Das entstandene Profil und die zugehörigen -D-Argumente konfigurieren die von Seatbelt durchgesetzten Beschränkungen. Der Netzwerk-Proxy setzt zusätzliche Netzwerkregeln durch. Sobald die vollständige Argumentliste vorliegt, ist der Aufruf von sandbox-exec unkompliziert.
Korrektes SBPL zu erzeugen ist anspruchsvoll, da Apple die Sprache nicht für die Nutzung durch Dritte dokumentiert. Tatsächlich steht in man sandbox-exec: The sandbox-exec command is DEPRECATED. Auch die über man 3 sandbox_init dokumentierte Bibliotheksfunktion sandbox_init() gilt als veraltet. Trotz dieses Hinweises liefert macOS weiterhin Seatbelt-Profile unter /usr/share/sandbox mit. Auch Software von Drittanbietern, darunter Google Chrome und Chromium(wird in einem neuen Fenster geöffnet), setzt weiterhin auf Seatbelt. Daher planen wir, Seatbelt auf absehbare Zeit weiterzuverwenden.
Zum Erstellen der Sandbox unter Linux kombiniert Codex bubblewrap(wird in einem neuen Fenster geöffnet) (bwrap), ein Befehlszeilentool zum Aufbau isolierter Umgebungen, mit seccomp-bpf(wird in einem neuen Fenster geöffnet), einem Mechanismus des Linux-Kernels zum Filtern von Systemaufrufen. Ein internes Hilfsprogramm namens codex-linux-sandbox koordiniert die Einrichtung. Wie sandbox-exec unter macOS nimmt es eine Sandbox-Konfiguration entgegen, gefolgt vom auszuführenden Befehl:
Wenn Dateisystemisolierung oder Proxy-Routing erforderlich ist, ruft codex-linux-sandbox das Programm bwrap auf, um die anfängliche Sandbox-Umgebung zu erstellen. Anschließend startet bwrap darin codex-linux-sandbox --apply-seccomp-then-exec. Dieser zweite Aufruf wendet mit seccomp-bpf zusätzliche Beschränkungen an, bevor der gewünschte Befehl ausgeführt wird.
Zum Aufbau dieser anfänglichen Sandbox-Umgebung erstellt Codex mit bubblewrap eine Dateisystemansicht in einem separaten Mount-Namensraum. Sie bildet die Dateisystemregeln des Berechtigungsprofils ab. Da dies ein grundlegender Bestandteil der Sandbox-Implementierung ist, liefert Codex eine eigene Kopie von bwrap mit, falls keine installiert ist. Es bevorzugt jedoch eine kompatible Installation von (wird in einem neuen Fenster geöffnet)bwrap(wird in einem neuen Fenster geöffnet) im PATH, sofern vorhanden. In der Praxis deaktivieren einige Linux-Distributionen den Zugriff auf Benutzer-Namensräume standardmäßig(wird in einem neuen Fenster geöffnet), gewähren aber eine Ausnahme für das systemeigene bwrap.
Wie sandbox-exec nimmt auch bwrap eine Sandbox-Konfiguration entgegen, gefolgt von einem Befehl, der innerhalb der Sandbox ausgeführt werden soll. Statt einer eigenen Konfigurationssprache wie SBPL verwendet bwrap einzelne Flags zur Konfiguration. Codex erstellt die Dateisystemansicht mit folgenden Optionen:
--bindlegt eine beschreibbare Datei oder ein beschreibbares Verzeichnis fest--ro-bindlegt eine schreibgeschützte Datei oder ein schreibgeschütztes Verzeichnis fest--perms 000 --tmpfs DIR --remount-ro DIRsperrt den Zugriff aufDIR--perms 000 --ro-bind-data FD FILEsperrt den Zugriff aufFILE(wobeiFDein offener Dateideskriptor für/dev/nullist)
Um Glob-Muster für Zugriffssperren mit diesen Optionen anzuwenden, löst Codex sie vor dem Start jedes Befehls in konkrete Pfade auf. Neue passende Pfade werden den Sandbox-Beschränkungen dieses Befehls nicht automatisch hinzugefügt.
Codex setzt außerdem Optionen wie --unshare-ipc und --unshare-pid, damit die Sandbox nicht auf andere Arten von Host-Ressourcen zugreifen kann. bubblewrap beeinflusst also nicht nur die Sichtbarkeit von Dateien.
Bei Verwendung von bubblewrap übergibt Codex immer dann --unshare-net, wenn der Netzwerkzugriff deaktiviert ist oder Verbindungen über den Netzwerk-Proxy laufen müssen. Dadurch entsteht ein neuer Netzwerk-Namensraum für die Sandbox. Anschließend beschränken wir mit seccomp-bpf zusätzlich die Netzwerk-Systemaufrufe und Socket-Familien, die dem Befehl zur Verfügung stehen.
Dazu verwenden wir die Crate seccompiler(wird in einem neuen Fenster geöffnet), um anhand der gewünschten Filter dynamisch ein BPF-Programm zu kompilieren(wird in einem neuen Fenster geöffnet). Wir wenden es auf einen Startprozess in der Sandbox an, sodass der gesamte Prozessbaum die Beschränkungen erbt. Daher führt bwrap nicht den gewünschten Befehl aus, sondern das Startprogramm codex-linux-sandbox mit dessen eigenen Konfigurationsargumenten, gefolgt vom gewünschten Befehl:
Um seccomp-Filter ohne erhöhte Rechte anzuwenden, setzt das Startprogramm das Linux-Flag no_new_privs(wird in einem neuen Fenster geöffnet). Untergeordnete Prozesse erben dieses Flag. Es verhindert, dass sie beim Ausführen eines anderen Programms, etwa einer setuid-Datei, zusätzliche Rechte erhalten.
Die seccomp-Filter hängen von der Netzwerkkonfiguration ab. Bei deaktiviertem Netzwerkzugriff blockieren wir mehrere netzwerkbezogene Systemaufrufe, etwa connect(2) und bind(2). Ist der Netzwerk-Proxy in der Sandbox aktiviert, erlauben wir hingegen IP-Sockets, damit der von codex-linux-sandbox erstellte TCP-Listener erreichbar ist. Die Erstellung eigenständiger Unix-Domain-Sockets blockieren wir standardmäßig, da sie unbeabsichtigten Zugriff auf Host-Ressourcen ermöglichen könnten.
Wenn die Sandbox-Konfiguration einen Netzwerk-Proxy erfordert, erstellt der Codex-Harness eine Proxy-Instanz. Diese lässt sich für mehrere Aufrufe von codex-linux-sandbox innerhalb desselben Codex-Threads wiederverwenden. Jede Sandbox muss diesen gemeinsamen Proxy aus ihrem isolierten Netzwerk-Namensraum heraus erreichen können. Codex stellt in diesem Namensraum einen Loopback-TCP-Listener bereit. Ein Prozess außerhalb der Sandbox nimmt dessen Verbindungen an und leitet sie an den Proxy weiter.
Die folgenden Diagramme zeigen diesen Aufbau für einen Proxy-Endpunkt. Das letzte Diagramm zeigt eine Verbindung über diesen Endpunkt. Vor dem Start von bubblewrap erstellt codex-linux-sandbox ein Unix-Socket-Paar als Steuerkanal und erzeugt per Fork einen untergeordneten Prozess. Der untergeordnete Prozess führt run_host_bridge() aus und wartet darauf, den Dateideskriptor des Listeners über diesen Kanal zu erhalten:
In diesem Beispiel ersetzt der übergeordnete Prozess sein Prozessabbild mithilfe von exec durch bwrap. Dieses richtet die Sandbox ein und startet darin codex-linux-sandbox --apply-seccomp-then-exec. Dabei gibt es den Dateideskriptor für den Steuerkanal weiter:
Im Netzwerk-Namensraum der Sandbox erstellt der zweite Aufruf von codex-linux-sandbox einen Loopback-TCP-Listener und übergibt dessen Dateideskriptor über den Socket. Der Listener bleibt dem Netzwerk-Namensraum der Sandbox zugeordnet. So kann der außerhalb der Sandbox verbliebene untergeordnete Prozess Verbindungen von Programmen in der Sandbox annehmen und zugleich seine ausgehenden Verbindungen im Netzwerk-Namensraum des Hosts öffnen. Nach der Übergabe schließen beide Prozesse ihre Steuerkanal-Deskriptoren. Der Prozess innerhalb der Sandbox schließt außerdem seine Kopie des Listeners.
Sobald der TCP-Listener bereit ist, setzt der Prozess innerhalb der Sandbox den passenden Wert für HTTP_PROXY(wird in einem neuen Fenster geöffnet) und zugehörige Umgebungsvariablen so, dass sie auf diesen Listener verweisen. Anschließend wendet er seccomp an, bevor er einen untergeordneten Prozess erzeugt und darin den gewünschten Befehl ausführt:
Der Prozess außerhalb der Sandbox hält den Listener offen. Für jede angenommene Verbindung öffnet er eine Verbindung zum konfigurierten Proxy und leitet Daten in beide Richtungen weiter.
Durch diesen zusätzlichen Mechanismus erhält der Befehl einen eigenen Netzwerk-Namensraum mit einer separaten Loopback-Schnittstelle. Unter macOS erlaubt Seatbelt dem Befehl, sich direkt mit festgelegten Ports auf der Loopback-Schnittstelle des Hosts zu verbinden. Unter Linux verbindet sich der Befehl stattdessen mit einem Listener in seinem isolierten Namensraum. Ein Prozess außerhalb der Sandbox leitet diese Verbindungen an den konfigurierten Proxy weiter. Die Übergabe des Deskriptors ermöglicht diese Verbindung, ohne dem Befehl Zugriff auf den Netzwerk-Namensraum des Hosts zu gewähren.
Anfang dieses Jahres haben wir Sandboxing unter Windows implementiert und über unsere Arbeit daran berichtet. Seitdem hat Microsoft eine Bibliothek namens MXC sowie neue Funktionen zur Prozessisolierung im Windows-Betriebssystem veröffentlicht. Wir ersetzen unsere bisherige Sandbox derzeit durch eine Sandbox, die die MXC-Bibliothek nutzt.
MXC (Microsoft eXecution Container) ist ein System zur Codeausführung in einer Sandbox(wird in einem neuen Fenster geöffnet) von Microsoft, das mehrere Isolierungs-Backends für Windows, Linux und macOS unterstützt. Codex unterstützt auf kompatiblen Windows-Geräten eine MXC-basierte Sandbox. Sie nutzt native Prozessisolierung, um Befehle innerhalb der bestehenden Nutzerumgebung einzuschränken.
Mit dem Umstieg auf MXC wollen wir Sicherheit und Benutzerfreundlichkeit verbessern und mehrere Einschränkungen unserer bisherigen Windows-Sandbox beheben:
Erhöhte Rechte bzw. Adminrechte zur Einrichtung der Sandbox erforderlich
Aufwendige und langsame Vorgänge zum Prüfen und Setzen von ACLs
Dauerhaft auf dem Host verbleibende Sandbox-Einrichtung, darunter
ACLs
Firewall-Regeln
Sandbox-Benutzerkonten
Dateien der Steuerungsebene
MXC stellt ein JSON-Konfigurationsschema(wird in einem neuen Fenster geöffnet) bereit. Codex erstellt mit dem MXC SDK(wird in einem neuen Fenster geöffnet) eine Ausführungsanfrage nach diesem Schema. Sie enthält den Befehl, das Arbeitsverzeichnis, die Umgebung und die Berechtigungen. Diese Berechtigungen umfassen Datei- und Netzwerkzugriffe sowie den Zugriff auf Windows-Ressourcen wie Desktop und Zwischenablage.
Codex verwendet für mehrere Schutzfunktionen feste Einstellungen, um Kompatibilität und Sicherheit auszubalancieren. Es erlaubt Lesezugriffe auf die Registrierung und behält den Zugriff auf Win32k und den Desktop bei, den PowerShell beim Start benötigt. Der Zugriff auf die Zwischenablage, das Einschleusen von Eingaben sowie die Steuerung von Desktop- und Systemeinstellungen sind deaktiviert. Außerdem wird verhindert, dass MXC ersatzweise die Dateisystemberechtigungen des Hosts verändert.
Codex überträgt die Dateisystem- und Netzwerkregeln des Berechtigungsprofils in die MXC-Konfiguration. Für das zuvor gezeigte Profil dev gelten folgende Annahmen:
C:\,D:\undZ:\sind die einzigen lokalen Laufwerke des Rechners.Das Stammverzeichnis des Arbeitsbereichs und das Arbeitsverzeichnis sind
C:\work\demo.Das Nutzer-Home-Verzeichnis ist
D:\Users\dev. Daher wird~/build-cachezuD:\Users\dev\build-cacheaufgelöst.Das Glob-Muster für Zugriffssperren trifft nur auf
C:\work\demo\config\dev.envundC:\work\demo\config\prod.envzu.
Die entsprechenden MXC-Einstellungen würden Folgendes umfassen:
Die Dateisystemrichtlinie von MXC verweigert Zugriffe standardmäßig. Codex fügt daher Leseberechtigungen für die lokalen Laufwerksstammverzeichnisse hinzu, um die von diesem Profil erlaubten weitreichenden Lesezugriffe zu ermöglichen. Diese Berechtigungen gelten rekursiv im Rahmen der bestehenden Nutzer-Betriebssystemberechtigungen.
Eine Besonderheit: Schreibberechtigungen für Laufwerksstammverzeichnisse gelten nicht rekursiv. Codex erweitert sie daher auf die vorhandenen Dateien und Ordner direkt unterhalb des Stammverzeichnisses.
Spezifischere Pfade überschreiben die Berechtigungen übergeordneter Pfade. So kann C:\work\demo unterhalb des schreibgeschützten C:\ beschreibbar sein, während C:\work\demo\.git schreibgeschützt bleibt.
Wenn unterschiedliche Pfadschreibweisen oder Aliase über symbolische Links bzw. Junctions auf denselben Pfad verweisen, wendet MXC die strengere Berechtigung an: Eine Zugriffssperre hat Vorrang vor reinem Lesezugriff, dieser wiederum vor Lese- und Schreibzugriff.
MXC akzeptiert nur konkrete Sperrpfade. Daher löst Codex Glob-Muster für Zugriffssperren vor dem Start in passende Dateien und Verzeichnisse auf. Neue Pfade, die dem Glob-Muster entsprechen, werden während der Befehlsausführung nicht automatisch hinzugefügt.
Domainregeln wie *.openai.com setzt der zuvor beschriebene gemeinsame Codex-Netzwerk-Proxy durch. Codex führt diesen Proxy außerhalb der Sandbox aus und übergibt seine Adressen über die bereits erwähnten Standard-Umgebungsvariablen *_PROXY an den Befehl. MXC blockiert direkte externe Verbindungen, erlaubt aber Verbindungen über die Loopback-Schnittstelle des Hosts, einschließlich des Zugriffs auf den Proxy. Andere lokale Dienste bleiben erreichbar.
Unter macOS, Linux und Windows verwendet der Harness dieselbe Sandbox-API, um Befehle unter einem Berechtigungsprofil zu starten. Die plattformspezifischen Implementierungen übernehmen die nötige Einrichtung, um diese Beschränkungen anzuwenden.
Code zu schreiben und auszuführen gibt Agenten eine flexible Möglichkeit, auch jenseits der Softwareentwicklung Probleme zu lösen. Die Codex-Sandbox lässt sie diese Fähigkeit in der bestehenden Nutzerumgebung einsetzen, mit expliziten Grenzen für Datei- und Netzwerkzugriffe. Sie ist ein wiederverwendbarer Grundbaustein im Harness. Der Befehl codex sandbox macht sie auch für selbst entwickelte Tools verfügbar.
Da Agenten immer mehr Aufgaben übernehmen, wollen wir Sandboxing für mehr Tools und Umgebungen praktikabel machen. Dazu wollen wir die Konfiguration von Berechtigungen vereinfachen und verbesserte Schutzfunktionen der Betriebssysteme nutzen, sobald sie verfügbar sind. Unser Ziel ist es, die Fähigkeiten von Agenten zu erweitern, während Menschen weiterhin kontrollieren, worauf die Agenten zugreifen dürfen.


