Codex hilft dir, deinen Code und deine Daten zu schützen, und verringert das Risiko eines Missbrauchs.
Hier erfährst du, wie du Codex sicher einsetzt und wie Sandboxing, Genehmigungen und Netzwerkzugriff dabei zusammenspielen. Informationen zu Codex Security, dem Produkt zum Scannen verbundener GitHub-Repositorys, findest du unter Codex Security.
Standardmäßig läuft der Agent ohne Netzwerkzugriff. Lokal nutzt Codex eine Sandbox, deren Grenzen das Betriebssystem durchsetzt. Sie beschränkt den Zugriff in der Regel auf den aktuellen Arbeitsbereich. Eine Genehmigungsrichtlinie legt außerdem fest, wann Codex anhalten und deine Genehmigung einholen muss, bevor es eine Aktion ausführt.
Wie Sandboxing in der ChatGPT-Desktop-App, der Codex CLI und der IDE-Erweiterung funktioniert, erfährst du im Überblick zum Sandboxing. Einen umfassenderen Überblick zur Sicherheit in Unternehmen bietet das Whitepaper zur Sicherheit von Codex.
Von der eingestellten Genehmigungsrichtlinie untrusted umsteigen
Codex und ChatGPT Work unterstützen approval_policy = "untrusted" nicht mehr. Diese Einstellung kann bei beiden Clients den Start verhindern. Entferne sie aus der Benutzer- oder Projektkonfiguration, aus Profildateien, Startskripten und verwalteten Standardeinstellungen. Für die interaktive Nutzung ohne Schreibzugriff verwende folgende Konfiguration:
sandbox_mode = "read-only"
approval_policy = "on-request"
Alternativ kannst du codex --sandbox read-only --ask-for-approval on-request ausführen.
Mit on-request können Befehle, die die Sandbox zulässt, ohne Genehmigung laufen, zugängliche Dateien lesen und bei aktiviertem Netzwerkzugriff das Netzwerk nutzen.
Wenn du die strengere Genehmigungsregel für Befehle beibehalten möchtest, verzichte auf eine explizite approval_policy und ergänze in deiner benutzerspezifischen ~/.codex/config.toml einen Projekteintrag:
[projects."/path/to/project"]
trust_level = "untrusted"
Befehle erfordern dann eine Genehmigung, sofern keine Regel der Ausführungsrichtlinie sie zulässt. Außerdem ist die projektlokale Konfiguration damit deaktiviert. Wenn du on-request explizit setzt, hat diese Einstellung Vorrang vor der aus dem Projekt abgeleiteten Richtlinie. Damit die abgeleitete Richtlinie zulässig ist, muss die verwaltete Einstellung allowed_approval_policies den Wert untrusted enthalten.
Sandbox und Genehmigungen
Beim Zugriff auf einen lokalen Computer mit Work Cloud gelten für die lokale Ausführung und die Ausführung in der Cloud getrennte Richtlinien:
- Ausführung in der Cloud: Für die Cloud-Container von Work gelten die bestehenden Richtlinien von Work Cloud.
- Lokale Ausführung: Für den verbundenen Computer gelten die Anforderungen an die lokale Ausführung. MDM-Anforderungen und ältere Vorgaben für verwaltete Geräte haben Vorrang vor Agent Security. Agent Security wiederum hat Vorrang vor den Vorgaben in der Datei mit den Systemanforderungen des Geräts.
Bei Work mit lokalem Zugriff und bei dots gelten die unterstützten Richtlinien aus „Global“ für den gemeinsamen Cloud-Orchestrator, wenn die verwaltete Richtlinie aktiviert ist. Für die Cloud-Container von Work und die Cloud-Computer der dots gelten jeweils eigene Ausführungskonfigurationen und Anforderungen. Teste die lokalen und die Cloud-Einstellungen getrennt. Verwalte die Einstellungen des Orchestrators, einschließlich Genehmigungen und Websuche, in „Global“. Nutze die Einstellungen „Zulässige Genehmigungsrichtlinien“ und „Zulässige Websuchmodi“, sofern sie verfügbar sind. Verwende für andere unterstützte Felder TOML. Prüfe in der Konfigurationsreferenz, welche Felder verfügbar sind und wo sie bei der Ausführung gelten, bevor du ein Codex-Beispiel auf den lokalen Computerzugriff mit Work Cloud überträgst.
Wenn du zwischen Desktop, Web und Mobilgerät wechselst, erhältst du dadurch keinen Zugriff auf einen anderen Computer. Bevor du die Synchronisierung aktivierst oder den Zugriff erweiterst, prüfe die Grundkonfiguration von Agent Security und teste in jeder Ausführungsumgebung je eine erlaubte und eine blockierte Aktion. Weitere Informationen findest du unter Verwaltete Konfiguration.
Für die Sicherheit von Codex greifen zwei Ebenen ineinander:
- Sandbox-Modus: Er legt fest, was Codex bei der Ausführung modellgenerierter Befehle technisch tun kann, etwa wo Codex schreiben darf und ob es das Netzwerk erreicht.
- Genehmigungsrichtlinie: Sie legt fest, wann Codex vor einer Aktion deine Genehmigung einholen muss, etwa um die Sandbox zu verlassen, das Netzwerk zu nutzen oder einen Befehl außerhalb einer Gruppe vertrauenswürdiger Befehle auszuführen.
Welchen Sandbox-Modus Codex verwendet, hängt von der Ausführungsumgebung ab:
- Codex Cloud (Legacy): Codex läuft in isolierten, von OpenAI verwalteten Containern und kann weder auf dein Hostsystem noch auf Daten außerhalb der jeweiligen Umgebung zugreifen. Die Ausführung erfolgt in zwei Phasen. Das Setup läuft vor der Agentenphase und kann über das Netzwerk angegebene Abhängigkeiten installieren. Die anschließende Agentenphase läuft standardmäßig offline, sofern du für diese Umgebung keinen Internetzugriff aktivierst. Für Cloud-Umgebungen konfigurierte Secrets sind nur während des Setups verfügbar und werden vor Beginn der Agentenphase entfernt.
- Aktuelle Codex Cloud: Wie Codex beim Setup und während der Ausführung von Aufgaben mit Zugangsdaten umgeht, erfährst du unter Umgebungsvariablen und Netzwerk-Secrets.
- Codex CLI und IDE-Erweiterung: Das Betriebssystem setzt die Sandbox-Richtlinien durch. Standardmäßig ist der Netzwerkzugriff deaktiviert und der Schreibzugriff auf den aktiven Arbeitsbereich beschränkt. Du kannst die Sandbox, die Genehmigungsrichtlinie und die Netzwerkeinstellungen an das für dich vertretbare Risiko anpassen.
Mit der Voreinstellung Auto (zum Beispiel --sandbox workspace-write --ask-for-approval on-request) kann Codex im Arbeitsverzeichnis automatisch Dateien lesen, Änderungen vornehmen und Befehle ausführen.
Codex fordert eine Genehmigung an, wenn es Dateien außerhalb des Arbeitsbereichs bearbeiten oder Befehle ausführen soll, die Netzwerkzugriff erfordern. Wenn du nur chatten oder planen möchtest, wechsle in den Modus read-only. Verwende dazu den Befehl /permissions.
Codex kann auch für Tool-Aufrufe von Apps (Konnektoren) eine Genehmigung anfordern, wenn das Tool Nebenwirkungen ausweist. Das gilt auch für Aktionen, die weder einen Shell-Befehl ausführen noch eine Datei ändern. Destruktive Tool-Aufrufe von Apps oder über MCP erfordern immer eine Genehmigung, wenn das Tool die Aktion als destruktiv kennzeichnet. Weist das Tool zugleich eine Leseoperation aus, hat diese Kennzeichnung Vorrang.
Sicherheitsüberwachung und pausierte Aufgaben
GPT-6 Astra umfasst eine Sicherheitsüberwachung für Codex und ChatGPT Work. Sie läuft asynchron und kann eine Aufgabe pausieren, wenn sie potenziell unsicheres Modellverhalten erkennt. Es kann vorkommen, dass die auslösende Aktivität bereits abgeschlossen ist, wenn die Überwachung die Aufgabe pausiert. Die Überwachung ersetzt weder Sandboxing und Berechtigungen noch die Prüfung des Ergebnisses.
Wenn eine Aufgabe pausiert wird, lies den Hinweis und prüfe die Befunde, sofern sie verfügbar sind. Setze die Aufgabe erst fort, wenn du geprüft hast, dass dies sicher möglich ist. Wenn laut Hinweis die Aufgabe beendet wurde oder keine Option zum Fortsetzen angeboten wird, kannst du sie auf dieser Oberfläche nicht fortsetzen.
| Oberfläche und Einstellungen zur Datennutzung | Befunde und Fortsetzung |
|---|---|
| Clients von Codex und ChatGPT Work, in denen du Befunde prüfen und Aufgaben fortsetzen kannst, sofern keine der hier aufgeführten Dateneinstellungen gilt | Prüfe die Befunde, bevor du die Aufgabe fortsetzt. |
| Codex CLI und Mobilgeräte | Die vollständigen Befunde sind nicht verfügbar. Die Aufgabe endet und lässt sich nicht fortsetzen. |
| Keine Datenaufbewahrung, Modified Abuse Monitoring oder Datenresidenz mit Speicherung außerhalb der USA | Die vollständigen Befunde sind nicht verfügbar. Die Aufgabe endet und lässt sich nicht fortsetzen. |
Die Sicherheitsüberwachung bewertet das Modellverhalten während einer Aufgabe. Die automatische Überprüfung von Genehmigungsanfragen bewertet einzelne genehmigungspflichtige Aktionen vor ihrer Ausführung. Auch wenn eine Aktion bei der automatischen Überprüfung genehmigt wurde, kann die Sicherheitsüberwachung die zugehörige Aufgabe später pausieren.
Netzwerkzugriff Erhöhtes Risiko
Die Netzwerkeinstellungen der aktuellen Codex Cloud findest du unter Verbindung zu Diensten herstellen. Wie du in Codex Cloud (Legacy) den vollständigen Internetzugriff aktivierst oder nur bestimmte Domains zulässt, erfährst du unter Internetzugriff für Agenten.
In der ChatGPT-Desktop-App, der Codex CLI und der IDE-Erweiterung bleibt der Netzwerkzugriff im standardmäßigen Sandbox-Modus workspace-write deaktiviert, sofern du ihn nicht in deiner Konfiguration aktivierst:
[sandbox_workspace_write]
network_access = true
Netzwerkisolation
Bei unterstützten verwalteten Ausführungswegen in Codex Cloud beschränken die Anforderungen von Agent Security den Netzwerkzugriff von Befehlen. Die Interneteinstellungen der jeweiligen Codex Cloud-Umgebung gelten unabhängig davon. Eine in Agent Security zugelassene Domain hebt keine Beschränkung in den Interneteinstellungen der Cloud-Umgebung auf. Die Netzwerkregeln für Befehle allein deaktivieren weder die gehostete Websuche noch Apps oder MCP. ChatGPT Work Cloud verfügt über eigene Funktionsberechtigungen und übernimmt diese Anforderungen von Agent Security nicht.
Eine verwaltete Zulassungsliste für den Netzwerkzugriff von Befehlen gilt für Befehle, die den verwalteten Proxy verwenden. Wenn die Richtlinie eine vollständige Aufhebung der Sandbox-Beschränkungen erlaubt und diese genehmigt wird, kann der Befehl bei dieser Ausführung den Proxy umgehen. Eine begrenzte Netzwerkfreigabe unterscheidet sich von einer vollständigen Aufhebung der Sandbox-Beschränkungen. Lege verbindliche Genehmigungs- und Sandbox-Anforderungen passend zur gewünschten Sicherheitsgrenze fest. Teste sowohl reguläre Befehle als auch Befehle mit erweiterten Berechtigungen. Weitere Informationen findest du unter Verwaltete Konfiguration.
Regeln für Netzwerkziele steuern den Netzwerkzugriff von Skripten, Programmen und Unterprozessen, die ein Befehl startet. Wenn der Netzwerkzugriff für Befehle bereits aktiviert ist, aktiviere die Funktion network_proxy, um diesen Datenverkehr auf die Ziele zu beschränken, die deine Netzwerkrichtlinie erlaubt. Domainregeln allein aktivieren den Proxy nicht.
[features.network_proxy]
enabled = true
domains = { "api.openai.com" = "allow", "example.com" = "deny" }
Wenn du die Funktion für eine einzelne CLI-Sitzung nur ein- oder ausschalten möchtest, genügt die Kurzform mit einem booleschen Wert. Verwende die Tabellenform, wenn du auch Richtlinienoptionen festlegst:
codex \
-c 'features.network_proxy=true' \
-c 'sandbox_workspace_write.network_access=true'
codex \
-c 'features.network_proxy.enabled=true' \
-c 'features.network_proxy.domains={ "api.openai.com" = "allow", "example.com" = "deny" }' \
-c 'sandbox_workspace_write.network_access=true'
Die Funktion regelt den bereits aktivierten Netzwerkzugriff. Sie gewährt selbst keinen Zugriff. Mit sandbox_workspace_write.network_access legst du in der Konfiguration für workspace-write fest, ob Befehle überhaupt auf das Netzwerk zugreifen können:
- Netzwerk aus +
network_proxyein: Der Netzwerkzugriff bleibt deaktiviert. Die Funktion hat keine Wirkung. - Netzwerk ein +
network_proxyaus: Der Netzwerkzugriff bleibt aktiviert. Direkte ausgehende Verbindungen sind uneingeschränkt möglich. - Netzwerk ein +
network_proxyein: Der Netzwerkzugriff bleibt aktiviert. Die konfigurierte Netzwerkrichtlinie beschränkt den ausgehenden Datenverkehr.
Die Proxy-Funktion gilt auch für Berechtigungsprofile. Die Einstellung network.enabled = true in einem Profil gewährt Befehlen Netzwerkzugriff. Mit features.network_proxy = true setzt der Proxy die Domainregeln dieses Profils durch:
default_permissions = "project-edit"
[features]
network_proxy = true
[permissions.project-edit]
extends = ":workspace"
[permissions.project-edit.network]
enabled = true
[permissions.project-edit.network.domains]
"api.openai.com" = "allow"
Wenn du die Proxy-Funktion in diesem Beispiel weglässt, haben Befehle direkten Netzwerkzugriff. Die Zulassungsregel für api.openai.com schränkt die erreichbaren Ziele dann nicht ein.
Die zentral verwalteten Anforderungen für experimental_network gelten unabhängig davon, ob du die Funktion selbst aktivierst. Über diese Anforderungen lässt sich der Netzwerkzugriff innerhalb der Sandbox auch ohne features.network_proxy konfigurieren und starten. Sie aktivieren jedoch keinen Netzwerkzugriff, wenn die aktive Sandbox ihn deaktiviert. Unter Verwaltete Konfiguration findest du den Aufbau der requirements.toml für die Administration.
Netzwerkrichtlinie
Domainregeln lassen nur ausdrücklich zugelassene Ziele zu:
- Ein exakt angegebener Hostname gilt nur für diesen Host.
*.example.comerfasst Subdomains wieapi.example.com, aber nichtexample.com.**.example.comerfasst sowohl die Stammdomain als auch ihre Subdomains.- Eine globale Zulassungsregel mit
*erfasst jeden öffentlichen Host, der nicht gesperrt ist. Mit*gewährst du weitreichenden Netzwerkzugriff. Verwende nach Möglichkeit enger gefasste Regeln. denyhat immer Vorrang vorallow. Das globale*ist nur in Zulassungsregeln gültig.
Lokale und private Ziele
Standardmäßig blockiert allow_local_binding = false Loopback-Adressen, linklokale Adressen und private Ziele:
- Gezielte Ausnahmen: Wenn ein Befehl ein bestimmtes lokales Ziel erreichen muss, füge eine Zulassungsregel mit der exakten lokalen IP-Adresse oder mit
localhosthinzu. - Erweiterter Zugriff: Setze
allow_local_binding = truenur, wenn du bewusst mehr lokale oder private Ziele zulassen möchtest. - Platzhalter: Regeln mit Platzhaltern gelten nicht als explizite Ausnahmen für lokale Ziele.
- Aufgelöste Adressen: Hostnamen, die zu lokalen oder privaten IP-Adressen aufgelöst werden, bleiben auch dann gesperrt, wenn sie einer Zulassungsregel entsprechen.
Schutz vor DNS-Rebinding
Bevor Codex einen Hostnamen zulässt, prüft es nach Möglichkeit die DNS-Auflösung und die Klassifizierung der IP-Adressen:
- Schlägt die DNS-Abfrage fehl oder überschreitet sie das Zeitlimit, wird der Zugriff blockiert.
- Hostnamen, die zu nicht öffentlichen Adressen aufgelöst werden, werden blockiert.
- Die Prüfung verringert das Risiko von DNS-Rebinding. Um es vollständig auszuschließen, müssten die aufgelösten IP-Adressen bis in die Transportschicht fest gebunden bleiben.
Wenn manipulierte DNS-Antworten zu deinem Bedrohungsmodell gehören, beschränke ausgehende Verbindungen auch auf einer tieferen Netzwerkschicht.
Gefährliche Einstellungen
Mit zwei Einstellungen lässt sich die Vertrauensgrenze gezielt erweitern:
dangerously_allow_non_loopback_proxy = truekann Proxy-Listener auch außerhalb der Loopback-Schnittstelle erreichbar machen.dangerously_allow_all_unix_sockets = trueumgeht die Zulassungsliste für Unix-Sockets.
Verwende diese Einstellungen nur in streng kontrollierten Umgebungen. Wenn der Proxy Unix-Sockets vermittelt, sind Listener ausschließlich über Loopback erreichbar, selbst wenn eine Bindung an eine andere Schnittstelle angefordert wurde. So entsteht über das Netzwerk der Sandbox kein Fernzugriff auf lokale Daemons.
network_proxy ist standardmäßig deaktiviert. Wenn du die Funktion aktivierst, gilt Folgendes:
| Einstellung | Standardwert | Verhalten |
|---|---|---|
enabled |
false |
Startet die Netzwerkfunktion der Sandbox nur, wenn der Netzwerkzugriff für Befehle bereits aktiviert ist. |
domains |
nicht gesetzt | Verwendet eine Zulassungsliste. Externe Ziele bleiben gesperrt, bis du allow-Regeln hinzufügst. Unterstützt exakte Hostnamen, auf bestimmte Domains beschränkte Platzhalter und globale Zulassungsregeln mit *. deny hat immer Vorrang. |
unix_sockets |
nicht gesetzt | Ziele für Unix-Sockets bleiben gesperrt, bis du explizite allow-Regeln hinzufügst. |
allow_local_binding |
false |
Blockiert standardmäßig lokale Ziele und Ziele in privaten Netzen. Für ein einzelnes Ziel kannst du eine Zulassungsregel mit der exakten lokalen IP-Adresse oder mit localhost hinzufügen. Du kannst den Zugriff auf lokale und private Ziele auch ausdrücklich erweitern. |
enable_socks5 |
true |
Stellt SOCKS5 bereit, wenn die Richtlinie dies zulässt. |
enable_socks5_udp |
true |
Erlaubt UDP über SOCKS5, wenn SOCKS5 verfügbar ist. |
allow_upstream_proxy |
true |
Ermöglicht der Sandbox, einen in der Umgebung konfigurierten vorgeschalteten Proxy zu verwenden. |
dangerously_allow_non_loopback_proxy |
false |
Beschränkt Listener-Endpunkte auf Loopback, sofern du sie nicht bewusst über localhost hinaus zugänglich machst. |
dangerously_allow_all_unix_sockets |
false |
Beschränkt den Zugriff auf Unix-Sockets anhand der Zulassungsliste, sofern du diesen Schutz nicht bewusst umgehst. |
Datenverkehr außerhalb des Netzwerkproxys für Befehle
Der Netzwerkproxy filtert den Datenverkehr von Skripten, Programmen und Kindprozessen, die in der lokalen Befehls-Sandbox laufen. Er filtert weder die Websuche noch Tool-Aufrufe von Apps oder Konnektoren, Verbindungen zu MCP-Servern, Browseraktivitäten, die Computernutzung, Cloud-Aufgaben von Codex oder Modell- und Authentifizierungsanfragen des Clients. Diese Funktionen nutzen eigene Dienstverbindungen. Für sie gelten separate Funktionseinstellungen, Workspace-Richtlinien oder Umgebungseinstellungen.
Browser-Tools prüfen vor dem Zugriff auf einen Origin separat die verwalteten Sperrregeln und exklusiven Zulassungslisten. Richtlinien für Browser-Origins können den Zugriff auf Websites, Uploads, Downloads und Entwicklertools weiter einschränken. Weitere Informationen findest du unter Verwaltete Browsereinstellungen.
Kombiniere für verwaltete Konten die Netzwerkrichtlinie für Befehle mit Einstellungen wie allowed_web_search_modes, zugelassenen mcp_servers und Funktionsanforderungen für Apps, Plug-ins, Browser oder die Computernutzung. Weitere Informationen findest du unter Verwaltete Konfiguration.
Du kannst auch das Tool für die Websuche steuern, ohne den gestarteten Befehlen uneingeschränkten Netzwerkzugriff zu gewähren. Standardmäßig ruft Codex Suchergebnisse aus einem Cache ab. Dieser Cache ist ein von OpenAI gepflegter Index. Im Cache-Modus erhältst du daher bereits indexierte Ergebnisse, ohne dass Codex Seiten live abruft. Das verringert das Risiko einer Prompt Injection durch beliebige Live-Inhalte. Behandle Web-Ergebnisse als nicht vertrauenswürdig. Wenn du --yolo oder eine andere Sandbox-Einstellung mit Vollzugriff verwendest, liefert die Websuche standardmäßig Live-Ergebnisse. Verwende --search oder setze web_search = "live", um Live-Zugriff zuzulassen. Mit "disabled" schaltest du das Tool aus:
web_search = "cached" # default
# web_search = "disabled"
# web_search = "live" # same as --search
Setze web_search = "indexed", wenn der Suchindex den Zugriff auf externe Webinhalte begrenzen soll. Aktiviere den Netzwerkzugriff oder die Websuche in Codex mit Bedacht. Durch Prompt Injection kann der Agent dazu gebracht werden, nicht vertrauenswürdige Anweisungen abzurufen und zu befolgen.
Standardeinstellungen und Empfehlungen
- Beim Start erkennt Codex, ob der Ordner unter Versionskontrolle steht, und empfiehlt folgende Einstellungen:
- Ordner unter Versionskontrolle:
Auto(Schreibzugriff im Arbeitsbereich und Genehmigungen auf Anfrage) - Ordner ohne Versionskontrolle:
read-only
- Ordner unter Versionskontrolle:
- Je nach Konfiguration startet Codex möglicherweise auch im Modus
read-only, bis du das Arbeitsverzeichnis ausdrücklich als vertrauenswürdig einstufst, etwa bei der ersten Einrichtung oder über/permissions. - Der Arbeitsbereich umfasst das aktuelle Verzeichnis und temporäre Verzeichnisse wie
/tmp. Mit dem Befehl/statussiehst du, welche Verzeichnisse zum Arbeitsbereich gehören. - Wenn du die Standardeinstellungen übernehmen möchtest, führe
codexaus. - Du kannst die Einstellungen auch explizit angeben:
codex --sandbox workspace-write --ask-for-approval on-requestcodex --sandbox read-only --ask-for-approval on-request
Geschützte Pfade in beschreibbaren Stammverzeichnissen
Bei der standardmäßigen Sandbox-Richtlinie workspace-write sind bestimmte Pfade auch in beschreibbaren Stammverzeichnissen geschützt:
- Auf
<writable_root>/.gitist nur Lesezugriff möglich, unabhängig davon, ob es sich um ein Verzeichnis oder eine Datei handelt. - Wenn
<writable_root>/.giteine Verweisdatei ist (gitdir: ...), ist auch auf das Git-Verzeichnis, auf das sie verweist, nur Lesezugriff möglich. - Auf
<writable_root>/.agentsist nur Lesezugriff möglich, wenn der Pfad als Verzeichnis existiert. - Auf
<writable_root>/.codexist nur Lesezugriff möglich, wenn der Pfad als Verzeichnis existiert. - Auf
<writable_root>/.awsist nur Lesezugriff möglich, wenn der Pfad als Verzeichnis existiert. - Der Schutz gilt rekursiv. Auch auf alle untergeordneten Pfade ist nur Lesezugriff möglich.
Ohne Genehmigungsanfragen ausführen
Mit --ask-for-approval never oder der Kurzform -a never kannst du Genehmigungsanfragen deaktivieren.
Diese Option funktioniert mit allen --sandbox-Modi. Du legst also weiterhin fest, wie eigenständig Codex handeln darf. Codex versucht, die Aufgabe innerhalb der von dir gesetzten Grenzen auszuführen.
Wenn Codex ohne Genehmigungsanfragen Dateien lesen, Änderungen vornehmen und Befehle mit Netzwerkzugriff ausführen soll, verwende --sandbox danger-full-access (oder das Flag --dangerously-bypass-approvals-and-sandbox). Prüfe vorher sorgfältig, ob du diesen Zugriff gewähren möchtest.
Mit approval_policy = { granular = { ... } } kannst du einzelne Kategorien von Genehmigungsanfragen weiterhin interaktiv bearbeiten und andere automatisch ablehnen. Die granulare Richtlinie umfasst Sandbox-Genehmigungen, Anfragen aufgrund von Ausführungsregeln, MCP-Anfragen, request_permissions-Anfragen und Genehmigungen für Skill-Skripte.
Automatische Überprüfung von Genehmigungsanfragen
Standardmäßig gehen Genehmigungsanfragen an dich:
approvals_reviewer = "user"
Die Funktion „Automatische Überprüfung“ greift bei interaktiven Genehmigungen, etwa mit approval_policy = "on-request" oder einer granularen Genehmigungsrichtlinie. Setze approvals_reviewer = "auto_review", damit ein Prüfagent geeignete Genehmigungsanfragen bewertet, bevor Codex die angeforderte Aktion ausführt.
approval_policy = "on-request"
approvals_reviewer = "auto_review"
Den vollständigen Prüfablauf, die Auslöser, die Rangfolge der Konfigurationseinstellungen und das Verhalten bei Fehlern findest du unter Automatische Überprüfung.
Der Prüfagent bewertet nur Aktionen, die bereits eine Genehmigung erfordern. Dazu gehören etwa die Erweiterung von Sandbox-Berechtigungen, genehmigungspflichtige Netzwerkanfragen, request_permissions-Anfragen sowie genehmigungspflichtige Tool-Aufrufe von Apps oder über MCP. Eine Befehlsregel kann auch innerhalb der Sandbox eine Überprüfung verlangen.
Der Prüfagent prüft anhand seiner Richtlinie, ob eine Aktion Daten abzieht, Zugangsdaten ausspäht, Sicherheitsvorkehrungen dauerhaft schwächt oder destruktiv ist. Aktionen mit geringem oder mittlerem Risiko können ausgeführt werden, wenn die Richtlinie sie zulässt. Aktionen mit kritischem Risiko lehnt die Richtlinie ab. Bei hohem Risiko musst du die Aktion in ausreichendem Umfang autorisiert haben und es darf keine Sperrregel greifen. Bei Fehlern beim Erstellen des Prompts, in der Prüfsitzung oder beim Parsen bleibt die Aktion blockiert. Zeitüberschreitungen werden gesondert angezeigt. Auch dann wird die Aktion nicht ausgeführt.
Wie du die Richtlinie lokal oder organisationsweit ersetzt, erfährst du unter Automatische Überprüfung konfigurieren.
In der ChatGPT-Desktop-App erscheinen diese Prüfungen als Einträge der Funktion „Automatische Überprüfung“. Der Status gibt zum Beispiel an, ob die Prüfung läuft, die Anfrage genehmigt oder abgelehnt wurde, die Prüfung abgebrochen wurde oder das Zeitlimit abgelaufen ist. Ein Eintrag kann auch die Risikostufe und eine Einschätzung dazu enthalten, inwieweit du die angeforderte Aktion autorisiert hast.
Die Funktion „Automatische Überprüfung“ nutzt zusätzliche Modellaufrufe und kann dadurch deine Codex-Nutzung erhöhen. Die Administration kann sie über allowed_approvals_reviewers einschränken.
Gängige Kombinationen aus Sandbox-Modus und Genehmigungsrichtlinie
| Zweck | Flags oder Konfiguration | Wirkung |
|---|---|---|
| Auto (Voreinstellung) | keine Flags erforderlich oder --sandbox workspace-write --ask-for-approval on-request |
Codex kann im Arbeitsbereich Dateien lesen, Änderungen vornehmen und Befehle ausführen. Für Änderungen außerhalb des Arbeitsbereichs und für Netzwerkzugriff benötigt Codex eine Genehmigung. |
| Sicheres Erkunden ohne Schreibzugriff | --sandbox read-only --ask-for-approval on-request |
Codex kann in der Sandbox ohne Schreibzugriff Dateien lesen und Befehle ausführen. Aktionen außerhalb der Sandbox können eine Genehmigung erfordern. |
| Nicht interaktiv und ohne Schreibzugriff (CI) | --sandbox read-only --ask-for-approval never |
Codex kann in der Sandbox ohne Schreibzugriff Dateien lesen und Befehle ausführen. Es fordert nie eine Genehmigung an. |
| Auto-Prüfmodus | --sandbox workspace-write --ask-for-approval on-request -c approvals_reviewer=auto_review oder approvals_reviewer = "auto_review" |
Es gelten dieselben Sandbox-Grenzen wie im Standardmodus mit Genehmigungen auf Anfrage. Geeignete Genehmigungsanfragen gehen an die Funktion „Automatische Überprüfung“, statt dir angezeigt zu werden. |
| Gefährlicher Vollzugriff | --dangerously-bypass-approvals-and-sandbox (Alias: --yolo) |
Erhöhtes Risiko Ohne Sandbox und ohne Genehmigungen (nicht empfohlen) |
Für nicht interaktive Ausführungen verwende codex exec --sandbox workspace-write.
Konfiguration in config.toml
Weitere Informationen zur Konfiguration findest du in den Grundlagen der Konfiguration, in der erweiterten Konfiguration und in der Konfigurationsreferenz.
# Interactive approvals with a read-only sandbox
approval_policy = "on-request"
sandbox_mode = "read-only"
allow_login_shell = false # optional hardening: disallow login shells for shell-based tools
# Optional: Allow network in workspace-write mode
[sandbox_workspace_write]
network_access = true
# Optional: granular approval policy
# approval_policy = { granular = {
# sandbox_approval = true,
# rules = true,
# mcp_elicitations = true,
# request_permissions = false,
# skill_approval = false
# } }
Du kannst Voreinstellungen auch als Profildateien speichern und anschließend mit codex --profile profile-name auswählen:
# ~/.codex/full_auto.config.toml
approval_policy = "on-request"
sandbox_mode = "workspace-write"
# ~/.codex/readonly_quiet.config.toml
approval_policy = "never"
sandbox_mode = "read-only"
Sandbox lokal testen
Mit den folgenden Befehlen der Codex CLI kannst du testen, wie sich ein Befehl in der Codex-Sandbox verhält:
# macOS
codex sandbox macos [--permissions-profile <name>] [--log-denials] [COMMAND]...
# Linux
codex sandbox linux [--permissions-profile <name>] [COMMAND]...
# Windows
codex sandbox windows [--permissions-profile <name>] [COMMAND]...
Der Befehl sandbox ist auch als codex debug verfügbar. Die plattformspezifischen Hilfsbefehle haben ebenfalls Aliasse, zum Beispiel codex sandbox seatbelt und codex sandbox landlock.
Sandbox auf Betriebssystemebene
Wie Codex die Sandbox-Grenzen durchsetzt, hängt von deinem Betriebssystem ab:
- macOS nutzt Seatbelt-Richtlinien und führt Befehle über
sandbox-execmit einem Profil (-p) aus, das deinem gewählten--sandbox-Modus entspricht. Wenn bei eingeschränktem Lesezugriff die Plattformvorgaben aktiv sind, ergänzt Codex eine gezielt zusammengestellte macOS-Richtlinie. So bleiben gängige Tools kompatibel, ohne dass Codex/Systempauschal freigibt. - Linux verwendet standardmäßig
bwrapzusammen mitseccomp. - Windows unterstützt MXC. Als ältere Ausweichlösungen stehen
elevatedundunelevatedzur Verfügung. Im Windows-Subsystem für Linux 2 (WSL2) verwendet Codex die Linux-Sandbox. Codex unterstützte WSL1 bis einschließlich Version0.114. Seit Version0.115nutzt die Linux-Sandboxbwrapund unterstützt WSL1 deshalb nicht mehr.
Die Codex IDE-Erweiterung für Windows unterstützt WSL2 direkt. Damit der Agent in WSL2 läuft, sobald es verfügbar ist, ergänze deine VS Code-Einstellungen wie folgt:
{
"chatgpt.runCodexInWindowsSubsystemForLinux": true
}
Dadurch gelten für Befehle, Genehmigungen und Dateisystemzugriffe der IDE-Erweiterung die Regeln der Linux-Sandbox, auch wenn Windows das Hostbetriebssystem ist. Weitere Informationen findest du im WSL-Leitfaden.
Wenn Gerät und Richtlinie MXC unterstützen, verwende unter Windows vorzugsweise MXC. Ergänze dafür in config.toml folgende Einstellung:
[features]
prefer_mxc = true
Behalte in windows.sandbox eine zulässige ältere Implementierung als Ausweichlösung bei. Details zur Konfiguration und zu den Grenzen der Kompatibilität findest du im Setup-Leitfaden für Windows.
Wenn du Linux in einer Containerumgebung wie Docker ausführst, funktioniert die Sandbox möglicherweise nicht. Das kann passieren, wenn die Host- oder Containerkonfiguration die benötigten Namespace-Operationen, die Ausführung von bwrap mit gesetztem setuid-Bit oder die erforderlichen seccomp-Operationen blockiert.
Konfiguriere deinen Docker-Container in diesem Fall so, dass er die erforderliche Isolation bietet. Führe dann codex innerhalb des Containers mit --sandbox danger-full-access (oder dem Flag --dangerously-bypass-approvals-and-sandbox) aus.
Codex in Dev Containers ausführen
Wenn dein Host die Linux-Sandbox nicht direkt ausführen kann oder deine Organisation standardmäßig in Containern entwickelt, kannst du Codex mit Dev Containers ausführen. Docker übernimmt dann die äußere Isolation. Das funktioniert mit Visual Studio Code Dev Containers und kompatiblen Tools.
Dev Containers bieten weitreichenden Schutz, können aber nicht jeden Angriff verhindern. Wenn du Codex im Container mit --sandbox danger-full-access oder --dangerously-bypass-approvals-and-sandbox ausführst, kann ein bösartiges Projekt alle im Container verfügbaren Daten abziehen, einschließlich deiner Codex-Zugangsdaten. Nutze diese Konfiguration nur mit vertrauenswürdigen Repositorys und überwache die Aktivitäten von Codex wie in jeder anderen Umgebung mit erweiterten Berechtigungen.
Wähle innerhalb des Containers einen der folgenden Modi:
- Lass die Linux-Sandbox von Codex aktiviert, wenn das Profil des Dev Containers die Berechtigungen gewährt, die
bwrapzum Erstellen der inneren Sandbox benötigt. - Wenn der Container selbst die Sicherheitsgrenze bilden soll, führe Codex darin mit
--sandbox danger-full-accessaus. Codex versucht dann nicht, eine zweite Sandbox einzurichten.
Versionskontrolle
Codex funktioniert am besten, wenn du mit Versionskontrolle arbeitest:
- Arbeite auf einem Feature-Branch und stelle mit
git statussicher, dass vor dem Delegieren keine offenen Änderungen vorliegen. So kannst du die Patches von Codex leichter von anderen Änderungen trennen und rückgängig machen. - Arbeite vorzugsweise mit Patches (zum Beispiel mit
git diff/git apply), statt versionierte Dateien direkt zu bearbeiten. Erstelle häufig Commits, damit du Änderungen in kleinen Schritten zurücknehmen kannst. - Prüfe Vorschläge von Codex wie jeden anderen Pull Request. Führe gezielte Prüfungen aus, sieh dir die Diffs an und dokumentiere Entscheidungen in den Commit-Nachrichten, damit sie später nachvollziehbar sind.
Überwachung und Telemetrie
Codex unterstützt die optionale Überwachung mit OpenTelemetry (OTel). Damit können Teams die Nutzung nachvollziehen, Probleme untersuchen und Compliance-Anforderungen erfüllen, ohne die lokalen Sicherheitsvorgaben zu lockern. Telemetrie ist standardmäßig deaktiviert. Aktiviere sie bei Bedarf explizit in deiner Konfiguration.
Überblick
- Codex deaktiviert den OTel-Export standardmäßig, damit lokale Ausführungen ohne externe Telemetriedienste auskommen.
- Bei aktiviertem Export gibt Codex strukturierte Protokollereignisse für Chats, API-Anfragen, Aktivitäten in SSE- und WebSocket-Streams, Benutzer-Prompts (standardmäßig ohne Inhalt), Genehmigungsentscheidungen für Tools und Tool-Ergebnisse aus.
- Codex kennzeichnet exportierte Ereignisse mit
service.name(Quelle), der CLI-Version und einer Umgebungskennung. So lässt sich der Datenverkehr aus Entwicklung, Staging und Produktion unterscheiden.
OTel aktivieren (optional)
Füge einen [otel]-Block in deine Codex-Konfiguration ein (in der Regel ~/.codex/config.toml). Wähle darin einen Exporter und lege fest, ob Codex Prompt-Texte protokollieren soll.
[otel]
environment = "staging" # dev | staging | prod
exporter = "none" # none | otlp-http | otlp-grpc
log_user_prompt = false # redact prompt text unless policy allows
- Mit
exporter = "none"bleibt die Instrumentierung aktiv, ohne Daten zu versenden. - Um Ereignisse an deinen eigenen Collector zu senden, wähle eine der folgenden Konfigurationen:
[otel]
exporter = { otlp-http = {
endpoint = "https://otel.example.com/v1/logs",
protocol = "binary",
headers = { "x-otlp-api-key" = "${OTLP_TOKEN}" }
}}
[otel]
exporter = { otlp-grpc = {
endpoint = "https://otel.example.com:4317",
headers = { "x-otlp-meta" = "abc123" }
}}
Codex bündelt Ereignisse und sendet beim Beenden die noch ausstehenden Daten. Es exportiert ausschließlich Telemetriedaten aus seinem OTel-Modul.
Ereigniskategorien
Typische Ereignisse sind:
codex.conversation_starts(Modell, Einstellungen für den Reasoning-Aufwand, Sandbox- und Genehmigungsrichtlinie)codex.api_request(Versuch, Status und Erfolg, Dauer und Fehlerdetails)codex.sse_event(Art des Stream-Ereignisses, Erfolg oder Fehler, Dauer sowie Anzahl der Token beiresponse.completed)codex.websocket_requestundcodex.websocket_event(Dauer der Anfrage sowie Art, Erfolg oder Fehler pro Nachricht)codex.user_prompt(Länge des Prompts, Inhalt nur bei explizit aktivierter Protokollierung)codex.tool_decision(genehmigt oder abgelehnt, Entscheidung durch Konfiguration oder Person)codex.tool_result(Dauer, Erfolg, Auszug aus der Ausgabe)
Zu den zugehörigen OTel-Metriken gehören codex.api_request, codex.sse_event, codex.websocket.request, codex.websocket.event und codex.tool.call. Für jede gibt es einen Zähler und ein Histogramm für die Dauer mit dem entsprechenden .duration_ms-Instrument.
Den vollständigen Ereigniskatalog und die Konfigurationsreferenz findest du in der Dokumentation zur Codex-Konfiguration auf GitHub.
Hinweise zu Sicherheit und Datenschutz
- Behalte
log_user_prompt = falsebei, sofern deine Richtlinie das Speichern von Prompt-Inhalten nicht ausdrücklich erlaubt. Prompts können Quellcode und sensible Daten enthalten. - Sende Telemetriedaten nur an Collector-Instanzen, die du kontrollierst. Lege Aufbewahrungsfristen und Zugriffsbeschränkungen entsprechend deinen Compliance-Anforderungen fest.
- Behandle Tool-Argumente und -Ausgaben als sensible Daten. Entferne oder maskiere sensible Inhalte nach Möglichkeit im Collector oder im SIEM.
- Prüfe die Einstellungen für die lokale Datenaufbewahrung (zum Beispiel
history.persistence/history.max_bytes), wenn Codex keine Sitzungsprotokolle unterCODEX_HOMEspeichern soll. Details findest du in der erweiterten Konfiguration und in der Konfigurationsreferenz. - Wenn du die CLI ohne Netzwerkzugriff ausführst, erreicht der OTel-Export deinen Collector nicht. Erlaube für den Export im Modus
workspace-writeden Netzwerkzugriff auf den OTel-Endpunkt oder exportiere aus Codex Cloud und nimm die Domain des Collectors in deine Zulassungsliste auf. - Prüfe die Ereignisse regelmäßig auf Änderungen an Genehmigungen oder der Sandbox sowie auf unerwartete Tool-Ausführungen.
OTel ist optional. Es ergänzt den Schutz durch die oben beschriebene Sandbox und die Genehmigungsrichtlinien und ersetzt diese Schutzmaßnahmen nicht.
Verwaltete Konfiguration
Wenn du einen Enterprise-Workspace verwaltest, kannst du die Sicherheitseinstellungen für Codex in der verwalteten Konfiguration festlegen. Dort findest du auch Details zum Setup und zu den Richtlinien.