OpenAI

18. november 2026

Tehnologija

Pogled v peskovnik Codex

Kako Codex izvaja ukaze v vašem računalniku z omejitvami, ki jih določate sami.

Michael Bolin, član tehnične ekipe

Pri OpenAI za zaščito agentov uporabljamo pristop večplastne obrambe⁠(odpre se v novem oknu). Čeprav so naše naložbe v učenje in usklajevanje temelj teh prizadevanj, za dodatno zaščito uvajamo tudi funkcije v svojem agentskem ogrodju Codex⁠(odpre se v novem oknu). Ker je izvajanje ukazov v vašem računalniku eno najpogostejših (in potencialno tveganih) opravil sistema Codex, smo razvili peskovnik Codex. Ta omogoča, da Codex deluje v vašem obstoječem okolju z omejitvami dostopa do datotečnega sistema in omrežja, ki jih določate sami.

Peskovnik⁠(odpre se v novem oknu) ⁠(odpre se v novem oknu)omejuje, do česa lahko program dostopa med izvajanjem. Za urejanje fotografij lahko peskovnik Codex nastavite tako, da ukazom dovoli branje in spreminjanje datotek v ~/Pictures, hkrati pa blokira omrežni dostop in s tem prepreči nalaganje. Za pregled kode lahko dovolite dostop do spletne dokumentacije, izvorne datoteke pa ohranite samo za branje. Uporabniki peskovnik Codex nastavljajo s pomočjo ⁠(odpre se v novem oknu)profilov dovoljenj⁠(odpre se v novem oknu), ki določajo omejitve datotečnega sistema in omrežja za sejo Codex.

V tem članku bomo najprej predstavili kompromise pri privzetih nastavitvah peskovnika Codex, nato pa pojasnili njegovo zasnovo in kako ga ogrodje uporablja za izvajanje ukazov. Pokazali bomo, kako lahko končni uporabniki in podjetja dovoljenja prilagodijo svojim potrebam ter kako lahko razvijalci peskovnik ponovno uporabijo v svojih orodjih. Nazadnje bomo preučili, kako se te omejitve uveljavljajo v sistemih macOS, Linux in Windows.

Določanje meja peskovnika

Pri sistemu Codex si prizadevamo določiti previdne privzete nastavitve peskovnika, ki še vedno omogočajo koristno delo. Če je na primer korenski imenik delovnega prostora repozitorij Git, vgrajeni profil dovoljenj :workspace:

  • Dovoljuje pisanje znotraj delovnega prostora, imenike, kot sta .git in .codex, pa ohranja samo za branje. Tako lahko Codex ureja izvorno kodo, ne da bi za vsako spremembo zahteval dovoljenje, hkrati pa so preprečene neposredne spremembe datoteke .codex/config.toml ali kaveljčkov Git v .git/hooks.

  • Omogoča širok dostop za branje datotečnega sistema ob upoštevanju uporabnikovih obstoječih dovoljenj v operacijskem sistemu. Prevajalniki, izvajalna okolja in orodja za gradnjo so odvisni od razvojnih kompletov SDK, knjižnic in konfiguracije zunaj repozitorija. Omejitev branja na delovni prostor bi onemogočila številne običajne delovne poteke. Slabost tega je, da lahko ostanejo berljive tudi občutljive datoteke drugje v računalniku, na primer konfiguracijske datoteke s ključi API.

  • Onemogoči omrežni dostop. S tem blokira neposredno nalaganje v zunanje storitve, vključno s poskusi odtujitve podatkov, ki jih ukaz lahko bere. Prepreči tudi legitimna opravila, kot je prenos odvisnosti, za katera je potreben dodaten dostop.

Te omejitve preprečijo širok nabor neželenega vedenja, vendar so škodljiva dejanja še vedno mogoča. Agent bi lahko na primer v lokalno nameščeni paket, kot je node_modules/prettier, vstavil zlonamerno kodo. Takšna sprememba se morda ne bi prikazala v izpisu git status, saj Git pogosto prezre node_modules. Če uporabnikov urejevalnik ob shranjevanju zažene to kopijo orodja Prettier, bi že samo shranjevanje datoteke lahko izvedlo zlonamerno kodo zunaj peskovnika Codex. Zato uporabljamo večplastno obrambo: peskovnik omejuje dostop ukazov, učenje in usklajevanje pa modelu pomagata ta dostop uporabljati skladno z uporabnikovim namenom.

Navodila za prilagajanje dovoljenj peskovnika in njihovo združevanje z drugimi zaščitnimi ukrepi v poslovnem okolju najdete v praktičnem vodniku za varnost sistema Codex⁠(odpre se v novem oknu).

Zasnova peskovnika

Navidezni stroji in vsebniki⁠(odpre se v novem oknu) so dva priljubljena mehanizma za izvajanje v peskovniku, vendar pri peskovniku Codex uporabljamo drugačen pristop. Namesto da bi izvajanje zaradi izolacije preselil v ločeno okolje, Codex uporablja mehanizme peskovnika posamezne platforme za omejevanje ukazov v uporabnikovem obstoječem okolju.

Številnim razvijalcem prenosnik služi kot prilagojeno razvojno okolje, ki ga lahko kadar koli spremenijo po svojih željah. Reprodukcija tega okolja v vsebniku Docker lahko zahteva precej dela, nekateri delovni poteki pa so še vedno odvisni od orodij, ki se izvajajo na gostitelju.

Vzemimo na primer uporabo sistema Codex za razvoj aplikacije iOS v računalniku Mac. Če bi se odločili Codex izolirati z izvajanjem v vsebniku Docker, ne bi mogel zagnati nabora orodij za gradnjo za iOS, ki ga sestavljajo izvorni izvršljivi programi za Mac, niti simulatorja iPhone za izvajanje kode. Delovni potek na osnovi Dockerja bi lahko gradnjo in opravila simulatorja prepustil gostiteljskemu računalniku Mac, vendar bi se ta opravila izvajala zunaj peskovnika vsebnika in bi potrebovala lastne omejitve. Pri sistemu Codex želimo ohraniti preprostost, zato veliko vlagamo v peskovnike, prilagojene posameznim operacijskim sistemom. Tako lahko Codex deluje v okolju, ki je najprimernejše za trenutno nalogo.

Ogrodje te mehanizme peskovnika, specifične za operacijski sistem, ponuja prek skupnega API-ja za macOS, Windows in Linux. Ta API sprejme ukaz in profil dovoljenj. Če profil dovoljenj omogoča omejen omrežni dostop, mora klicatelj zagotoviti omrežni posredniški strežnik, ki te omejitve uveljavlja:

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:

Ta funkcija zažene proces v peskovniku in vrne ročico Child, s katero lahko ogrodje počaka, da se proces konča. Vsak podrejeni proces podeduje omejitve peskovnika svojega nadrejenega procesa. Zato te veljajo za celotno drevo procesov, ki ga zažene ukaz, tudi za potomce, ki se izvajajo še po koncu prvotnega procesa.

Naslednji diagram prikazuje, kako se ti deli povezujejo, od konfiguracije do izvajanja ukaza v peskovniku. V nadaljnjih razdelkih je pojasnjena vsaka stopnja.

Diagram poteka: konfiguracija in upravljane zahteve določijo profil dovoljenj seje; ogrodje Codex zažene ukaze z omejitvami peskovnika, prilagojenimi platformi macOS, Linux ali Windows. Podrejeni procesi podedujejo te omejitve, izbirni omrežni posredniški strežnik pa uveljavlja domenska pravila.

Kako ogrodje uporablja peskovnik

Kot je pojasnjeno v članku Podroben pogled v agentsko zanko Codex, je ogrodje Codex odgovorno za izvajanje klicev orodij, ki jih ustvari model. Pri programerskih nalogah se najpogosteje uporablja orodje lupine, ki izvaja ukaze podobno kot uporabnik v interaktivni lupini, kot je Bash. Tukaj si bomo ogledali orodje lupine za enkratno izvedbo ⁠(odpre se v novem oknu)exec_command⁠(odpre se v novem oknu) v lupini⁠(odpre se v novem oknu), da ponazorimo, kako ogrodje uporablja peskovnik za zagotavljanje želenih zaščit.

To je poenostavljen prikaz, kako bi ogrodje Codex obdelalo klic orodja
exec_command brez peskovnika:

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}

Za izvajanje ukaza v peskovniku ogrodje nadomesti klic subprocess.Popen() s klicem spawn_command_under_sandbox(). Ogrodje poda profil dovoljenj in po potrebi omrežni posredniški strežnik:

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}

Orodje exec_command modelu omogoča tudi, da za posamezen ukaz zahteva drugačna dovoljenja, vendar o odobritvi zahteve odloči ogrodje:

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

Če je določeno use_default, ogrodje uporabi privzeto konfiguracijo peskovnika za trenutni korak pogovora. with_additional_permissions zahteva razširjen dostop znotraj peskovnika, require_escalated pa izvajanje zunaj njega. Ogrodje pred izvedbo ukaza oceni zahtevo na podlagi uporabnikovih nastavitev. (Codex lahko na primer neposredno vpraša uporabnika ali zahtevo usmeri v samodejni pregled⁠(odpre se v novem oknu).) Če je izvedba odobrena, Codex funkciji perform_exec_command_with_sandboxing() poda ustrezna permission_profile in network_proxy skupaj z argumenti ukaza iz prvotnega ExecCommandToolCall.

Orodje lupine je glavni uporabnik funkcije spawn_command_under_sandbox(), ogrodje pa svojo infrastrukturo peskovnika ponovno uporablja tudi za opravila, kot sta branje in spreminjanje lokalnih datotek. Ponovna uporaba sega tudi zunaj ogrodja: ukaz codex sandbox omogoča vključitev izvajanja ukazov v peskovniku v vaša orodja, kot bomo videli pozneje. V nadaljevanju si bomo ogledali, kako so opredeljeni profili dovoljenj.

Nastavljanje peskovnika

Poimenovan profil dovoljenj omogoča ponovno uporabo istih omejitev datotečnega sistema in omrežja v različnih projektih. Lastne profile lahko opredelite v razdelku [permissions] datoteke config.toml. Naslednji primer opredeli profil z imenom dev, ki razširja⁠(odpre se v novem oknu) vgrajeni profil :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"

Profil dev doda dovoljenje za pisanje v ~/build-cache in uvede dodatne omejitve za datoteke v delovnem prostoru. Vnosi za datotečni sistem lahko dovolijo dostop samo za branje (read), dovolijo branje in pisanje (write) ali povsem blokirajo dostop (deny).

Tabela :workspace_roots omogoča določanje pravil za poti, relativne na korenske imenike delovnega prostora projekta. Codex CLI privzeto uporablja svoj delovni imenik kot edini korenski imenik delovnega prostora, namizna aplikacija ChatGPT pa uporablja mape z izvorno kodo projekta. Codex vsako pravilo uveljavi za vsak korenski imenik. Vnos .vscode v profilu dev zato nastavi imenik .vscode pod vsakim korenskim imenikom samo za branje.

Profil dev poleg lastnih pravil od profila :workspace podeduje naslednje zaščite:

TOML

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

Omrežna dovoljenja

Pri nastavljanju omrežja za peskovnik Codex so na voljo tri osnovne možnosti:

  • Onemogočite ves omrežni dostop (privzeto za profil :workspace)

  • Omogočite poln, neposreden omrežni dostop (privzeto za profil :danger-full-access)

  • Omrežni dostop omejite na posredniški strežnik, ki na podlagi profila dovoljenj odloča, kaj bo prepustil


Če želite profilu
dev omogočiti neposreden omrežni dostop, na vrhnji ravni datoteke config.toml nastavite permissions.dev.network.enabled = true. To omogoči poln omrežni dostop, kadar je omrežni posredniški strežnik onemogočen.

Če želite profil dev omejiti na nabor domen, omogočite omrežni posredniški strežnik in nastavite njegova domenska pravila:

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

Domenska pravila podpirajo natančna imena in vzorce z nadomestnimi znaki, pri čemer imajo izrecne prepovedi prednost pred dovoljenji. Zahteve za druge domene zahtevajo odobritev ali so blokirane, kot je opisano spodaj v razdelku Omrežni posredniški strežnik.

Plastenje konfiguracije in uveljavljanje omejitev

Posamezni uporabniki lahko določijo privzete nastavitve za vse projekte in jih preglasijo za določen zaupanja vreden projekt. Skrbniki v podjetjih lahko prav tako želijo določiti privzete nastavitve za svoje uporabnike in omejiti, katere nastavitve lahko ti spreminjajo. Codex oboje podpira s plasteno konfiguracijo in upravljanimi zahtevami.

Kot je opisano v razdelku Prednostni vrstni red konfiguracije,⁠(odpre se v novem oknu) Codex združuje nastavitve iz več datotek config.toml. Tabele se združujejo rekurzivno; kadar so vrednosti v sporu, prevlada vir z višjo prednostjo. Polja se zamenjajo v celoti.

Zato profili dovoljenj za poti datotečnega sistema in omrežne domene uporabljajo tabele. Ekipa lahko v svoji konfiguraciji doda ali preglasi posamezne vnose ter samodejno podeduje spremembe vseh drugih vnosov v osnovni konfiguraciji organizacije:

TOML

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

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

Skrbniki lahko prek datoteke requirements.toml podajo tudi upravljane zahteve⁠(odpre se v novem oknu), s katerimi omejijo uporabnikove možnosti nastavljanja. Te zahteve lahko izvirajo iz več virov, vključno s sistemskimi datotekami in pravilniki iz oblaka. Pogost primer uporabe je določitev allowed_permission_profiles, s čimer omejimo nabor profilov dovoljenj, ki jih lahko izbere uporabnik v podjetju. Skrbnik bi lahko na primer določil naslednje zahteve iz oblaka:

TOML

1
default_permissions = ":read-only"
2

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

Zahteve iz oblaka bi imele prednost pred sistemsko datoteko z zahtevami na poti /etc/codex/requirements.toml, zato vnos v tej datoteki ne more preglasiti zgornje izrecne nastavitve ":danger-full-access" = false. Če :workspace ni določen, lahko ta vnos zagotovi druga plast zahtev. Profili, katerih vnosi imajo vrednost false ali jih ni v končni združeni tabeli, niso na voljo.

Ta ločitev organizacijam omogoča uveljavljanje omejitev, uporabnikom pa prilagajanje konfiguracije znotraj teh omejitev. Tako nastale profile dovoljenj lahko uporablja ogrodje ali pa jih uporabimo neposredno za ukaz, kot bomo videli v nadaljevanju.

Uporaba ukaza codex sandbox

Codex CLI ponuja ukaz sandbox, ki olajša izvajanje poljubnega ukaza s profilom dovoljenj, opredeljenim v konfiguraciji Codex. Običajno se uporablja za preizkušanje profila, s katerim preverimo, ali peskovnik preprečuje vedenje, ki naj bi ga blokiral.

Naslednji ukaz na primer poskuša nastaviti VS Code tako, da ob shranjevanju zažene zlonamerno orodje za samodejno oblikovanje kode. Če .vscode že obstaja, bi moral zgoraj opredeljeni profil dev blokirati to pisanje, saj je ta imenik samo za branje (codex sandbox privzeto obravnava cwd kot korenski imenik delovnega prostora):

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

V sistemu macOS ukaz res odpove z naslednjim sporočilom:

Navadno besedilo

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

Ukaz codex sandbox omogoča uporabo mehanizma peskovnika Codex neodvisno od agentske seje. Isti konfiguracijski jezik in uveljavljanje omejitev, prilagojeno platformi, lahko uporabite za omejevanje ukazov, ki jih zaganjajo vaša orodja.

Primer: izvajanje strežnika MCP v peskovniku

Pri strežniku MCP s komunikacijo prek stdio, nastavljenem v config.toml, ogrodje Codex ukaza za zagon strežnika ne poskuša izvesti v peskovniku. Codex ne more zanesljivo sklepati, katere datoteke ali omrežne storitve strežnik potrebuje, zato bi lahko privzeti profil peskovnika onemogočil sicer veljavno konfiguracijo.

Običajen način nastavitve strežnika MCP @modelcontextprotocol/server-memory⁠(odpre se v novem oknu) za uporabo s sistemom Codex je na primer naslednji:

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"

Ker se ta ukaz npx izvaja zunaj peskovnika, lahko piše datoteke in pošilja omrežne zahteve z enakimi dovoljenji kot uporabnik, ki izvaja Codex, kar mu daje preširok dostop. Da ga omejimo, lahko opredelimo profil dovoljenj z imenom memory-mcp, nato pa prvotni ukaz npx ovijemo z codex sandbox --permission-profile memory-mcp. S tem omejimo, kam lahko strežnik piše, in mu preprečimo dostop do omrežja:

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"

Pred zagonom strežnika ustvarite njegov podatkovni imenik in v predpomnilnik npm shranite paket z določeno različico. Tako lahko npx --offline zažene strežnik s profilom, ki onemogoča omrežni dostop:

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

Ko je paket v predpomnilniku, lahko Codex zažene pomnilniški strežnik brez omrežnega dostopa, pisanje pa je omejeno na predpomnilnik npm in podatkovni imenik strežnika.

Izvedba peskovnika Codex

Izvedba peskovnika pretvori profil dovoljenj v omejitve, ki jih uveljavlja operacijski sistem. Osnovna logika obdelave zahtev in pravilnikov omrežnega posredniškega strežnika je skupna vsem trem glavnim operacijskim sistemom, njegova vzpostavitev in povezava s peskovnikom pa sta prilagojeni posameznemu sistemu. Najprej si bomo ogledali skupni posredniški strežnik, nato pa izvedbe za macOS, Linux in Windows.

Omrežni posredniški strežnik

Za uveljavitev omrežnih omejitev profila dovoljenj ogrodje zažene omrežni posredniški strežnik in peskovnik nastavi tako, da dovoljuje povezave z njim, neposredne povezave z zunanjimi gostitelji pa blokira. Posredniški strežnik vsako zahtevo preveri glede na domenska pravila profila in določi, ali jo bo posredoval.

V repozitoriju Codex je omrežni posredniški strežnik izveden v paketu codex-network-proxy⁠(odpre se v novem oknu), ki ga ogrodje uporablja kot knjižnico, mogoče pa ga je zgraditi tudi kot samostojno orodje ukazne vrstice⁠(odpre se v novem oknu). Ko je omogočen, codex-network-proxy privzeto zažene tako posredniški strežnik HTTP kot SOCKS5. Naslova teh posredniških strežnikov se procesu, ki ga zažene peskovnik, posredujeta prek okoljskih spremenljivk. Poleg standardnih okoljskih spremenljivk, kot so HTTP_PROXY, HTTPS_PROXY in ALL_PROXY, se vstavijo tudi številne znane okoljske spremenljivke za posamezne aplikacije⁠(odpre se v novem oknu), na primer PIP_PROXY. Seveda teh okoljskih spremenljivk ne upoštevajo vsi programi. Če se program poskuša neposredno povezati z zunanjim gostiteljem, povezavo blokirajo omejitve peskovnika v operacijskem sistemu, kot je opisano v spodnjih razdelkih za posamezne platforme.

Omrežni posredniški strežnik je odgovoren za uveljavljanje omrežnih omejitev, določenih v profilu dovoljenj. Prej prikazani profil dev na primer dovoljuje zahteve za *.openai.com in izrecno zavrača zahteve za evil.example. Če je zahteva namenjena domeni, ki se ne ujema z nobenim pravilom za dovolitev ali zavrnitev, jo lahko posredniški strežnik začasno zadrži in preda ogrodju v odobritev. Tako kot v primeru ukaza lupine lahko Codex neposredno vpraša uporabnika ali pa zahtevo usmeri v samodejni pregled⁠(odpre se v novem oknu). Ko posredniški strežnik prejme odločitev, zahtevi dovoli nadaljevanje ali jo zavrne z odgovorom o napaki.

Vrstni red je pomemben, saj lahko že poizvedba DNS razkrije podatke, zakodirane v imenu gostitelja. Zato posredniški strežnik razreši zahtevano ime gostitelja šele, ko ugotovi, da je dovoljeno ali odobreno. Upoštevajte, da lahko široka pravila z nadomestnimi znaki ali dostop do storitev DNS še vedno omogočijo odtujitev podatkov prek DNS.

macOS

V sistemu macOS Codex uporablja Seatbelt⁠(odpre se v novem oknu), Applov mehanizem peskovnika, katerega omejitve uveljavlja jedro. Pravilniki Seatbelt so zapisani v jeziku Sandbox Profile Language (SBPL), ki temelji na jeziku Scheme in je namenjen izražanju omejitev peskovnika. Codex pokliče Seatbelt prek ukaza /usr/bin/sandbox-exec v sistemu macOS. Podobno kot codex sandbox sprejme možnosti, ki opisujejo peskovnik, nato pa ukaz za izvedbo:

Bash

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

PROFILE je niz v jeziku SBPL z vnosi za konfiguracijo peskovnika. Naslednji izsek SBPL na primer v pravilniku peskovnika omogoči branje in pisanje za /dev/null in /dev/zero:

Scheme

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

Ko je pri zagonu peskovnika omogočen omrežni posredniški strežnik, se v profil vstavijo pravila, kot so naslednja, ki povezave omejijo na ustrezna lokalna vrata:

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"))


Osnovni profil sistema Codex se začne z
(deny default), zato izhodne povezave ostanejo blokirane, razen če so izrecno dovoljene.

SBPL lahko vsebuje tudi ograde z uporabo (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)))

Te se zapolnijo z možnostmi -Dkey=value, podanimi ukazu sandbox-exec.

Za izvedbo lastnega API-ja peskovnika Codex sestavi seznam argumentov⁠(odpre se v novem oknu) za sandbox-exec, pri čemer izhaja iz osnovnega pravilnika⁠(odpre se v novem oknu). Nato ga s pomočjo permission_profile in drugih kontekstnih podatkov dopolni v celoten profil Seatbelt. Nastali profil in pripadajoči argumenti -D določajo omejitve, ki jih uveljavlja Seatbelt, omrežni posredniški strežnik pa uveljavlja dodatna omrežna pravila. Ko je celoten seznam argumentov sestavljen, je klic sandbox-exec preprost.

Ustvarjanje pravilnega SBPL je zahtevno, saj Apple tega jezika ne dokumentira za uporabo tretjih oseb. V man sandbox-exec je celo navedeno The sandbox-exec command is DEPRECATED, kar pomeni, da je ukaz zastarel (enako velja za knjižnično funkcijo sandbox_init(), dokumentirano v man 3 sandbox_init). Kljub opozorilu o zastarelosti macOS še vedno vključuje profile Seatbelt v /usr/share/sandbox, programska oprema tretjih oseb, vključno z Google Chrome in Chromium⁠(odpre se v novem oknu), pa se še naprej opira na Seatbelt. Zato nameravamo Seatbelt uporabljati tudi v dogledni prihodnosti.

Linux

Za ustvarjanje peskovnika v sistemu Linux Codex uporablja kombinacijo orodja bubblewrap⁠(odpre se v novem oknu) (bwrap), orodja ukazne vrstice za ustvarjanje izoliranih okolij, in seccomp-bpf⁠(odpre se v novem oknu), mehanizma jedra Linux za filtriranje sistemskih klicev. Vzpostavitev usklajuje interno pomožno orodje z imenom codex-linux-sandbox. Podobno kot sandbox-exec v sistemu macOS sprejme konfiguracijo peskovnika, ki ji sledi ukaz za izvedbo:

Bash

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

Kadar je potrebna izolacija datotečnega sistema ali usmerjanje prek posredniškega strežnika, codex-linux-sandbox pokliče bwrap, da ustvari začetno okolje peskovnika. bwrap nato v njem zažene codex-linux-sandbox --apply-seccomp-then-exec. Ta drugi klic s pomočjo seccomp-bpf uveljavi dodatne omejitve, preden zažene uporabnikov ukaz.

Za pripravo začetnega okolja peskovnika Codex z orodjem bubblewrap ustvari pogled na datotečni sistem v ločenem imenskem prostoru priklopov, ki odraža pravila datotečnega sistema iz profila dovoljenj. Ker je to temeljni del izvedbe peskovnika, Codex vključuje lastno kopijo bwrap, če uporabnik nima svoje. Kadar pa je na PATH na voljo združljiva namestitev, prednostno uporabi nameščeni ⁠(odpre se v novem oknu)bwrap⁠(odpre se v novem oknu). V praksi nekatere distribucije Linuxa privzeto onemogočajo dostop do uporabniških imenskih prostorov⁠(odpre se v novem oknu), vendar dovoljujejo izjemo za sistemski bwrap.

Podobno kot sandbox-exec tudi bwrap sprejme konfiguracijo peskovnika, ki ji sledi ukaz za izvedbo v njem. Namesto posebnega konfiguracijskega jezika, kot je SBPL, bwrap za konfiguracijo uporablja posamezne zastavice. Codex za ustvarjanje pogleda na datotečni sistem uporablja naslednje možnosti:

  • --bind za določitev zapisljive datoteke ali imenika

  • --ro-bind za določitev datoteke ali imenika samo za branje

  • --perms 000 --tmpfs DIR --remount-ro DIR za zavrnitev dostopa do DIR

  • --perms 000 --ro-bind-data FD FILE za zavrnitev dostopa do FILE (kjer je FD odprt datotečni deskriptor za /dev/null)

Za uveljavitev vzorcev glob za zavrnitev dostopa s temi možnostmi jih Codex pred zagonom vsakega ukaza razširi v konkretne poti. Nove ujemajoče se poti se ne dodajo samodejno med omejitve peskovnika za ta ukaz.

Codex določi tudi možnosti, kot sta --unshare-ipc in --unshare-pid, da peskovniku prepreči dostop do drugih vrst virov na gostitelju. Zato bubblewrap ne vpliva le na vidnost datotek.

Pri uporabi orodja bubblewrap Codex poda --unshare-net, kadar je omrežje onemogočeno ali morajo povezave potekati prek omrežnega posredniškega strežnika. S tem za peskovnik ustvari nov omrežni imenski prostor. Nato s seccomp-bpf uveljavimo dodatne omejitve omrežnih sistemskih klicev in družin vtičnic, ki so na voljo ukazu.


Natančneje, s paketom
seccompiler⁠(odpre se v novem oknu) dinamično prevedemo program BPF na podlagi želenih filtrov⁠(odpre se v novem oknu) in ga uveljavimo za zagonski proces v peskovniku, tako da omejitve podeduje celotno drevo procesov. Zato bwrap ne zažene uporabnikovega ukaza, temveč zaganjalnik codex-linux-sandbox z njegovimi konfiguracijskimi argumenti, ki jim sledi uporabnikov ukaz:

Bash

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

Za uveljavitev filtrov seccomp brez povišanih pravic zaganjalnik nastavi zastavico no_new_privs v sistemu Linux⁠(odpre se v novem oknu). To zastavico podedujejo podrejeni procesi. Preprečuje jim pridobitev dodatnih pravic pri izvajanju drugega programa, na primer izvršljive datoteke z nastavljenim bitom setuid.

Filtri seccomp so odvisni od omrežne konfiguracije. Ko je omrežni dostop onemogočen, blokiramo več sistemskih klicev, povezanih z omrežjem, kot sta connect(2) in bind(2). Ko pa je v peskovniku omogočen omrežni posredniški strežnik, dovolimo vtičnice IP, da je dosegljiv poslušalnik TCP, ki ga ustvari codex-linux-sandbox. Privzeto pa blokiramo ustvarjanje samostojnih domenskih vtičnic Unix, saj bi lahko omogočile nenameren dostop do gostiteljevih virov.

Povezovanje z omrežnim posredniškim strežnikom

Kadar konfiguracija peskovnika zahteva omrežni posredniški strežnik, ogrodje Codex ustvari en primerek strežnika, ki ga je mogoče ponovno uporabiti pri več klicih codex-linux-sandbox znotraj iste niti Codex. Vsak peskovnik potrebuje način za dostop do tega skupnega posredniškega strežnika iz svojega izoliranega omrežnega imenskega prostora. Codex v tem imenskem prostoru zagotovi poslušalnik TCP na povratni zanki in poskrbi, da proces zunaj peskovnika sprejema njegove povezave ter jih posreduje posredniškemu strežniku.

Naslednji diagrami ponazarjajo to postavitev za eno končno točko posredniškega strežnika. Zadnji diagram prikazuje eno povezavo prek nje. Pred zagonom orodja bubblewrap codex-linux-sandbox ustvari par vtičnic Unix za krmilni kanal in se razveji. Podrejeni proces zažene run_host_bridge() in počaka, da prek tega kanala prejme datotečni deskriptor poslušalnika:

Diagram ogrodja Codex, ki zažene codex-linux-sandbox. Ta se razveji v prenosni proces, povezan prek krmilnega kanala z vtičnico Unix.

V tem primeru nadrejeni proces z exec zamenja svojo programsko sliko s programom bwrap. Ta vzpostavi peskovnik in v njem zažene codex-linux-sandbox --apply-seccomp-then-exec, pri čemer mu posreduje datotečni deskriptor krmilnega kanala:

Diagram prikazuje, kako bwrap ustvari omrežni imenski prostor peskovnika in v njem zažene codex-linux-sandbox, krmilni kanal prek vtičnice Unix pa ga povezuje s prenosnim procesom zunaj peskovnika.

V omrežnem imenskem prostoru peskovnika drugi klic codex-linux-sandbox ustvari poslušalnik TCP na povratni zanki in prek vtičnice preda njegov datotečni deskriptor. Poslušalnik ostane povezan z omrežnim imenskim prostorom peskovnika. Tako lahko podrejeni proces, ki je ostal zunaj peskovnika, sprejema povezave programov v peskovniku, povezave proti posredniškemu strežniku pa odpira v gostiteljevem omrežnem imenskem prostoru. Po predaji oba procesa zapreta svoja deskriptorja krmilnega kanala, proces znotraj peskovnika pa zapre svojo kopijo poslušalnika.

Ko je poslušalnik TCP pripravljen, proces v peskovniku nastavi ustrezno vrednost spremenljivke HTTP_PROXY⁠(odpre se v novem oknu) in povezanih okoljskih spremenljivk, tako da kažejo na ta poslušalnik. Nato pred razvejitvijo procesa in izvedbo uporabnikovega ukaza uveljavi seccomp:

Diagram prikazuje program v peskovniku, ki se povezuje s poslušalnikom TCP na povratni zanki, zunanji prenosni proces codex-linux-sandbox pa promet posreduje omrežnemu posredniškemu strežniku Codex.

Proces zunaj peskovnika ohranja poslušalnik odprt. Za vsako sprejeto povezavo odpre povezavo z nastavljenim posredniškim strežnikom in prenaša podatke v obe smeri.

Ta dodatni mehanizem ukazu zagotovi lasten omrežni imenski prostor, vključno z ločenim vmesnikom povratne zanke. V sistemu macOS Seatbelt ukazu omogoča neposredno povezovanje z določenimi vrati na vmesniku povratne zanke gostitelja. V sistemu Linux se ukaz namesto tega poveže s poslušalnikom v svojem izoliranem imenskem prostoru, proces zunaj peskovnika pa te povezave posreduje nastavljenemu posredniškemu strežniku. Predaja deskriptorja omogoča to povezavo, ne da bi ukazu razkrila gostiteljev omrežni imenski prostor.

Windows

V začetku tega leta smo uvedli peskovnik za Windows in pisali o svojem delu na tem področju. Od takrat je Microsoft izdal knjižnico MXC skupaj z novimi funkcijami za izolacijo procesov v operacijskem sistemu Windows. Trenutno obstoječi peskovnik nadomeščamo s takim, ki uporablja knjižnico MXC.

Kaj je MXC?

MXC (Microsoft eXecution Container) je Microsoftov sistem za izvajanje kode v peskovniku⁠(odpre se v novem oknu), ki podpira več zalednih mehanizmov za izolacijo v sistemih Windows, Linux in macOS. Codex v združljivih napravah s sistemom Windows podpira peskovnik na osnovi MXC, ki z vgrajeno izolacijo procesov omejuje ukaze v uporabnikovem obstoječem okolju.

Na MXC prehajamo zaradi izboljšanja varnosti in uporabnosti ter odpravljanja več omejitev obstoječega peskovnika za Windows:

  • Potreba po povišanih oziroma skrbniških pravicah za vzpostavitev peskovnika

  • Potratno in počasno preverjanje ter nastavljanje seznamov ACL

  • Trajno stanje nastavitve peskovnika na gostiteljskem računalniku, vključno z naslednjim:

    • Seznami ACL

    • Pravila požarnega zidu

    • Uporabniki peskovnika

    • Datoteke krmilne ravnine

MXC ponuja konfiguracijsko shemo JSON⁠(odpre se v novem oknu). Codex s pomočjo MXC SDK⁠(odpre se v novem oknu) sestavi zahtevo za izvedbo, ki sledi tej shemi ter vsebuje ukaz, delovni imenik, okolje in dovoljenja. Ta dovoljenja zajemajo dostop do datotečnega sistema in omrežja ter virov sistema Windows, kot sta namizje in odložišče.

Pretvorba pravilnika v klic MXC

Codex za več nadzornih mehanizmov uporablja fiksne nastavitve, da uravnoteži združljivost in varnost. Dovoljuje branje registra ter ohranja dostop do Win32k in namizja, ki ga PowerShell potrebuje ob zagonu. Dostop do odložišča, vbrizgavanje vhodnih dogodkov ter upravljanje namizja in sistemskih nastavitev so onemogočeni. Poleg tega je MXC onemogočeno, da bi kot nadomestno rešitev spreminjal dovoljenja gostiteljevega datotečnega sistema.

Codex pravila profila dovoljenj za datotečni sistem in omrežje pretvori v konfiguracijo MXC. Če uporabimo prej predstavljeni profil dev in predpostavimo naslednje:

  • C:\, D:\ in Z:\ so edini lokalni pogoni računalnika.

  • Korenski imenik delovnega prostora in delovni imenik sta C:\work\demo.

  • Uporabnikov domači imenik je D:\Users\dev, zato se ~/build-cache razreši v D:\Users\dev\build-cache.

  • Vzorec glob za zavrnitev dostopa se ujema le s potema C:\work\demo\config\dev.env in C:\work\demo\config\prod.env.

Ustrezne nastavitve MXC bi vključevale:

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
}

Dostop do korenskih imenikov pogonov

Pravilnik datotečnega sistema MXC privzeto zavrača dostop. Codex zato doda dovoljenja samo za branje korenskih imenikov lokalnih pogonov in tako zagotovi širok dostop za branje, ki ga ta profil dovoljuje. Ta dovoljenja veljajo rekurzivno, ob upoštevanju uporabnikovih obstoječih dovoljenj v operacijskem sistemu.

Obstaja posebnost: dovoljenja za pisanje v korenske imenike pogonov ne veljajo rekurzivno, zato jih Codex razširi na obstoječe neposredno podrejene datoteke in imenike pogona.

Nasprotujoča si dovoljenja

Bolj specifične poti preglasijo dovoljenja nadrejenih poti, zato je lahko C:\work\demo zapisljiv znotraj C:\, ki je samo za branje, medtem ko C:\work\demo\.git ostane samo za branje.

Kadar se različni zapisi poti ali vzdevki prek simbolnih povezav oziroma stičnih točk nanašajo na isto pot, MXC uveljavi strožje dovoljenje: zavrnitev dostopa ima prednost pred branjem, branje pa pred branjem in pisanjem.

Vzorci glob za zavrnitev dostopa

MXC sprejema le konkretne poti za zavrnitev dostopa, zato Codex pred zagonom vzorce glob razširi v ujemajoče se datoteke in imenike. Nove poti, ki se ujemajo z vzorcem glob, se med izvajanjem ukaza ne dodajajo samodejno.

Omrežni dostop

Domenska pravila, kot je *.openai.com, uveljavlja prej opisani skupni omrežni posredniški strežnik Codex. Codex ta posredniški strežnik izvaja zunaj peskovnika in njegove naslove ukazu posreduje prek istih standardnih okoljskih spremenljivk *_PROXY, ki smo jih že omenili. MXC blokira neposredne zunanje povezave, dovoljuje pa povezave prek gostiteljeve povratne zanke, vključno z dostopom do posredniškega strežnika. Druge lokalne storitve ostanejo dosegljive.

Ogrodje v sistemih macOS, Linux in Windows uporablja isti API peskovnika za zagon ukazov s profilom dovoljenj. Izvedbe za posamezne platforme poskrbijo za pripravo, potrebno za uveljavitev teh omejitev.

Nadaljnja gradnja na peskovniku Codex

Pisanje in izvajanje kode agentom omogoča prilagodljivo reševanje problemov tudi zunaj razvoja programske opreme. Peskovnik Codex jim omogoča uporabo te zmožnosti v uporabnikovem obstoječem okolju z izrecnimi omejitvami dostopa do datotečnega sistema in omrežja. Je ponovno uporabljiv osnovni gradnik ogrodja, ukaz codex sandbox pa omogoča njegovo uporabo v orodjih, ki jih razvijete sami.

Ker agenti prevzemajo vse več nalog, želimo omogočiti praktično uporabo peskovnika v več orodjih in okoljih. To pomeni preprostejše nastavljanje dovoljenj in uporabo izboljšanih zaščit operacijskih sistemov, ko postanejo na voljo. Naš cilj je razširiti zmožnosti agentov, pri tem pa ljudem ohraniti nadzor nad tem, do česa lahko agenti dostopajo.

Avtorji

OpenAI

Zahvale

Posebna zahvala Davidu Wiesnu, Charlieju Weemsu, Viyatu Bhalodii in Fotisu Chantzisu za prispevke k tej objavi.