Wenn du Codex einführst, legst du fest, auf welche Konten, Dateien und Dienste Codex zugreifen und welche Aktionen Codex ausführen darf. Dieser Praxisleitfaden zeigt dir, wie du diese Entscheidungen bei der Administration von Codex im Unternehmen umsetzt, die Konfiguration testest und erkennst, wo zusätzlicher Schutz nötig ist.
Mit diesen Sicherheitsempfehlungen kannst du Entwicklungsteams den Zugriff auf Codex geben, den sie für ihre Arbeit brauchen. Gleichzeitig verringerst du das Risiko unbeabsichtigter Änderungen, der Offenlegung sensibler Daten und der Veränderung der Schutzmaßnahmen selbst. Wähle Kontrollen, die zu deinen Arbeitsabläufen und Risikoanforderungen passen, mache dich mit ihren Grenzen vertraut und überprüfe ihre Wirkung in deiner Umgebung. Sie ergänzen die Maßnahmen, mit denen deine Organisation bereits Identitäten, Endgeräte, Netzwerke und Dienste schützt.
Du kannst mit einer konkreten Aufgabe beginnen, etwa die Anmeldung auf den Workspace deines Unternehmens zu beschränken. Du kannst auch von einem übergeordneten Ziel ausgehen, etwa Codex für die Entwicklung freizugeben und zugleich die Produktionsumgebung zu schützen.
Wähle den Einstieg, der zu deiner Aufgabe passt:
-
Konfigurationsanleitungen beschreiben einzelne Kontrollen. Sie zeigen, wie du diese einrichtest, überprüfst und zurücksetzt und wo ihre Grenzen liegen.
-
Kombinierte Anleitungen zeigen, wie du mehrere Kontrollen mit Schutzmaßnahmen für Identitätsverwaltung, Versionsverwaltung, Deployment und weitere Systeme kombinierst, um ein gemeinsames Sicherheitsziel zu erreichen.
Passe die Beispiele an deine Organisation an. Beachte zu jedem Konfigurationsbeispiel die Hinweise dazu, wo die Einstellungen hingehören, für welche Clients oder Umgebungen sie gelten und welche Zugriffe und Aktionen sie erfassen.
Teste die Konfiguration vor der breiteren Einführung auf einem Testgerät. Prüfe, ob ein vorgesehener Arbeitsablauf gelingt und eine bewusst eingeschränkte Aktion blockiert wird. Nutze die Ergebnisse, um die Konfiguration anzupassen und den Menschen, die Codex nutzen werden, die Grenzen zu erklären.
Den passenden Einstieg wählen
Über die Seitengliederung kannst du einen der folgenden Abschnitte öffnen.
| Dein Ziel | Einstieg |
|---|---|
| Eine bestimmte Kontrolle konfigurieren | Konfigurationsanleitungen |
| Codex für die Entwicklung freigeben und die Produktionsumgebung schützen | Codex für die Entwicklung freigeben und die Produktionsumgebung schützen |
| Das Risiko einer Veröffentlichung von internem Code verringern | Das Risiko einer Veröffentlichung von internem Code verringern |
| Verhindern, dass Codex die eigenen Schutzmaßnahmen verändert | Verhindern, dass Codex die eigenen Schutzmaßnahmen verändert |
Die kombinierten Anleitungen beschreiben für jedes Ziel die relevanten Kontrollen, externen Schutzmaßnahmen und Prüfschritte.
Erste Schritte
-
Erfasse, wo du Codex einsetzt: Desktop-App, CLI, IDE-Erweiterung, Codex Cloud, CI-Runner und Remote-Hosts.
-
Erprobe die Konfiguration vor der breiteren Einführung auf einem Testgerät.
-
Halte die niedrigste unterstützte Codex-Version fest. Zulassungslisten für Berechtigungsprofile setzen Codex 0.138.0 oder höher voraus.
-
Bewahre von jedem verwalteten Konfigurationspaket eine Kopie auf, damit du die vorherige Konfiguration wiederherstellen kannst.
-
Teste nach jeder Änderung einen erlaubten und einen bewusst blockierten Arbeitsablauf.
Verwaltete Anforderungen sind Einschränkungen, die die Administration durchsetzt. Verwaltete Standardwerte legen die Einstellungen beim Start fest. Nutze Anforderungen für unterstützte Einschränkungen bei Authentifizierung, Sandbox, Genehmigungen, MCP, Plugins, Hooks und Netzwerkzugriff. Authentifizierungsanforderungen musst du lokal oder über macOS-MDM verteilen. Über die Cloud verwaltete Anforderungen setzen sie nicht durch. Siehe Verwaltete Konfiguration und Konfigurationsreferenz.
Wo die Konfiguration hingehört
Passe diese Konfigurationsbeispiele an deine Organisation an, bevor du sie an eine Pilotgruppe verteilst. Die TOML-Blöcke enthalten Ausschnitte aus Richtlinien. Füge die benötigten Einstellungen in deine vorhandenen Dateien ein, ohne Tabellen doppelt anzulegen. Ersetze die Namen, Domains und Pfade aus den Beispielen. Die Prüfschritte beschreiben die Ergebnisse, die du in deiner Umgebung bestätigen solltest.
Wenn du Codex lokal einsetzt, kannst du verbindliche Anforderungen mit Administrationsrechten unter macOS und Linux in /etc/codex/requirements.toml bereitstellen, unter Windows in %ProgramData%\OpenAI\Codex\requirements.toml. Auf verwalteten macOS-Geräten lässt sich die Einstellung com.openai.codex:requirements_toml_base64 per MDM verteilen. Eine über die Cloud verwaltete Richtlinie kannst du auch in der Administrationskonsole unter Agentensicherheit konfigurieren. Wähle eine Richtlinie und die passende Umgebung oder das Betriebssystem aus und konfiguriere die Anforderungen. Schütze die Richtliniendatei und ihr übergeordnetes Verzeichnis vor Änderungen durch das Codex-Benutzerkonto. Einstellungen in einer regulären config.toml oder in den verwalteten Standardwerten legen Startwerte fest und erzwingen keine Anforderungen. Siehe Verwaltete Konfiguration und Agentensicherheit.
Konfigurationsanleitungen
Wähle die benötigte Kontrolle. In der jeweiligen Anleitung findest du die Konfiguration, die Prüfschritte, Hinweise zum Zurücksetzen und die Grenzen der Kontrolle. Hake die Punkte bei der Überprüfung ab. Wenn Browserspeicher verfügbar ist, speichert dieser Browser deinen Fortschritt.
| Kontrolle | Anleitung |
|---|---|
| Authentifizierung | Anmeldung auf den Unternehmens-Workspace beschränken |
| Laufzeitberechtigungen | Berechtigungsprofile und Vollzugriff einschränken |
| MCP-Server | Nur genehmigte MCP-Server zulassen |
| Überwachung und Audit | Codex-Aktivitäten überwachen |
| Netzwerkzugriff | Netzwerkziele einschränken |
| Dateien und Zugangsdaten | Geheimnisse und nicht benötigte Repositorys schützen |
| Sensible Befehle | Genehmigung für sensible Befehle verlangen |
Nutze diese Anleitung, wenn sich Mitarbeitende über den ChatGPT-Workspace deines Unternehmens bei Codex anmelden sollen und auf verwalteten Endgeräten weder persönliche ChatGPT-Konten noch die Authentifizierung per API-Schlüssel zulässig sind.
Ziel
Auf Geräten, die das Unternehmen verwaltet, akzeptiert Codex nur die Anmeldung über ChatGPT im ChatGPT-Workspace des Unternehmens.
Voraussetzungen
-
Die UUID des genehmigten Workspace in ChatGPT Enterprise.
-
Eine Möglichkeit, die verwaltete Codex-Konfiguration an Endgeräte zu verteilen.
-
Die Entscheidung, die Authentifizierung per API-Schlüssel auf verwalteten Endgeräten zu untersagen.
Konfigurieren
-
Hinterlege die UUID des genehmigten Workspace in deinem internen Konfigurations-Repository.
-
Ergänze in der lokalen
requirements.tomldie verbindlichen Authentifizierungsanforderungen:allowed_login_methods = ["chatgpt"] allowed_chatgpt_workspaces = ["00000000-0000-0000-0000-000000000000"]Der erste Schlüssel erlaubt nur die Authentifizierung über ChatGPT. Der zweite beschränkt die Anmeldung auf den genehmigten Workspace. Ersetze die Beispiel-UUID durch die UUID deines Workspace. Siehe Referenz für Anforderungen.
-
Verteile die Anforderungen über die lokale
requirements.tomloder als MDM-Anforderungen für macOS. Verwende die Pfade aus Wo die Konfiguration hingehört. Diese Authentifizierungsanforderungen greifen, bevor Codex Zugangsdaten lädt und die Cloud-Richtlinie abruft. In über die Cloud verwalteten Anforderungen ignoriert Codex sie. Schütze die Datei und ihr übergeordnetes Verzeichnis vor Änderungen durch Nutzende. Die Standardwerte im älteren Formatmanaged_config.tomlsetzen diese Einschränkung nicht durch. -
Melde während des Pilotbetriebs die Nutzenden ab oder entferne zuvor gespeicherte persönliche Codex-Sitzungen. Verlass dich nicht darauf, dass eine neue Richtlinie bestehende Sitzungen rückwirkend ungültig macht.
-
Kombiniere die Anmeldebeschränkung mit Workspace-Rollen und Zugriffsrechten für Gruppen. Die Authentifizierung bestimmt, welche Identität sich anmeldet. Die rollenbasierte Zugriffskontrolle (RBAC) bestimmt, welche Codex-Funktionen diese Identität nutzen darf. Siehe Authentifizierung.
Überprüfen
-
Melde dich von Codex ab.
-
Versuche, dich mit einem persönlichen ChatGPT-Konto anzumelden. Erwartetes Ergebnis: Die Anmeldung im persönlichen Workspace wird abgelehnt.
-
Versuche, dich per API-Schlüssel bei Codex anzumelden. Erwartetes Ergebnis: Die Anmeldung per API-Schlüssel wird abgelehnt.
-
Melde dich mit dem Unternehmenskonto im genehmigten Workspace an. Erwartetes Ergebnis: Die Anmeldung gelingt.
-
Starte die Desktop-App, die CLI und die IDE-Erweiterung neu und wiederhole die Prüfung.
Zurücksetzen
Stelle die vorherigen lokalen Authentifizierungsanforderungen wieder her und verteile das geprüfte Paket erneut.
Grenzen
Diese Kontrolle gilt für verwaltete Codex-Clients auf verwalteten Endgeräten. Wenn die Vorgabe lautet „Keine private Nutzung von Codex über Unternehmensressourcen“, ergänze sie durch Anwendungskontrollen auf den Endgeräten und eine Netzwerkrichtlinie.
Nutze diese Anleitung, wenn Entwicklungsteams ohne Schreibzugriff oder nur innerhalb des Workspace arbeiten sollen. Damit verhinderst du, dass sie Vollzugriff auswählen oder Genehmigungen und Sandboxing mit --yolo umgehen.
Ziel
Nutzende können nur genehmigte Profile ohne Schreibzugriff oder mit auf den Workspace beschränktem Zugriff auswählen.
danger-full-access,approval_policy = "never"und--yolostehen ihnen nicht zur Verfügung.
Konfigurieren
-
Definiere ein genehmigtes Workspace-Profil:
[permissions.corp-workspace] description = "Company workspace access with no unrestricted host access." extends = ":workspace" -
Setze die zulässigen Profile und Genehmigungsrichtlinien durch:
allowed_approval_policies = ["on-request", "untrusted"] allowed_approvals_reviewers = ["user"] default_permissions = "corp-workspace" [allowed_permission_profiles] ":read-only" = true "corp-workspace" = true ":danger-full-access" = falseDie Zulassungsliste ist abschließend. Profile, die fehlen oder auf false gesetzt sind, werden abgelehnt. Das gilt auch für Profile, die in künftigen Versionen hinzukommen. Siehe Konfigurationsreferenz.
-
Für ältere Clients, die noch
sandbox_modeverwenden, gelten folgende Einstellungen:allowed_approval_policies = ["on-request", "untrusted"] allowed_sandbox_modes = ["read-only", "workspace-write"] -
Verteile diese Einstellungen als verbindliche administrative Anforderungen. Eine von Nutzenden bearbeitbare Konfigurationsdatei reicht dafür nicht aus.
-
Wenn du später die automatische Überprüfung zulassen möchtest, teste sie zuerst und aktiviere sie dann gezielt. Die automatische Überprüfung ändert, wer eine Grenzüberschreitung prüft. Eine entfernte Grenze stellt sie nicht wieder her. Siehe Automatische Überprüfung.
Überprüfen
-
Öffne die Berechtigungsauswahl. Erwartetes Ergebnis: Vollzugriff ist nicht verfügbar oder wird abgelehnt.
-
Starte Codex mit
--dangerously-bypass-approvals-and-sandbox. Erwartetes Ergebnis: Codex verweigert den Start oder erzwingt ein kompatibles Profil. -
Starte Codex mit
--sandbox danger-full-access --ask-for-approval never. Erwartetes Ergebnis: Codex verweigert den Start. -
Führe eine gewöhnliche Aufgabe im Workspace aus. Erwartetes Ergebnis: Die Aufgabe gelingt. Aktionen, die über die festgelegten Grenzen hinausgehen, erfordern weiterhin eine Genehmigung.
Zurücksetzen
Stelle das vorherige Anforderungspaket wieder her. Halte uneingeschränkten Zugriff gesperrt, sofern dafür keine separat genehmigte Ausnahme vorliegt.
Grenzen
Diese Einstellungen kontrollieren die Laufzeitberechtigungen von Codex. Ein privilegiertes Betriebssystemkonto behält seine Rechte.
Nutze diese Anleitung, wenn deine Organisation festlegen und durchsetzen muss, welche MCP-Server Codex verwenden darf.
Einen Server zuzulassen und ihn zu konfigurieren sind zwei getrennte Schritte. Ein Eintrag in der Zulassungsliste erlaubt einen passenden Server, legt aber keine Serverkonfiguration an. Konfiguriere den Server separat mit dem passenden Namen, der passenden Identität und der erforderlichen Authentifizierung.
Ziel
Codex aktiviert nur MCP-Server, bei denen sowohl der konfigurierte Name als auch die konfigurierte Identität mit einem vom Unternehmen genehmigten Eintrag übereinstimmen.
Konfigurieren
-
Erfasse für jeden genehmigten Server die Zuständigkeit, den Zweck, das Transportverfahren, die genaue ausführbare Datei oder URL, die Authentifizierung, die Datenklassifizierung und die Tools mit Schreibzugriff.
-
Sperre zunächst alle Server. Eine leere verwaltete Tabelle deaktiviert alle MCP-Server:
[mcp_servers] -
Füge genehmigte HTTP-Server mit ihrer genauen URL hinzu:
[mcp_servers.internal_docs] identity = { url = "https://mcp.example.com/docs" } -
Füge genehmigte stdio-Server anhand der ausführbaren Datei und der Positionsargumente hinzu:
[mcp_servers.internal_build.identity] command = { executable = "/usr/local/bin/company-mcp", args = [ { match = "exact", value = "serve" }, { match = "prefix", value = "--workspace=" }, ] }Der strukturierte Abgleich prüft die ausführbare Datei sowie Anzahl und Reihenfolge der Argumente. Er schränkt
cwd,envundenv_varsnicht ein. Genehmige einen stdio-Server nur, wenn du seinen gesamten Startkontext kontrollierst. Schütze die ausführbare Datei und ihre Abhängigkeiten. Verhindere, dass nicht vertrauenswürdige Benutzer- oder Projektkonfigurationen ein Arbeitsverzeichnis oder eine Umgebung vorgeben, die das Verhalten des Servers verändern können. Wenn du diese Grenze nicht unabhängig durchsetzen kannst, erteile dem stdio-Server keine Genehmigung und verwende einen geprüften HTTP-Server. -
Füge die Identitäten der mit Plugins ausgelieferten MCP-Server separat unter
plugins.<plugin>.mcp_servers.<server>hinzu. -
Speichere die Zulassungsliste in einem Konfigurations-Repository mit Änderungsprüfung und verteile sie als verbindliche administrative Anforderungen.
Der Client aktiviert einen Server nur, wenn sowohl sein Name als auch seine Identität mit einem genehmigten Eintrag übereinstimmen. Siehe Verwaltete Konfiguration.
Überprüfen
-
Konfiguriere den genehmigten Server exakt wie vorgegeben. Erwartetes Ergebnis: Der Server startet.
-
Ändere ein Zeichen in der URL. Erwartetes Ergebnis: Der Server wird deaktiviert.
-
Ändere Anzahl oder Reihenfolge der stdio-Argumente oder übergib ein Argument, das die konfigurierten Regeln verletzt. Erwartetes Ergebnis: Der Server wird deaktiviert. Werte, die weiterhin einem zulässigen Präfix entsprechen, bleiben erlaubt.
-
Probiere in einem temporären, vertrauenswürdigen Testprojekt harmlose Änderungen an
cwd,envundenv_varsaus. Behalte dabei die passende ausführbare Datei und die Argumente bei. Der Identitätsabgleich allein lehnt diese Änderungen nicht ab. Prüfe, ob deine unabhängige Kontrolle des Startkontexts unsichere Änderungen ablehnt oder der stdio-Server weiterhin nicht genehmigt ist. Verwende keinen echten Angriffscode. -
Füge einen nicht genehmigten Namen hinzu. Erwartetes Ergebnis: Der Server wird deaktiviert.
-
Teste einen Server, den ein Plugin mitliefert. Erwartetes Ergebnis: Der Server funktioniert nur mit der genehmigten Identität.
Zurücksetzen
Entferne den neu hinzugefügten Eintrag. Um die gesamte MCP-Nutzung sofort zu unterbinden, verteile eine leere mcp_servers-Tabelle.
Grenzen
Eine Zulassungsliste für Identitäten belegt nicht, dass die Tools eines Servers, seine vorgelagerten Datenquellen, seine Zugangsdaten oder seine Startumgebung sicher sind. Lokale stdio-MCP-Prozesse laufen außerhalb der lokalen Befehls-Sandbox. Der Abgleich der ausführbaren Datei und ihrer Argumente beschränkt den Zugriff des Servers nicht und verhindert auch nicht, dass der Server über seine Umgebung Code lädt. Prüfe den gesamten Startkontext und die Serverberechtigungen unabhängig. Siehe Anforderungen an MCP-Identitäten.
Nutze diese Anleitung, wenn dein Sicherheitsteam nachvollziehen muss, was Codex auf Endgeräten und in deinem Netzwerk tut. Für Untersuchungen führst du Ereignisse zu Ausführungen und Tool-Aufrufen, Genehmigungsentscheidungen, Auditdaten aus dem Workspace und Netzwerkprotokolle zusammen.
Ziel
Sicherheitsteams können Codex-Ausführungen, Entscheidungen zu Tool-Aufrufen, Genehmigungen, Auditdaten aus dem Workspace und den tatsächlichen ausgehenden Netzwerkverkehr miteinander in Beziehung setzen, ohne sich auf die Darstellung des Modells zu verlassen.
Vier Datenquellen nutzen
-
Codex OpenTelemetry erfasst Ereignisse zu Ausführungen, API, Modell, Sandbox, Genehmigungen und Tools.
-
Verwaltete Lebenszyklus-Hooks erfassen auf dem Endgerät Vorgänge rund um Tool-Aufrufe und Berechtigungsanfragen.
-
Protokolle von Netzwerk-Proxys oder Gateways zeigen tatsächliche DNS- und HTTP-Ziele sowie das Ergebnis der Verbindungsversuche.
-
Die Compliance API liefert Audit- und Untersuchungsdaten auf Workspace-Ebene.
Keine dieser Quellen allein ermöglicht eine vollständige Netzwerküberwachung.
Konfigurieren
-
Sende die OpenTelemetry-Protokolle von Codex an deinen Collector, ohne die Prompts im Wortlaut zu erfassen:
[otel] environment = "enterprise" log_user_prompt = false [otel.exporter.otlp-http] endpoint = "https://otel.example.com/v1/logs" protocol = "binary" headers = { "x-otlp-api-key" = "${OTLP_TOKEN}" }Stelle dem Codex-Prozess
OTLP_TOKENvor dem Start des Clients über deine genehmigte Geheimnisverwaltung oder die Prozessumgebung bereit. Speichere das Token weder in verteilten TOML-Dateien noch in der Versionsverwaltung.Codex kann den Beginn von Unterhaltungen, API-Anfragen, Streaming-Ereignisse, Prompt-Metadaten, Entscheidungen zu Tool-Aufrufen und Tool-Ergebnisse melden. Siehe Erweiterte Konfiguration.
-
Stelle OTel außerhalb der lokalen Projektkonfiguration bereit. Projektdateien vom Typ
.codex/config.tomlkönnen das Ziel der Telemetriedaten nicht überschreiben. -
Ergänze verwaltete Lebenszyklus-Hooks für
SessionStart,PreToolUse,PermissionRequest,PostToolUse,StopundSessionEnd. -
Installiere die Hook-Skripte in einem administrativ verwalteten Verzeichnis. Setze
allow_managed_hooks_only = true, wenn Codex Benutzer-, Projekt- und Plugin-Hooks ignorieren soll. -
Leite den Netzwerkverkehr von Befehlen in der Sandbox über einen Proxy mit eigener Protokollierung. OTel erfasst, dass ein Tool ausgeführt wurde. Der Proxy erfasst, zu welchem Ziel der Unterprozess eine Verbindung aufzubauen versucht hat.
-
Konfiguriere separate Telemetrie für Websuche, Apps, Konnektoren, MCP-Server, Browseraktivitäten und Codex Cloud. Die Proxyregeln für lokale Befehle erfassen diese nicht automatisch.
-
Übertrage unterstützte Datensätze der Compliance API fortlaufend an das SIEM. Wende deine eigenen Vorgaben zur Aufbewahrung und zur Sicherung von Daten für rechtliche Verfahren an. Siehe Compliance API und Audit-Ereignisse.
-
Verknüpfe Benutzer- oder Dienstkonto, Host oder Runner, Unterhaltungs-ID, Modell, Clientversion, Berechtigungsprofil, Genehmigungsentscheidung, Ziel und Tool-Namen miteinander.
Überprüfen
Führe eine kontrollierte Codex-Sitzung mit folgenden Schritten durch:
-
Lass Codex eine zulässige Datei lesen.
-
Lass Codex versuchen, eine gesperrte Datei zu lesen.
-
Lass Codex einen zulässigen Befehl ausführen.
-
Lass Codex versuchen, eine gesperrte ausgehende Netzwerkanfrage zu senden.
-
Lass Codex eine Genehmigung anfordern und stelle sicher, dass die Anfrage abgelehnt wird.
-
Beende die Sitzung.
Erwartete Ergebnisse je Datenquelle:
-
OTel zeigt Ereignisse zu Ausführungen und Tool-Aufrufen.
-
Die Hooks bilden den Lebenszyklus der Sitzung ab.
-
Die Proxyprotokolle zeigen erlaubte und blockierte Ziele.
-
Die Datenerfassung für Compliance empfängt die unterstützten Datensätze.
-
Das SIEM ordnet diese Datensätze dem Benutzerkonto oder der Workload zu.
Zurücksetzen
Stelle die vorherige Konfiguration wieder her, um den Exporter und die Hooks zu deaktivieren. Behalte beim Zurücksetzen der Telemetrie die unabhängige Proxyprotokollierung bei.
Grenzen
Sichere nicht zu, dass die Codex-Telemetrie jedes Befehlsargument, jedes Ausgabebyte oder jedes Netzwerkpaket erfasst. Dokumentiere, was jede Ebene abdeckt.
Nutze diese Anleitung, wenn Codex keinen Internetzugriff haben oder nur genehmigte Ziele erreichen soll. Wähle je nach Umgebung das lokale oder das Cloud-Verfahren. Die jeweiligen Richtlinien haben unterschiedliche Geltungsbereiche.
Ziel
Je nach Konfiguration hat Codex keinen Internetzugriff oder erreicht nur genehmigte Domains. In Umgebungen von Codex Cloud (Legacy) kannst du zusätzlich die HTTP-Methoden einschränken.
Aktuelle Version von Codex Cloud konfigurieren
-
Erstelle separate Umgebungen für unterschiedliche Vertrauensstufen, etwa no-internet-review, approved-dependencies-build und cyber-lab.
-
Deaktiviere in der Umgebungskonfiguration die Optionen Gesamten öffentlichen Internetzugriff aktivieren und Paketmanager-Domains aktivieren.
-
Wenn öffentlicher Internetzugriff erforderlich ist, trage unter Zusätzlich erlaubte Domains die genauen genehmigten Hostnamen ein. Entferne HTTP-Geheimnisse, die nicht genehmigte öffentliche Ziele zulassen. Um den öffentlichen Internetzugriff außerhalb des VPN zu sperren, lass die Liste leer und entferne HTTP-Geheimnisse, die öffentliche Ziele zulassen.
-
Speichere die Konfiguration und teste die Dienste während des Setups. Veröffentliche die Umgebung oder veröffentliche sie erneut. Teste anschließend in einer neuen Aufgabe den Zugriff auf genehmigte und nicht genehmigte Ziele. Prüfe Setup-Skripte separat. Lege feste Versionen für Abhängigkeiten fest, bevorzuge genehmigte Spiegelserver und vermeide Downloads ungeprüfter ausführbarer Dateien.
Siehe Verbindungen zu Diensten herstellen. Die aktuelle Version von Codex Cloud bietet keine Auswahl der HTTP-Methoden wie in der Legacy-Version.
Codex Cloud (Legacy) konfigurieren
-
Lass den Internetzugriff des Agenten auf Aus, wenn er nicht erforderlich ist. In der Legacy-Version ist der Internetzugriff während der Agentenphase standardmäßig gesperrt. Setup-Skripte haben weiterhin Internetzugriff, um Abhängigkeiten zu installieren.
-
Wenn der Agent Internetzugriff benötigt, stelle ihn auf Ein und verwende eine eng begrenzte Zulassungsliste. Beginne mit Keine und füge die genauen Domains hinzu.
-
Erlaube für reine Download-Workflows nur
GET,HEADundOPTIONS. Dadurch werdenPOST,PUT,PATCH,DELETEund andere Methoden blockiert. Prüfe Setup-Skripte separat, da die Einschränkung für die Agentenphase nicht für deren Internetzugriff gilt.
Siehe Internetzugriff des Agenten in der Legacy-Version. Diese Voreinstellungen und Kontrollen für HTTP-Methoden gelten nur für die Legacy-Version von Codex Cloud.
Codex lokal konfigurieren
-
Definiere und wähle das genehmigte Netzwerkprofil in der administrativ verwalteten
requirements.tomlund beschränke die Auswahl auf dieses Profil:default_permissions = "corp-build" [allowed_permission_profiles] "corp-build" = true [permissions.corp-build] description = "Workspace access with approved dependency destinations." extends = ":workspace" [permissions.corp-build.network] enabled = true allow_local_binding = false [permissions.corp-build.network.domains] "registry.npmjs.org" = "allow" "pypi.org" = "allow" "files.pythonhosted.org" = "allow" -
Verteile das geprüfte Anforderungspaket wie in Verwaltete Konfiguration beschrieben. Ein benanntes Profil ist allein noch nicht aktiv.
default_permissionswählt es aus, und die Zulassungsliste verhindert die Auswahl anderer Profile. -
Aktiviere den administrativ verwalteten Proxy im selben Anforderungspaket, damit die Domainbeschränkungen greifen und Nutzende keine weiteren Domains zulassen können. Stelle den Proxy und das Profil mit Netzwerkzugriff gemeinsam bereit. Ohne aktiven Proxy gewährt ein solches Profil direkten Netzwerkzugriff, ohne seine Domainregeln durchzusetzen:
Achtung:
[experimental_network]ist experimentell und kann sich ändern. Prüfe die Funktion vor der breiteren Einführung mit jeder unterstützten lokalen Clientversion und auf jedem unterstützten Betriebssystem. Die Unterstützung für Windows ist eingeschränkt. Wende diese Richtlinie unter Windows erst an, nachdem du ihre Durchsetzung in deiner Umgebung getestet hast.[experimental_network] enabled = true managed_allowed_domains_only = true [experimental_network.domains] "registry.npmjs.org" = "allow" "pypi.org" = "allow" "files.pythonhosted.org" = "allow" -
Lass das Binden lokaler Ports deaktiviert, sofern der Arbeitsablauf es nicht erfordert. Konfiguriere den Zugriff auf private Netzwerkziele separat. Wenn du eine Domain zulässt, sind ihre privaten Adressen nicht automatisch genehmigt. Siehe Anforderungen an den Netzwerkzugriff.
-
Konfiguriere Websuche, Apps, MCP-Server, Browseraktivitäten und Codex Cloud separat. Lokale Sandbox-Regeln gelten dafür nicht.
Überprüfen
-
Sende eine Anfrage an eine genehmigte Domain und prüfe, ob sie erfolgreich ist.
-
Sende eine Anfrage an eine nicht genehmigte Domain und prüfe, ob sie blockiert wird.
-
Sende Anfragen an localhost, an eine private IP-Adresse und an einen Endpunkt für Cloud-Metadaten. Prüfe, ob jede Anfrage ohne ausdrückliche Genehmigung blockiert wird.
-
Versuche in Codex Cloud (Legacy), eine
POST-Anfrage an eine erlaubte Domain zu senden. Prüfe, ob die Anfrage blockiert wird, wenn nurGET,HEADundOPTIONSzulässig sind. -
Prüfe, ob die Proxy- oder Gateway-Protokolle sowohl erlaubte als auch abgelehnte Anfragen enthalten.
Zurücksetzen
Stelle den Internetzugriff der Umgebung wieder auf Aus oder stelle die vorherige Domainrichtlinie wieder her. Vermeide es, zu uneingeschränktem Internetzugriff zurückzukehren.
Grenzen
Eine genehmigte vollständige Aufhebung der Sandbox-Beschränkungen kann den lokalen Befehlsproxy umgehen. Teste gewöhnliche Befehle in der Sandbox und genehmigte Befehle mit erweiterten Rechten getrennt, bevor du dich auf die Beschränkung verlässt.
Auch eine erlaubte Domain kann Inhalte mit Prompt Injection, kompromittierte Pakete oder unsichere Dokumentation bereitstellen.
Nutze diese Anleitung, wenn Codex auf genehmigte Quellcodeverzeichnisse zugreifen soll, Geheimnisse, .env-Dateien, SSH-Schlüssel und nicht benötigte Repositorys aber unzugänglich bleiben sollen. Du schränkst den Dateizugriff ein und verringerst die Zahl der Umgebungsvariablen mit Zugangsdaten, die an gestartete Befehle weitergegeben werden.
Ziel
Codex kann in genehmigten Quellcodeverzeichnissen arbeiten. Gängige Dateien mit Geheimnissen sind vor Lesezugriffen geschützt, und Codex erbt nur eingeschränkt Umgebungsvariablen mit Zugangsdaten.
Konfigurieren
-
Definiere im Workspace-Profil Pfadmuster, für die der Lesezugriff gesperrt ist:
[permissions.corp-workspace] description = "Workspace edits with secret-bearing paths denied." extends = ":workspace" [permissions.corp-workspace.filesystem] glob_scan_max_depth = 6 [permissions.corp-workspace.filesystem.":workspace_roots"] "**/.env*" = "deny" "**/*.pem" = "deny" "**/*.p12" = "deny" "**/id_*" = "deny" "**/.aws/**" = "deny" "**/.kube/**" = "deny" -
Sperre zusätzlich die genauen Pfade bekannter Verzeichnisse mit Zugangsdaten, von Signaturschlüsseln, Produktionskonfigurationen und benachbarten Repositorys.
-
Beschränke in der systemweiten
/etc/codex/config.tomloder der benutzerspezifischen~/.codex/config.toml, welche Umgebungsvariablen an gestartete Befehle weitergegeben werden:[shell_environment_policy] inherit = "core" ignore_default_excludes = false [shell_environment_policy.filters] "AWS_*" = "exclude" "AZURE_*" = "exclude" "GITHUB_*" = "exclude" "*_TOKEN" = "exclude" "*_SECRET" = "exclude" "*_PASSWORD" = "exclude"Dies ist ein von Nutzenden konfigurierbarer Standardwert und keine verbindliche Anforderung. Er begrenzt die vererbten Variablen. Der Zugriff auf Dateien mit Zugangsdaten, Hilfsprogramme zur Authentifizierung, beim Shell-Start geladene Inhalte oder andere Identitäten bleibt möglich. Siehe Erweiterte Konfiguration.
-
Wähle in der administrativ verwalteten
requirements.tomldas eingeschränkte Profil aus und erlaube nur dieses Profil. Integrierte Profile übernehmen dessen Lesesperren für Dateien mit Geheimnissen nicht:default_permissions = "corp-workspace" [allowed_permission_profiles] "corp-workspace" = true ":danger-full-access" = false -
Lege fest, wie deine Cloud-Umgebung Zugangsdaten erhält:
- Verwende in der aktuellen Version von Codex Cloud HTTP-Geheimnisse für Zugangsdaten, die an einen erlaubten HTTPS-Dienst gesendet werden. Programme erhalten einen Platzhalter. Während des Setups und der Aufgaben ersetzt der Proxy diesen bei genehmigten Zielen auf Port 443 durch den tatsächlichen Wert. Die Zugangsdaten selbst landen weder in einem lokalen Prozess noch in einer Datei. Direkt gesetzte Umgebungsvariablen stehen Programmen zur Verfügung. Siehe Umgebungsvariablen und Netzwerkgeheimnisse.
- In Codex Cloud (Legacy) ermöglichen Geheimnisse die Authentifizierung während des Setups und werden vor der Agentenphase entfernt. Umgebungsvariablen bleiben für den gesamten Chat verfügbar. Siehe Cloud-Umgebungen der Legacy-Version.
-
Wenn sich der Agent authentifizieren muss, lass einen unabhängigen Vermittlungsdienst kurzlebige Zugangsdaten ausstellen, die nur für das genaue Ziel und die konkrete Aktion gelten. Siehe Empfohlene Konfiguration.
Überprüfen
Erstelle harmlose Testdateien:
.env.test
test-key.pem
.aws/credentials
.kube/configBitte Codex anschließend, folgende Aktionen auszuführen:
-
Eine normale Datei lesen.
-
Jede Testdatei lesen.
-
Rekursiv nach Geheimnissen suchen.
-
Die Umgebung der gestarteten Befehle ausgeben.
-
Ein benachbartes Repository lesen.
Erwartetes Ergebnis: Die normale Datei lässt sich lesen. Gesperrte Dateien und benachbarte Repositorys bleiben unzugänglich. Die ausgeschlossenen Variablen fehlen in der Befehlsumgebung.
Zurücksetzen
Stelle das vorherige Profil wieder her. Behalte beim Untersuchen fehlgeschlagener Arbeitsabläufe die Lesesperren für Dateien bei, von denen du zuverlässig weißt, dass sie Geheimnisse enthalten.
Grenzen
Dateisystemsperren entfernen keine Geheimnisse, die bereits in Prompts eingefügt, in lesbaren Quellcode eingecheckt, von Konnektoren zurückgegeben oder in für das Modell zugängliche Protokolle geschrieben wurden.
Nutze diese Anleitung, wenn Aktionen wie git push, Deployments, Datenbankmigrationen und Cloud-CLI-Befehle vor der Ausführung eine Genehmigung benötigen. Lege fest, welche Befehle eine Überprüfung erfordern und welche verboten sind. Konfiguriere anschließend die entsprechenden Regeln.
Ziel
Sensible Befehle warten zuverlässig auf eine Genehmigung oder werden gesperrt, selbst wenn das Modell sie für angemessen hält.
Konfigurieren
- Lege fest, welche Befehle eine Genehmigungsanfrage auslösen und welche verboten sind.
| Befehlsklasse | Entscheidung |
|---|---|
git push, git commit |
Genehmigung anfordern |
terraform apply |
Genehmigung anfordern |
kubectl apply/delete/patch |
Genehmigung anfordern |
| Datenbankmigrationen | Genehmigung anfordern |
| Destruktive Host-Befehle | Verboten |
-
Füge verbindliche administrative Befehlsregeln hinzu:
[rules] prefix_rules = [ { pattern = [{ token = "git" }, { any_of = ["push", "commit"] }], decision = "prompt", justification = "Require review before mutating shared Git state." }, { pattern = [{ token = "terraform" }, { token = "apply" }], decision = "prompt", justification = "Require review before infrastructure changes." }, { pattern = [{ token = "kubectl" }, { any_of = ["apply", "delete", "patch"] }], decision = "prompt", justification = "Require review before Kubernetes changes." }, { pattern = [{ token = "rm" }], decision = "forbidden", justification = "Destructive removal is not permitted in managed Codex workflows." }, ]Regeln in den Anforderungen können eine Genehmigungsanfrage verlangen oder einen Befehl verbieten. Sie können keinen Befehl erlauben. Siehe Verwaltete Konfiguration.
-
Ergänze bei Profilen mit hohem Risiko im selben
prefix_rules-Array einen Eintrag für Shell-Wrapper, wenn diese sensible Befehle verbergen könnten:{ pattern = [{ any_of = ["bash", "sh", "zsh"] }], decision = "prompt", justification = "Review shell wrappers that could obscure sensitive commands." },Dieser Eintrag löst viele Genehmigungsanfragen aus. Setze ihn gezielt ein.
-
Wenn eine Person die Befehle genehmigen muss, setze diese Einstellungen verbindlich durch:
allowed_approval_policies = ["on-request", "untrusted"] allowed_approvals_reviewers = ["user"]Die automatische Überprüfung ändert, wer die Prüfung übernimmt. Sie bietet keine deterministische Sicherheitsgarantie. Siehe Automatische Überprüfung.
-
Sende PermissionRequest-Ereignisse sowie Ereignisse zu Entscheidungen über Tool-Aufrufe und zu Tool-Ergebnissen an deine Sicherheitspipeline.
Überprüfen
-
Führe
git statusaus. Erwartetes Ergebnis: Es erscheint keine Genehmigungsanfrage. -
Führe
git pushaus. Erwartetes Ergebnis: Es erscheint eine Genehmigungsanfrage. -
Führe
terraform applyaus. Erwartetes Ergebnis: Es erscheint eine Genehmigungsanfrage. -
Führe
kubectl delete pod testaus. Erwartetes Ergebnis: Es erscheint eine Genehmigungsanfrage. -
Führe
rm -rf test-directoryaus. Erwartetes Ergebnis: Der Befehl ist verboten. -
Lehne eine Genehmigungsanfrage ab. Erwartetes Ergebnis: Der Befehl wird nicht ausgeführt und die Ablehnung wird protokolliert.
-
Starte den Client neu und wiederhole die Prüfung. Erwartetes Ergebnis: Die Regel wird weiterhin durchgesetzt.
Zurücksetzen
Stelle das vorherige Anforderungspaket wieder her. Grenze ein zu weit gefasstes Token-Muster ein, anstatt eine ganze Klasse sensibler Befehle aus den Regeln zu entfernen.
Grenzen
Präfixregeln decken nicht alle Richtlinien ab, die ein Betriebssystem durchsetzen kann. Kombiniere sie mit Sandboxing, Betriebssystemkonten mit minimalen Rechten, Netzwerkbeschränkungen, Cloud-IAM, Branch-Schutz, Deployment-Genehmigungen und Datenbankberechtigungen.
Kombinierte Anleitungen für Sicherheitsziele im Unternehmen
Diese Beispiele zeigen, wie du Kontrollen für typische Sicherheitsziele im Unternehmen kombinierst. Teste die Konfiguration auf jedem betroffenen Client und in jeder betroffenen Umgebung.
Verwendete Konfigurationsanleitungen: Berechtigungsprofile und Vollzugriff einschränken, Geheimnisse und nicht benötigte Repositorys schützen, Genehmigung für sensible Befehle verlangen.
Dein Entwicklungsteam hat berechtigten Zugriff auf die Produktionsumgebung. Codex soll bei der Entwicklung helfen, ohne ungeprüfte Änderungen an der Produktionsumgebung vorzunehmen.
-
Definiere ein genehmigtes Workspace-Profil und setze die zulässigen Profile und Genehmigungsrichtlinien durch. Verteile diese Einstellungen als verbindliche administrative Anforderungen, damit Nutzende sie nicht überschreiben können.
-
Führe Codex unter einer separaten Identität mit geringeren Rechten oder in einer Umgebung aus, die weder auf Zugangsdaten mit Schreibrechten für die Produktion zugreifen noch solche Zugangsdaten beziehen kann. Das Entwicklungsteam kann seinen Produktionszugriff über einen separaten autorisierten Arbeitsablauf behalten.
-
Beschränke die Zahl der Umgebungsvariablen, die an gestartete Befehle weitergegeben werden. Wenn sich der Agent authentifizieren muss, lass einen unabhängigen Vermittlungsdienst kurzlebige Zugangsdaten ausstellen, die nur für das genaue Ziel und die konkrete Aktion gelten.
-
Lege fest, welche Befehle eine Genehmigungsanfrage auslösen und welche verboten sind. Verlange für ausgewählte Befehle mit weitreichenden Auswirkungen eine Genehmigung durch eine Person, etwa für
git push,terraform apply, Kubernetes-Änderungen und Datenbankmigrationen. Verbiete Befehle, die unter keinen Umständen ausgeführt werden dürfen. -
Setze IAM-Regeln für die Produktion, Branch-Schutz und Deployment-Genehmigungen unabhängig von Codex durch.
Berechtigungsprofile einschränken und Prüfung durch eine Person verlangen
Erlaube in der administrativ verwalteten requirements.toml das integrierte Workspace-Profil und das integrierte Profil ohne Schreibzugriff. Verlange bei genehmigungspflichtigen Aktionen eine Prüfung durch die nutzende Person:
allowed_approval_policies = ["on-request"]
allowed_approvals_reviewers = ["user"]
default_permissions = ":workspace"
[allowed_permission_profiles]
":read-only" = true
":workspace" = trueDas Workspace-Profil erlaubt Arbeiten im Workspace innerhalb seiner Sandbox. Für Aufgaben mit geringerem Berechtigungsbedarf steht das Profil ohne Schreibzugriff zur Verfügung. Profile mit Vollzugriff stehen nicht auf der Zulassungsliste.
Setze approval_policy = "on-request" in der Clientkonfiguration, wenn der Client eine ausdrücklich festgelegte kompatible Einstellung benötigt. on-request ermöglicht bei Bedarf eine Genehmigungsanfrage, löst sie aber nicht bei jedem Befehl aus. Ergänze ausdrückliche Regeln für prüfpflichtige Aktionen und behalte die unabhängige Autorisierung für Produktionszugriffe bei.
Verwaltete Zulassungslisten für Profile setzen Codex 0.138.0 oder höher voraus. Verwende und teste für ältere Clients die dokumentierten Anforderungen für den bisherigen Sandbox-Modus.
Starte jeden Pilotclient neu. Prüfe, ob das genehmigte Profil funktioniert und ein unzulässiges Profil mit Vollzugriff abgelehnt wird.
Codex-Identität von Zugangsdaten für die Produktion trennen
Erstelle über die Geräteverwaltung oder das System zur Bereitstellung von Entwicklungsumgebungen ein eigenes Benutzerkonto, einen Container oder einen Entwicklungshost für Codex. Beschränke den Zugriff auf den benötigten Quellcode und die erforderlichen Entwicklungsdienste. Binde weder Dateien mit Produktionszugangsdaten des Entwicklungsteams noch dessen Token-Hilfsprogramme oder Schlüsselbunde in diese Umgebung ein. Verhindere, dass die Identität Rollen mit Schreibrechten für die Produktion übernehmen kann.
Wenn der Agent Zugriff auf einen Dienst benötigt, konfiguriere den Vermittlungsdienst für Zugangsdaten deiner Organisation so, dass er kurzlebige Zugangsdaten für die konkrete Entwicklungsressource und Aktion ausstellt. Für einen separaten autorisierten Arbeitsablauf in der Produktion können Mitglieder des Entwicklungsteams weiterhin ihre gewöhnliche Identität verwenden.
Öffne beispielsweise in AWS IAM Rollen, wähle die Entwicklungsrolle für Codex aus und füge unter Berechtigungen eine geprüfte Inline-Richtlinie wie die folgende hinzu. Ersetze Konto und Rolle durch deine eigenen Angaben:
{
"Version": "2012-10-17",
"Statement": [
{
"Sid": "DenyAssumeExampleProductionRole",
"Effect": "Deny",
"Action": "sts:AssumeRole",
"Resource": "arn:aws:iam::111122223333:role/ExampleProductionRole"
}
]
}Das Beispiel verhindert die Übernahme der genannten Rolle. Versuche, andere Rollen zu übernehmen, blockiert es nicht. Entferne auch direkte Produktionsberechtigungen, beschränke andere Produktionsrollen und Quellen für Zugangsdaten und prüfe Vertrauensrichtlinien sowie Kontrollen auf Organisationsebene.
Teste die Entwicklungsrolle anhand typischer Entwicklungs- und Produktionsberechtigungen, ohne die Produktionsumgebung zu verändern. Siehe Beispiele für Rollenrichtlinien in AWS IAM.
Shell-Umgebung auf das Nötige beschränken
Lege in /etc/codex/config.toml für eine systemweite Startkonfiguration oder in ~/.codex/config.toml für ein einzelnes Benutzerkonto fest, welche Umgebungsvariablen gestartete Befehle erben:
[shell_environment_policy]
inherit = "core"
ignore_default_excludes = false
[shell_environment_policy.filters]
"AWS_*" = "exclude"
"AZURE_*" = "exclude"
"GITHUB_*" = "exclude"
"*_TOKEN" = "exclude"
"*_SECRET" = "exclude"
"*_PASSWORD" = "exclude"Dies ist ein konfigurierbarer Standardwert. Er erzwingt keine Zugriffsbeschränkung für Zugangsdaten. Benutzereinstellungen, die Shell-Initialisierung oder Shell-Snapshots, Hilfsprogramme zur Authentifizierung und weitere Quellen können Zugangsdaten weiterhin zugänglich machen.
Mit den folgenden optionalen Einschränkungen in requirements.toml kannst du Login-Shells und Shell-Snapshots deaktivieren, sofern dein Arbeitsablauf dies zulässt:
allow_login_shell = false
[features]
shell_snapshot = falseErprobe diese Einstellungen im Pilotbetrieb, da einige Arbeitsabläufe auf die Initialisierung der Login-Shell angewiesen sind.
Starte Codex mit harmlosen synthetischen Variablen, die den Filtern entsprechen, und prüfe die Umgebung eines gestarteten Befehls. Prüfe außerdem, ob die Anforderung einer Login-Shell abgelehnt wird, wenn Login-Shells deaktiviert sind. Stelle unabhängig davon sicher, dass die ausführende Identität nicht auf echte Produktionszugangsdaten zugreifen kann. Siehe Richtlinie für die Shell-Umgebung.
Genehmigung für ausgewählte Befehle mit weitreichenden Auswirkungen anfordern
Ergänze die Anforderungen um Regeln für die Befehle, die deine Organisation verwendet. Beispiel:
[rules]
prefix_rules = [
{ pattern = [{ token = "git" }, { token = "push" }], decision = "prompt", justification = "Review Git pushes." },
{ pattern = [{ token = "terraform" }, { token = "apply" }], decision = "prompt", justification = "Review infrastructure changes." },
{ pattern = [{ token = "kubectl" }, { any_of = ["apply", "delete", "patch"] }], decision = "prompt", justification = "Review cluster changes." },
{ pattern = [{ token = "python3" }, { token = "manage.py" }, { token = "migrate" }], decision = "prompt", justification = "Review database migrations." },
]Verwende forbidden für einen Befehl, der niemals ausgeführt werden darf. Ersetze oder ergänze die Muster entsprechend den tatsächlich eingesetzten Deployment- und Migrationstools.
Diese Regeln gleichen Befehlspräfixe ab und erfassen nicht jede gleichwertige Aktion. Teste absolute Pfade, Wrapper, andere Argumentreihenfolgen, weitere Clients und andere Tools separat.
Führe auf einem temporären Testziel einen normalen Befehl aus, fordere eine aufgeführte Aktion an und lehne die Genehmigungsanfrage ab. Prüfe, ob die Aktion tatsächlich unterblieben ist. Siehe Befehlsregeln durchsetzen.
Genehmigungen für Repositorys und Deployments außerhalb von Codex durchsetzen
Schütze auf deiner Plattform für die Versionsverwaltung Produktions-Branches wie main. Verlange geprüfte Änderungen, die nötigen Genehmigungen und Statusprüfungen. Prüfe, welche Rollen diese Anforderungen umgehen können. Konfiguriere Deployment-Genehmigungen im zuständigen Deployment-System und Datenbankrechte in der Datenbank selbst.
Prüfe mit einem temporären Repository, ob eine geprüfte Änderung gelingt und ein unautorisierter direkter Push abgelehnt wird. Diese Kontrollen gelten unabhängig davon, ob eine Aktion über Codex angefordert wurde.
Überprüfen
Auf einem temporären Testziel:
-
Führe eine gewöhnliche Aufgabe im Workspace aus. Erwartetes Ergebnis: Die Aufgabe gelingt.
-
Versuche, einen typischen sensiblen Befehl auszuführen, und lehne die Genehmigungsanfrage ab. Erwartetes Ergebnis: Der abgelehnte Befehl wird nicht ausgeführt.
-
Stelle sicher, dass die Codex-Identität keine Schreibrechte für die Produktion erlangen kann.
-
Starte den Client neu und wiederhole die Prüfung.
Grenzen
Präfixregeln decken nicht alle Richtlinien ab, die ein Betriebssystem durchsetzen kann. Kombiniere sie mit Sandboxing, Betriebssystemkonten mit minimalen Rechten, Netzwerkbeschränkungen, Cloud-IAM, Branch-Schutz, Deployment-Genehmigungen und Datenbankberechtigungen.
Verwendete Konfigurationsanleitungen: Geheimnisse und nicht benötigte Repositorys schützen, Netzwerkziele einschränken, nur genehmigte MCP-Server zulassen, Genehmigung für sensible Befehle verlangen.
Dein Entwicklungsteam verwendet Codex mit internen Repositorys. Du möchtest das Risiko verringern, dass Code in einem öffentlichen Repository oder als öffentliches Code-Snippet landet oder an ein anderes nicht genehmigtes Ziel übertragen wird.
-
Sperre die genauen Pfade bekannter Verzeichnisse mit Zugangsdaten und nicht benötigter Repositorys. Beschränke die Zahl der Umgebungsvariablen, die an gestartete Befehle weitergegeben werden.
-
Wenn der Agent Internetzugriff benötigt, verwende eine eng begrenzte Liste genehmigter Domains. Erlaube bei MCP-Servern nur genehmigte Namen und Identitäten. Verlange für ausgewählte Befehle zur Veröffentlichung wie
git pusheine Prüfung oder verbiete sie. -
Nutze Hooks und Berechtigungen der Versionsverwaltung, Richtlinien für öffentliche Repositorys und Code-Snippets sowie Maßnahmen zur Verhinderung von Datenverlust, die zu deiner Organisation passen.
Zugriff auf nicht benötigte Repositorys und Dateien mit Zugangsdaten sperren
Ergänze in der administrativ verwalteten requirements.toml die genauen Pfade, die der lokale Agent nicht lesen darf:
[permissions.filesystem]
deny_read = ["~/.ssh", "~/.aws/credentials", "~/.kube/config", "/work/unrelated-repository"]Ersetze die Beispiele durch Pfade auf deinen verwalteten Geräten. Diese verwaltete Sperre gilt für alle zulässigen Berechtigungsprofile. Eine Sperre, die nur in einem benutzerdefinierten Profil konfiguriert ist, schützt nicht, wenn jemand ein anderes Profil auswählt. Bevorzuge genaue, bekannte Pfade. Teste Glob-Muster auf den benötigten Verzeichnistiefen.
Unter nativem Windows erfasst die verwaltete Einstellung deny_read direkte Dateizugriffe über Tools, verhindert allein aber keine Lesezugriffe durch Shell-Unterprozesse. Nutze zusätzlich Betriebssystemidentitäten und Zugriffssteuerungslisten für Dateien.
Lege harmlose Testdateien an den gesperrten Speicherorten an. Prüfe in jedem zulässigen Profil, ob direkte Lesezugriffe und Lesezugriffe über die Shell auf diese Dateien scheitern und sich eine genehmigte Quellcodedatei lesen lässt. Siehe Verwaltete Anforderungen für Lesesperren.
Shell-Variablen mit Zugangsdaten auf das Nötige beschränken
Lege in /etc/codex/config.toml oder ~/.codex/config.toml fest, dass nur wenige Umgebungsvariablen vererbt werden:
[shell_environment_policy]
inherit = "core"
ignore_default_excludes = false
[shell_environment_policy.filters]
"AWS_*" = "exclude"
"AZURE_*" = "exclude"
"GITHUB_*" = "exclude"
"*_TOKEN" = "exclude"
"*_SECRET" = "exclude"
"*_PASSWORD" = "exclude"Diese Einstellung begrenzt die vererbten Variablen. Nutzende können sie ändern. Sie verhindert keinen Zugriff auf Dateien mit Zugangsdaten, Hilfsprogramme zur Authentifizierung, beim Shell-Start geladene Inhalte oder andere Identitäten.
Bei Bedarf kannst du mit Administrationsrechten auch die folgenden Einschränkungen in requirements.toml ergänzen. Erprobe im Pilotbetrieb, wie sie sich auf die Arbeitsabläufe des Entwicklungsteams auswirken:
allow_login_shell = false
[features]
shell_snapshot = falseTeste mit synthetischen Testvariablen und einer separaten Ausführungsidentität mit minimalen Rechten. Verwende keine echten Zugangsdaten. Siehe Richtlinie für die Shell-Umgebung.
Für lokale Befehle nur genehmigte Netzwerkziele zulassen
Wenn lokale Befehle in der Sandbox Netzwerkzugriff benötigen, füge sowohl das folgende Profil als auch die Einstellungen für den verwalteten Proxy in requirements.toml ein. Ersetze die Domains durch genehmigte Endpunkte:
default_permissions = "corp_network"
[allowed_permission_profiles]
corp_network = true
[permissions.corp_network]
extends = ":workspace"
[permissions.corp_network.network]
enabled = true
[experimental_network]
enabled = true
managed_allowed_domains_only = true
[experimental_network.domains]
"git.corp.example" = "allow"
"registry.corp.example" = "allow"Das Profil mit Netzwerkzugriff ermöglicht dem Befehl in der Sandbox eine Netzwerkverbindung. Der verwaltete Proxy beschränkt die erreichbaren Ziele. Stelle beide gemeinsam bereit. Ohne den vorgesehenen verwalteten Proxy setzt das Profil nicht dieselben Zielbeschränkungen durch. Wenn kein Internetzugriff nötig ist, lass den Netzwerkzugriff deaktiviert.
Kombiniere die maßgebliche Tabelle domains nicht mit den älteren Einstellungen allowed_domains oder denied_domains. Migriere und teste die bestehende Richtlinie.
Starte den Client neu. Prüfe, ob ein genehmigter Endpunkt erreichbar ist und ein nicht genehmigter Endpunkt blockiert wird.
Diese Einstellungen sind experimentell. Prüfe, ob Betriebssystem und Client sie unterstützen. Konfiguriere den Zugriff auf private Netzwerke separat, wenn ein genehmigter Host zu einer privaten Adresse aufgelöst wird. Eine genehmigte vollständige Aufhebung der Sandbox-Beschränkungen kann den Befehlsproxy umgehen.
Diese Netzwerkkontrolle für lokale Befehle deckt Websuche, Apps, MCP-Server, Browseraktivitäten und Cloud-Umgebungen allein nicht ab. Dafür brauchst du separate Richtlinien. Auf einer genehmigten Hosting-Domain können auch öffentliche Repositorys oder öffentliche Code-Snippets liegen. Eine Zulassungsliste für Ziele allein schützt daher keine Inhalte. Siehe Anforderungen an den Netzwerkzugriff.
Netzwerkzugriff der Cloud-Umgebung separat konfigurieren
Öffne in der aktuellen Oberfläche von Codex Cloud die Umgebungskonfiguration. Deaktiviere Gesamten öffentlichen Internetzugriff aktivieren und Paketmanager-Domains aktivieren. Wenn öffentlicher Internetzugriff erforderlich ist, trage unter Zusätzlich erlaubte Domains die genauen genehmigten Hostnamen ein. Entferne HTTP-Geheimnisse, die nicht genehmigte öffentliche Ziele zulassen. Um den öffentlichen Internetzugriff außerhalb des VPN zu sperren, lass die Liste leer und entferne HTTP-Geheimnisse, die öffentliche Ziele zulassen. Speichere die Konfiguration, veröffentliche die Umgebung erstmals oder erneut und teste den Zugriff in einer neuen Aufgabe.
Prüfe die Authentifizierung und die Funktionen der Dienste unabhängig davon.
Die Legacy-Version von Codex Cloud hat für jede Umgebung eine separate Einstellung für den Internetzugriff des Agenten. Darüber lassen sich erlaubte Domains und HTTP-Methoden steuern. Für Setup-Skripte gelten eigene Zugriffsregeln.
Teste die Version der Umgebung, die du tatsächlich nutzt. Siehe Verbindungen zu Diensten herstellen und Interneteinstellungen der Legacy-Version.
MCP-Server einschränken und vor Git-Pushes eine Genehmigung anfordern
Erlaube in requirements.toml nur genehmigte Identitäten lokaler MCP-Server. Beispiel:
[mcp_servers.internal]
identity = { url = "https://mcp.corp.example/mcp" }Konfiguriere den Server selbst separat in der benutzerspezifischen config.toml oder der Variante für verwaltete Standardwerte. Verwende den passenden Namen, die passende URL und die vom Server benötigte Authentifizierung:
[mcp_servers.internal]
url = "https://mcp.corp.example/mcp"Die Anforderung erlaubt lediglich einen passenden Server und legt ihn nicht an. Prüfe die Zugriffsrechte und Tools des Servers selbst.
Prüfe, ob der genehmigte Server eine Verbindung herstellen kann und ein Server mit abweichendem Namen oder abweichender URL nicht zugelassen wird.
Ergänze eine verwaltete Befehlsregel, die vor einem typischen Veröffentlichungsbefehl eine Prüfung verlangt:
[rules]
prefix_rules = [
{ pattern = [{ token = "git" }, { token = "push" }], decision = "prompt", justification = "Review the destination before publishing." },
]Wenn eine Person die Prüfung übernehmen muss, ergänze allowed_approval_policies = ["on-request"] und allowed_approvals_reviewers = ["user"] als Anforderungen auf oberster Ebene.
Lehne einen Test-Push ab und prüfe, ob er tatsächlich unterbleibt.
Der Präfixabgleich erfasst nicht jeden Wrapper, jeden API-Client, jede App oder jeden anderen Weg zur Veröffentlichung.
Veröffentlichung über Versionsverwaltung und DLP einschränken
Beschränke auf deiner Plattform für die Versionsverwaltung das Anlegen öffentlicher Repositorys und lege fest, wer die Sichtbarkeit von Repositorys ändern darf, soweit die Plattform dies unterstützt. Prüfe, welche privilegierten Konten die Vorgaben umgehen dürfen. Prüfe persönliche Konten, Code-Snippets, externe Organisationen und den Zugriff per Token separat. Die Organisationseinstellungen gelten nicht für jedes Ziel.
Verlange im betreffenden Repository geprüfte Änderungen. Prüfe den Branch-Schutz und die Berechtigungen, mit denen er sich umgehen lässt.
Konfiguriere in der DLP-Konsole deiner Organisation eine Pilotrichtlinie für sensible Quellcodeinhalte und die Upload- oder Repository-Kanäle, die dein DLP-Produkt tatsächlich abdeckt. Lege als Aktion das Blockieren fest und teste die Richtlinie mit einer harmlosen synthetischen Markierung.
Wenn die Plattform für die Versionsverwaltung serverseitige Kontrollen unterstützt, konfiguriere geprüfte Hooks für Repositorys, die Pushes empfangen, und setze sie verbindlich durch.
Verwende autorisierte Testziele und prüfe vor jeder Veröffentlichung, ob die Sperre greift.
Überprüfen
-
Erstelle harmlose Testdateien und prüfe, ob Versuche scheitern, gesperrte Dateien zu lesen.
-
Prüfe bei aktiviertem Netzwerkzugriff, ob ein genehmigtes Ziel erreichbar ist und ein nicht genehmigtes Ziel blockiert wird. Prüfe andernfalls, ob Netzwerkanfragen blockiert werden.
-
Prüfe mit einer harmlosen Markierung und temporären Testkonten oder Testzielen, ob typische Versuche, Inhalte öffentlich zugänglich zu machen, vor der Veröffentlichung blockiert werden.
Grenzen
Eine erlaubte Domain kann weiterhin öffentliche Inhalte bereitstellen. Konfiguriere Websuche, Apps, MCP-Server, Browseraktivitäten und Codex Cloud separat. Lokale Sandbox-Regeln gelten dafür nicht.
Verwendete Konfigurationsanleitungen: Berechtigungsprofile und Vollzugriff einschränken, nur genehmigte MCP-Server zulassen, Netzwerkziele einschränken, Geheimnisse und nicht benötigte Repositorys schützen, Genehmigung für sensible Befehle verlangen.
Die für Codex festgelegten Einschränkungen sollen wirksam bleiben, wenn Codex in einem Repository arbeitet oder jemand lokale Konfigurationen ändert.
-
Verteile unterstützte Einschränkungen für Berechtigungen, Genehmigungen, MCP, Netzwerkzugriff und Befehle als verbindliche administrative Anforderungen.
-
Installiere Hook-Skripte in einem administrativ verwalteten Verzeichnis. Lass ausschließlich verwaltete Hooks zu, wenn Codex Benutzer-, Projekt- und Plugin-Hooks ignorieren soll.
-
Schütze Richtliniendateien und den Verteilungsweg der Konfiguration über das Betriebssystem und die Geräteverwaltung. Führe Codex ohne die Rechte aus, die zum Ändern dieser Schutzmaßnahmen erforderlich sind.
-
Prüfe die tatsächlich wirksame Konfiguration für jeden betroffenen Client und jede betroffene Umgebung.
Vorgaben für Profile, Genehmigungen, Serveridentitäten und Befehle durchsetzen
Füge geprüfte Einstellungen in die administrativ verwaltete requirements.toml ein. Verlass dich dafür nicht auf bearbeitbare Benutzer- oder Repository-Einstellungen. Beispiel:
allowed_approval_policies = ["on-request"]
allowed_approvals_reviewers = ["user"]
default_permissions = ":workspace"
[allowed_permission_profiles]
":read-only" = true
":workspace" = true
[mcp_servers.internal]
identity = { url = "https://mcp.corp.example/mcp" }
[rules]
prefix_rules = [
{ pattern = [{ token = "git" }, { token = "push" }], decision = "prompt", justification = "Review Git pushes." },
]Dieses Beispiel lässt zwei Profile zu, verlangt bei genehmigungspflichtigen Aktionen die Prüfung durch eine Person, erlaubt eine passende MCP-Identität und fordert bei einem bestimmten Befehlspräfix eine Genehmigung an.
Konfiguriere den MCP-Server selbst separat und ergänze die weiteren Muster für sensible Befehle deiner Organisation. Füge bei Bedarf globale Datei- und Netzwerkbeschränkungen hinzu. Anforderungen beschränken die unterstützten Einstellungen. Sie ersetzen keine Kontrollen für Identitäten, Dienste und Ziele außerhalb von Codex.
Verwaltete Zulassungslisten für Profile setzen Codex 0.138.0 oder höher voraus.
Versuche auf einem Pilotclient, ein unzulässiges Profil auszuwählen, eine eingeschränkte Benutzer- oder Projekteinstellung zu ändern und eine MCP-Identität außerhalb der Zulassungsliste zu verwenden. Prüfe für jeden Versuch, ob er abgelehnt wird oder die Einschränkung nach einem Neustart weiterhin greift. Lehne die Genehmigungsanfrage für einen Testbefehl ab und prüfe, ob der Befehl tatsächlich unterbleibt.
Verwaltete Datei- und Netzwerkbeschränkungen ergänzen
Um den Lesezugriff auf sensible lokale Dateien in allen erlaubten Profilen zu sperren, füge die folgende Tabelle in requirements.toml ein. Ersetze die Beispiele durch die Pfade deiner Organisation:
[permissions.filesystem]
deny_read = ["~/.ssh", "~/.aws/credentials", "~/.kube/config"]Wenn lokale Befehle in der Sandbox Netzwerkzugriff benötigen, definiere ein zulässiges Profil mit Netzwerkzugriff und lege zugleich die verwalteten Ziele fest:
default_permissions = "corp_network"
[allowed_permission_profiles]
corp_network = true
[permissions.corp_network]
extends = ":workspace"
[permissions.corp_network.network]
enabled = true
[experimental_network]
enabled = true
managed_allowed_domains_only = true
[experimental_network.domains]
"git.corp.example" = "allow"Verwende diese Profilrichtlinie anstelle des vorherigen Standardprofils :workspace oder nimm bewusst beide Profilnamen auf. Füge keine Schlüssel oder Tabellen doppelt ein. Wenn Befehle keinen Netzwerkzugriff benötigen, lass ihn deaktiviert.
Prüfe die genauen gesperrten Pfade mit harmlosen Dateien. Teste sowohl genehmigte als auch nicht genehmigte Ziele.
Verwende unter nativem Windows zusätzlich Zugriffssteuerungslisten für Dateien, da die verwaltete Einstellung deny_read allein keine Lesezugriffe durch Shell-Unterprozesse erfasst.
Die Netzwerkeinstellungen für lokale Befehle gelten nicht für andere Clients, Apps, Konnektoren oder die Ausführung in der Cloud.
Administrativ verwaltete Hooks installieren und durchsetzen
Lass ein geprüftes Hook-Programm mit Administrationsrechten in einem von root verwalteten Verzeichnis installieren, etwa unter /etc/codex/hooks/pre_tool_use_policy.py. Verhindere, dass das Codex-Benutzerkonto die Datei oder ihr Verzeichnis ändern kann. Aktiviere in requirements.toml Hooks und lege fest, dass Codex Benutzer-, Projekt-, Sitzungs- und Plugin-Hooks ignoriert:
allow_managed_hooks_only = true
[features]
hooks = true
[hooks]
managed_dir = "/etc/codex/hooks"
[[hooks.PreToolUse]]
matcher = "^Bash$"
[[hooks.PreToolUse.hooks]]
type = "command"
command = "/usr/bin/python3 /etc/codex/hooks/pre_tool_use_policy.py"
timeout = 30
statusMessage = "Checking managed Bash command"Die Anforderung registriert den Hook, installiert ihn aber nicht. Speichere für einen lokalen Integrationstest unter macOS den folgenden Code als pre_tool_use_policy.py und lass die Datei mit Administrationsrechten über die unten stehenden Befehle installieren.
Der Hook blockiert nur Befehle mit der synthetischen Markierung. Ersetze ihn durch eine geprüfte Richtlinie deiner Organisation, bevor du dich auf seinen Schutz verlässt. Prüfe, ob /usr/bin/python3 auf dem Zielsystem vorhanden ist, und passe den Interpreterpfad bei Bedarf an:
1
2
3
4
5
6
7
8import json
import sys
event = json.load(sys.stdin)
command = event.get("tool_input", {}).get("command", "")
if "CODEX_HOOK_TEST_DENY" in command:
print("Synthetic test command blocked by managed hook.", file=sys.stderr)
sys.exit(2)sudo install -d -o root -g wheel -m 755 /etc/codex/hooks
sudo install -o root -g wheel -m 644 ./pre_tool_use_policy.py /etc/codex/hooks/pre_tool_use_policy.pyStarte den lokalen Client neu und führe die folgenden Prüfungen durch:
-
Prüfe, ob ein harmloser Bash-Befehl ausgeführt wird.
-
Prüfe, ob ein Befehl mit
CODEX_HOOK_TEST_DENYblockiert wird. -
Prüfe, ob das Codex-Benutzerkonto weder die Richtlinie noch ihre Abhängigkeiten ändern kann.
allow_managed_hooks_only überspringt alle nicht verwalteten Benutzer-, Projekt-, Sitzungs- und Plugin-Hooks und kann sich auf andere Arbeitsabläufe auswirken.
Der Bash-Abgleich erfasst nicht jedes Tool und auch nicht jede Eingabe, die später an einen bereits laufenden Prozess übergeben wird. Bei Fehlern, Zeitüberschreitungen oder fehlerhaft formatierten Hook-Antworten kann ein Tool-Aufruf dennoch ausgeführt werden.
Bei der Orchestrierung von Work in der Cloud werden andere Hook-Handler unterstützt. Behalte unabhängige Schutzmaßnahmen für Betriebssystem und Dienste bei. Siehe Verwaltete Hooks und Verhalten von Hooks.
Richtlinie und Verteilungsweg schützen
Unter macOS kannst du mit Administrationsrechten eine geprüfte, zusammengeführte Anforderungsdatei in einem übergeordneten Verzeichnis bereitstellen, das root gehört, und dem Codex-Benutzerkonto den Schreibzugriff auf die Datei verwehren:
sudo install -d -o root -g wheel -m 755 /etc/codex
sudo install -o root -g wheel -m 644 ./requirements.reviewed.toml /etc/codex/requirements.toml
ls -ld /etc/codex
ls -l /etc/codex/requirements.tomlVerwende unter Linux die passende Administrationsgruppe. Schütze unter Windows das ProgramData-Verzeichnis und die Datei mit administrativ verwalteten Zugriffssteuerungslisten. Beschränke, wer die MDM- oder Cloud-Richtlinie ändern darf, prüfe Änderungen und bewahre eine Kopie zur Wiederherstellung auf.
Prüfe mit einem Pilotkonto ohne Administrationsrechte, ob es weder die Richtlinie noch das übergeordnete Verzeichnis noch das verwaltete Hook-Programm ändern kann. Probiere eine weniger strenge Benutzer- oder Projekteinstellung aus, starte Codex neu und prüfe, ob die verbindlichen Vorgaben weiterhin greifen.
Teste jeden betroffenen Client und jede betroffene Umgebung. Setze nicht voraus, dass alle Clients dieselbe Richtlinie laden.
Überprüfen
Verwende eine Testidentität ohne Administrationsrechte:
-
Versuche, die verwaltete Richtlinie zu bearbeiten. Erwartetes Ergebnis: Die verwaltete Datei lässt sich nicht ändern.
-
Versuche, eine Einschränkung über die Benutzer- oder Projektkonfiguration abzuschwächen. Erwartetes Ergebnis: Weniger strenge Einstellungen werden abgelehnt oder bleiben durch die Vorgaben eingeschränkt.
-
Starte den Client neu und prüfe, ob die Einschränkungen weiterhin gelten.
Grenzen
Eine Person oder ein Agent mit ausreichenden Administrationsrechten auf dem Host kann die umgebenden Schutzmaßnahmen unter Umständen ändern. Einstellungen, die Nutzende selbst bearbeiten können, ersetzen allein keine administrativ verwalteten Anforderungen.