OpenAI

18 november 2026

Teknik

Inuti Codex-sandlådan

Så kör Codex kommandon på din dator med begränsningar som du styr.

Av Michael Bolin, medlem i det tekniska teamet

På OpenAI tillämpar vi djupförsvar⁠(öppnas i ett nytt fönster) för att skydda agenter. Våra satsningar på träning och anpassning till mänskliga intentioner är grundläggande för detta arbete, men vi implementerar också funktioner i vår körmiljö för agenter, Codex⁠(öppnas i ett nytt fönster), för att ge ytterligare skydd. En av de vanligaste (och potentiellt riskfyllda) sakerna Codex gör är att köra kommandon på din dator. Därför byggde vi Codex-sandlådan, så att Codex kan arbeta i din befintliga miljö med begränsningar för filsystem och nätverk som du styr.

En ⁠(öppnas i ett nytt fönster)sandlåda⁠(öppnas i ett nytt fönster) begränsar vad ett program kan komma åt medan det körs. För en uppgift som går ut på att organisera foton kan du konfigurera Codex-sandlådan så att kommandon får läsa och ändra filer i ~/Pictures, medan nätverksåtkomst blockeras för att förhindra uppladdningar. Vid kodgranskning kan du tillåta åtkomst till dokumentation på nätet men behålla källfilerna skrivskyddade. Användare konfigurerar Codex-sandlådan via ⁠(öppnas i ett nytt fönster)behörighetsprofiler⁠(öppnas i ett nytt fönster), som definierar filsystems- och nätverksbegränsningarna för en Codex-session.

I den här artikeln börjar vi med avvägningarna bakom Codex-sandlådans standardinställningar. Sedan förklarar vi hur sandlådan är utformad och hur körmiljön använder den för att köra kommandon. Vi visar hur slutanvändare och företag kan anpassa behörigheterna efter sina behov och hur utvecklare kan återanvända sandlådan i egna verktyg. Till sist undersöker vi hur dessa begränsningar upprätthålls på macOS, Linux och Windows.

Att välja sandlådans gränser

Vår filosofi i Codex är att välja försiktiga standardinställningar för sandlådan som ändå gör det möjligt att utföra meningsfullt arbete. Med ett Git-förvar som arbetsytans rot gör exempelvis den inbyggda behörighetsprofilen :workspace följande:

  • Tillåter skrivning inom arbetsytan, men behåller kataloger som .git och .codex skrivskyddade. Det låter Codex redigera källkod utan att be om tillstånd för varje ändring, samtidigt som direkta ändringar av .codex/config.toml eller Git-hookar under .git/hooks förhindras.

  • Tillåter bred läsåtkomst till filsystemet, inom ramen för användarens befintliga behörigheter i operativsystemet. Kompilatorer, exekveringsmiljöer och byggverktyg är beroende av SDK:er, bibliotek och konfiguration utanför förvaret. Om läsning begränsades till arbetsytan skulle många vanliga arbetsflöden sluta fungera. Nackdelen är att även känsliga filer på andra platser på datorn kan förbli läsbara, till exempel konfigurationsfiler som innehåller API-nycklar.

  • Inaktiverar nätverksåtkomst. Det blockerar direkta uppladdningar till externa tjänster, inklusive försök att föra ut data som kommandot kan läsa. Det förhindrar också legitima åtgärder som att ladda ned beroenden, vilket kräver ytterligare åtkomst.

Dessa begränsningar förhindrar många typer av oönskat beteende, men skadliga handlingar är fortfarande möjliga. Agenten skulle till exempel kunna injicera skadlig kod i ett lokalt installerat paket som node_modules/prettier. En sådan ändring kanske inte syns i git status eftersom node_modules ofta ignoreras av Git. Om användarens editor kör den kopian av Prettier när en fil sparas, skulle det räcka att spara en fil för att köra den skadliga koden utanför Codex-sandlådan. Det är därför vi tillämpar djupförsvar: sandlådan begränsar vad kommandon kan komma åt, medan träning och anpassning till mänskliga intentioner hjälper modellen att använda åtkomsten i enlighet med användarens avsikt.

Vägledning om hur du anpassar sandlådebehörigheter och kombinerar dem med andra skydd i en företagsmiljö finns i Codex säkerhetshandbok⁠(öppnas i ett nytt fönster).

Sandlådans utformning

Virtuella maskiner och containrar⁠(öppnas i ett nytt fönster) är två populära mekanismer för sandlådeisolering, men med Codex-sandlådan väljer vi ett annat tillvägagångssätt. I stället för att flytta beräkningarna till en separat miljö för att skapa isolering använder Codex varje plattforms sandlådemekanismer för att begränsa kommandon som körs i användarens befintliga miljö.

För många utvecklare är den bärbara datorn en skräddarsydd utvecklingsmiljö som de kan ändra när de vill. Att återskapa den miljön i en Docker-container kan kräva arbete, och vissa arbetsflöden är ändå beroende av verktyg som körs på värddatorn.

Tänk dig till exempel att du använder Codex för att utveckla en iOS-app på en Mac. Om du valde att isolera Codex genom att köra det i Docker skulle Codex varken kunna köra iOS-verktygskedjan, som består av program byggda för Mac, eller starta iPhone-simulatorn för att köra koden. Ett Docker-baserat arbetsflöde skulle kunna delegera byggen och simulatoråtgärder till Mac-värden, men dessa åtgärder skulle då köras utanför containerns sandlåda och behöva egna begränsningar. För Codex föredrar vi att hålla det enkelt genom att satsa stort på operativsystemsspecifik sandlådeisolering, så att Codex kan köras i den miljö som passar bäst för uppgiften.

Körmiljön gör dessa operativsystemsspecifika sandlådemekanismer tillgängliga via ett gemensamt API för macOS, Windows och Linux. Detta API tar emot ett kommando och en behörighetsprofil. Om behörighetsprofilen tillåter begränsad nätverksåtkomst måste anroparen tillhandahålla en nätverksproxy som upprätthåller begränsningarna:

Python

1
# This is a simplified version of the actual API.
2
def spawn_command_under_sandbox(
3
program_and_args: list[str],
4
cwd: Path,
5
env: dict[str, str],
6
permission_profile: PermissionProfile,
7
network_proxy: NetworkProxy | None,
8
) -> Child:

Den här funktionen startar processen i en sandlåda och returnerar ett Child-handtag som körmiljön kan använda för att vänta tills processen är klar. Varje barnprocess ärver föräldraprocessens sandlådebegränsningar. Begränsningarna gäller därför i hela det processträd som kommandot startar, även för efterkommande processer som lever vidare efter den ursprungliga processen.

Följande diagram visar hur delarna hänger ihop, från konfiguration till körning av ett kommando i sandlådan. De följande avsnitten förklarar varje steg.

Flödesschema: konfiguration och centralt hanterade krav definierar en behörighetsprofil för sessionen. Codex-körmiljön startar kommandon med plattformsspecifika sandlådebegränsningar på macOS, Linux eller Windows. Barnprocesser ärver begränsningarna, och en valfri nätverksproxy upprätthåller domänregler.

Så använder körmiljön sandlådan

Som beskrivs i Codex agentloop steg för steg ansvarar Codex-körmiljön för att utföra de verktygsanrop som modellen genererar. För kodningsuppgifter är det vanligaste verktyget ett skalverktyg, som kör kommandon ungefär som en användare skulle göra i ett interaktivt skal som Bash. Här tittar vi på One-shot-varianten av ⁠(öppnas i ett nytt fönster)exec_command⁠(öppnas i ett nytt fönster) som skalverktyg⁠(öppnas i ett nytt fönster) för att illustrera hur körmiljön använder sandlådan för att ge det önskade skyddet.

Det här är en förenklad version av hur verktygsanropet
exec_command skulle hanteras av Codex-körmiljön utan sandlådeisolering:

Python

1
# Illustrative implementation of the exec_command tool call.
2

3
class ExecCommandToolCall:
4
cmd: str
5
workdir: str | None = None
6
shell: str | None = None
7
login: bool = True
8
timeout_ms: int = 10_000
9

10

11
def perform_exec_command(tool_call: ExecCommandToolCall):
12
program_and_args = [
13
tool_call.shell or os.environ.get("SHELL") or "/bin/sh",
14
"-lc" if tool_call.login else "-c",
15
tool_call.cmd,
16
]
17
child = subprocess.Popen(
18
program_and_args,
19
# workdir defaults to the turn's cwd, assumed here to be the process cwd.
20
cwd=Path(tool_call.workdir or ".").absolute(),
21
stdout=subprocess.PIPE,
22
stderr=subprocess.STDOUT,
23
)
24
output, exit_code = collect_output(child, timeout_ms=tool_call.timeout_ms)
25
return {"output": output, "exit_code": exit_code}

För att köra kommandot i en sandlåda ersätter körmiljön anropet till subprocess.Popen() med spawn_command_under_sandbox(). Körmiljön tillhandahåller behörighetsprofilen och vid behov nätverksproxyn:

Python

1
# Honoring the exec_command tool call while enforcing sandbox constraints.
2

3
def perform_exec_command_with_sandboxing(
4
tool_call: ExecCommandToolCall,
5
permission_profile: PermissionProfile,
6
network_proxy: NetworkProxy | None,
7
):
8
# ...build program_and_args as in the previous example...
9
child = spawn_command_under_sandbox(
10
program_and_args=program_and_args,
11
cwd=Path(tool_call.workdir or ".").absolute(),
12
env=os.environ.copy(),
13
permission_profile=permission_profile,
14
network_proxy=network_proxy,
15
)
16
output, exit_code = collect_output(child, timeout_ms=tool_call.timeout_ms)
17
return {"output": output, "exit_code": exit_code}

Verktyget exec_command låter också modellen begära andra behörigheter för ett enskilt kommando, men körmiljön avgör om begäran ska beviljas:

Python

1
class ExecCommandToolCall:
2
# ...command-related fields...
3

4
# Per-command sandbox override. Defaults to "use_default".
5
sandbox_permissions: Literal[
6
"use_default",
7
"with_additional_permissions",
8
"require_escalated",
9
] = "use_default"
10

11
# User-facing approval question; only for "require_escalated".
12
justification: str | None = None
13

14
# Expand network or filesystem access; only for "with_additional_permissions".
15
# AdditionalPermissions supports fine-grained options.
16
additional_permissions: AdditionalPermissions | None = None

När use_default anges använder körmiljön turens standardkonfiguration för sandlådan. with_additional_permissions begär utökad åtkomst inom sandlådan, medan require_escalated begär körning utanför den. Körmiljön utvärderar begäran utifrån användarens inställningar innan kommandot körs. (Codex kan till exempel fråga användaren direkt eller skicka begäran till automatisk granskning⁠(öppnas i ett nytt fönster).) Om körningen godkänns skickar Codex lämpliga värden för permission_profile och network_proxy till perform_exec_command_with_sandboxing() tillsammans med kommandoargumenten från det ursprungliga ExecCommandToolCall.

Skalverktyget är den huvudsakliga användaren av spawn_command_under_sandbox(), och körmiljön återanvänder även sin sandlådeinfrastruktur för åtgärder som att läsa och ändra lokala filer. Återanvändningen sträcker sig även utanför körmiljön: kommandot codex sandbox låter dig integrera kommandokörning i sandlådor i dina egna verktyg, vilket vi ska se senare. Härnäst tittar vi på hur behörighetsprofiler definieras.

Konfigurera sandlådan

Med en namngiven behörighetsprofil kan du återanvända samma filsystems- och nätverksbegränsningar i flera projekt. Du kan definiera egna profiler under [permissions] i config.toml. Följande exempel definierar en profil som heter dev och som utökar⁠(öppnas i ett nytt fönster) den inbyggda profilen :workspace:

TOML

1
# Use the dev profile by default.
2
default_permissions = "dev"
3

4
[permissions.dev]
5
# This is displayed when /permissions is run in the Codex CLI.
6
description = "Development with extra read-only protections."
7

8
# A profile can be derived from an existing profile.
9
# Profiles starting with ":" are provided by Codex.
10
extends = ":workspace"
11

12
[permissions.dev.filesystem]
13
"~/build-cache" = "write"
14

15
[permissions.dev.filesystem.":workspace_roots"]
16
".devcontainer" = "read"
17
".vscode" = "read"
18
"**/*.env" = "deny"
19
"secrets" = "deny"

Profilen dev lägger till skrivåtkomst till ~/build-cache och inför ytterligare begränsningar för filer i arbetsytan. Filsystemsposter kan ge enbart läsåtkomst (read), ge läs- och skrivåtkomst (write) eller blockera åtkomst helt (deny).

Tabellen :workspace_roots låter dig definiera regler för sökvägar relativt rötterna i ett projekts arbetsyta. Som standard använder Codex CLI sin arbetskatalog som arbetsytans enda rot, medan ChatGPT:s skrivbordsapp använder projektets källmappar. Codex tillämpar varje regel på varje rot, så posten .vscode i dev gör katalogen .vscode skrivskyddad under varje rot.

Utöver sina egna regler ärver dev följande skydd från :workspace:

TOML

1
[permissions.":workspace".filesystem.":workspace_roots"]
2
".agents" = "read"
3
".aws" = "read"
4
".codex" = "read"
5
".git" = "read"

Nätverksbehörigheter

Det finns i stort sett tre alternativ för att konfigurera nätverket för sandlådan i Codex:

  • Inaktivera all nätverksåtkomst (standard för profilen :workspace)

  • Aktivera fullständig, direkt nätverksåtkomst (standard för profilen :danger-full-access)

  • Begränsa nätverksåtkomsten till en proxy som avgör vad som ska släppas igenom utifrån behörighetsprofilen


För att ge
dev direkt nätverksåtkomst anger du permissions.dev.network.enabled = true på den översta nivån i config.toml. Det ger fullständig nätverksåtkomst när nätverksproxyn är inaktiverad.

För att begränsa dev till en uppsättning domäner aktiverar du nätverksproxyn och konfigurerar dess domänregler:

TOML

1
[permissions.dev.network]
2
enabled = true
3

4
[permissions.dev.network.domains]
5
"*.openai.com" = "allow"
6
# Allow requests to local services by hostname or by IPv4/IPv6 loopback address.
7
"localhost" = "allow"
8
"127.0.0.1" = "allow"
9
"::1" = "allow"
10
"evil.example" = "deny"
11

12
[features]
13
# If neither local config nor managed requirements enable the proxy,
14
# this profile allows direct network access; domain rules are not enforced.
15
network_proxy = true

Domänregler stöder exakta namn och jokerteckenmönster. Uttryckliga regler för nekad åtkomst har företräde framför tillåtande regler. Anrop till andra domäner kräver godkännande eller blockeras, enligt beskrivningen i Nätverksproxy nedan.

Konfiguration i lager och tvingande begränsningar

Enskilda användare kan konfigurera standardinställningar som gäller för alla projekt och åsidosätta dem för ett visst betrott projekt. Företagsadministratörer kan också vilja konfigurera standardinställningar för sina användare och begränsa vilka inställningar användarna får ändra. Codex stöder båda genom konfiguration i lager och centralt hanterade krav.

Som beskrivs i Prioritetsordning för konfiguration,⁠(öppnas i ett nytt fönster) slår Codex samman inställningar från flera config.toml-filer. Tabeller slås samman rekursivt, och källan med högre prioritet avgör vid motstridiga värden. Arrayer ersätts i sin helhet.

Det är därför behörighetsprofiler använder tabeller för filsystemssökvägar och nätverksdomäner. Ett team kan lägga till eller åsidosätta enskilda poster i sin egen konfiguration och automatiskt ärva ändringar i alla övriga poster i organisationens grundkonfiguration:

TOML

1
[permissions.dev.filesystem.":workspace_roots"]
2
".idea" = "read"
3

4
[permissions.dev.network.domains]
5
"example.com" = "allow"

Administratörer kan också tillhandahålla centralt hanterade krav⁠(öppnas i ett nytt fönster) via requirements.toml för att begränsa användarnas konfigurationsval. Kraven kan komma från flera källor, inklusive systemfiler och policyer som tillhandahålls via molnet. Ett vanligt användningsfall är att ange allowed_permission_profiles för att begränsa vilka behörighetsprofiler en företagsanvändare kan välja. En administratör skulle till exempel kunna ange följande molnkrav:

TOML

1
default_permissions = ":read-only"
2

3
[allowed_permission_profiles]
4
":read-only" = true
5
":danger-full-access" = false

Molnkraven skulle ha företräde framför systemets kravfil på /etc/codex/requirements.toml, så en post i den filen kan inte åsidosätta den uttryckliga inställningen ":danger-full-access" = false ovan. Om :workspace lämnas ospecificerad kan ett annat kravlager tillhandahålla den posten. Profiler vars poster är false eller saknas i den slutliga sammanslagna tabellen är inte tillgängliga.

Denna uppdelning låter organisationer upprätthålla begränsningar samtidigt som användare anpassar sin konfiguration inom dessa gränser. De resulterande behörighetsprofilerna kan användas av körmiljön eller tillämpas direkt på ett kommando, vilket vi ska se härnäst.

Använda kommandot codex sandbox

Codex CLI har ett sandbox-kommando som gör det enkelt att köra valfritt kommando med en behörighetsprofil definierad i Codex-konfigurationen. Det används ofta för att testa profilen och kontrollera att sandlådan förhindrar det beteende som den är avsedd att blockera.

Följande kommando försöker till exempel konfigurera VS Code så att ett skadligt autoformateringsverktyg körs när en fil sparas. Om .vscode redan finns bör profilen dev som definieras ovan blockera skrivningen eftersom katalogen är skrivskyddad (codex sandbox behandlar som standard cwd som en rot för arbetsytan):

Bash

1
codex sandbox --permission-profile dev -- \
2
bash -c 'cat > .vscode/settings.json' <<'JSON'
3
{
4
"prettier.prettierPath": "./node_modules/evil-prettier",
5
"[typescript]": {
6
"editor.defaultFormatter": "esbenp.prettier-vscode",
7
"editor.formatOnSave": true
8
}
9
}
10
JSON

På macOS misslyckas detta mycket riktigt med:

Plain text

1
bash: .vscode/settings.json: Operation not permitted

Kommandot codex sandbox gör Codex sandlådemekanism tillgänglig oberoende av en agentsession. Du kan använda samma konfigurationsspråk och plattformsspecifika skydd för att begränsa kommandon som startas av dina egna verktyg.

Exempel: isolera en MCP-server i en sandlåda

För en MCP-server med stdio som konfigurerats i config.toml försöker Codex-körmiljön inte isolera kommandot som startar servern i en sandlåda. Codex kan inte med säkerhet avgöra vilka filer eller nätverkstjänster servern behöver, så en standardsandlådeprofil skulle kunna få en i övrigt giltig konfiguration att sluta fungera.

Så här konfigurerar man till exempel vanligtvis MCP-servern @modelcontextprotocol/server-memory⁠(öppnas i ett nytt fönster) för användning med Codex:

TOML

1
[mcp_servers.memory]
2
command = "npx"
3
args = [
4
"-y",
5
"@modelcontextprotocol/server-memory@1.0.0"
6
]
7

8
[mcp_servers.memory.env]
9
MEMORY_FILE_PATH = "~/mcp-data/memory.jsonl"

Eftersom detta npx-kommando körs utan sandlåda kan det skriva filer och göra nätverksanrop med samma behörigheter som användaren som kör Codex, vilket ger alltför stor åtkomst. För att begränsa åtkomsten kan vi definiera en behörighetsprofil som heter memory-mcp och sedan köra det ursprungliga npx-kommandot via codex sandbox --permission-profile memory-mcp. Det begränsar var servern kan skriva och hindrar den från att komma åt nätverket:

TOML

1
[permissions.memory-mcp.filesystem]
2
# Allow broad reads for Node.js/npm dependencies and configuration.
3
":root" = "read"
4
"~/.npm" = "write"
5
"~/mcp-data" = "write"
6

7
[permissions.memory-mcp.network]
8
enabled = false
9

10
[mcp_servers.memory]
11
command = "codex"
12
args = [
13
"sandbox",
14
"--permission-profile",
15
"memory-mcp",
16
"--",
17
"npx",
18
"--offline",
19
"@modelcontextprotocol/server-memory@1.0.0"
20
]
21

22
[mcp_servers.memory.env]
23
MEMORY_FILE_PATH = "~/mcp-data/memory.jsonl"

Innan servern startas skapar du dess datakatalog och lägger den låsta paketversionen i npm-cachen. Då kan npx --offline starta servern med en profil som inaktiverar nätverksåtkomst:

Bash

1
# The sandbox can write to this folder, but it cannot create it.
2
mkdir -p ~/mcp-data
3

4
# Installing the MCP server requires network access.
5
npx -y --package=@modelcontextprotocol/server-memory@1.0.0 -c true

När paketet finns i cachen kan Codex starta minnesservern utan nätverksåtkomst, med skrivåtkomst begränsad till npm-cachen och serverns datakatalog.

Implementeringen av Codex-sandlådan

Sandlådeimplementationen omvandlar en behörighetsprofil till begränsningar som upprätthålls av operativsystemet. Nätverksproxyns grundläggande logik för anropshantering och policy är gemensam för alla tre stora operativsystem, medan konfigurationen av proxyn och dess integration med sandlådan är operativsystemsspecifika. Vi tittar först på den gemensamma proxyn och sedan på implementationerna för macOS, Linux och Windows.

Nätverksproxy

För att upprätthålla behörighetsprofilens nätverksbegränsningar startar körmiljön en nätverksproxy och konfigurerar sandlådan så att anslutningar till proxyn tillåts, medan direkta anslutningar till externa värdar blockeras. Proxyn kontrollerar varje anrop mot profilens domänregler för att avgöra om det ska vidarebefordras.

I Codex-förvaret är nätverksproxyn implementerad i Rust-paketet codex-network-proxy⁠(öppnas i ett nytt fönster), som körmiljön använder som bibliotek. Det kan dock även byggas som ett fristående kommandoradsverktyg⁠(öppnas i ett nytt fönster). När codex-network-proxy är aktiverat startar det som standard både en HTTP-proxy och en SOCKS5-proxy. Proxyadresserna förmedlas till processen som startas av sandlådan via miljövariabler. Utöver standardmiljövariabler som HTTP_PROXY, HTTPS_PROXY och ALL_PROXY läggs även ett antal välkända programspecifika miljövariabler⁠(öppnas i ett nytt fönster) till, exempelvis PIP_PROXY. Alla program tar visserligen inte hänsyn till dessa miljövariabler. Om ett program försöker ansluta direkt till en extern värd blockerar operativsystemets sandlådebegränsningar anslutningen, enligt beskrivningen i de plattformsspecifika avsnitten nedan.

Nätverksproxyn ansvarar för att upprätthålla de nätverksbegränsningar som definieras i en behörighetsprofil. Profilen dev som visades tidigare tillåter till exempel anrop till *.openai.com och nekar uttryckligen anrop till evil.example. När ett anrop riktas till en domän som inte matchar någon regel för tillåten eller nekad åtkomst kan proxyn pausa anropet och överlåta åt körmiljön att inhämta godkännande. Precis som i exemplet med skalkommandot kan Codex fråga användaren direkt eller skicka begäran till automatisk granskning⁠(öppnas i ett nytt fönster). När proxyn har fått ett beslut låter den antingen anropet fortsätta eller avvisar det med ett felsvar.

Ordningen är viktig här, eftersom även en DNS-uppslagning kan läcka information som kodats i ett värdnamn. Proxyn slår därför upp det begärda värdnamnet först efter att ha fastställt att det är tillåtet eller godkänt. Observera att breda jokerteckenregler eller åtkomst till DNS-tjänster fortfarande kan göra det möjligt att föra ut data via DNS.

macOS

På macOS använder Codex Seatbelt⁠(öppnas i ett nytt fönster), Apples sandlådemekanism vars begränsningar upprätthålls av kärnan. Seatbelt-policyer skrivs i Sandbox Profile Language (SBPL), ett Scheme-baserat språk för att uttrycka sandlådebegränsningar. Codex anropar Seatbelt via macOS-kommandot /usr/bin/sandbox-exec. Precis som codex sandbox tar det emot alternativ som beskriver sandlådan, följda av kommandot som ska köras:

Bash

1
sandbox-exec -p PROFILE [-Dkey=value]* -- PROG ARGS...

PROFILE är en SBPL-sträng med poster som konfigurerar sandlådan. Följande SBPL-kodsnutt gör till exempel /dev/null och /dev/zero läs- och skrivbara enligt sandlådepolicyn:

Scheme

1
(allow file-read* file-test-existence file-write-data
2
(literal "/dev/null")
3
(literal "/dev/zero"))

När nätverksproxyn aktiveras vid ett sandlådeanrop läggs regler som följande till i profilen för att begränsa anslutningar till rätt lokala portar:

Scheme

1
; local HTTP proxy launched by Codex
2
(allow network-outbound (remote ip "localhost:3128"))
3

4
; local SOCKS proxy launched by Codex
5
(allow network-outbound (remote ip "localhost:8081"))


Codex grundprofil börjar med
(deny default), så utgående anslutningar förblir blockerade om de inte uttryckligen tillåts.

Slutligen kan SBPL innehålla platshållare som använder (param):

Scheme

1
; Pass -DWRITABLE_ROOT_0=/path/to/dir to specify a folder that cannot be removed.
2
(deny file-write-unlink
3
(require-all
4
(literal (param "WRITABLE_ROOT_0"))
5
(vnode-type DIRECTORY)))

Dessa fylls i med de -Dkey=value-alternativ som skickas till sandbox-exec.

För att implementera sitt eget sandlåde-API bygger Codex upp argumentlistan⁠(öppnas i ett nytt fönster) till sandbox-exec utifrån en grundpolicy⁠(öppnas i ett nytt fönster). Sedan används permission_profile och annan kontext för att anpassa den till en fullständig Seatbelt-profil. Den resulterande profilen och tillhörande -D-argument konfigurerar de begränsningar som Seatbelt upprätthåller, medan nätverksproxyn upprätthåller ytterligare nätverksregler. När hela argumentlistan är sammanställd är anropet till sandbox-exec enkelt.

Att generera korrekt SBPL är svårt eftersom Apple inte dokumenterar språket för användning av tredje part. I man sandbox-exec står faktiskt The sandbox-exec command is DEPRECATED (detsamma gäller biblioteksfunktionen sandbox_init(), som dokumenteras i man 3 sandbox_init). Trots varningen om utfasning levereras macOS fortfarande med Seatbelt-profiler i /usr/share/sandbox, och tredjepartsprogram, bland annat Google Chrome och Chromium⁠(öppnas i ett nytt fönster), fortsätter att förlita sig på Seatbelt. Därför planerar vi att fortsätta använda Seatbelt under överskådlig tid.

Linux

För att skapa sandlådan på Linux använder Codex en kombination av bubblewrap⁠(öppnas i ett nytt fönster) (bwrap), ett kommandoradsverktyg för att skapa isolerade miljöer, och seccomp-bpf⁠(öppnas i ett nytt fönster), en mekanism i Linux-kärnan för att filtrera systemanrop. Ett internt hjälpprogram som heter codex-linux-sandbox samordnar konfigurationen. Precis som sandbox-exec på macOS tar det emot en sandlådekonfiguration följd av ett kommando som ska köras:

Bash

1
codex-linux-sandbox SANDBOX_ARGS... -- PROG ARGS...

När filsystemet behöver isoleras eller trafiken dirigeras via en proxy anropar codex-linux-sandbox bwrap för att skapa den inledande sandlådemiljön. bwrap startar sedan codex-linux-sandbox --apply-seccomp-then-exec i den. Detta andra anrop använder seccomp-bpf för att tillämpa ytterligare begränsningar innan användarens kommando körs.

För att skapa den inledande sandlådemiljön använder Codex bubblewrap för att bygga en filsystemsvy i en separat monteringsnamnrymd som återspeglar behörighetsprofilens filsystemsregler. Eftersom detta är grundläggande för sandlådeimplementationen levereras Codex med en egen kopia av bwrap ifall användaren inte har installerat en egen, men föredrar en kompatibel installation av ⁠(öppnas i ett nytt fönster)bwrap⁠(öppnas i ett nytt fönster) på PATH när en sådan finns. Vi har sett att vissa Linux-distributioner inaktiverar åtkomst till användarnamnrymder som standard⁠(öppnas i ett nytt fönster), men gör ett undantag för systemets bwrap.

Precis som sandbox-exec tar bwrap emot en sandlådekonfiguration följd av ett kommando som ska köras i sandlådan. I stället för ett särskilt konfigurationsspråk som SBPL använder bwrap enskilda flaggor för konfigurationen. Codex använder följande alternativ för att skapa filsystemsvyn:

  • --bind för att ange en skrivbar fil eller katalog

  • --ro-bind för att ange en skrivskyddad fil eller katalog

  • --perms 000 --tmpfs DIR --remount-ro DIR för att neka åtkomst till DIR

  • --perms 000 --ro-bind-data FD FILE för att neka åtkomst till FILE (där FD är en öppen filbeskrivare för /dev/null)

För att tillämpa glob-mönster för nekad åtkomst med dessa alternativ expanderar Codex dem till konkreta sökvägar innan varje kommando startas. Nya matchande sökvägar läggs inte automatiskt till i kommandots sandlådebegränsningar.

Codex anger också alternativ som --unshare-ipc och --unshare-pid för att hindra sandlådan från att komma åt andra typer av resurser på värden, så bubblewrap påverkar mer än bara vilka filer som är synliga.

När Codex använder bubblewrap skickar det med --unshare-net om nätverket är inaktiverat eller anslutningar måste gå via nätverksproxyn. Det skapar en ny nätverksnamnrymd för sandlådan. Vi använder sedan seccomp-bpf för att ytterligare begränsa de nätverksrelaterade systemanrop och socketfamiljer som kommandot kan använda.


Mer specifikt använder vi
Rust-paketet seccompiler⁠(öppnas i ett nytt fönster) för att dynamiskt kompilera ett BPF-program utifrån önskade filter⁠(öppnas i ett nytt fönster) och tillämpa det på en startprocess i sandlådan, så att begränsningarna ärvs av hela processträdet. Därför kör bwrap inte användarens kommando direkt, utan startprogrammet codex-linux-sandbox med dess egna konfigurationsargument följda av användarens kommando:

Bash

1
bwrap BWRAP_ARGS... -- \
2
codex-linux-sandbox --apply-seccomp-then-exec CODEX_LINUX_SANDBOX_ARGS... -- \
3
PROG ARGS...

För att tillämpa seccomp-filter utan förhöjda behörigheter anger startprogrammet Linux-flaggan no_new_privs för processen⁠(öppnas i ett nytt fönster). Flaggan ärvs av barnprocesser och hindrar dem från att få ytterligare behörigheter när de kör ett annat program, till exempel en körbar fil med setuid.

Seccomp-filtren beror på nätverkskonfigurationen. När nätverksåtkomst är inaktiverad blockerar vi ett antal nätverksrelaterade systemanrop, som connect(2) och bind(2). När nätverksproxyn är aktiverad i sandlådan tillåter vi däremot IP-socketar så att TCP-lyssnaren som skapas av codex-linux-sandbox kan nås. Som standard blockerar vi dock skapandet av fristående Unix-domänsocketar, eftersom de oavsiktligt skulle kunna ge åtkomst till resurser på värden.

Anslutning till nätverksproxyn

När sandlådekonfigurationen kräver nätverksproxyn skapar Codex-körmiljön en proxyinstans som kan återanvändas vid flera anrop till codex-linux-sandbox inom samma Codex-tråd. Varje sandlåda behöver kunna nå den delade proxyn från sin isolerade nätverksnamnrymd. Codex tillhandahåller en TCP-lyssnare på loopback-gränssnittet i namnrymden och ser till att en process utanför sandlådan accepterar dess anslutningar och vidarebefordrar dem till proxyn.

Följande diagram visar upplägget för en proxyslutpunkt. I det sista diagrammet visas en anslutning genom den. Innan bubblewrap startas skapar codex-linux-sandbox ett par Unix-socketar som kontrollkanal och förgrenar sig. Barnprocessen kör run_host_bridge() och väntar på att ta emot lyssnarens filbeskrivare via kanalen:

Diagram över hur Codex-körmiljön startar codex-linux-sandbox, som förgrenar sig till en vidarebefordringsprocess ansluten via en kontrollkanal med Unix-socketar.

I det här exemplet använder föräldraprocessen exec för att ersätta sin programavbild med bwrap. Detta konfigurerar sandlådan och startar codex-linux-sandbox --apply-seccomp-then-exec i den, med kontrollkanalens filbeskrivare som argument:

Diagram som visar hur bwrap skapar en nätverksnamnrymd för sandlådan och startar codex-linux-sandbox i den, med en kontrollkanal via Unix-socketar till vidarebefordringsprocessen utanför sandlådan.

Inuti sandlådans nätverksnamnrymd skapar det andra anropet till codex-linux-sandbox en TCP-lyssnare på loopback-gränssnittet och skickar dess filbeskrivare via socketen. Lyssnaren förblir knuten till sandlådans nätverksnamnrymd. Därmed kan barnprocessen som stannade utanför sandlådan acceptera anslutningar från program i sandlådan, samtidigt som den öppnar sina anslutningar vidare i värdens nätverksnamnrymd. Efter överlämningen stänger båda processerna sina filbeskrivare för kontrollkanalen, och processen i sandlådan stänger sin kopia av lyssnaren.

När TCP-lyssnaren är redo anger processen i sandlådan rätt värde för HTTP_PROXY⁠(öppnas i ett nytt fönster) och relaterade miljövariabler så att de pekar på lyssnaren. Den tillämpar sedan seccomp innan den förgrenar sig och kör användarens kommando:

Diagram som visar hur ett program i en sandlåda ansluter till en TCP-lyssnare på loopback-gränssnittet, medan en extern codex-linux-sandbox-process vidarebefordrar trafiken till Codex nätverksproxy.

Processen utanför sandlådan håller lyssnaren öppen. För varje accepterad anslutning öppnar den en anslutning till den konfigurerade proxyn och vidarebefordrar data i båda riktningarna.

Den här extra mekanismen ger kommandot en egen nätverksnamnrymd med ett separat loopback-gränssnitt. På macOS låter Seatbelt kommandot ansluta direkt till angivna portar på värdens loopback-gränssnitt. På Linux ansluter kommandot i stället till en lyssnare i sin isolerade namnrymd, och en process utanför sandlådan vidarebefordrar dessa anslutningar till den konfigurerade proxyn. Överlämningen av filbeskrivaren möjliggör anslutningen utan att exponera värdens nätverksnamnrymd för kommandot.

Windows

Tidigare i år implementerade vi sandlådestöd på Windows och skrev om vårt arbete med detta. Sedan dess har Microsoft släppt ett bibliotek som heter MXC tillsammans med nya funktioner för processisolering i Windows. Vi håller nu på att ersätta vår befintliga sandlåda med en som använder MXC-biblioteket.

Vad är MXC?

MXC (Microsoft eXecution Container) är ett system för kodkörning i sandlådor⁠(öppnas i ett nytt fönster) från Microsoft med stöd för flera isoleringslösningar på Windows, Linux och macOS. Codex stöder en MXC-baserad sandlåda på kompatibla Windows-enheter och använder operativsystemets inbyggda processisolering för att begränsa kommandon i användarens befintliga miljö.

Vi går över till MXC för att förbättra säkerheten och användbarheten och samtidigt åtgärda flera begränsningar i vår befintliga Windows-sandlåda:

  • Krav på förhöjda behörigheter eller administratörsåtkomst för att konfigurera sandlådan

  • Resurskrävande och långsamma åtgärder för att kontrollera och ange ACL:er

  • Sandlådekonfiguration som blir kvar på värddatorn, bland annat

    • ACL:er

    • Brandväggsregler

    • Sandlådeanvändare

    • Kontrollplansfiler

MXC tillhandahåller ett JSON-schema för konfiguration⁠(öppnas i ett nytt fönster). Codex använder MXC SDK⁠(öppnas i ett nytt fönster) för att skapa en körningsbegäran som följer schemat och innehåller kommandot, arbetskatalogen, miljön och behörigheterna. Behörigheterna omfattar åtkomst till filsystem och nätverk samt Windows-resurser som skrivbordet och urklipp.

Från policy till MXC-anrop

Codex använder fasta inställningar för flera skyddsmekanismer för att balansera kompatibilitet och säkerhet. Det tillåter läsning av registret och behåller den åtkomst till Win32k och skrivbordet som PowerShell behöver vid start. Åtkomst till urklipp, inmatningsinjektion och möjligheten att styra skrivbordet och systeminställningarna är inaktiverade. Slutligen hindras MXC från att som reservlösning ändra behörigheter i värdens filsystem.

Codex omvandlar behörighetsprofilens filsystems- och nätverksregler till MXC-konfiguration. Vi utgår från den tidigare profilen dev och antar att:

  • C:\, D:\ och Z:\ är datorns enda lokala enheter.

  • Arbetsytans rot och arbetskatalogen är C:\work\demo.

  • Användarens hemkatalog är D:\Users\dev, så ~/build-cache motsvarar D:\Users\dev\build-cache.

  • Glob-mönstret för nekad åtkomst matchar endast C:\work\demo\config\dev.env och C:\work\demo\config\prod.env.

Motsvarande MXC-inställningar skulle omfatta:

JSON

1
{
2
...
3
"filesystem": {
4
"readwritePaths": [
5
"C:\\work\\demo",
6
"D:\\Users\\dev\\build-cache",
7
...
8
],
9
"readonlyPaths": [
10
"C:\\",
11
"D:\\",
12
"Z:\\",
13
"C:\\work\\demo\\.agents",
14
"C:\\work\\demo\\.aws",
15
"C:\\work\\demo\\.codex",
16
"C:\\work\\demo\\.devcontainer",
17
"C:\\work\\demo\\.git",
18
"C:\\work\\demo\\.vscode",
19
...
20
],
21
"deniedPaths": [
22
"C:\\work\\demo\\config\\dev.env",
23
"C:\\work\\demo\\config\\prod.env",
24
"C:\\work\\demo\\secrets"
25
]
26
},
27
"network": {
28
"egress": {
29
"default": "deny",
30
"allow": [{
31
"to": [
32
{"cidr": "127.0.0.0/8"},
33
{"cidr": "::1/128"}
34
]
35
}]
36
},
37
"ingress": {
38
"default": "deny",
39
"hostLoopback": "allow"
40
}
41
},
42
...
43
}

Åtkomst till enhetsrötter

MXC:s filsystemspolicy nekar åtkomst som standard. Codex lägger därför till läsbehörigheter för de lokala enheternas rotkataloger för att ge den breda läsåtkomst som profilen tillåter. Dessa behörigheter gäller rekursivt, inom ramen för användarens befintliga behörigheter i operativsystemet.

En komplikation: skrivbehörigheter för enhetsrötter gäller inte rekursivt, så Codex utökar dem till att omfatta enhetens befintliga filer och kataloger direkt under roten.

Motstridiga behörigheter

Mer specifika sökvägar åsidosätter behörigheter för överordnade kataloger, så C:\work\demo kan vara skrivbar under en skrivskyddad C:\, medan C:\work\demo\.git förblir skrivskyddad.

När olika skrivsätt för sökvägar eller alias via symboliska länkar eller junctions pekar på samma sökväg tillämpar MXC den striktare behörigheten: nekad åtkomst går före skrivskydd, som i sin tur går före läs- och skrivåtkomst.

Glob-mönster för nekad åtkomst

MXC tar endast emot konkreta sökvägar för nekad åtkomst, så Codex expanderar glob-mönstren till matchande filer och kataloger före start. Nya sökvägar som matchar glob-mönstret läggs inte till automatiskt medan kommandot körs.

Nätverksåtkomst

Domänregler som *.openai.com upprätthålls av den gemensamma Codex-nätverksproxy som beskrivits tidigare. Codex kör proxyn utanför sandlådan och skickar dess adresser till kommandot via samma standardmiljövariabler, *_PROXY, som nämnts tidigare. MXC blockerar direkta externa anslutningar men tillåter anslutningar till värdens loopback-gränssnitt, inklusive åtkomst till proxyn. Andra lokala tjänster förblir nåbara.

På macOS, Linux och Windows använder körmiljön samma sandlåde-API för att starta kommandon med en behörighetsprofil. De plattformsspecifika implementationerna hanterar de förberedelser som krävs för att tillämpa begränsningarna.

Bygga vidare på Codex-sandlådan

Genom att skriva och köra kod kan agenter lösa problem på ett flexibelt sätt även utanför programvaruutveckling. Codex-sandlådan låter dem använda den förmågan i användarens befintliga miljö med uttryckliga begränsningar för åtkomst till filsystem och nätverk. Den är en återanvändbar byggsten i körmiljön, och kommandot codex sandbox gör den tillgänglig för verktyg som du bygger själv.

När agenter tar sig an fler uppgifter vill vi göra sandlådeisolering praktiskt användbar för fler verktyg och miljöer. Det innebär att göra behörigheter enklare att konfigurera och dra nytta av bättre skydd i operativsystemen när de blir tillgängliga. Vårt mål är att utöka vad agenter kan göra, samtidigt som människor behåller kontrollen över vad de kan komma åt.

Författare

OpenAI

Tack

Ett särskilt tack till David Wiesen, Charlie Weems, Viyat Bhalodia och Fotis Chantzis för deras bidrag till det här inlägget.