OpenAI

18 ta’ Novembru 2026

Inġinerija

Ġewwa s-sandbox ta' Codex

Kif Codex iħaddem kmandi fuq il-magna tiegħek b'limiti li tikkontrolla int.

Minn Michael Bolin, Membru tal-Persunal Tekniku

F'OpenAI, nadottaw approċċ ta' difiża f'diversi saffi⁠(jinfetaħ f’tieqa ġdida) biex nipproteġu l-aġenti. Għalkemm l-investimenti tagħna fit-taħriġ u fl-allinjament huma fundamentali għal dan l-isforz, nimplimentaw ukoll karatteristiċi fil-harness aġentiku tagħna, Codex⁠(jinfetaħ f’tieqa ġdida), biex nipprovdu protezzjoni addizzjonali. Billi waħda mill-aktar affarijiet komuni (u potenzjalment riskjużi) li jagħmel Codex hija li jħaddem kmandi fuq il-kompjuter tiegħek, bnejna s-sandbox ta' Codex biex Codex ikun jista' jaħdem fl-ambjent eżistenti tiegħek fil-limiti tas-sistema tal-fajls u tan-network li tikkontrolla int.

Ambjent ⁠(jinfetaħ f’tieqa ġdida)sandbox⁠(jinfetaħ f’tieqa ġdida) jillimita dak li programm jista' jaċċessa waqt li jkun qed jaħdem. Għal kompitu ta' organizzazzjoni tar-ritratti, tista' tikkonfigura s-sandbox ta' Codex biex tħalli l-kmandi jaqraw u jimmodifikaw fajls f'~/Pictures, filwaqt li timblokka l-aċċess għan-network biex tipprevjeni l-uploads. Għar-reviżjoni tal-kodiċi, tista' tippermetti l-aċċess għad-dokumentazzjoni online filwaqt li żżomm il-fajls sors għall-qari biss. L-utenti jikkonfiguraw is-sandbox ta' Codex permezz ta' ⁠(jinfetaħ f’tieqa ġdida)profili tal-permessi⁠(jinfetaħ f’tieqa ġdida), li jiddefinixxu r-restrizzjonijiet tas-sistema tal-fajls u tan-network għal sessjoni ta' Codex.

F'dan l-artiklu, nibdew bil-kompromessi wara s-settings predefiniti tas-sandbox ta' Codex, imbagħad nispjegaw id-disinn tas-sandbox u kif il-harness jużaha biex iħaddem il-kmandi. Se nuru kif l-utenti finali u l-intrapriżi jistgħu jadattaw il-permessi tagħha għall-ħtiġijiet tagħhom u kif l-iżviluppaturi jistgħu jerġgħu jużaw is-sandbox fl-għodod tagħhom stess. Fl-aħħar nett, se neżaminaw kif dawn ir-restrizzjonijiet jiġu infurzati fuq macOS, Linux u Windows.

L-għażla tal-limiti tas-sandbox

F'Codex, il-filosofija tagħna hija li nispeċifikaw settings predefiniti konservattivi għas-sandbox li xorta jippermettu xogħol utli. Pereżempju, b'repożitorju Git bħala l-għerq tal-ispazju tax-xogħol, il-profil tal-permessi integrat :workspace:

  • Jippermetti l-kitba fl-ispazju tax-xogħol, filwaqt li jżomm direttorji bħal .git u .codex għall-qari biss. Dan iħalli lil Codex jeditja l-kodiċi sors mingħajr ma jitlob permess għal kull bidla, filwaqt li jipprevjeni bidliet diretti f'.codex/config.toml jew fil-hooks ta' Git taħt .git/hooks.

  • Jippermetti aċċess wiesa' għall-qari tas-sistema tal-fajls, soġġett għall-permessi eżistenti tal-utent fis-sistema operattiva. Il-kompilaturi, l-ambjenti ta' eżekuzzjoni u l-għodod tal-bini jiddependu fuq SDKs, libreriji u konfigurazzjoni barra mir-repożitorju. Il-limitazzjoni tal-qari għall-ispazju tax-xogħol twaqqaf ħafna flussi tax-xogħol ordinarji milli jaħdmu. Il-kompromess huwa li fajls sensittivi f'postijiet oħra fuq il-magna jistgħu jibqgħu jinqraw ukoll (bħal fajls ta' konfigurazzjoni li fihom ċwievet tal-API).

  • Jiddiżattiva l-aċċess għan-network. Dan jimblokka uploads diretti lejn servizzi esterni, inklużi tentattivi biex tittieħed bil-moħbi data li l-kmand jista' jaqra. Jipprevjeni wkoll operazzjonijiet leġittimi bħat-tniżżil ta' dipendenzi, li jeħtieġu aċċess addizzjonali.

Dawn ir-restrizzjonijiet jipprevjenu firxa wiesgħa ta' mġiba ħażina, iżda xorta jistgħu jsiru azzjonijiet dannużi. Pereżempju, l-aġent jista' jinjetta kodiċi malizzjuż f'pakkett installat lokalment bħal node_modules/prettier. Bidla bħal din tista' ma tidhirx f'git status għax Git spiss jinjora node_modules. Jekk l-editur tal-utent iħaddem dik il-kopja ta' Prettier meta jissejvja, is-sempliċi fatt li jissejvja fajl jista' jeżegwixxi l-kodiċi malizzjuż barra mis-sandbox ta' Codex. Għalhekk nadottaw approċċ ta' difiża f'diversi saffi: is-sandbox tillimita dak li jistgħu jaċċessaw il-kmandi, filwaqt li t-taħriġ u l-allinjament jgħinu lill-mudell juża dak l-aċċess skont l-intenzjoni tal-utent.

Għal gwida dwar kif tadatta l-permessi tas-sandbox u tgħaqqadhom ma' protezzjonijiet oħra f'ambjent ta' intrapriża, ara l- gwida prattika għas-sigurtà ta' Codex⁠(jinfetaħ f’tieqa ġdida).

Id-disinn tas-sandbox

Il-magni virtwali u l-containers⁠(jinfetaħ f’tieqa ġdida) huma żewġ mekkaniżmi popolari għall-ħolqien ta' sandboxes, iżda bis-sandbox ta' Codex nadottaw approċċ differenti. Minflok imexxi l-komputazzjoni lejn ambjent separat biex jipprovdi iżolament, Codex juża l-faċilitajiet ta' sandboxing ta' kull pjattaforma biex jirrestrinġi l-kmandi li jitħaddmu fl-ambjent eżistenti tal-utent.

Għal ħafna żviluppaturi, il-laptop tagħhom iservi bħala ambjent ta' żvilupp imfassal għalihom li jistgħu jbiddlu xħin iridu. Ir-riproduzzjoni ta' dak l-ambjent f'container Docker tista' tieħu x-xogħol, u xi flussi tax-xogħol xorta jiddependu fuq għodod li jitħaddmu fuq il-host.

Pereżempju, ikkunsidra li tuża Codex biex tiżviluppa app tal-iOS fuq Mac. Jekk tiddeċiedi li tiżola lil Codex billi tħaddmu f'Docker, Codex ma jkunx jista' jħaddem il-katina tal-għodod tal-bini tal-iOS magħmula minn eżekutabbli nattivi tal-Mac, u lanqas iniedi s-simulatur tal-iPhone biex iħaddem il-kodiċi. Fluss tax-xogħol ibbażat fuq Docker jista' jiddelega l-bini u l-operazzjonijiet tas-simulatur lill-host Mac, iżda dawk l-operazzjonijiet jitwettqu barra mis-sandbox tal-container u jkollhom bżonn ir-restrizzjonijiet tagħhom stess. Għal Codex, nippreferu nżommu l-affarijiet sempliċi billi ninvestu ħafna f'sandboxing speċifiku għas-sistema operattiva, biex Codex ikun jista' jaħdem fl-ambjent l-aktar adattat għall-kompitu li jkun qed iwettaq.

Il-harness jesponi dawn il-mekkaniżmi ta' sandboxing speċifiċi għas-sistema operattiva permezz ta' API komuni għal macOS, Windows u Linux. Din l-API tieħu kmand u profil tal-permessi. Jekk il-profil tal-permessi jippermetti aċċess limitat għan-network, il-komponent li jsejjaħ l-API għandu jipprovdi proxy tan-network biex jinforza dawk il-limiti:

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:

Din il-funzjoni tibda l-proċess f'sandbox u tirritorna handle Child li l-harness jista' juża biex jistenna li l-proċess jintemm. Kull proċess wild jiret ir-restrizzjonijiet tas-sandbox tal-ġenitur tiegħu, għalhekk dawk ir-restrizzjonijiet japplikaw fis-siġra kollha tal-proċessi mibdija mill-kmand, anki għad-dixxendenti li jibqgħu jaħdmu wara li jintemm il-proċess oriġinali.

Id-dijagramma li ġejja turi kif dawn il-partijiet jaħdmu flimkien, mill-konfigurazzjoni sat-tħaddim ta' kmand f'sandbox. It-taqsimiet li jsegwu jispjegaw kull stadju.

Dijagramma tal-fluss: il-konfigurazzjoni u r-rekwiżiti ġestiti jiddefinixxu profil tal-permessi tas-sessjoni; il-harness ta' Codex iniedi kmandi taħt restrizzjonijiet tas-sandbox speċifiċi għall-pjattaforma fuq macOS, Linux jew Windows. Il-proċessi wlied jirtu dawk ir-restrizzjonijiet, u proxy tan-network fakultattiv jinforza r-regoli tad-dominji.

Kif il-harness juża s-sandbox

Kif spjegat f'Iċ-ċiklu tal-aġent ta' Codex pass pass, il-harness ta' Codex huwa responsabbli għall-eżekuzzjoni tas-sejħiet tal-għodod iġġenerati mill-mudell. Għall-kompiti tal-ipprogrammar, l-aktar għodda użata hija għodda tas-shell, li tħaddem kmandi bħalma jagħmel utent f'shell interattiv bħal Bash. Hawn se neżaminaw l-għodda tas-shell ⁠(jinfetaħ f’tieqa ġdida)exec_command⁠(jinfetaħ f’tieqa ġdida) b'eżekuzzjoni waħda⁠(jinfetaħ f’tieqa ġdida) biex nuru kif il-harness juża s-sandbox biex jikseb il-protezzjonijiet mixtieqa.

Din hija verżjoni simplifikata ta' kif il-harness ta' Codex iwettaq is-sejħa tal-għodda
exec_command mingħajr sandboxing:

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}

Biex iħaddem il-kmand f'sandbox, il-harness jissostitwixxi s-sejħa lil subprocess.Popen() b'spawn_command_under_sandbox(). Il-harness jipprovdi l-profil tal-permessi u, meta jkun meħtieġ, il-proxy tan-network:

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}

L-għodda exec_command tħalli wkoll lill-mudell jitlob permessi differenti għal kmand individwali, iżda huwa l-harness li jiddeċiedi jekk jilqax it-talba:

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

Meta jiġi speċifikat use_default, il-harness juża l-konfigurazzjoni predefinita tas-sandbox għal dak it-turn. with_additional_permissions jitlob aċċess usa' fis-sandbox, filwaqt li require_escalated jitlob eżekuzzjoni barra minnha. Il-harness jevalwa t-talba skont il-preferenzi tal-utent qabel jeżegwixxi l-kmand. (Pereżempju, Codex jista' jistaqsi lill-utent direttament, jew jgħaddi t-talba għal reviżjoni awtomatika⁠(jinfetaħ f’tieqa ġdida).) Jekk l-eżekuzzjoni tiġi awtorizzata, Codex jgħaddi l-permission_profile u n-network_proxy xierqa lil perform_exec_command_with_sandboxing() bl-argumenti tal-kmand mill-ExecCommandToolCall oriġinali.

L-għodda tas-shell hija l-komponent ewlieni li juża spawn_command_under_sandbox(), u l-harness jerġa' juża wkoll l-infrastruttura tas-sandboxing tiegħu għal operazzjonijiet bħall-qari u l-modifika ta' fajls lokali. Dan l-użu mill-ġdid jestendi lil hinn mill-harness: il-kmand codex sandbox iħallik tinkorpora l-eżekuzzjoni ta' kmandi f'sandbox fl-għodod tiegħek stess, kif se naraw aktar tard. Issa se naraw kif jiġu definiti l-profili tal-permessi.

Il-konfigurazzjoni tas-sandbox

Profil tal-permessi b'isem iħallik terġa' tuża l-istess restrizzjonijiet tas-sistema tal-fajls u tan-network fi proġetti differenti. Tista' tiddefinixxi l-profili tiegħek taħt [permissions] f'config.toml. Pereżempju, dan li ġej jiddefinixxi profil bl-isem dev li jestendi⁠(jinfetaħ f’tieqa ġdida) l-profil integrat :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"

Il-profil dev iżid aċċess għall-kitba f'~/build-cache u jimponi restrizzjonijiet addizzjonali fuq il-fajls fl-ispazju tax-xogħol. L-entrati tas-sistema tal-fajls jistgħu jagħtu aċċess għall-qari biss (read), jagħtu aċċess għall-qari u l-kitba (write), jew jimblokkaw l-aċċess għalkollox (deny).

It-tabella :workspace_roots tħallik tiddefinixxi regoli għal mogħdijiet relattivi għall-għeruq tal-ispazju tax-xogħol ta' proġett. B'mod predefinit, il-CLI ta' Codex juża d-direttorju tax-xogħol tiegħu bħala l-uniku għerq tal-ispazju tax-xogħol, filwaqt li l-app tad-desktop ta' ChatGPT tuża l-folders sors tal-proġett. Codex japplika kull regola għal kull għerq, għalhekk l-entrata .vscode f'dev tagħmel id-direttorju .vscode taħt kull għerq disponibbli għall-qari biss.

Minbarra r-regoli tiegħu stess, dev jiret il-protezzjonijiet li ġejjin minn :workspace:

TOML

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

Permessi tan-network

Biex tikkonfigura n-network għas-sandbox f'Codex, hemm bejn wieħed u ieħor tliet għażliet:

  • Iddiżattiva kull aċċess għan-network (l-issettjar predefinit għall-profil :workspace)

  • Attiva aċċess sħiħ u dirett għan-network (l-issettjar predefinit għall-profil :danger-full-access)

  • Illimita l-aċċess għan-network għal proxy, li jiddeċiedi x'jgħaddi skont il-profil tal-permessi


Biex tagħti aċċess dirett għan-network lil
dev, issettja permissions.dev.network.enabled = true fl-ogħla livell ta' config.toml. Dan jagħti aċċess sħiħ għan-network meta l-proxy tan-network ikun diżattivat.

Biex tillimita lil dev għal sett ta' dominji, attiva l-proxy tan-network u kkonfigura r-regoli tad-dominji tiegħu:

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

Ir-regoli tad-dominji jappoġġjaw ismijiet eżatti u mudelli b'karattri ġolly, bir-regoli espliċiti ta' ċaħda jieħdu preċedenza fuq ir-regoli li jippermettu l-aċċess. Talbiet lejn dominji oħra jeħtieġu approvazzjoni jew jiġu mblokkati, kif deskritt fit-taqsima Proxy tan-network hawn taħt.

Konfigurazzjoni f'saffi u infurzar tal-limiti

L-utenti individwali jistgħu jikkonfiguraw settings predefiniti li japplikaw għall-proġetti kollha u jissostitwuhom għal proġett partikolari fdat. L-amministraturi tal-intrapriżi jistgħu wkoll ikunu jridu jikkonfiguraw settings predefiniti għall-utenti tagħhom u jirrestrinġu liema settings jistgħu jbiddlu dawk l-utenti. Codex jappoġġja t-tnejn permezz ta' konfigurazzjoni f'saffi u rekwiżiti ġestiti.

Kif deskritt f'Preċedenza tal-konfigurazzjoni,⁠(jinfetaħ f’tieqa ġdida) Codex jgħaqqad settings minn diversi fajls config.toml. It-tabelli jingħaqdu b'mod rikursiv, bis-sors ta' preċedenza ogħla jirbaħ meta l-valuri jkunu f'kunflitt. L-arrays jiġu sostitwiti sħaħ.

Għalhekk il-profili tal-permessi jużaw tabelli għall-mogħdijiet tas-sistema tal-fajls u għad-dominji tan-network. Tim jista' jżid jew jissostitwixxi entrati individwali fil-konfigurazzjoni tiegħu stess u jiret awtomatikament il-bidliet fl-entrati l-oħra kollha tal-konfigurazzjoni bażi tal-organizzazzjoni:

TOML

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

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

L-amministraturi jistgħu wkoll jipprovdu rekwiżiti ġestiti⁠(jinfetaħ f’tieqa ġdida) permezz ta' requirements.toml biex jirrestrinġu l-għażliet ta' konfigurazzjoni tal-utenti. Dawn ir-rekwiżiti jistgħu jiġu minn diversi sorsi, inklużi fajls tas-sistema u politika pprovduta mill-cloud. Użu komuni huwa li jiġi speċifikat allowed_permission_profiles biex jiġi ristrett is-sett ta' profili tal-permessi li utent ta' intrapriża jista' jagħżel. Pereżempju, amministratur jista' jispeċifika dawn ir-rekwiżiti tal-cloud:

TOML

1
default_permissions = ":read-only"
2

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

Ir-rekwiżiti tal-cloud jieħdu preċedenza fuq il-fajl tar-rekwiżiti tas-sistema f'/etc/codex/requirements.toml, għalhekk entrata f'dak il-fajl ma tistax tieħu preċedenza fuq l-issettjar espliċitu ":danger-full-access" = false ta' hawn fuq. Jekk :workspace jitħalla mhux speċifikat, saff ieħor ta' rekwiżiti jkun jista' jipprovdi dik l-entrata. Il-profili li l-entrati tagħhom huma false jew assenti mit-tabella finali magħquda ma jkunux disponibbli.

Din is-separazzjoni tħalli lill-organizzazzjonijiet jinfurzaw il-limiti filwaqt li l-utenti jadattaw il-konfigurazzjoni tagħhom f'dawk il-limiti. Il-profili tal-permessi li jirriżultaw jistgħu jintużaw mill-harness jew jiġu applikati direttament għal kmand, kif se naraw li jmiss.

L-użu tal-kmand codex sandbox

Il-CLI ta' Codex jipprovdi kmand sandbox biex jiffaċilita t-tħaddim ta' kwalunkwe kmand taħt profil tal-permessi definit fil-konfigurazzjoni ta' Codex. Dan spiss jintuża biex jiġi ttestjat il-profil, biex jiġi żgurat li s-sandbox tipprevjeni l-imġiba li kienet iddisinjata biex timblokka.

Pereżempju, il-kmand li ġej jipprova jikkonfigura VS Code biex iħaddem formattatur awtomatiku malizzjuż meta jissejvja. Jekk .vscode diġà jeżisti, il-profil dev definit hawn fuq għandu jimblokka din il-kitba għax dak id-direttorju huwa għall-qari biss (codex sandbox jittratta cwd bħala għerq tal-ispazju tax-xogħol b'mod predefinit):

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

Tabilħaqq, fuq macOS dan ifalli b'dan il-messaġġ:

Test sempliċi

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

Il-kmand codex sandbox jagħmel il-mekkaniżmu ta' sandboxing ta' Codex disponibbli indipendentement minn sessjoni ta' aġent. Tista' tuża l-istess lingwa ta' konfigurazzjoni u infurzar speċifiku għall-pjattaforma biex tirrestrinġi kmandi mnedija mill-għodod tiegħek stess.

Eżempju: l-iżolament ta' server MCP f'sandbox

Għal server MCP li juża stdio u huwa kkonfigurat f'config.toml, il-harness ta' Codex ma jippruvax iqiegħed f'sandbox il-kmand użat biex jinbeda s-server. Codex ma jistax jiddeduċi b'mod affidabbli liema fajls jew servizzi tan-network jeħtieġ dak is-server, għalhekk l-applikazzjoni ta' profil predefinit tas-sandbox tista' twaqqaf konfigurazzjoni valida milli taħdem.

Pereżempju, il-mod standard biex tikkonfigura s-server MCP @modelcontextprotocol/server-memory⁠(jinfetaħ f’tieqa ġdida) għall-użu ma' Codex huwa dan:

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"

Billi dan il-kmand npx jitħaddem barra minn sandbox, jista' jikteb fajls u jagħmel talbiet tan-network bl-istess permessi tal-utent li jħaddem Codex, u dan jagħtih aktar aċċess milli meħtieġ. Biex nirrestrinġuh, nistgħu niddefinixxu profil tal-permessi bl-isem memory-mcp u mbagħad inħaddmu l-kmand oriġinali npx permezz ta' codex sandbox --permission-profile memory-mcp biex nillimitaw fejn is-server jista' jikteb u nipprevjenuh milli jaċċessa n-network:

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"

Qabel tibda s-server, oħloq id-direttorju tad-data tiegħu u imla l-cache ta' npm bil-verżjoni speċifikata tal-pakkett. Dan iħalli lil npx --offline iniedi s-server taħt profil li jiddiżattiva l-aċċess għan-network:

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

Ladarba l-pakkett ikun fil-cache, Codex jista' jibda s-server tal-memorja mingħajr aċċess għan-network, bil-kitba limitata għall-cache ta' npm u għad-direttorju tad-data tas-server.

L-implimentazzjoni tas-sandbox ta' Codex

L-implimentazzjoni tas-sandbox tikkonverti profil tal-permessi f'restrizzjonijiet infurzati mis-sistema operattiva. Il-loġika ewlenija tal-proxy tan-network għall-immaniġġjar tat-talbiet u għall-politika hija kondiviża bejn it-tliet sistemi operattivi ewlenin, filwaqt li t-twaqqif tal-proxy u l-integrazzjoni tiegħu mas-sandbox huma speċifiċi għas-sistema operattiva. L-ewwel se neżaminaw il-proxy kondiviż, imbagħad l-implimentazzjonijiet għal macOS, Linux u Windows.

Proxy tan-network

Biex jinforza r-restrizzjonijiet tan-network ta' profil tal-permessi, il-harness jibda proxy tan-network u jikkonfigura s-sandbox biex tippermetti konnessjonijiet miegħu filwaqt li timblokka konnessjonijiet diretti ma' hosts esterni. Il-proxy jiċċekkja kull talba mar-regoli tad-dominji tal-profil biex jiddetermina jekk għandux jgħaddiha.

Fir-repożitorju ta' Codex, il-proxy tan-network huwa implimentat fil-crate codex-network-proxy⁠(jinfetaħ f’tieqa ġdida), li l-harness juża bħala librerija, għalkemm jista' jinbena wkoll bħala CLI indipendenti⁠(jinfetaħ f’tieqa ġdida). Meta jkun attivat, codex-network-proxy jibda kemm proxy HTTP kif ukoll proxy SOCKS5 b'mod predefinit. Dawn l-indirizzi tal-proxy jiġu mgħoddija lill-proċess imniedi mis-sandbox permezz ta' varjabbli tal-ambjent. Minbarra l-injezzjoni ta' varjabbli standard tal-ambjent bħal HTTP_PROXY, HTTPS_PROXY u ALL_PROXY, jiġu injettati wkoll għadd ta' varjabbli tal-ambjent speċifiċi għall-applikazzjoni⁠(jinfetaħ f’tieqa ġdida) magħrufa sew (bħal PIP_PROXY). Tajjeb ngħidu li mhux il-programmi kollha jirrispettaw dawn il-varjabbli tal-ambjent. Jekk programm jipprova jikkonnettja direttament ma' host estern, ir-restrizzjonijiet tas-sandbox tas-sistema operattiva jimblokkawh, kif deskritt fit-taqsimiet speċifiċi għall-pjattaforma hawn taħt.

Il-proxy tan-network huwa responsabbli għall-implimentazzjoni tar-restrizzjonijiet tan-network definiti fi profil tal-permessi. Pereżempju, il-profil dev muri qabel jippermetti talbiet lejn *.openai.com u jiċħad b'mod espliċitu talbiet lejn evil.example. Meta talba tkun lejn dominju li ma jaqbilx ma' regola ta' permess jew ċaħda, il-proxy jista' jissospendi t-talba waqt li jgħaddiha lill-harness għall-approvazzjoni. Bħal fl-eżempju tal-kmand tas-shell, Codex jista' jistaqsi lill-utent direttament, jew jgħaddi t-talba għal reviżjoni awtomatika⁠(jinfetaħ f’tieqa ġdida). Malli jirċievi deċiżjoni, il-proxy jew iħalli t-talba tkompli jew jiċħadha b'risposta ta' żball.

L-ordni hija importanti hawn għax anki tfittxija DNS tista' tikxef informazzjoni kkodifikata f'isem ta' host. Għalhekk il-proxy jsolvi l-isem tal-host mitlub biss wara li jiddetermina li huwa permess jew approvat. Innota li regoli wesgħin b'karattri ġolly jew aċċess għal servizzi DNS xorta jistgħu jippermettu t-teħid ta' data bil-moħbi permezz tad-DNS.

macOS

Fuq macOS, Codex juża Seatbelt⁠(jinfetaħ f’tieqa ġdida), il-mekkaniżmu ta' sandboxing ta' Apple infurzat mill-kernel. Il-politiki ta' Seatbelt jinkitbu f'Sandbox Profile Language (SBPL), lingwa bbażata fuq Scheme biex tesprimi r-restrizzjonijiet tas-sandbox. Codex jinvoka Seatbelt permezz tal-kmand /usr/bin/sandbox-exec ta' macOS. Bħal codex sandbox, jieħu għażliet li jiddeskrivu s-sandbox segwiti mill-kmand li għandu jitħaddem:

Bash

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

Il-PROFILE huwa string ta' SBPL li fih entrati li jikkonfiguraw is-sandbox. Pereżempju, il-framment SBPL li ġej jippermetti l-qari u l-kitba ta' /dev/null u /dev/zero taħt il-politika tas-sandbox:

Scheme

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

Meta l-proxy tan-network jiġi attivat bħala parti minn invokazzjoni tas-sandbox, jiġu injettati fil-profil regoli bħal dawn li ġejjin biex il-konnessjonijiet jiġu limitati għall-ports lokali xierqa:

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


Il-profil bażi ta' Codex jibda b'
(deny default), għalhekk il-konnessjonijiet 'il barra jibqgħu mblokkati sakemm ma jiġux permessi b'mod espliċitu.

Fl-aħħar nett, l-SBPL jista' jkun fih placeholders li jużaw (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)))

li jimtlew bl-għażliet -Dkey=value mgħoddija lil sandbox-exec.

Biex jimplimenta l-API tas-sandbox tiegħu stess, Codex jibni l-lista ta' argumenti⁠(jinfetaħ f’tieqa ġdida) għal sandbox-exec billi jibda minn politika bażi⁠(jinfetaħ f’tieqa ġdida), u mbagħad juża permission_profile u kuntest ieħor biex jemendaha u jipproduċi l-profil sħiħ ta' Seatbelt. Il-profil li jirriżulta u l-argumenti -D li jakkumpanjawh jikkonfiguraw ir-restrizzjonijiet infurzati minn Seatbelt, filwaqt li l-proxy tan-network jinforza regoli addizzjonali tan-network. Ladarba l-lista sħiħa tal-argumenti tkun lesta, l-invokazzjoni ta' sandbox-exec tkun sempliċi.

Il-ġenerazzjoni ta' SBPL korrett hija diffiċli għax Apple ma tiddokumentax il-lingwa għall-użu minn partijiet terzi. Tabilħaqq, man sandbox-exec jgħid The sandbox-exec command is DEPRECATED (kif inhi wkoll il-funzjoni tal-librerija sandbox_init() dokumentata permezz ta' man 3 sandbox_init). Minkejja t-twissija li l-użu tiegħu m'għadux rakkomandat, macOS għadu jinkludi profili Seatbelt f'/usr/share/sandbox, u software ta' partijiet terzi, inklużi Google Chrome u Chromium⁠(jinfetaħ f’tieqa ġdida), għadu jiddependi fuq Seatbelt. Għalhekk, qed nippjanaw li nkomplu nużaw Seatbelt għall-futur prevedibbli.

Linux

Biex joħloq is-sandbox fuq Linux, Codex juża kombinazzjoni ta' bubblewrap⁠(jinfetaħ f’tieqa ġdida) (bwrap), għodda tal-linja tal-kmand għall-bini ta' ambjenti iżolati, u seccomp-bpf⁠(jinfetaħ f’tieqa ġdida), mekkaniżmu tal-kernel ta' Linux għall-filtrazzjoni tas-sejħiet tas-sistema. Programm intern ta' għajnuna bl-isem codex-linux-sandbox jikkoordina t-twaqqif. Bħal sandbox-exec fuq macOS, jieħu konfigurazzjoni tas-sandbox segwita minn kmand li għandu jitħaddem:

Bash

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

Meta jkun meħtieġ iżolament tas-sistema tal-fajls jew rotta permezz ta' proxy, codex-linux-sandbox jinvoka bwrap biex joħloq l-ambjent inizjali tas-sandbox. Imbagħad bwrap iniedi codex-linux-sandbox --apply-seccomp-then-exec ġo fih. Din it-tieni invokazzjoni tuża seccomp-bpf biex tapplika restrizzjonijiet addizzjonali qabel tħaddem il-kmand tal-utent.

Biex jibni dak l-ambjent inizjali tas-sandbox, Codex juża bubblewrap biex joħloq veduta tas-sistema tal-fajls fi spazju separat tal-ismijiet tal-mounts li jirrifletti r-regoli tas-sistema tal-fajls tal-profil tal-permessi. Billi dan huwa fundamentali għall-implimentazzjoni tas-sandbox, Codex jinkludi l-kopja tiegħu stess ta' bwrap f'każ li l-utent ma jkunx installa waħda, iżda jippreferi installazzjoni kompatibbli ta' ⁠(jinfetaħ f’tieqa ġdida)bwrap⁠(jinfetaħ f’tieqa ġdida) li tinstab f'PATH, meta tkun disponibbli. Fil-prattika, xi distribuzzjonijiet ta' Linux jiddiżattivaw l-aċċess għall-ispazji tal-ismijiet tal-utent b'mod predefinit⁠(jinfetaħ f’tieqa ġdida), iżda jagħmlu eċċezzjoni għal bwrap tas-sistema.

Bħal sandbox-exec, bwrap jieħu konfigurazzjoni tas-sandbox segwita minn kmand li jitħaddem fiha. Minflok juża lingwa ta' konfigurazzjoni apposta bħal SBPL, bwrap juża bnadar individwali għall-konfigurazzjoni. Codex juża l-għażliet li ġejjin biex joħloq il-veduta tas-sistema tal-fajls:

  • --bind biex jispeċifika fajl jew direttorju li jista' jinkiteb fih

  • --ro-bind biex jispeċifika fajl jew direttorju għall-qari biss

  • --perms 000 --tmpfs DIR --remount-ro DIR biex jiċħad l-aċċess għal DIR

  • --perms 000 --ro-bind-data FD FILE biex jiċħad l-aċċess għal FILE (fejn FD huwa deskrittur ta' fajl miftuħ għal /dev/null)

Biex japplika globs ta' ċaħda b'dawn l-għażliet, Codex jespandihom f'mogħdijiet konkreti qabel iniedi kull kmand. Mogħdijiet ġodda li jaqblu magħhom ma jiżdiedux awtomatikament mar-restrizzjonijiet tas-sandbox ta' dak il-kmand.

Codex jispeċifika wkoll għażliet bħal --unshare-ipc u --unshare-pid biex jipprevjeni lis-sandbox milli taċċessa tipi oħra ta' riżorsi fuq il-host, għalhekk bubblewrap jaffettwa aktar milli sempliċement il-viżibbiltà tal-fajls.

Meta juża bubblewrap, Codex jgħaddi --unshare-net kull meta n-network ikun diżattivat jew il-konnessjonijiet ikollhom jgħaddu mill-proxy tan-network, u dan joħloq spazju ġdid tal-ismijiet tan-network għas-sandbox. Imbagħad nużaw seccomp-bpf biex napplikaw restrizzjonijiet addizzjonali fuq is-sejħiet tas-sistema relatati man-network u l-familji ta' sockets disponibbli għall-kmand.


Speċifikament, nużaw il-
crate seccompiler⁠(jinfetaħ f’tieqa ġdida) biex nikkumpilaw programm BPF dinamikament skont il-filtri mixtieqa⁠(jinfetaħ f’tieqa ġdida) u napplikawh għal proċess ta' tnedija fis-sandbox biex ir-restrizzjonijiet jintirtu mis-siġra kollha tal-proċessi. Għalhekk, bwrap ma jħaddimx il-kmand tal-utent, iżda jħaddem il-programm ta' tnedija codex-linux-sandbox bl-argumenti tal-konfigurazzjoni tiegħu stess segwiti mill-kmand tal-utent:

Bash

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

Biex japplika l-filtri seccomp mingħajr privileġġi elevati, il-programm ta' tnedija jissettja l-bandiera no_new_privs ta' Linux⁠(jinfetaħ f’tieqa ġdida). Din il-bandiera tintiret mill-proċessi wlied u tipprevjenihom milli jiksbu privileġġi addizzjonali meta jeżegwixxu programm ieħor, bħal eżekutabbli setuid.

Il-filtri seccomp jiddependu fuq il-konfigurazzjoni tan-network. Meta l-aċċess għan-network ikun diżattivat, nimblokkaw għadd ta' sejħiet tas-sistema relatati man-network, bħal connect(2) u bind(2). Iżda meta l-proxy tan-network ikun attivat fis-sandbox, inħallu sockets IP biex ikun jista' jintlaħaq il-listener TCP maħluq minn codex-linux-sandbox, filwaqt li nimblokkaw b'mod predefinit il-ħolqien ta' sockets tad-dominju Unix indipendenti, għax dawn jistgħu jippermettu aċċess mhux intenzjonat għal riżorsi tal-host.

Il-konnessjoni mal-proxy tan-network

Meta l-konfigurazzjoni tas-sandbox tkun teħtieġ il-proxy tan-network, il-harness ta' Codex joħloq istanza waħda tal-proxy li tista' terġa' tintuża f'diversi invokazzjonijiet ta' codex-linux-sandbox fl-istess thread ta' Codex. Kull sandbox teħtieġ mod kif tilħaq dak il-proxy kondiviż mill-ispazju iżolat tal-ismijiet tan-network tagħha. Codex jipprovdi listener TCP loopback f'dak l-ispazju tal-ismijiet u jorganizza proċess barra mis-sandbox biex jaċċetta l-konnessjonijiet tiegħu u jgħaddihom lill-proxy.

Id-dijagrammi li ġejjin juru dan l-arranġament għal punt ta' tmiem wieħed tal-proxy, b'konnessjoni waħda li tgħaddi minnu murija fl-aħħar dijagramma. Qabel iniedi bubblewrap, codex-linux-sandbox joħloq par sockets Unix biex iservu bħala kanal ta' kontroll u joħloq proċess wild tiegħu stess. Il-proċess wild iħaddem run_host_bridge() u jistenna li jirċievi d-deskrittur tal-fajl tal-listener minn dak il-kanal:

Dijagramma tal-harness ta' Codex li jniedi codex-linux-sandbox, li joħloq proċess wild għat-trażmissjoni konness permezz ta' kanal ta' kontroll b'socket Unix.

F'dan l-eżempju, il-proċess ġenitur juża exec biex jissostitwixxi l-immaġni tal-programm tiegħu b'bwrap. Dan iwaqqaf is-sandbox u jniedi codex-linux-sandbox --apply-seccomp-then-exec fiha, filwaqt li jgħaddilu l-FD għall-kanal ta' kontroll:

Dijagramma li turi lil bwrap joħloq spazju tal-ismijiet tan-network għas-sandbox u jniedi codex-linux-sandbox fih, b'kanal ta' kontroll b'socket Unix għall-proċess ta' trażmissjoni barra mis-sandbox.

Fl-ispazju tal-ismijiet tan-network tas-sandbox, it-tieni invokazzjoni ta' codex-linux-sandbox toħloq listener TCP loopback u tgħaddi d-deskrittur tal-fajl tiegħu permezz tas-socket. Il-listener jibqa' assoċjat mal-ispazju tal-ismijiet tan-network tas-sandbox, u jippermetti lill-proċess wild li baqa' barra mis-sandbox jaċċetta konnessjonijiet minn programmi fiha filwaqt li jiftaħ il-konnessjonijiet tiegħu lejn il-proxy fl-ispazju tal-ismijiet tan-network tal-host. Wara t-trasferiment, iż-żewġ proċessi jagħlqu d-deskritturi tal-kanal ta' kontroll tagħhom, u l-proċess fis-sandbox jagħlaq il-kopja tiegħu tal-listener.

Ladarba l-listener TCP ikun lest, il-proċess fis-sandbox jissettja l-valur xieraq għal HTTP_PROXY⁠(jinfetaħ f’tieqa ġdida) u l-varjabbli tal-ambjent relatati biex jippuntaw lejn dak il-listener. Imbagħad japplika seccomp qabel ma joħloq proċess wild u jeżegwixxi l-kmand tal-utent:

Dijagramma li turi programm f'sandbox jikkonnettja ma' listener TCP loopback, bi proċess estern ta' trażmissjoni codex-linux-sandbox jgħaddi t-traffiku lill-proxy tan-network ta' Codex.

Il-proċess barra mis-sandbox iżomm il-listener miftuħ. Għal kull konnessjoni aċċettata, jiftaħ konnessjoni mal-proxy kkonfigurat u jgħaddi d-data fiż-żewġ direzzjonijiet.

Dan il-mekkaniżmu addizzjonali jagħti lill-kmand l-ispazju tal-ismijiet tan-network tiegħu stess, inkluża interfaċċa loopback separata. Fuq macOS, Seatbelt jippermetti lill-kmand jikkonnettja direttament ma' ports speċifikati fuq l-interfaċċa loopback tal-host. Fuq Linux, minflok, il-kmand jikkonnettja ma' listener fl-ispazju iżolat tal-ismijiet tiegħu, u proċess barra mis-sandbox jgħaddi dawk il-konnessjonijiet lill-proxy kkonfigurat. It-trasferiment tad-deskrittur jagħmel din il-konnessjoni possibbli mingħajr ma jesponi l-ispazju tal-ismijiet tan-network tal-host għall-kmand.

Windows

Aktar kmieni din is-sena, implimentajna sandbox fuq Windows u ktibna dwar l-isforzi tagħna f'dan il-qasam. Minn dakinhar, Microsoft ħarġet librerija msejħa MXC flimkien ma' karatteristiċi ġodda għall-iżolament tal-proċessi fis-sistema operattiva Windows. Bħalissa qed nibdlu s-sandbox eżistenti tagħna ma' waħda li tuża l-librerija MXC.

X'inhu MXC?

MXC (Microsoft eXecution Container) hija sistema għall-eżekuzzjoni tal-kodiċi f'sandbox⁠(jinfetaħ f’tieqa ġdida) ta' Microsoft li tappoġġja diversi backends ta' iżolament fuq Windows, Linux u macOS. Codex jappoġġja sandbox ibbażata fuq MXC fuq apparati Windows kompatibbli, billi juża iżolament nattiv tal-proċessi biex jirrestrinġi l-kmandi fl-ambjent eżistenti tal-utent.

Qed naqilbu għal MXC biex intejbu s-sigurtà u l-faċilità tal-użu, filwaqt li nindirizzaw diversi limitazzjonijiet tas-sandbox eżistenti tagħna għal Windows:

  • Il-ħtieġa ta' aċċess bi privileġġi elevati jew ta' amministratur biex titwaqqaf is-sandbox

  • Operazzjonijiet ta' verifika u ssettjar tal-ACLs li jieħdu ħafna riżorsi jew ħin

  • Stat persistenti tal-konfigurazzjoni tas-sandbox fuq il-magna host, inklużi

    • ACLs

    • Regoli tal-firewall

    • Utenti tas-sandbox

    • Fajls tas-saff tal-kontroll

MXC jesponi skemi ta' konfigurazzjoni JSON⁠(jinfetaħ f’tieqa ġdida). Codex juża l-MXC SDK⁠(jinfetaħ f’tieqa ġdida) biex jibni talba ta' eżekuzzjoni li ssegwi dik l-iskemi u tinkludi l-kmand, id-direttorju tax-xogħol, l-ambjent u l-permessi. Dawk il-permessi jkopru l-aċċess għas-sistema tal-fajls u għan-network, flimkien ma' riżorsi tal-Windows bħad-desktop u l-clipboard.

Il-konverżjoni tal-politika f'invokazzjoni ta' MXC

Codex juża settings fissi għal diversi kontrolli biex jibbilanċja l-kompatibbiltà u s-sigurtà. Jippermetti l-qari tar-reġistru u jżomm l-aċċess għal Win32k u għad-desktop li PowerShell jeħtieġ waqt l-istartjar. L-aċċess għall-clipboard, l-injezzjoni tal-input, u l-kontrolli tad-desktop u tas-settings tas-sistema huma diżattivati. Fl-aħħar nett, MXC ma jitħalliex jirrikorri għall-modifika tal-permessi tas-sistema tal-fajls tal-host bħala alternattiva.

Codex jikkonverti r-regoli tas-sistema tal-fajls u tan-network tal-profil tal-permessi fil-konfigurazzjoni ta' MXC. Jekk nużaw il-profil dev ta' qabel, u nassumu li:

  • C:\, D:\ u Z:\ huma l-uniċi drives lokali tal-magna.

  • L-għerq tal-ispazju tax-xogħol u d-direttorju tax-xogħol huma C:\work\demo.

  • Id-direttorju home tal-utent huwa D:\Users\dev, għalhekk ~/build-cache jirreferi għal D:\Users\dev\build-cache.

  • Il-glob ta' ċaħda jaqbel biss ma' C:\work\demo\config\dev.env u C:\work\demo\config\prod.env.

Is-settings korrispondenti ta' MXC ikunu jinkludu:

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
}

Aċċess għall-għerq tad-drive

Il-politika tas-sistema tal-fajls ta' MXC tiċħad l-aċċess b'mod predefinit. Għalhekk Codex jagħti permessi ta' qari biss għall-għeruq tad-drives lokali biex jipprovdi l-aċċess wiesa' għall-qari permess minn dan il-profil. Dawn il-permessi japplikaw b'mod rikursiv, soġġetti għall-permessi eżistenti tal-utent fis-sistema operattiva.

Hemm kumplikazzjoni waħda: il-permessi għall-kitba fl-għerq tad-drive ma japplikawx b'mod rikursiv, għalhekk Codex jestendihom biex jinkludi l-elementi eżistenti direttament taħt l-għerq tad-drive.

Permessi f'kunflitt

Mogħdijiet aktar speċifiċi jieħdu preċedenza fuq il-permessi tal-antenati tagħhom, għalhekk C:\work\demo jista' jippermetti l-kitba taħt C:\ li jippermetti l-qari biss, filwaqt li C:\work\demo\.git jibqa' għall-qari biss.

Meta forom differenti ta' mogħdija jew psewdonimi permezz ta' symlinks jew junctions jirreferu għall-istess mogħdija, MXC japplika l-permess aktar strett: iċ-ċaħda tieħu preċedenza fuq il-qari biss, li jieħu preċedenza fuq il-qari u l-kitba.

Globs ta' ċaħda

MXC jaċċetta biss mogħdijiet konkreti għaċ-ċaħda tal-aċċess, għalhekk Codex jespandi l-globs ta' ċaħda għall-fajls u d-direttorji li jaqblu magħhom qabel it-tnedija. Mogħdijiet ġodda li jaqblu mal-glob ma jiżdiedux awtomatikament waqt li jkun qed jaħdem il-kmand.

Aċċess għan-network

Regoli tad-dominji bħal *.openai.com jiġu infurzati mill-proxy tan-network kondiviż ta' Codex deskritt qabel. Codex iħaddem dak il-proxy barra mis-sandbox u jgħaddi l-indirizzi tiegħu lill-kmand permezz tal-istess varjabbli standard tal-ambjent *_PROXY imsemmija qabel. MXC jimblokka konnessjonijiet esterni diretti filwaqt li jippermetti konnessjonijiet mal-loopback tal-host, inkluż l-aċċess għall-proxy. Servizzi lokali oħra jibqgħu aċċessibbli.

Fuq macOS, Linux u Windows, il-harness juża l-istess API tas-sandbox biex iniedi kmandi taħt profil tal-permessi. L-implimentazzjonijiet speċifiċi għall-pjattaforma jieħdu ħsieb it-twaqqif meħtieġ biex jiġu applikati dawk ir-restrizzjonijiet.

Nibnu fuq is-sandbox ta' Codex

Il-kitba u l-eżekuzzjoni tal-kodiċi jagħtu lill-aġenti mod flessibbli biex isolvu problemi lil hinn mill-iżvilupp tas-software. Is-sandbox ta' Codex tħallihom jużaw dik il-kapaċità fl-ambjent eżistenti tal-utent b'limiti espliċiti fuq l-aċċess għas-sistema tal-fajls u għan-network. Hija komponent bażiku li jista' jerġa' jintuża fil-harness, u l-kmand codex sandbox jagħmilha disponibbli għall-għodod li tibni inti stess.

Hekk kif l-aġenti jieħdu f'idejhom aktar kompiti, irridu nagħmlu s-sandboxing prattiku għal aktar għodod u ambjenti. Dan ifisser li nagħmlu l-permessi aktar faċli biex jiġu kkonfigurati u nieħdu vantaġġ minn protezzjonijiet aħjar tas-sistema operattiva hekk kif isiru disponibbli. L-għan tagħna huwa li nwessgħu dak li jistgħu jagħmlu l-aġenti filwaqt li nħallu f'idejn in-nies il-kontroll ta' dak li l-aġenti jistgħu jaċċessaw.

Awtur

OpenAI

Rikonoxximenti

Grazzi speċjali lil David Wiesen, Charlie Weems, Viyat Bhalodia u Fotis Chantzis għall-kontribut tagħhom għal dan l-artiklu.