OpenAI

18 noiembrie 2026

Inginerie

În culisele mediului izolat Codex

Cum execută Codex comenzi pe calculatorul tău, în limitele pe care le controlezi.

De Michael Bolin, membru al echipei tehnice

La OpenAI, adoptăm o abordare de apărare în profunzime⁠(se deschide într-o fereastră nouă) pentru protejarea agenților. Deși investițiile noastre în antrenare și aliniere sunt fundamentale pentru acest efort, implementăm și funcții în cadrul nostru de testare pentru agenți, Codex⁠(se deschide într-o fereastră nouă), pentru a oferi protecție suplimentară. Întrucât executarea comenzilor pe calculatorul tău este una dintre cele mai frecvente activități ale Codex, dar și una potențial riscantă, am creat mediul izolat Codex, pentru ca acesta să poată lucra în mediul tău existent, în limitele de acces la sistemul de fișiere și la rețea pe care le controlezi.

Un ⁠(se deschide într-o fereastră nouă)mediu izolat⁠(se deschide într-o fereastră nouă) limitează resursele pe care le poate accesa un program în timpul execuției. Pentru o sarcină de organizare a fotografiilor, ai putea configura mediul izolat Codex astfel încât comenzile să poată citi și modifica fișiere din ~/Pictures, blocând totodată accesul la rețea pentru a împiedica încărcarea lor. Pentru revizuirea codului, ai putea permite accesul la documentația online, menținând fișierele sursă în modul doar pentru citire. Utilizatorii configurează mediul izolat Codex prin ⁠(se deschide într-o fereastră nouă)profiluri de permisiuni⁠(se deschide într-o fereastră nouă), care definesc restricțiile privind sistemul de fișiere și rețeaua pentru o sesiune Codex.

În acest articol, vom începe cu compromisurile care stau la baza setărilor implicite ale mediului izolat Codex, apoi vom explica arhitectura acestuia și modul în care cadrul de testare îl folosește pentru a executa comenzi. Vom arăta cum utilizatorii finali și companiile îi pot adapta permisiunile la nevoile lor și cum dezvoltatorii pot reutiliza mediul izolat în propriile instrumente. La final, vom analiza cum sunt impuse aceste restricții pe macOS, Linux și Windows.

Stabilirea limitelor mediului izolat

În Codex, filosofia noastră este să stabilim setări implicite prudente pentru mediul izolat, care să permită totuși desfășurarea unei activități utile. De exemplu, dacă rădăcina spațiului de lucru este un depozit Git, profilul de permisiuni încorporat :workspace:

  • Permite scrierea în spațiul de lucru, păstrând directoare precum .git și .codex doar pentru citire. Astfel, Codex poate edita codul sursă fără a cere permisiunea pentru fiecare schimbare, împiedicând totodată modificarea directă a .codex/config.toml sau a hook-urilor Git din .git/hooks.

  • Permite acces extins la citire în sistemul de fișiere, în limitele permisiunilor existente ale utilizatorului în sistemul de operare. Compilatoarele, mediile de execuție și instrumentele de construire depind de SDK-uri, biblioteci și configurații din afara depozitului. Limitarea citirii la spațiul de lucru ar împiedica funcționarea multor fluxuri de lucru obișnuite. Compromisul este că fișierele sensibile aflate în alte locuri pe calculator pot rămâne și ele accesibile pentru citire, cum ar fi fișierele de configurare care conțin chei API.

  • Dezactivează accesul la rețea. Acest lucru blochează încărcarea directă către servicii externe, inclusiv încercările de exfiltrare a datelor pe care comanda le poate citi. De asemenea, împiedică operațiuni legitime, cum ar fi descărcarea dependențelor, care necesită acces suplimentar.

Aceste restricții împiedică o gamă largă de comportamente nedorite, dar acțiunile dăunătoare rămân posibile. De exemplu, agentul ar putea injecta cod rău intenționat într-un pachet instalat local, precum node_modules/prettier. O astfel de modificare ar putea să nu apară în git status, deoarece node_modules este adesea ignorat de Git. Dacă editorul utilizatorului rulează acea copie a Prettier la salvare, simpla salvare a unui fișier ar putea executa codul rău intenționat în afara mediului izolat Codex. De aceea adoptăm o abordare de apărare în profunzime: mediul izolat limitează resursele pe care le pot accesa comenzile, iar antrenarea și alinierea ajută modelul să folosească acel acces în conformitate cu intenția utilizatorului.

Pentru îndrumări privind adaptarea permisiunilor mediului izolat și combinarea lor cu alte măsuri de protecție într-un mediu de întreprindere, consultă Ghidul practic de securitate Codex⁠(se deschide într-o fereastră nouă).

Proiectarea mediului izolat

Mașinile virtuale și containerele⁠(se deschide într-o fereastră nouă) sunt două mecanisme populare de izolare, dar pentru mediul izolat Codex adoptăm o abordare diferită. În loc să mute execuția într-un mediu separat pentru a asigura izolarea, Codex folosește funcțiile de izolare ale fiecărei platforme pentru a restricționa comenzile care rulează în mediul existent al utilizatorului.

Pentru mulți dezvoltatori, laptopul este un mediu de dezvoltare personalizat, pe care îl pot schimba oricând doresc. Reproducerea acelui mediu într-un container Docker poate necesita efort, iar unele fluxuri de lucru depind în continuare de instrumente care rulează pe gazdă.

Să luăm, de exemplu, utilizarea Codex pentru a dezvolta o aplicație iOS pe un Mac. Dacă ai decide să izolezi Codex rulându-l în Docker, acesta nu ar putea rula lanțul de instrumente de construire iOS, alcătuit din executabile native pentru Mac, și nici nu ar putea lansa simulatorul iPhone pentru a rula codul. Un flux de lucru bazat pe Docker ar putea delega construirile și operațiunile simulatorului către gazda Mac, dar acele operațiuni s-ar executa în afara mediului izolat al containerului și ar necesita propriile restricții. Pentru Codex, preferăm să păstrăm lucrurile simple, investind substanțial în izolarea specifică fiecărui sistem de operare, astfel încât Codex să poată rula în mediul cel mai potrivit pentru sarcina de rezolvat.

Cadrul de testare pune la dispoziție aceste mecanisme de izolare specifice sistemului de operare printr-un API comun pentru macOS, Windows și Linux. Acest API primește o comandă și un profil de permisiuni. Dacă profilul de permisiuni permite acces limitat la rețea, apelantul trebuie să furnizeze un proxy de rețea care să impună acele limite:

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:

Această funcție pornește procesul într-un mediu izolat și returnează un handle Child, pe care cadrul de testare îl poate folosi pentru a aștepta încheierea procesului. Fiecare proces fiu moștenește constrângerile de izolare ale părintelui său, astfel încât restricțiile se aplică întregului arbore de procese inițiat de comandă, inclusiv descendenților care continuă să ruleze după încheierea procesului inițial.

Diagrama următoare arată cum se îmbină aceste componente, de la configurare până la executarea unei comenzi într-un mediu izolat. Secțiunile următoare explică fiecare etapă.

Diagramă de flux: configurația și cerințele gestionate definesc un profil de permisiuni pentru sesiune; cadrul de testare Codex lansează comenzi cu restricții de izolare specifice platformei pe macOS, Linux sau Windows. Procesele fiu moștenesc acele restricții, iar un proxy de rețea opțional impune regulile de domeniu.

Cum folosește cadrul de testare mediul izolat

După cum se explică în Analiza buclei agentului Codex, cadrul de testare Codex este responsabil de executarea apelurilor de instrumente generate de model. Pentru sarcinile de programare, instrumentul cel mai des folosit este un instrument shell, care execută comenzi la fel cum ar face-o un utilizator într-un shell interactiv precum Bash. Aici vom analiza instrumentul shell ⁠(se deschide într-o fereastră nouă)exec_command⁠(se deschide într-o fereastră nouă) cu execuție unică⁠(se deschide într-o fereastră nouă), pentru a ilustra cum folosește cadrul de testare mediul izolat pentru a asigura protecția dorită.

Aceasta este o versiune simplificată a modului în care cadrul de testare Codex ar executa apelul instrumentului
exec_command fără izolare:

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}

Pentru a izola comanda, cadrul de testare înlocuiește apelul subprocess.Popen() cu spawn_command_under_sandbox(). Cadrul de testare furnizează profilul de permisiuni și, când este necesar, proxy-ul de rețea:

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}

Instrumentul exec_command permite și modelului să solicite permisiuni diferite pentru o anumită comandă, dar cadrul de testare decide dacă aprobă cererea:

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

Când este specificat use_default, cadrul de testare folosește configurația implicită a mediului izolat pentru tura curentă. with_additional_permissions solicită acces extins în mediul izolat, în timp ce require_escalated solicită executarea în afara acestuia. Cadrul de testare evaluează cererea pe baza preferințelor utilizatorului înainte de a executa comanda. (De exemplu, Codex îi poate cere direct aprobarea utilizatorului sau poate trimite cererea către revizuirea automată⁠(se deschide într-o fereastră nouă).) Dacă execuția este autorizată, Codex transmite valorile corespunzătoare pentru permission_profile și network_proxy către perform_exec_command_with_sandboxing(), împreună cu argumentele comenzii din ExecCommandToolCall original.

Instrumentul shell este principalul utilizator al spawn_command_under_sandbox(), iar cadrul de testare își reutilizează infrastructura de izolare și pentru operațiuni precum citirea și modificarea fișierelor locale. Această reutilizare depășește cadrul de testare: comanda codex sandbox îți permite să integrezi executarea comenzilor în medii izolate în propriile instrumente, așa cum vom vedea mai târziu. În continuare, vom vedea cum sunt definite profilurile de permisiuni.

Configurarea mediului izolat

Un profil de permisiuni cu nume îți permite să reutilizezi aceleași restricții pentru sistemul de fișiere și rețea în mai multe proiecte. Îți poți defini propriile profiluri în secțiunea [permissions] din config.toml. De exemplu, configurația următoare definește un profil numit dev, care extinde⁠(se deschide într-o fereastră nouă) profilul încorporat :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"

Profilul dev adaugă acces de scriere la ~/build-cache și impune restricții suplimentare asupra fișierelor din spațiul de lucru. Intrările pentru sistemul de fișiere pot acorda acces doar pentru citire (read), acces pentru citire și scriere (write) sau pot bloca integral accesul (deny).

Tabelul :workspace_roots îți permite să definești reguli pentru căi relative la rădăcinile spațiului de lucru al unui proiect. Implicit, interfața CLI Codex folosește directorul său de lucru ca unică rădăcină a spațiului de lucru, în timp ce aplicația ChatGPT pentru desktop folosește folderele sursă ale proiectului. Codex aplică fiecare regulă fiecărei rădăcini, astfel încât intrarea .vscode din dev face ca directorul .vscode din fiecare rădăcină să permită doar citirea.

Pe lângă propriile reguli, dev moștenește următoarele măsuri de protecție de la :workspace:

TOML

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

Permisiuni de rețea

Pentru configurarea rețelei în mediul izolat Codex, există, în linii mari, trei opțiuni:

  • Dezactivarea completă a accesului la rețea (implicită pentru profilul :workspace)

  • Activarea accesului complet și direct la rețea (implicită pentru profilul :danger-full-access)

  • Limitarea accesului la rețea la un proxy, care decide ce trafic permite pe baza profilului de permisiuni


Pentru a oferi profilului
dev acces direct la rețea, setează permissions.dev.network.enabled = true la nivelul superior al fișierului config.toml. Această setare acordă acces complet la rețea când proxy-ul de rețea este dezactivat.

Pentru a limita dev la un set de domenii, activează proxy-ul de rețea și configurează-i regulile de domeniu:

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

Regulile de domeniu acceptă nume exacte și șabloane cu metacaractere, iar regulile explicite de interzicere au prioritate față de regulile de permitere. Cererile către alte domenii necesită aprobare sau sunt blocate, după cum se descrie mai jos, în secțiunea Proxy de rețea.

Configurarea pe niveluri și impunerea limitelor

Utilizatorii individuali pot configura setări implicite aplicabile în toate proiectele și le pot suprascrie pentru un anumit proiect de încredere. Administratorii din companii pot dori, de asemenea, să configureze setări implicite pentru utilizatori și să limiteze setările pe care aceștia le pot modifica. Codex le permite pe ambele prin configurare pe niveluri și cerințe gestionate.

După cum se descrie în Ordinea de prioritate a configurațiilor,⁠(se deschide într-o fereastră nouă) Codex îmbină setările din mai multe fișiere config.toml. Tabelele sunt îmbinate recursiv, iar când valorile intră în conflict, prevalează sursa cu prioritate mai mare. Tablourile sunt înlocuite integral.

De aceea, profilurile de permisiuni folosesc tabele pentru căile din sistemul de fișiere și domeniile de rețea. O echipă poate adăuga sau suprascrie intrări individuale în propria configurație și poate moșteni automat modificările tuturor celorlalte intrări din configurația de bază a organizației:

TOML

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

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

Administratorii pot furniza și cerințe gestionate⁠(se deschide într-o fereastră nouă) prin requirements.toml, pentru a limita opțiunile de configurare ale utilizatorilor. Aceste cerințe pot proveni din mai multe surse, inclusiv fișiere de sistem și politici furnizate din cloud. Un caz de utilizare frecvent este specificarea allowed_permission_profiles pentru a limita setul de profiluri de permisiuni pe care îl poate selecta un utilizator dintr-o companie. De exemplu, un administrator ar putea specifica aceste cerințe din cloud:

TOML

1
default_permissions = ":read-only"
2

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

Cerințele din cloud ar avea prioritate față de fișierul de cerințe de sistem de la /etc/codex/requirements.toml, astfel încât o intrare din acel fișier nu poate suprascrie setarea explicită ":danger-full-access" = false de mai sus. Dacă :workspace nu este specificat, un alt nivel de cerințe poate furniza acea intrare. Profilurile ale căror intrări sunt false sau lipsesc din tabelul final rezultat din îmbinare nu sunt disponibile.

Această separare permite organizațiilor să impună limite, în timp ce utilizatorii își adaptează configurația în interiorul acelor limite. Profilurile de permisiuni rezultate pot fi folosite de cadrul de testare sau aplicate direct unei comenzi, așa cum vom vedea în continuare.

Utilizarea comenzii codex sandbox

Interfața CLI Codex oferă comanda sandbox pentru a facilita executarea oricărei comenzi cu un profil de permisiuni definit în configurația Codex. Aceasta este folosită frecvent pentru a testa profilul și a verifica dacă mediul izolat împiedică comportamentul pe care a fost conceput să îl blocheze.

De exemplu, următoarea comandă încearcă să configureze VS Code pentru a rula un instrument de formatare automată rău intenționat la salvare. Presupunând că .vscode există deja, profilul dev definit mai sus ar trebui să blocheze această scriere, deoarece acel director permite doar citirea (codex sandbox tratează implicit cwd ca rădăcină a spațiului de lucru):

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

Într-adevăr, pe macOS operațiunea eșuează cu mesajul:

Text simplu

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

Comanda codex sandbox face disponibil mecanismul de izolare Codex independent de o sesiune de agent. Poți folosi același limbaj de configurare și aceleași mecanisme de aplicare specifice platformei pentru a restricționa comenzile lansate de propriile instrumente.

Exemplu: izolarea unui server MCP

Pentru un server MCP stdio configurat în config.toml, cadrul de testare Codex nu încearcă să izoleze comanda folosită pentru a porni serverul. Codex nu poate deduce în mod fiabil de ce fișiere sau servicii de rețea are nevoie acel server, așa că aplicarea unui profil de izolare implicit ar putea împiedica funcționarea unei configurații altfel valide.

De exemplu, modul standard de configurare a serverului MCP @modelcontextprotocol/server-memory⁠(se deschide într-o fereastră nouă) pentru utilizarea cu Codex este următorul:

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"

Întrucât această comandă npx rulează fără izolare, poate scrie fișiere și trimite cereri de rețea cu aceleași permisiuni ca utilizatorul care rulează Codex, ceea ce îi oferă acces excesiv. Pentru a-i restrânge accesul, putem defini un profil de permisiuni numit memory-mcp, apoi putem executa comanda npx originală prin codex sandbox --permission-profile memory-mcp, pentru a limita locurile în care serverul poate scrie și a-i bloca accesul la rețea:

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"

Înainte de a porni serverul, creează directorul său de date și adaugă în memoria cache npm pachetul cu versiunea fixată. Astfel, npx --offline poate lansa serverul cu un profil care dezactivează accesul la rețea:

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

Odată ce pachetul se află în memoria cache, Codex poate porni serverul de memorie fără acces la rețea, cu scrierea limitată la memoria cache npm și la directorul de date al serverului.

Implementarea mediului izolat Codex

Implementarea mediului izolat transformă un profil de permisiuni în restricții impuse de sistemul de operare. Logica de bază a proxy-ului de rețea pentru gestionarea cererilor și aplicarea politicilor este comună celor trei sisteme de operare principale, în timp ce configurarea proxy-ului și integrarea cu mediul izolat sunt specifice fiecărui sistem. Vom analiza mai întâi proxy-ul comun, apoi implementările pentru macOS, Linux și Windows.

Proxy de rețea

Pentru a impune restricțiile de rețea ale unui profil de permisiuni, cadrul de testare pornește un proxy de rețea și configurează mediul izolat să permită conexiunile către acesta, blocând totodată conexiunile directe către gazde externe. Proxy-ul verifică fiecare cerere în raport cu regulile de domeniu ale profilului, pentru a decide dacă o transmite mai departe.

În depozitul Codex, proxy-ul de rețea este implementat în pachetul crate codex-network-proxy⁠(se deschide într-o fereastră nouă), pe care cadrul de testare îl folosește ca bibliotecă, deși poate fi compilat și ca interfață CLI independentă⁠(se deschide într-o fereastră nouă). Când este activat, codex-network-proxy pornește implicit atât un proxy HTTP, cât și un proxy SOCKS5. Adresele acestor proxy-uri sunt comunicate procesului lansat de mediul izolat prin variabile de mediu. Pe lângă variabilele de mediu standard, precum HTTP_PROXY, HTTPS_PROXY și ALL_PROXY, sunt injectate și o serie de variabile de mediu consacrate, specifice aplicațiilor⁠(se deschide într-o fereastră nouă) (cum ar fi PIP_PROXY). Desigur, nu toate programele țin cont de aceste variabile de mediu. Dacă un program încearcă să se conecteze direct la o gazdă externă, restricțiile de izolare ale sistemului de operare îl blochează, după cum se descrie în secțiunile dedicate fiecărei platforme de mai jos.

Proxy-ul de rețea este responsabil de implementarea restricțiilor de rețea definite într-un profil de permisiuni. De exemplu, profilul dev prezentat anterior permite cererile către *.openai.com și interzice explicit cererile către evil.example. Când o cerere vizează un domeniu care nu corespunde unei reguli de permitere sau de interzicere, proxy-ul poate suspenda cererea și poate delega aprobarea către cadrul de testare. Ca în exemplul cu comanda shell, Codex îi poate cere direct aprobarea utilizatorului sau poate trimite cererea către revizuirea automată⁠(se deschide într-o fereastră nouă). După primirea unei decizii, proxy-ul fie permite continuarea cererii, fie o respinge cu un răspuns de eroare.

Ordinea contează aici, deoarece chiar și o interogare DNS poate divulga informații codificate într-un nume de gazdă. Prin urmare, proxy-ul rezolvă numele de gazdă solicitat doar după ce stabilește că acesta este permis sau aprobat. Reține că regulile largi cu metacaractere sau accesul la servicii DNS pot permite în continuare exfiltrarea prin DNS.

macOS

Pe macOS, Codex folosește Seatbelt⁠(se deschide într-o fereastră nouă), mecanismul de izolare Apple aplicat la nivel de nucleu. Politicile Seatbelt sunt scrise în Sandbox Profile Language (SBPL), un limbaj bazat pe Scheme pentru exprimarea restricțiilor de izolare. Codex apelează Seatbelt prin comanda /usr/bin/sandbox-exec din macOS. La fel ca codex sandbox, aceasta primește opțiuni care descriu mediul izolat, urmate de comanda de executat:

Bash

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

PROFILE este un șir de cod SBPL care conține intrări pentru configurarea mediului izolat. De exemplu, următorul fragment SBPL permite citirea și scrierea în /dev/null și /dev/zero conform politicii mediului izolat:

Scheme

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

Când proxy-ul de rețea este activat la lansarea unui mediu izolat, în profil sunt injectate reguli precum cele de mai jos, pentru a limita conexiunile la porturile locale corespunzătoare:

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


Profilul de bază Codex începe cu
(deny default), astfel încât conexiunile de ieșire rămân blocate dacă nu sunt permise explicit.

În plus, SBPL poate conține substituenți care folosesc (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)))

aceștia sunt completați prin opțiunile -Dkey=value transmise către sandbox-exec.

Pentru a-și implementa propriul API de izolare, Codex construiește lista de argumente⁠(se deschide într-o fereastră nouă) pentru sandbox-exec pornind de la o politică de bază⁠(se deschide într-o fereastră nouă), apoi folosește permission_profile și alte informații de context pentru a o modifica și a produce profilul Seatbelt complet. Profilul rezultat și argumentele -D asociate configurează restricțiile impuse de Seatbelt, în timp ce proxy-ul de rețea impune reguli de rețea suplimentare. Odată alcătuită lista completă de argumente, apelarea sandbox-exec este simplă.

Generarea unui cod SBPL corect este dificilă, deoarece Apple nu documentează limbajul pentru utilizarea de către terți. Într-adevăr, man sandbox-exec precizează The sandbox-exec command is DEPRECATED (același lucru este valabil și pentru funcția de bibliotecă sandbox_init(), documentată prin man 3 sandbox_init). În ciuda avertismentului de depreciere, macOS include în continuare profiluri Seatbelt în /usr/share/sandbox, iar software-ul terț, inclusiv Google Chrome și Chromium⁠(se deschide într-o fereastră nouă), continuă să se bazeze pe Seatbelt. Prin urmare, intenționăm să folosim în continuare Seatbelt în viitorul previzibil.

Linux

Pentru a crea mediul izolat pe Linux, Codex combină bubblewrap⁠(se deschide într-o fereastră nouă) (bwrap), un instrument în linie de comandă pentru construirea mediilor izolate, cu seccomp-bpf⁠(se deschide într-o fereastră nouă), un mecanism al nucleului Linux pentru filtrarea apelurilor de sistem. Un utilitar intern numit codex-linux-sandbox coordonează configurarea. La fel ca sandbox-exec pe macOS, acesta primește o configurație a mediului izolat, urmată de o comandă de executat:

Bash

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

Când este necesară izolarea sistemului de fișiere sau rutarea prin proxy, codex-linux-sandbox apelează bwrap pentru a crea mediul izolat inițial. Apoi, bwrap lansează codex-linux-sandbox --apply-seccomp-then-exec în interiorul acestuia. Acest al doilea apel folosește seccomp-bpf pentru a aplica restricții suplimentare înainte de a rula comanda utilizatorului.

Pentru a construi mediul izolat inițial, Codex folosește bubblewrap pentru a crea o vedere a sistemului de fișiere într-un spațiu de nume de montare separat, care reflectă regulile pentru sistemul de fișiere din profilul de permisiuni. Întrucât acesta este un element fundamental al implementării mediului izolat, Codex include propria copie a bwrap, în cazul în care utilizatorul nu a instalat una, dar preferă o instalare compatibilă de ⁠(se deschide într-o fereastră nouă)bwrap⁠(se deschide într-o fereastră nouă) găsită în PATH, atunci când este disponibilă. În practică, unele distribuții Linux dezactivează implicit accesul la spațiile de nume de utilizator⁠(se deschide într-o fereastră nouă), dar acordă o excepție pentru bwrap din sistem.

Tot la fel ca sandbox-exec, bwrap primește o configurație a mediului izolat, urmată de o comandă de executat în acel mediu. În locul unui limbaj de configurare dedicat, precum SBPL, bwrap folosește opțiuni individuale pentru configurare. Codex folosește următoarele opțiuni pentru a crea vederea sistemului de fișiere:

  • --bind pentru a specifica un fișier sau un director în care se poate scrie

  • --ro-bind pentru a specifica un fișier sau un director doar pentru citire

  • --perms 000 --tmpfs DIR --remount-ro DIR pentru a interzice accesul la DIR

  • --perms 000 --ro-bind-data FD FILE pentru a interzice accesul la FILE (unde FD este un descriptor de fișier deschis pentru /dev/null)

Pentru a aplica șabloanele glob de interzicere folosind aceste opțiuni, Codex le extinde în căi concrete înainte de lansarea fiecărei comenzi. Căile noi care se potrivesc nu sunt adăugate automat la restricțiile mediului izolat al acelei comenzi.

Codex specifică și opțiuni precum --unshare-ipc și --unshare-pid pentru a împiedica mediul izolat să acceseze alte tipuri de resurse de pe gazdă, astfel încât bubblewrap nu afectează doar vizibilitatea fișierelor.

Când folosește bubblewrap, Codex transmite --unshare-net ori de câte ori accesul la rețea este dezactivat sau conexiunile trebuie să treacă prin proxy-ul de rețea, ceea ce creează un nou spațiu de nume de rețea pentru mediul izolat. Apoi folosim seccomp-bpf pentru a aplica restricții suplimentare apelurilor de sistem pentru rețea și familiilor de socketuri disponibile comenzii.


Mai exact, folosim
pachetul crate seccompiler⁠(se deschide într-o fereastră nouă) pentru a compila dinamic un program BPF pe baza filtrelor dorite⁠(se deschide într-o fereastră nouă) și a-l aplica unui proces de lansare din mediul izolat, astfel încât constrângerile să fie moștenite de întregul arbore de procese. Prin urmare, bwrap nu rulează comanda utilizatorului, ci programul de lansare codex-linux-sandbox, cu propriile argumente de configurare, urmate de comanda utilizatorului:

Bash

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

Pentru a aplica filtrele seccomp fără privilegii ridicate, programul de lansare setează indicatorul no_new_privs din Linux⁠(se deschide într-o fereastră nouă). Acest indicator este moștenit de procesele fiu și le împiedică să obțină privilegii suplimentare când execută un alt program, cum ar fi un executabil setuid.

Filtrele seccomp depind de configurația rețelei. Când accesul la rețea este dezactivat, blocăm o serie de apeluri de sistem legate de rețea, precum connect(2) și bind(2). În schimb, când proxy-ul de rețea este activat în mediul izolat, permitem socketuri IP pentru ca socketul de ascultare TCP creat de codex-linux-sandbox să fie accesibil, dar blocăm implicit crearea de socketuri de domeniu Unix independente, deoarece acestea ar putea permite accesul neintenționat la resursele gazdei.

Conectarea la proxy-ul de rețea

Când configurația mediului izolat necesită utilizarea proxy-ului de rețea, cadrul de testare Codex creează o instanță a proxy-ului, care poate fi reutilizată pentru mai multe apeluri ale codex-linux-sandbox în același fir de conversație Codex. Fiecare mediu izolat are nevoie de o modalitate de a accesa acel proxy comun din spațiul său de nume de rețea izolat. Codex oferă un socket de ascultare TCP pe interfața loopback din acel spațiu de nume și configurează un proces din afara mediului izolat pentru a-i accepta conexiunile și a le retransmite către proxy.

Diagramele următoare ilustrează această configurație pentru un punct final proxy, iar ultima diagramă prezintă o conexiune care trece prin acesta. Înainte de a lansa bubblewrap, codex-linux-sandbox creează o pereche de socketuri Unix care servește drept canal de control și creează un proces fiu prin fork. Procesul fiu rulează run_host_bridge() și așteaptă să primească descriptorul de fișier al socketului de ascultare prin acel canal:

Diagramă în care cadrul de testare Codex lansează codex-linux-sandbox, care creează prin fork un proces de retransmisie conectat printr-un canal de control bazat pe socketuri Unix.

În acest exemplu, procesul părinte folosește exec pentru a-și înlocui imaginea programului cu bwrap. Acesta configurează mediul izolat și lansează codex-linux-sandbox --apply-seccomp-then-exec în interiorul lui, transmițând mai departe descriptorul de fișier pentru canalul de control:

Diagramă în care bwrap creează un spațiu de nume de rețea pentru mediul izolat și lansează codex-linux-sandbox în interiorul acestuia, cu un canal de control bazat pe socketuri Unix către procesul de retransmisie din afara mediului izolat.

În spațiul de nume de rețea al mediului izolat, al doilea apel al codex-linux-sandbox creează un socket de ascultare TCP pe interfața loopback și îi transmite descriptorul de fișier prin socket. Socketul de ascultare rămâne asociat cu spațiul de nume de rețea al mediului izolat, permițând procesului fiu rămas în afara acestuia să accepte conexiuni de la programele izolate, în timp ce își deschide conexiunile către proxy în spațiul de nume de rețea al gazdei. După transfer, ambele procese își închid descriptorii canalului de control, iar procesul din mediul izolat își închide copia socketului de ascultare.

Odată ce socketul de ascultare TCP este pregătit, procesul din mediul izolat setează valoarea corespunzătoare pentru HTTP_PROXY⁠(se deschide într-o fereastră nouă) și variabilele de mediu asociate, astfel încât să indice acel socket. Apoi aplică seccomp înainte de a crea un proces fiu și de a executa comanda utilizatorului:

Diagramă în care un program izolat se conectează la un socket de ascultare TCP pe interfața loopback, iar un proces de retransmisie codex-linux-sandbox din exterior transmite traficul către proxy-ul de rețea Codex.

Procesul din afara mediului izolat menține deschis socketul de ascultare. Pentru fiecare conexiune acceptată, deschide o conexiune la proxy-ul configurat și retransmite datele în ambele sensuri.

Acest mecanism suplimentar îi oferă comenzii propriul spațiu de nume de rețea, inclusiv o interfață loopback separată. Pe macOS, Seatbelt permite comenzii să se conecteze direct la porturile specificate de pe interfața loopback a gazdei. Pe Linux, comanda se conectează în schimb la un socket de ascultare din spațiul său de nume izolat, iar un proces din afara mediului izolat retransmite acele conexiuni către proxy-ul configurat. Transferul descriptorului face posibilă această conexiune fără a expune comenzii spațiul de nume de rețea al gazdei.

Windows

La începutul acestui an, am implementat izolarea pe Windows și am scris despre eforturile noastre în această direcție. De atunci, Microsoft a lansat o bibliotecă numită MXC, alături de noi funcții pentru izolarea proceselor în sistemul de operare Windows. În prezent, înlocuim mediul izolat existent cu unul care folosește biblioteca MXC.

Ce este MXC?

MXC (Microsoft eXecution Container) este un sistem de execuție a codului în medii izolate⁠(se deschide într-o fereastră nouă) de la Microsoft, care acceptă mai multe mecanisme de izolare pe Windows, Linux și macOS. Codex acceptă un mediu izolat bazat pe MXC pe dispozitivele Windows compatibile, folosind izolarea nativă a proceselor pentru a restricționa comenzile în mediul existent al utilizatorului.

Trecem la MXC pentru a îmbunătăți securitatea și ușurința în utilizare, eliminând totodată mai multe limitări ale mediului nostru izolat existent pentru Windows:

  • Necesitatea unor privilegii ridicate/de administrator pentru configurarea mediului izolat

  • Operațiuni costisitoare/lente de verificare și setare a ACL-urilor

  • Starea de configurare a mediului izolat care persistă pe calculatorul gazdă, inclusiv

    • ACL-uri

    • Reguli de firewall

    • Utilizatorii mediului izolat

    • Fișierele planului de control

MXC pune la dispoziție o schemă de configurare JSON⁠(se deschide într-o fereastră nouă). Codex folosește SDK-ul MXC⁠(se deschide într-o fereastră nouă) pentru a construi o cerere de execuție conform acelei scheme, care conține comanda, directorul de lucru, mediul și permisiunile. Aceste permisiuni acoperă accesul la sistemul de fișiere și la rețea, precum și la resurse Windows, cum ar fi desktopul și clipboardul.

Transpunerea politicii într-un apel MXC

Codex folosește setări fixe pentru mai multe mecanisme de control, pentru a echilibra compatibilitatea și securitatea. Permite citirea registrului și păstrează accesul la Win32k și la desktop de care PowerShell are nevoie la pornire. Accesul la clipboard, injectarea de intrări și comenzile pentru desktop și setările de sistem sunt dezactivate. În plus, MXC nu poate recurge la modificarea permisiunilor sistemului de fișiere al gazdei ca soluție de rezervă.

Codex transpune regulile pentru sistemul de fișiere și rețea ale profilului de permisiuni în configurația MXC. Folosind profilul dev de mai sus și presupunând că:

  • C:\, D:\ și Z:\ sunt singurele unități locale ale calculatorului.

  • Rădăcina spațiului de lucru și directorul de lucru sunt C:\work\demo.

  • Directorul personal al utilizatorului este D:\Users\dev, deci ~/build-cache se rezolvă la D:\Users\dev\build-cache.

  • Șablonul glob de interzicere se potrivește doar cu C:\work\demo\config\dev.env și C:\work\demo\config\prod.env.

Setările MXC corespunzătoare ar include:

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
}

Accesul la rădăcina unităților

Politica MXC pentru sistemul de fișiere interzice accesul în mod implicit. Prin urmare, Codex adaugă permisiuni doar de citire pentru rădăcinile unităților locale, pentru a oferi accesul extins la citire permis de acest profil. Aceste permisiuni se aplică recursiv, în limitele permisiunilor existente ale utilizatorului în sistemul de operare.

Există o particularitate: permisiunile de scriere pentru rădăcina unei unități nu se aplică recursiv, așa că Codex le extinde pentru a include elementele existente direct în rădăcina unității.

Permisiuni contradictorii

Căile mai specifice au prioritate față de permisiunile directoarelor strămoș, astfel încât C:\work\demo poate permite scrierea sub C:\, care permite doar citirea, în timp ce C:\work\demo\.git rămâne doar pentru citire.

Când forme diferite de scriere a căilor sau aliasuri prin legături simbolice/joncțiuni indică aceeași cale, MXC aplică permisiunea mai strictă: interzicerea are prioritate față de accesul doar pentru citire, care are prioritate față de accesul pentru citire și scriere.

Șabloane glob de interzicere

MXC acceptă doar căi concrete pentru interzicerea accesului, așa că, înainte de lansare, Codex extinde șabloanele glob de interzicere în fișierele și directoarele care se potrivesc. Căile noi care se potrivesc cu șablonul glob nu sunt adăugate automat în timpul executării comenzii.

Acces la rețea

Regulile de domeniu precum *.openai.com sunt impuse de proxy-ul de rețea comun Codex, descris mai sus. Codex rulează acel proxy în afara mediului izolat și transmite adresele lui comenzii prin aceleași variabile de mediu standard *_PROXY menționate anterior. MXC blochează conexiunile externe directe, permițând totodată conexiunile la interfața loopback a gazdei, inclusiv accesul la proxy. Celelalte servicii locale rămân accesibile.

Pe macOS, Linux și Windows, cadrul de testare folosește același API de izolare pentru a lansa comenzi cu un profil de permisiuni. Implementările specifice platformei asigură configurarea necesară pentru aplicarea acestor restricții.

Dezvoltarea pe baza mediului izolat Codex

Scrierea și executarea codului le oferă agenților o modalitate flexibilă de a rezolva probleme și dincolo de dezvoltarea software. Mediul izolat Codex le permite să folosească această capacitate în mediul existent al utilizatorului, cu limite explicite pentru accesul la sistemul de fișiere și la rețea. Este o componentă de bază reutilizabilă în cadrul de testare, iar comanda codex sandbox o face disponibilă instrumentelor pe care le construiești.

Pe măsură ce agenții preiau mai multe sarcini, vrem să facem izolarea practică pentru mai multe instrumente și medii. Asta înseamnă să simplificăm configurarea permisiunilor și să valorificăm măsurile de protecție îmbunătățite ale sistemelor de operare pe măsură ce devin disponibile. Scopul nostru este să extindem capacitățile agenților, păstrând în același timp controlul oamenilor asupra resurselor pe care aceștia le pot accesa.

Autor

OpenAI

Mulțumiri

Mulțumiri speciale lui David Wiesen, Charlie Weems, Viyat Bhalodia și Fotis Chantzis pentru contribuțiile la acest articol.