So sicherst du einen MCP-Server mit codex sandbox ab

Codex führt stdio-MCP-Server nicht in einer Sandbox aus, sodass npx-Server mit Ihren vollen Berechtigungen laufen. Erstellen Sie ein Berechtigungsprofil, kapseln Sie den Server in die Codex-Sandbox ein und testen Sie ihn.

INEZA Felin-Michel

INEZA Felin-Michel

20 November 2026

So sicherst du einen MCP-Server mit codex sandbox ab

Apidog für Unternehmen

On-Premises Bereitstellung

SSO & RBAC

SOC 2 konform

Apidog Enterprise entdecken

Um einen MCP-Server in der Codex-Sandbox auszuführen, definierst du ein Berechtigungsprofil in ~/.codex/config.toml und setzt dann das command des Servers auf codex sandbox --permission-profile <name> --, gefolgt vom ursprünglichen Befehl. Codex sandboxt stdio-MCP-Server standardmäßig nicht – ohne diesen Wrapper läuft ein npx-Server mit deinen vollen Benutzerberechtigungen.

OpenAIs Engineering-Beitrag Inside the Codex sandbox vom 18. November 2026 bringt es auf den Punkt: Codex kann nicht zuverlässig erraten, welche Dateien oder Netzwerkdienste ein Server benötigt, deshalb lässt es den Startbefehl des Servers unangetastet. Jeder MCP-Server, den du mit npx -y hinzufügst, kann deinen Home-Ordner lesen, überall schreiben, wo du schreiben kannst, und jeden Host im Internet aufrufen.

Im Folgenden erstellst du ein Profil für den Apidog MCP Server, bindest es bei abgeschaltetem Netzwerk an eine lokale OpenAPI-Datei, weist mit codex sandbox nach, dass das Profil funktioniert, und übergibst die Routinearbeit dann über die Apidog CLI an deinen Coding-Agenten.

Warum Codex stdio-MCP-Server ohne Sandbox lässt

Ein stdio-MCP-Server ist ein lokales Programm, das Codex startet und mit dem es über Standard-Ein- und -Ausgabe kommuniziert. Codex sandboxt die Shell-Befehle, die sein Modell ausführt, aber nicht den Befehl, der einen MCP-Server startet, weil es nicht erkennen kann, welche Dateien oder Hosts dieser Server benötigt. Der Server erbt deine vollen Benutzerberechtigungen.

Befehle, die das Modell ausführt, erhalten das eingebaute :workspace-Profil: Schreibzugriff nur innerhalb des Workspace, .git und .codex schreibgeschützt, umfangreiche Lesezugriffe, kein Netzwerk. Ein MCP-Server unter [mcp_servers] bekommt davon nichts.

Diese Lücke ist relevant, weil MCP-Server fremder Code sind, den du erst beim Start herunterlädst. Eine typische Konfiguration sieht so aus:

[mcp_servers.memory]
command = "npx"
args = ["-y", "@modelcontextprotocol/server-memory@1.0.0"]

npx -y lädt das Paket herunter und führt es ohne Rückfrage aus. Ist dieses Paket kompromittiert, kann es deine .env-Dateien und SSH-Schlüssel lesen und an beliebige Orte senden. Unser Leitfaden zu MCP-Sicherheitsrichtlinien behandelt das übergeordnete Bedrohungsmodell; dieser Beitrag schließt das eine Loch in deinem Codex-Setup.

So funktioniert ein Codex-Berechtigungsprofil

Ein Berechtigungsprofil ist eine benannte Sammlung von Dateisystem- und Netzwerkregeln unter [permissions] in config.toml. OpenAIs Beitrag und die Codex-Dokumentation zu Berechtigungen beschreiben drei Dateisystemstufen:

Wert Auswirkung
read Nur Lesezugriff
write Lese- und Schreibzugriff
deny Überhaupt kein Zugriff

Drei Schlüssel erledigen den Großteil der Arbeit:

  1. ":root" = "read" gewährt umfangreiche Lesezugriffe, die Node.js und npm benötigen, um ihre eigenen Dateien zu laden.
  2. Ein Pfad wie "~/.npm" = "write" gewährt Schreibzugriff ausschließlich auf diesen Ordner.
  3. Eine ":workspace_roots"-Tabelle wendet Regeln relativ zu jedem Workspace-Root an. "**/*.env" = "deny" blockiert jede .env-Datei darunter.

Beim Netzwerk gibt es drei Modi: aus, über Codex' Proxy mit einer Domain-Allowlist geleitet oder voller Zugriff.

Three network modes for a Codex permission profile: network.enabled = false for no network, a proxy with a domain allowlist such as api.apidog.com, and full network access to avoid for MCP servers

Die Open-Source-Codex-CLI setzt diese Regeln über das Betriebssystem durch: Seatbelt unter macOS, bubblewrap plus seccomp unter Linux und auf kompatiblen Windows-Geräten Microsofts MXC. Kindprozesse erben die Limits, sodass alles, was der Server startet, in derselben Box bleibt.

Schritt 1: Den sichersten Modus für den Apidog MCP Server wählen

Der Apidog MCP Server (apidog-mcp-server auf npm, derzeit Version 0.0.18) läuft in zwei Modi:

Der OAS-Modus mit einer lokalen Datei braucht überhaupt kein Netzwerk. Das ist das strengste Profil, das du schreiben kannst, deshalb ist es hier das Hauptbeispiel. Die Apidog CLI hält die Spec von außerhalb der Sandbox aktuell (Schritt 5).

Wir haben das Paket in Version 0.0.18 analysiert, um herauszufinden, was der Server schreibt: Er legt Daten in ~/.apidog-mcp-server ab (oder im Ordner aus APIDOG_DATA_LOCATION) und ruft im Projektmodus https://api.apidog.com auf, sofern du nicht --apidog-api-base-url übergibst.

Schritt 2: Das Berechtigungsprofil definieren

Füge Folgendes zu ~/.codex/config.toml hinzu:

[permissions.apidog-mcp.filesystem]
# Broad reads so Node.js and npm can load their own files.
":root" = "read"
"~/.npm" = "write"
"~/.apidog-mcp-server" = "write"

[permissions.apidog-mcp.filesystem.":workspace_roots"]
"**/*.env" = "deny"

[permissions.apidog-mcp.network]
enabled = false

Der Server kann die Spec lesen und in zwei Cache-Ordner schreiben. Er kann keine .env-Datei im Workspace öffnen und hat kein Netzwerk.

Schritt 3: Den Serverbefehl in codex sandbox einbetten

Ersetze nun den einfachen npx-Start durch codex sandbox. Das Flag -C legt das Arbeitsverzeichnis fest, das zugleich der Workspace-Root ist, auf den die .env-Regel angewendet wird:

[mcp_servers.pets-api-docs]
command = "codex"
args = [
  "sandbox",
  "--permission-profile", "apidog-mcp",
  "-C", "/Users/you/code/pets-api",
  "--",
  "npx", "--offline",
  "apidog-mcp-server@0.0.18",
  "--oas=/Users/you/code/pets-api/openapi.json"
]

Drei Details sind wichtig:

Die Apidog-README empfiehlt, den Server nach der API zu benennen, die er dokumentiert, etwa „Pets API Documentation“, damit das Modell weiß, wann es ihn einsetzen soll.

Diagram: Codex launches codex sandbox with the apidog-mcp profile, which runs npx --offline apidog-mcp-server with an OpenAPI file; inside the sandbox it can read openapi.json and write to ~/.npm and ~/.apidog-mcp-server, while .env files, the internet and other folders are blocked

Schritt 4: Das Paket vorab cachen und nachweisen, dass das Profil funktioniert

Die Sandbox kann in den Cache-Ordner schreiben, ihn aber nicht anlegen, und sie kann nichts herunterladen. Führe Folgendes einmal außerhalb der Sandbox aus:

mkdir -p ~/.apidog-mcp-server
npx -y --package=apidog-mcp-server@0.0.18 -c true

Teste das Profil dann, bevor du ihm vertraust. codex sandbox führt jeden beliebigen Befehl unter einem Profil aus und ist damit ein schneller Testrahmen:

cd /Users/you/code/pets-api

# 1. A .env file in the workspace is unreadable
codex sandbox --permission-profile apidog-mcp -- cat .env
# cat: .env: Operation not permitted

# 2. Writes outside the allowed folders fail
codex sandbox --permission-profile apidog-mcp -- bash -c 'echo x > /tmp/probe.txt'
# bash: /tmp/probe.txt: Operation not permitted

# 3. The allowed cache folder is writable
codex sandbox --permission-profile apidog-mcp -- touch ~/.apidog-mcp-server/probe
# (no output, exit 0)

# 4. No network
codex sandbox --permission-profile apidog-mcp -- curl -sS https://api.apidog.com/
# curl: (6) Could not resolve host: api.apidog.com

Das sind die Ergebnisse, die wir unter macOS erhalten haben. Prüfe anschließend, ob der Server noch funktioniert, indem du ihm einen MCP-Handshake sendest:

printf '%s\n' \
 '{"jsonrpc":"2.0","id":1,"method":"initialize","params":{"protocolVersion":"2025-06-18","capabilities":{},"clientInfo":{"name":"t","version":"1"}}}' \
 '{"jsonrpc":"2.0","method":"notifications/initialized"}' \
 '{"jsonrpc":"2.0","id":2,"method":"tools/list"}' \
| codex sandbox --permission-profile apidog-mcp -- \
  npx --offline apidog-mcp-server@0.0.18 --oas=$PWD/openapi.json

Bei abgeschaltetem Netzwerk antwortete der Server mit drei Tools: eines, das die OpenAPI-Spec liest, eines, das von $ref referenzierte Dateien liest, und eines, das die Spec aktualisiert. Mehr braucht Codex nicht, um Code gegen deine API zu schreiben.

Unter macOS kannst du jedem codex sandbox-Aufruf --log-denials hinzufügen, um die Seatbelt-Verweigerungen nach dem Beenden des Befehls auszugeben. Das ist der schnellste Weg, einen Ordner zu finden, den der Server legitim benötigt.

Schritt 5: Die Spec mit der Apidog CLI aktuell halten

Ein Offline-Server liest eine Datei, also muss irgendetwas diese Datei aktualisieren. Übergib diese Aufgabe mit der Apidog CLI an deinen Coding-Agenten. Sie läuft außerhalb der MCP-Sandbox unter den normalen Befehlsregeln von Codex, und der MCP-Server benötigt nie einen Token.

Einrichtung (einmalig):

npm install -g apidog-cli
apidog auth login --with-token <your-access-token>

Wenn du die CLI noch nicht in Codex eingebunden hast, folge So verwendest du die Apidog CLI in Codex.

Prompt für deinen Agenten:

Export the OpenAPI 3.1 spec for Apidog project 1234567 to ./openapi.json,
then run test scenario 637132 in environment 358171 against it and give me
a CLI summary. Don't touch any .env file.

Befehle, die der Agent ausführt (Flags aus apidog export --help und apidog run --help, CLI 2.2.12):

apidog export --project 1234567 --format openapi --oas-version 3.1 --output ./openapi.json
apidog run -t 637132 -e 358171 -r cli,junit --out-dir ./apidog-reports

export überschreibt die Datei, die der gesandboxte Server liest, sodass der nächste MCP-Aufruf die neuen Endpunkte sieht. run führt dein Testszenario aus und schreibt einen JUnit-Bericht für CI. Füge --upload-report hinzu, wenn du den Lauf in der Apidog-App überprüfen möchtest. Der Free-Plan von Apidog deckt bis zu 4 Benutzer ab.

Wenn der Server Netzwerk braucht: die Domain-Allowlist

Der Projektmodus muss api.apidog.com erreichen. Codex' Antwort darauf ist der Netzwerk-Proxy: Setze enabled = true, liste die erlaubten Domains auf und aktiviere das Feature network_proxy. Das ist die dokumentierte Form aus OpenAIs Beitrag, angepasst an Apidog:

[permissions.apidog-mcp-live.filesystem]
":root" = "read"
"~/.npm" = "write"
"~/.apidog-mcp-server" = "write"

[permissions.apidog-mcp-live.filesystem.":workspace_roots"]
"**/*.env" = "deny"

[permissions.apidog-mcp-live.network]
enabled = true

[permissions.apidog-mcp-live.network.domains]
"api.apidog.com" = "allow"

[features]
network_proxy = true

Ein explizites deny hat Vorrang vor allow, und der Proxy löst einen Hostnamen erst auf, nachdem eine Regel ihn erlaubt hat – denn selbst eine DNS-Abfrage kann Daten preisgeben. OpenAI warnt, dass breite Wildcards weiterhin DNS-basierte Exfiltration erlauben können; liste deshalb exakte Hosts auf.

Eine Warnung aus unserem eigenen Test. Auf unserem Mac startete der Proxy und injizierte HTTP_PROXY und Co. in die Sandbox, antwortete aber bei jedem Host mit 403 und x-proxy-error: blocked-by-allowlist – auch bei den erlaubten. Unser Rechner leitet DNS über eine lokale Proxy-App, was der Grund dafür sein könnte. Führe codex sandbox --permission-profile apidog-mcp-live -- curl -sS https://api.apidog.com/ auf deinem eigenen Rechner aus, bevor du dich auf dieses Profil verlässt. Wenn der erlaubte Host fehlschlägt, falle auf den OAS-Modus aus Schritt 1 zurück.

Welches Profil solltest du verwenden?

Servertyp Netzwerk Schreibzugriffe im Dateisystem Beispiel
Liest nur lokale Dateien enabled = false npm-Cache + eigener Datenordner Apidog MCP Server mit --oas
Ruft eine bekannte API auf Proxy + exakte Domains npm-Cache + eigener Datenordner Apidog MCP Server mit --project-id
Braucht offenes Internet Vermeiden oder in einer VM isolieren So eng wie möglich Web-Browsing-Server

Wenn du Codex im Team einsetzt, können Administratoren mit allowed_permission_profiles in requirements.toml festlegen, welche Profile Benutzer auswählen dürfen. Und falls du versucht bist, die Sandbox stattdessen einfach abzuschalten: Lies nach, warum du beim Umgehen der Codex-Sandbox genau diesen Schutz aufgibst.

FAQ

Sandboxt Codex MCP-Server standardmäßig? Nein. OpenAI stellt klar, dass Codex den Befehl nicht sandboxt, der einen in config.toml konfigurierten stdio-MCP-Server startet. Du fügst die Sandbox selbst hinzu, indem du den Server über codex sandbox --permission-profile <name> -- startest.

Warum npx --offline statt npx -y verwenden? Bei network.enabled = false kann npx nichts herunterladen. --offline weist es an, die Kopie zu verwenden, die du mit npx -y --package=<pkg>@<version> -c true gecacht hast, und das Pinnen der Version verhindert, dass ein neues Release den Code ersetzt.

Schützt die Sandbox meine API-Schlüssel? Sie blockiert, was du verweigerst. Das :workspace-Profil erlaubt umfangreiche Lesezugriffe, also ergänze deny-Regeln für .env-Dateien und Secret-Ordner. Bei abgeschaltetem Netzwerk kann der Server außerdem nichts senden, was er liest.

Funktioniert das unter Linux und Windows? Ja. Dasselbe Profil gilt überall; Codex setzt es unter Linux mit bubblewrap und seccomp und auf kompatiblen Windows-Geräten mit einer MXC-basierten Sandbox durch. Teste jeden Rechner mit codex sandbox, da sich Pfade und DNS-Setups unterscheiden.

Kann ich andere MCP-Server auf dieselbe Weise sandboxen? Ja. Jeder stdio-Server funktioniert: Finde heraus, in welche Ordner er schreibt und welche Hosts er aufruft, gib ihm ein Profil, umhülle den Befehl, cache das Paket vorab und teste. OpenAIs eigenes Beispiel sandboxt @modelcontextprotocol/server-memory mit Schreibzugriffen nur auf ~/.npm und ~/mcp-data.

Praktizieren Sie API Design-First in Apidog

Entdecken Sie eine einfachere Möglichkeit, APIs zu erstellen und zu nutzen