OpenAI

18 నవంబర్, 2026

ఇంజనీరింగ్

Codex సాండ్‌బాక్స్ అంతర్గత పనితీరు

మీరు నియంత్రించే పరిమితుల్లో Codex మీ యంత్రంపై ఆదేశాలను ఎలా అమలు చేస్తుంది.

రచన: మైఖేల్ బోలిన్, సాంకేతిక సిబ్బంది సభ్యుడు

OpenAIలో, ఏజెంట్ల భద్రత కోసం మేము బహుళ అంచెల రక్షణ⁠(కొత్త విండోలో తెరుచుకుంటుంది) విధానాన్ని అనుసరిస్తాము. శిక్షణ, వినియోగదారు ఉద్దేశాలకు అనుగుణంగా ప్రవర్తించేలా తీర్చిదిద్దడంపై మా పెట్టుబడులు ఈ ప్రయత్నానికి పునాది. అదనపు రక్షణ కోసం మా ఏజెంటిక్ హార్నెస్ Codex⁠(కొత్త విండోలో తెరుచుకుంటుంది)లోనూ ఫీచర్లను అమలు చేస్తున్నాము. మీ కంప్యూటర్‌లో ఆదేశాలను అమలు చేయడం Codex తరచూ చేసే పనుల్లో ఒకటి; ఇందులో ప్రమాదమూ ఉండవచ్చు. అందుకే, మీరు నియంత్రించే ఫైల్‌సిస్టమ్, నెట్‌వర్క్ పరిమితుల్లో మీ ప్రస్తుత వాతావరణంలోనే Codex పనిచేసేలా Codex సాండ్‌బాక్స్ను రూపొందించాము.

ఒక ⁠(కొత్త విండోలో తెరుచుకుంటుంది)సాండ్‌బాక్స్⁠(కొత్త విండోలో తెరుచుకుంటుంది) అనేది ప్రోగ్రామ్ నడుస్తున్నప్పుడు దేనిని యాక్సెస్ చేయవచ్చో పరిమితం చేస్తుంది. ఫోటోలను క్రమబద్ధీకరించే పని కోసం, ~/Picturesలోని ఫైళ్లను చదవడానికి, మార్చడానికి ఆదేశాలను అనుమతిస్తూ, అప్‌లోడ్‌లను నిరోధించేందుకు నెట్‌వర్క్ యాక్సెస్‌ను అడ్డుకునేలా Codex సాండ్‌బాక్స్‌ను కాన్ఫిగర్ చేయవచ్చు. కోడ్ సమీక్ష కోసం, మూల ఫైళ్లను చదవడానికి మాత్రమే ఉంచుతూ, ఆన్‌లైన్ మార్గదర్శక పత్రాలను యాక్సెస్ చేయడానికి అనుమతించవచ్చు. వినియోగదారులు ⁠(కొత్త విండోలో తెరుచుకుంటుంది)అనుమతుల ప్రొఫైల్‌ల⁠(కొత్త విండోలో తెరుచుకుంటుంది) ద్వారా Codex సాండ్‌బాక్స్‌ను కాన్ఫిగర్ చేస్తారు. ఇవి Codex సెషన్‌కు ఫైల్‌సిస్టమ్, నెట్‌వర్క్ పరిమితులను నిర్వచిస్తాయి.

ఈ వ్యాసంలో, Codex సాండ్‌బాక్స్ డిఫాల్ట్‌ల వెనుక ఉన్న లాభనష్టాలతో మొదలుపెట్టి, దాని రూపకల్పనను, ఆదేశాల అమలుకు హార్నెస్ దాన్ని ఎలా ఉపయోగిస్తుందో వివరిస్తాము. వినియోగదారులు, సంస్థలు తమ అవసరాలకు అనుగుణంగా అనుమతులను ఎలా మార్చుకోవచ్చో, డెవలపర్లు తమ సాధనాల్లో ఈ సాండ్‌బాక్స్‌ను ఎలా పునర్వినియోగించవచ్చో చూపిస్తాము. చివరగా, macOS, Linux, Windowsలో ఈ పరిమితులు ఎలా అమలవుతాయో పరిశీలిస్తాము.

సాండ్‌బాక్స్ హద్దులను ఎంచుకోవడం

అర్థవంతమైన పని చేయడానికి వీలు కల్పిస్తూనే, సాండ్‌బాక్స్‌కు జాగ్రత్తతో కూడిన డిఫాల్ట్‌లను నిర్దేశించడం Codexలో మా విధానం. ఉదాహరణకు, Git రిపోజిటరీని పని ప్రదేశపు మూలంగా తీసుకుంటే, అంతర్నిర్మిత :workspace అనుమతుల ప్రొఫైల్:

  • పని ప్రదేశంలో రాయడానికి అనుమతిస్తుంది, కానీ .git, .codex వంటి డైరెక్టరీలను చదవడానికి మాత్రమే ఉంచుతుంది. దీంతో ప్రతి మార్పుకూ అనుమతి అడగకుండానే Codex మూల కోడ్‌ను సవరించగలదు. అయితే .codex/config.toml లేదా .git/hooksలోని Git హుక్‌లను నేరుగా మార్చలేరు.

  • వినియోగదారు ప్రస్తుత ఆపరేటింగ్ సిస్టమ్ అనుమతులకు లోబడి, ఫైల్‌సిస్టమ్‌ను విస్తృతంగా చదవడానికి అనుమతిస్తుంది. కంపైలర్లు, రన్‌టైమ్‌లు, బిల్డ్ సాధనాలు రిపోజిటరీ వెలుపలి SDKలు, లైబ్రరీలు, కాన్ఫిగరేషన్‌పై ఆధారపడతాయి. చదవడాన్ని పని ప్రదేశానికే పరిమితం చేస్తే ఎన్నో సాధారణ పనిప్రవాహాలు పనిచేయవు. దీని ప్రతికూలత ఏమిటంటే, యంత్రంలో ఇతర చోట్ల ఉన్న సున్నితమైన ఫైళ్లనూ చదవగలిగే అవకాశం ఉంటుంది (ఉదాహరణకు API కీలున్న కాన్ఫిగరేషన్ ఫైళ్లు).

  • నెట్‌వర్క్ యాక్సెస్‌ను నిలిపివేస్తుంది. ఆదేశం చదవగల డేటాను దొంగతనంగా బయటకు పంపే ప్రయత్నాలతో సహా, బాహ్య సేవలకు నేరుగా అప్‌లోడ్ చేయడాన్ని ఇది అడ్డుకుంటుంది. అవసరమైన ఆధార ప్యాకేజీలను డౌన్‌లోడ్ చేయడం వంటి చట్టబద్ధమైన పనులనూ ఇది అడ్డుకుంటుంది. వాటికి అదనపు యాక్సెస్ అవసరం.

ఈ పరిమితులు అనేక రకాల అవాంఛిత ప్రవర్తనలను నిరోధిస్తాయి. అయినా హానికర చర్యలు సాధ్యమే. ఉదాహరణకు, స్థానికంగా ఇన్‌స్టాల్ చేసిన node_modules/prettier వంటి ప్యాకేజీలో ఏజెంట్ హానికర కోడ్‌ను చొప్పించవచ్చు. Git తరచూ node_modulesను విస్మరిస్తుంది కాబట్టి, అలాంటి మార్పు git statusలో కనిపించకపోవచ్చు. సేవ్ చేసేటప్పుడు వినియోగదారు ఎడిటర్ ఆ Prettier కాపీని అమలు చేస్తే, ఫైల్‌ను సేవ్ చేసినంత మాత్రాన హానికర కోడ్ Codex సాండ్‌బాక్స్ వెలుపల అమలవవచ్చు. అందుకే మేము బహుళ అంచెల రక్షణను అనుసరిస్తాము: సాండ్‌బాక్స్ ఆదేశాల యాక్సెస్‌ను పరిమితం చేస్తుంది. శిక్షణ, ఉద్దేశానుగుణ ప్రవర్తన కోసం చేసే కృషి మోడల్ ఆ యాక్సెస్‌ను వినియోగదారు ఉద్దేశానికి అనుగుణంగా వాడేందుకు తోడ్పడతాయి.

సంస్థలో సాండ్‌బాక్స్ అనుమతులను అవసరాలకు అనుగుణంగా మార్చి, ఇతర రక్షణలతో కలిపి ఉపయోగించే మార్గదర్శకాల కోసం Codex భద్రతా ఆచరణల మార్గదర్శిని⁠(కొత్త విండోలో తెరుచుకుంటుంది) చూడండి.

సాండ్‌బాక్స్ రూపకల్పన

వర్చువల్ యంత్రాలు, కంటైనర్లు⁠(కొత్త విండోలో తెరుచుకుంటుంది) సాండ్‌బాక్సింగ్ కోసం వాడే రెండు ప్రసిద్ధ పద్ధతులు. కానీ Codex సాండ్‌బాక్స్‌లో మేము వేరే విధానాన్ని అనుసరిస్తాము. ఐసోలేషన్ కోసం గణనను వేరే వాతావరణానికి తరలించకుండా, వినియోగదారు ప్రస్తుత వాతావరణంలో నడిచే ఆదేశాలను పరిమితం చేయడానికి Codex ఆయా ప్లాట్‌ఫామ్‌ల సాండ్‌బాక్సింగ్ సదుపాయాలను ఉపయోగిస్తుంది.

చాలా మంది డెవలపర్లకు, తమకు నచ్చినప్పుడు మార్చుకోగల, తమ అవసరాలకు తీర్చిదిద్దిన అభివృద్ధి వాతావరణమే వారి ల్యాప్‌టాప్. ఆ వాతావరణాన్ని Docker కంటైనర్‌లో పునఃసృష్టించడానికి శ్రమ అవసరం. కొన్ని పనిప్రవాహాలు అప్పటికీ హోస్ట్‌పై నడిచే సాధనాలపై ఆధారపడతాయి.

ఉదాహరణకు, Macలో iOS యాప్‌ను అభివృద్ధి చేయడానికి Codexను ఉపయోగిస్తున్నారని అనుకోండి. Codexను Docker లోపల నడిపి సాండ్‌బాక్స్ చేయాలని నిర్ణయిస్తే, స్థానిక Mac ఎగ్జిక్యూటబుల్స్‌తో కూడిన iOS బిల్డ్ సాధన సముదాయాన్ని Codex అమలు చేయలేదు. కోడ్‌ను నడిపేందుకు iPhone సిమ్యులేటర్‌నూ ప్రారంభించలేదు. Docker ఆధారిత పనిప్రవాహం బిల్డ్‌లు, సిమ్యులేటర్ కార్యకలాపాలను Mac హోస్ట్‌కు అప్పగించవచ్చు. కానీ అవి కంటైనర్ సాండ్‌బాక్స్ వెలుపల అమలవుతాయి కాబట్టి వాటికి ప్రత్యేక పరిమితులు అవసరం. Codex కోసం, ఆపరేటింగ్ సిస్టమ్‌కు ప్రత్యేకమైన సాండ్‌బాక్సింగ్‌పై విస్తృతంగా కృషి చేసి విషయాలను సరళంగా ఉంచాలనుకుంటున్నాము. దీంతో Codex చేపట్టిన పనికి అత్యంత తగిన వాతావరణంలో నడవగలదు.

macOS, Windows, Linux అంతటా ఉమ్మడి API ద్వారా ఈ ఆపరేటింగ్ సిస్టమ్-నిర్దిష్ట సాండ్‌బాక్సింగ్ పద్ధతులను హార్నెస్ అందుబాటులో ఉంచుతుంది. ఈ API ఒక ఆదేశాన్ని, అనుమతుల ప్రొఫైల్‌ను తీసుకుంటుంది. అనుమతుల ప్రొఫైల్ పరిమిత నెట్‌వర్క్ యాక్సెస్‌ను అనుమతిస్తే, ఆ పరిమితులను అమలు చేయడానికి పిలిచే కోడ్ నెట్‌వర్క్ ప్రాక్సీని అందించాలి:

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:

ఈ ఫంక్షన్ సాండ్‌బాక్స్‌లో ప్రాసెస్‌ను ప్రారంభించి, Child హ్యాండిల్‌ను తిరిగి ఇస్తుంది. ప్రాసెస్ పూర్తయ్యే వరకు వేచి ఉండేందుకు హార్నెస్ దీన్ని ఉపయోగించవచ్చు. ప్రతి చైల్డ్ ప్రాసెస్‌కు దాని పేరెంట్ సాండ్‌బాక్స్ పరిమితులు సంక్రమిస్తాయి. కాబట్టి ఆదేశం ప్రారంభించిన మొత్తం ప్రాసెస్ ట్రీకి అవి వర్తిస్తాయి; అసలు ప్రాసెస్ ముగిశాక కూడా కొనసాగే వారస ప్రాసెస్‌లకూ వర్తిస్తాయి.

కాన్ఫిగరేషన్ నుంచి సాండ్‌బాక్స్‌లో ఆదేశాన్ని నడపడం వరకు, ఈ భాగాలు ఎలా కలిసి పనిచేస్తాయో కింది రేఖాచిత్రం చూపిస్తుంది. తర్వాతి విభాగాలు ప్రతి దశనూ వివరిస్తాయి.

ప్రవాహ రేఖాచిత్రం: కాన్ఫిగరేషన్, నిర్వాహక నియంత్రిత అవసరాలు సెషన్ అనుమతుల ప్రొఫైల్‌ను నిర్వచిస్తాయి; Codex హార్నెస్ macOS, Linux లేదా Windowsలో ఆయా ప్లాట్‌ఫామ్‌లకు ప్రత్యేకమైన సాండ్‌బాక్స్ పరిమితుల కింద ఆదేశాలను ప్రారంభిస్తుంది. చైల్డ్ ప్రాసెస్‌లకు ఆ పరిమితులు సంక్రమిస్తాయి. ఐచ్ఛిక నెట్‌వర్క్ ప్రాక్సీ డొమైన్ నియమాలను అమలు చేస్తుంది.

హార్నెస్ సాండ్‌బాక్స్‌ను ఎలా ఉపయోగిస్తుంది

Codex ఏజెంట్ లూప్‌ను విపులంగా అర్థం చేసుకోవడంలో వివరించినట్లు, మోడల్ రూపొందించే సాధనాల పిలుపులను అమలు చేసే బాధ్యత Codex హార్నెస్‌దే. కోడింగ్ పనుల్లో అత్యంత తరచుగా వాడేది షెల్ సాధనం. Bash వంటి ఇంటరాక్టివ్ షెల్‌లో వినియోగదారు నడిపినట్లే ఇది ఆదేశాలను నడుపుతుంది. కావలసిన రక్షణల కోసం హార్నెస్ సాండ్‌బాక్స్‌ను ఎలా ఉపయోగిస్తుందో చూపించేందుకు, ఇక్కడ ఒక్కసారి అమలయ్యే ⁠(కొత్త విండోలో తెరుచుకుంటుంది)exec_command⁠(కొత్త విండోలో తెరుచుకుంటుంది) షెల్ సాధనాన్ని⁠(కొత్త విండోలో తెరుచుకుంటుంది) పరిశీలిస్తాము.

సాండ్‌బాక్సింగ్ లేకుండా Codex హార్నెస్ exec_command సాధన పిలుపును ఎలా అమలు చేస్తుందో చూపే సరళీకృత రూపం ఇది:

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}

ఆదేశాన్ని సాండ్‌బాక్స్‌లో నడిపేందుకు, హార్నెస్ subprocess.Popen() పిలుపు స్థానంలో spawn_command_under_sandbox()ను ఉపయోగిస్తుంది. హార్నెస్ అనుమతుల ప్రొఫైల్‌ను, అవసరమైనప్పుడు నెట్‌వర్క్ ప్రాక్సీని అందిస్తుంది:

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}

exec_command సాధనంతో మోడల్ ఒక నిర్దిష్ట ఆదేశానికి వేరే అనుమతులనూ అభ్యర్థించవచ్చు. కానీ వాటిని ఇవ్వాలో లేదో హార్నెస్ నిర్ణయిస్తుంది:

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

use_defaultను నిర్దేశించినప్పుడు, హార్నెస్ ఆ వంతుకు సంబంధించిన డిఫాల్ట్ సాండ్‌బాక్స్ కాన్ఫిగరేషన్‌ను ఉపయోగిస్తుంది. with_additional_permissions సాండ్‌బాక్స్ లోపల విస్తృత యాక్సెస్‌ను అభ్యర్థిస్తుంది. require_escalated దాని వెలుపల అమలును అభ్యర్థిస్తుంది. ఆదేశాన్ని అమలు చేసే ముందు, హార్నెస్ వినియోగదారు ప్రాధాన్యతల ఆధారంగా అభ్యర్థనను మూల్యాంకనం చేస్తుంది. (ఉదాహరణకు, Codex వినియోగదారుని నేరుగా అడగవచ్చు, లేదా అభ్యర్థనను స్వయంచాలక సమీక్షకు⁠(కొత్త విండోలో తెరుచుకుంటుంది) పంపవచ్చు.) అమలుకు అనుమతి లభిస్తే, Codex అసలు ExecCommandToolCallలోని ఆదేశ ఆర్గ్యుమెంట్లతో పాటు తగిన permission_profile, network_proxyలను perform_exec_command_with_sandboxing()కు అందిస్తుంది.

spawn_command_under_sandbox()ను ప్రధానంగా షెల్ సాధనం ఉపయోగిస్తుంది. స్థానిక ఫైళ్లను చదవడం, మార్చడం వంటి పనులకూ హార్నెస్ తన సాండ్‌బాక్సింగ్ మౌలిక సదుపాయాలను పునర్వినియోగిస్తుంది. ఈ పునర్వినియోగం హార్నెస్‌కే పరిమితం కాదు: తర్వాత చూడబోతున్నట్లు, codex sandbox ఆదేశంతో మీ సొంత సాధనాల్లోనూ సాండ్‌బాక్స్‌లో ఆదేశాల అమలును చేర్చవచ్చు. తర్వాత, అనుమతుల ప్రొఫైల్‌లను ఎలా నిర్వచిస్తారో చూద్దాం.

సాండ్‌బాక్స్‌ను కాన్ఫిగర్ చేయడం

పేరు పెట్టిన అనుమతుల ప్రొఫైల్‌తో ఒకే ఫైల్‌సిస్టమ్, నెట్‌వర్క్ పరిమితులను పలు ప్రాజెక్ట్‌లలో పునర్వినియోగించవచ్చు. config.tomlలోని [permissions] కింద మీ సొంత ప్రొఫైల్‌లను నిర్వచించవచ్చు. ఉదాహరణకు, కిందిది అంతర్నిర్మిత :workspace ప్రొఫైల్‌ను విస్తరించే⁠(కొత్త విండోలో తెరుచుకుంటుంది) dev అనే ప్రొఫైల్‌ను నిర్వచిస్తుంది:

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"

dev ప్రొఫైల్ ~/build-cacheలో రాయడానికి యాక్సెస్‌ను జోడిస్తుంది. పని ప్రదేశంలోని ఫైళ్లపై అదనపు పరిమితులు విధిస్తుంది. ఫైల్‌సిస్టమ్ ఎంట్రీలు చదవడానికి మాత్రమే (read), చదవడానికి-రాయడానికి (write) అనుమతించవచ్చు, లేదా యాక్సెస్‌ను పూర్తిగా అడ్డుకోవచ్చు (deny).

ప్రాజెక్ట్ పని ప్రదేశపు మూలాలకు సాపేక్షంగా ఉండే పాత్‌ల కోసం నియమాలను నిర్వచించడానికి :workspace_roots పట్టిక వీలు కల్పిస్తుంది. డిఫాల్ట్‌గా, Codex కమాండ్-లైన్ ఇంటర్‌ఫేస్ తన పని డైరెక్టరీనే ఏకైక పని ప్రదేశపు మూలంగా ఉపయోగిస్తుంది. ChatGPT డెస్క్‌టాప్ యాప్ మాత్రం ప్రాజెక్ట్ మూల ఫోల్డర్‌లను ఉపయోగిస్తుంది. Codex ప్రతి నియమాన్ని ప్రతి మూలానికీ వర్తింపజేస్తుంది. కాబట్టి devలోని .vscode ఎంట్రీ ప్రతి మూలం కింద ఉన్న .vscode డైరెక్టరీని చదవడానికి మాత్రమే పరిమితం చేస్తుంది.

సొంత నియమాలతో పాటు, devకు :workspace నుంచి ఈ రక్షణలు సంక్రమిస్తాయి:

TOML

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

నెట్‌వర్క్ అనుమతులు

Codexలో సాండ్‌బాక్స్ నెట్‌వర్క్‌ను కాన్ఫిగర్ చేయడానికి ప్రధానంగా మూడు ఎంపికలున్నాయి:

  • నెట్‌వర్క్ యాక్సెస్‌ను పూర్తిగా నిలిపివేయడం (:workspace ప్రొఫైల్ డిఫాల్ట్)

  • పూర్తి, ప్రత్యక్ష నెట్‌వర్క్ యాక్సెస్‌ను ప్రారంభించడం (:danger-full-access ప్రొఫైల్ డిఫాల్ట్)

  • నెట్‌వర్క్ యాక్సెస్‌ను ప్రాక్సీకే పరిమితం చేయడం; అనుమతుల ప్రొఫైల్ ఆధారంగా దేనిని అనుమతించాలో అది నిర్ణయిస్తుంది


devకు ప్రత్యక్ష నెట్‌వర్క్ యాక్సెస్ ఇవ్వడానికి, config.tomlలో పైస్థాయిలో permissions.dev.network.enabled = trueను సెట్ చేయండి. నెట్‌వర్క్ ప్రాక్సీ నిలిపివేసి ఉన్నప్పుడు ఇది పూర్తి నెట్‌వర్క్ యాక్సెస్ ఇస్తుంది.

devను కొన్ని డొమైన్‌లకే పరిమితం చేయడానికి, నెట్‌వర్క్ ప్రాక్సీని ప్రారంభించి దాని డొమైన్ నియమాలను కాన్ఫిగర్ చేయండి:

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

డొమైన్ నియమాలు ఖచ్చితమైన పేర్లు, వైల్డ్‌కార్డ్ నమూనాలకు మద్దతిస్తాయి. అనుమతి నియమాల కంటే స్పష్టమైన నిరాకరణ నియమాలకు ప్రాధాన్యం ఉంటుంది. కింద నెట్‌వర్క్ ప్రాక్సీ విభాగంలో వివరించినట్లు, ఇతర డొమైన్‌లకు అభ్యర్థనలకు ఆమోదం అవసరం లేదా అవి నిరోధించబడతాయి.

అంచెలవారీ కాన్ఫిగరేషన్, పరిమితుల అమలు

వ్యక్తిగత వినియోగదారులు ప్రాజెక్ట్‌లన్నిటికీ వర్తించే డిఫాల్ట్‌లను కాన్ఫిగర్ చేసి, విశ్వసనీయమైన నిర్దిష్ట ప్రాజెక్ట్‌కు వాటిని మార్చుకోవచ్చు. సంస్థ నిర్వాహకులు కూడా తమ వినియోగదారులకు డిఫాల్ట్‌లను కాన్ఫిగర్ చేసి, వారు ఏ సెట్టింగ్‌లను మార్చవచ్చో పరిమితం చేయాలనుకోవచ్చు. అంచెలవారీ కాన్ఫిగరేషన్, నిర్వాహక నియంత్రిత అవసరాల ద్వారా Codex రెండింటికీ మద్దతిస్తుంది.

కాన్ఫిగరేషన్ ప్రాధాన్య క్రమం,⁠(కొత్త విండోలో తెరుచుకుంటుంది) విభాగంలో వివరించినట్లు, Codex పలు config.toml ఫైళ్ల సెట్టింగ్‌లను విలీనం చేస్తుంది. పట్టికలు అన్ని ఉపస్థాయిల్లోనూ విలీనమవుతాయి. విలువలు విరుద్ధంగా ఉంటే, అధిక ప్రాధాన్యమున్న మూలానిదే పైచేయి. అరేలు పూర్తిగా భర్తీ చేయబడతాయి.

అందుకే అనుమతుల ప్రొఫైల్‌లు ఫైల్‌సిస్టమ్ పాత్‌లు, నెట్‌వర్క్ డొమైన్‌ల కోసం పట్టికలను ఉపయోగిస్తాయి. ఒక బృందం తన కాన్ఫిగరేషన్‌లో విడివిడి ఎంట్రీలను జోడించవచ్చు లేదా మార్చవచ్చు. సంస్థ ప్రాథమిక కాన్ఫిగరేషన్‌లోని మిగతా ఎంట్రీల మార్పులన్నీ దానికి ఆటోమేటిక్‌గా సంక్రమిస్తాయి:

TOML

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

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

వినియోగదారుల కాన్ఫిగరేషన్ ఎంపికలను పరిమితం చేసేందుకు నిర్వాహకులు requirements.toml ద్వారా నిర్వాహక నియంత్రిత అవసరాలను⁠(కొత్త విండోలో తెరుచుకుంటుంది) కూడా అందించవచ్చు. ఈ అవసరాలు సిస్టమ్ ఫైళ్లు, క్లౌడ్ అందించే విధానం సహా పలు మూలాల నుంచి రావచ్చు. సంస్థ వినియోగదారు ఎంచుకోగల అనుమతుల ప్రొఫైల్‌లను పరిమితం చేసేందుకు allowed_permission_profilesను నిర్దేశించడం ఒక సాధారణ వినియోగ సందర్భం. ఉదాహరణకు, నిర్వాహకుడు ఈ క్లౌడ్ అవసరాలను నిర్దేశించవచ్చు:

TOML

1
default_permissions = ":read-only"
2

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

/etc/codex/requirements.tomlలోని సిస్టమ్ అవసరాల ఫైల్ కంటే క్లౌడ్ అవసరాలకే ప్రాధాన్యం ఉంటుంది. కాబట్టి ఆ ఫైల్‌లోని ఎంట్రీ పైన స్పష్టంగా నిర్దేశించిన ":danger-full-access" = falseను అధిగమించలేదు. :workspaceను నిర్దేశించకుండా వదిలేస్తే, అవసరాల మరో పొర ఆ ఎంట్రీని అందించవచ్చు. తుది విలీన పట్టికలో ఎంట్రీలు falseగా ఉన్న లేదా అసలే లేని ప్రొఫైల్‌లు అందుబాటులో ఉండవు.

ఈ విభజనతో సంస్థలు పరిమితులను అమలు చేయగలవు. వినియోగదారులు ఆ పరిమితుల్లోనే తమ కాన్ఫిగరేషన్‌ను మార్చుకోవచ్చు. ఇలా రూపొందిన అనుమతుల ప్రొఫైల్‌లను హార్నెస్ ఉపయోగించవచ్చు, లేదా తర్వాత చూద్దామన్నట్లు నేరుగా ఆదేశానికే వర్తింపజేయవచ్చు.

codex sandbox ఆదేశాన్ని ఉపయోగించడం

Codex కాన్ఫిగరేషన్‌లో నిర్వచించిన అనుమతుల ప్రొఫైల్ కింద ఏ ఆదేశాన్నైనా సులభంగా అమలు చేసేందుకు Codex కమాండ్-లైన్ ఇంటర్‌ఫేస్ sandbox ఆదేశాన్ని అందిస్తుంది. ప్రొఫైల్‌ను పరీక్షించి, నిరోధించడానికి ఉద్దేశించిన ప్రవర్తనను సాండ్‌బాక్స్ నిజంగా అడ్డుకుంటోందని నిర్ధారించేందుకు దీన్ని సాధారణంగా వాడతారు.

ఉదాహరణకు, కింది ఆదేశం సేవ్ చేసేటప్పుడు హానికర ఆటో-ఫార్మాటర్‌ను నడిపేలా VS Codeను కాన్ఫిగర్ చేయడానికి ప్రయత్నిస్తుంది. .vscode ఇప్పటికే ఉందనుకుంటే, పైన నిర్వచించిన dev ప్రొఫైల్ ఈ రాతను అడ్డుకోవాలి. ఎందుకంటే ఆ డైరెక్టరీ చదవడానికి మాత్రమే అనుమతిస్తుంది (codex sandbox డిఫాల్ట్‌గా cwdని పని ప్రదేశపు మూలంగా పరిగణిస్తుంది):

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

నిజంగానే, macOSలో ఇది ఈ సందేశంతో విఫలమవుతుంది:

ప్లెయిన్ టెక్స్ట్

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

codex sandbox ఆదేశం ఏజెంట్ సెషన్‌తో సంబంధం లేకుండా Codex సాండ్‌బాక్సింగ్ వ్యవస్థను అందుబాటులోకి తెస్తుంది. మీ సొంత సాధనాలు ప్రారంభించే ఆదేశాలను పరిమితం చేయడానికి అదే కాన్ఫిగరేషన్ భాషను, ప్లాట్‌ఫామ్-నిర్దిష్ట అమలును ఉపయోగించవచ్చు.

ఉదాహరణ: MCP సర్వర్‌ను సాండ్‌బాక్స్‌లో నడపడం

config.tomlలో కాన్ఫిగర్ చేసిన stdio MCP సర్వర్‌ను ప్రారంభించే ఆదేశాన్ని సాండ్‌బాక్స్‌లో నడపడానికి Codex హార్నెస్ ప్రయత్నించదు. ఆ సర్వర్‌కు ఏ ఫైళ్లు లేదా నెట్‌వర్క్ సేవలు అవసరమో Codex విశ్వసనీయంగా ఊహించలేదు. కాబట్టి డిఫాల్ట్ సాండ్‌బాక్స్ ప్రొఫైల్‌ను వర్తింపజేస్తే, సరిగ్గా పనిచేసే కాన్ఫిగరేషన్ కూడా పనిచేయకపోవచ్చు.

ఉదాహరణకు, Codexతో వాడేందుకు @modelcontextprotocol/server-memory⁠(కొత్త విండోలో తెరుచుకుంటుంది) MCP సర్వర్‌ను కాన్ఫిగర్ చేసే ప్రామాణిక పద్ధతి ఇది:

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"

ఈ npx ఆదేశం సాండ్‌బాక్స్ లేకుండా నడుస్తుంది కాబట్టి, Codexను నడిపే వినియోగదారుతో సమానమైన అనుమతులతో ఫైళ్లలో రాయగలదు, నెట్‌వర్క్ అభ్యర్థనలు చేయగలదు. ఇది అవసరానికి మించిన అనుమతి. దీన్ని కట్టడి చేయడానికి memory-mcp అనే అనుమతుల ప్రొఫైల్‌ను నిర్వచించి, అసలు npx ఆదేశాన్ని codex sandbox --permission-profile memory-mcp ద్వారా నడపవచ్చు. దీంతో సర్వర్ ఎక్కడ రాయవచ్చో పరిమితం చేసి, నెట్‌వర్క్ యాక్సెస్‌ను నిరోధించవచ్చు:

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"

సర్వర్‌ను ప్రారంభించే ముందు దాని డేటా డైరెక్టరీని సృష్టించి, నిర్దిష్ట వెర్షన్‌కు స్థిరపరిచిన ప్యాకేజీని npm కాష్‌లో ఉంచండి. దీంతో నెట్‌వర్క్ యాక్సెస్‌ను నిలిపివేసే ప్రొఫైల్ కింద npx --offline సర్వర్‌ను ప్రారంభించగలదు:

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

ప్యాకేజీ కాష్‌లో చేరాక, Codex నెట్‌వర్క్ యాక్సెస్ లేకుండానే మెమరీ సర్వర్‌ను ప్రారంభించగలదు. రాయడం npm కాష్, సర్వర్ డేటా డైరెక్టరీకే పరిమితమవుతుంది.

Codex సాండ్‌బాక్స్ అమలు

సాండ్‌బాక్స్ అమలు అనుమతుల ప్రొఫైల్‌ను ఆపరేటింగ్ సిస్టమ్ అమలు చేసే పరిమితులుగా మారుస్తుంది. నెట్‌వర్క్ ప్రాక్సీలోని ప్రధాన అభ్యర్థన నిర్వహణ, విధాన తర్కం మూడు ప్రధాన ఆపరేటింగ్ సిస్టమ్‌లకూ ఉమ్మడిగా ఉంటాయి. ప్రాక్సీ ఏర్పాటు, సాండ్‌బాక్స్‌తో అనుసంధానం మాత్రం ఆయా ఆపరేటింగ్ సిస్టమ్‌లకు ప్రత్యేకం. ముందుగా ఉమ్మడి ప్రాక్సీని, ఆ తర్వాత macOS, Linux, Windows అమలులను పరిశీలిస్తాము.

నెట్‌వర్క్ ప్రాక్సీ

అనుమతుల ప్రొఫైల్‌లోని నెట్‌వర్క్ పరిమితులను అమలు చేసేందుకు, హార్నెస్ నెట్‌వర్క్ ప్రాక్సీని ప్రారంభిస్తుంది. దానికి కనెక్షన్లను అనుమతిస్తూ, బాహ్య హోస్ట్‌లకు నేరుగా కనెక్షన్లను అడ్డుకునేలా సాండ్‌బాక్స్‌ను కాన్ఫిగర్ చేస్తుంది. అభ్యర్థనను ముందుకు పంపాలా వద్దా అని నిర్ణయించేందుకు ప్రాక్సీ ప్రతి అభ్యర్థనను ప్రొఫైల్ డొమైన్ నియమాలతో సరిపోల్చి తనిఖీ చేస్తుంది.

Codex రిపోజిటరీలో, నెట్‌వర్క్ ప్రాక్సీని codex-network-proxy⁠(కొత్త విండోలో తెరుచుకుంటుంది) క్రేట్‌లో అమలు చేశారు. హార్నెస్ దీన్ని లైబ్రరీగా ఉపయోగిస్తుంది. దీన్ని స్వతంత్ర కమాండ్-లైన్ ఇంటర్‌ఫేస్‌గానూ⁠(కొత్త విండోలో తెరుచుకుంటుంది) బిల్డ్ చేయవచ్చు. ప్రారంభించినప్పుడు, codex-network-proxy డిఫాల్ట్‌గా HTTP ప్రాక్సీ, SOCKS5 ప్రాక్సీ రెండింటినీ ప్రారంభిస్తుంది. ఈ ప్రాక్సీ చిరునామాలను ఎన్విరాన్‌మెంట్ వేరియబుల్స్ ద్వారా సాండ్‌బాక్స్ సృష్టించిన ప్రాసెస్‌కు అందిస్తారు. HTTP_PROXY, HTTPS_PROXY, ALL_PROXY వంటి ప్రామాణిక ఎన్విరాన్‌మెంట్ వేరియబుల్స్‌తో పాటు, PIP_PROXY వంటి పలు ప్రసిద్ధ అప్లికేషన్-నిర్దిష్ట ఎన్విరాన్‌మెంట్ వేరియబుల్స్‌నూ⁠(కొత్త విండోలో తెరుచుకుంటుంది) చేర్చుతారు. అయితే, అన్ని ప్రోగ్రామ్‌లూ ఈ ఎన్విరాన్‌మెంట్ వేరియబుల్స్‌ను అనుసరించవు. ఒక ప్రోగ్రామ్ బాహ్య హోస్ట్‌కు నేరుగా కనెక్ట్ కావడానికి ప్రయత్నిస్తే, కింద ప్లాట్‌ఫామ్-నిర్దిష్ట విభాగాల్లో వివరించినట్లు ఆపరేటింగ్ సిస్టమ్ సాండ్‌బాక్స్ పరిమితులు దాన్ని అడ్డుకుంటాయి.

అనుమతుల ప్రొఫైల్‌లో నిర్వచించిన నెట్‌వర్క్ పరిమితులను అమలు చేసే బాధ్యత నెట్‌వర్క్ ప్రాక్సీదే. ఉదాహరణకు, ముందుగా చూపిన dev ప్రొఫైల్ *.openai.comకు అభ్యర్థనలను అనుమతిస్తుంది; evil.exampleకు అభ్యర్థనలను స్పష్టంగా నిరాకరిస్తుంది. అభ్యర్థన లక్ష్యంగా ఉన్న డొమైన్ ఏ అనుమతి లేదా నిరాకరణ నియమానికీ సరిపోలకపోతే, ప్రాక్సీ ఆమోదం కోసం హార్నెస్‌కు అప్పగిస్తూ అభ్యర్థనను నిలిపి ఉంచవచ్చు. షెల్ ఆదేశం ఉదాహరణలోలాగే, Codex వినియోగదారుని నేరుగా అడగవచ్చు, లేదా అభ్యర్థనను స్వయంచాలక సమీక్షకు⁠(కొత్త విండోలో తెరుచుకుంటుంది) పంపవచ్చు. నిర్ణయం అందాక, ప్రాక్సీ అభ్యర్థనను కొనసాగనిస్తుంది లేదా దోష ప్రతిస్పందనతో తిరస్కరిస్తుంది.

ఇక్కడ క్రమం ముఖ్యం. ఎందుకంటే DNS శోధన కూడా హోస్ట్ పేరులో ఎన్‌కోడ్ చేసిన సమాచారాన్ని బయటకు వెల్లడించవచ్చు. అందుకే అభ్యర్థించిన హోస్ట్ పేరు అనుమతించబడిందని లేదా ఆమోదించబడిందని నిర్ధారించాకే ప్రాక్సీ దాని చిరునామాను కనుగొంటుంది. విస్తృత వైల్డ్‌కార్డ్ నియమాలు లేదా DNS సేవలకు యాక్సెస్ వల్ల DNS ఆధారంగా డేటాను దొంగతనంగా బయటకు పంపడం ఇంకా సాధ్యమేనని గమనించండి.

macOS

macOSలో Codex, Apple అందించే కెర్నల్ ద్వారా అమలయ్యే సాండ్‌బాక్సింగ్ వ్యవస్థ Seatbelt⁠(కొత్త విండోలో తెరుచుకుంటుంది)ను ఉపయోగిస్తుంది. Seatbelt విధానాలను Sandbox Profile Language (SBPL)లో రాస్తారు. ఇది సాండ్‌బాక్స్ పరిమితులను వ్యక్తీకరించే Scheme ఆధారిత భాష. macOSలోని /usr/bin/sandbox-exec ఆదేశం ద్వారా Codex Seatbeltను పిలుస్తుంది. codex sandboxలాగే, ఇది సాండ్‌బాక్స్‌ను వివరించే ఎంపికలను, వాటి తర్వాత అమలు చేయాల్సిన ఆదేశాన్ని తీసుకుంటుంది:

Bash

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

PROFILE అనేది సాండ్‌బాక్స్‌ను కాన్ఫిగర్ చేసే ఎంట్రీలున్న SBPL స్ట్రింగ్. ఉదాహరణకు, కింది SBPL కోడ్ భాగం సాండ్‌బాక్స్ విధానం కింద /dev/null, /dev/zeroలను చదవడానికి, రాయడానికి అనుమతిస్తుంది:

Scheme

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

సాండ్‌బాక్స్ పిలుపులో భాగంగా నెట్‌వర్క్ ప్రాక్సీని ప్రారంభించినప్పుడు, కనెక్షన్లను తగిన స్థానిక పోర్ట్‌లకే పరిమితం చేసేందుకు కింది తరహా నియమాలను ప్రొఫైల్‌లో చేరుస్తారు:

Scheme

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

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


Codex ప్రాథమిక ప్రొఫైల్
(deny default)తో మొదలవుతుంది. కాబట్టి స్పష్టంగా అనుమతించకపోతే బయటి కనెక్షన్లు నిరోధించబడతాయి.

చివరగా, SBPLలో (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)))

వాటికి విలువలను sandbox-execకు అందించే -Dkey=value ఎంపికలు నింపుతాయి.

సొంత సాండ్‌బాక్స్ APIని అమలు చేసేందుకు, Codex ఒక ప్రాథమిక విధానం⁠(కొత్త విండోలో తెరుచుకుంటుంది) నుంచి మొదలుపెట్టి sandbox-execకు ఆర్గ్యుమెంట్ల జాబితాను రూపొందిస్తుంది⁠(కొత్త విండోలో తెరుచుకుంటుంది). తర్వాత permission_profile, ఇతర సందర్భ సమాచారంతో దాన్ని సవరించి పూర్తి Seatbelt ప్రొఫైల్‌ను తయారు చేస్తుంది. అలా రూపొందిన ప్రొఫైల్, దానితో వచ్చే -D ఆర్గ్యుమెంట్లు Seatbelt అమలు చేసే పరిమితులను కాన్ఫిగర్ చేస్తాయి. నెట్‌వర్క్ ప్రాక్సీ అదనపు నెట్‌వర్క్ నియమాలను అమలు చేస్తుంది. పూర్తి ఆర్గ్యుమెంట్ల జాబితా సిద్ధమయ్యాక, sandbox-execను పిలవడం సులభమే.

మూడవ పక్షాల వినియోగం కోసం Apple ఈ భాషకు మార్గదర్శక పత్రాలు అందించదు. అందువల్ల సరైన SBPLను రూపొందించడం కష్టం. నిజానికి, man sandbox-execలో The sandbox-exec command is DEPRECATED అని ఉంది (man 3 sandbox_init ద్వారా వివరించిన sandbox_init() లైబ్రరీ ఫంక్షన్ కూడా పాతబడినదే). వాడుక విరమణ హెచ్చరిక ఉన్నా, macOS ఇప్పటికీ /usr/share/sandboxలో Seatbelt ప్రొఫైల్‌లను అందిస్తుంది. Google Chrome, Chromium సహా⁠(కొత్త విండోలో తెరుచుకుంటుంది) మూడవ పక్ష సాఫ్ట్‌వేర్ Seatbeltపై ఆధారపడుతూనే ఉంది. అందువల్ల, సమీప భవిష్యత్తులోనూ Seatbelt వినియోగాన్ని కొనసాగించాలని భావిస్తున్నాము.

Linux

Linuxలో సాండ్‌బాక్స్‌ను సృష్టించేందుకు Codex రెండు సాధనాలను కలిపి ఉపయోగిస్తుంది: ప్రత్యేక వాతావరణాలను నిర్మించే కమాండ్-లైన్ సాధనం bubblewrap⁠(కొత్త విండోలో తెరుచుకుంటుంది) (bwrap), సిస్టమ్ కాల్స్‌ను ఫిల్టర్ చేసే Linux కెర్నల్ వ్యవస్థ seccomp-bpf⁠(కొత్త విండోలో తెరుచుకుంటుంది). codex-linux-sandbox అనే అంతర్గత సహాయక ప్రోగ్రామ్ ఈ ఏర్పాటును సమన్వయిస్తుంది. macOSలోని sandbox-execలాగే, ఇది ముందుగా సాండ్‌బాక్స్ కాన్ఫిగరేషన్‌ను, ఆ తర్వాత అమలు చేయాల్సిన ఆదేశాన్ని తీసుకుంటుంది:

Bash

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

ఫైల్‌సిస్టమ్ ఐసోలేషన్ లేదా ప్రాక్సీ రూటింగ్ అవసరమైనప్పుడు, తొలి సాండ్‌బాక్స్ వాతావరణాన్ని సృష్టించేందుకు codex-linux-sandbox అనేది bwrapను పిలుస్తుంది. తర్వాత bwrap దాని లోపల codex-linux-sandbox --apply-seccomp-then-execను ప్రారంభిస్తుంది. ఈ రెండో పిలుపు వినియోగదారు ఆదేశాన్ని అమలు చేసే ముందు seccomp-bpfతో అదనపు పరిమితులను వర్తింపజేస్తుంది.

తొలి సాండ్‌బాక్స్ వాతావరణాన్ని రూపొందించేందుకు, అనుమతుల ప్రొఫైల్‌లోని ఫైల్‌సిస్టమ్ నియమాలకు అనుగుణంగా ప్రత్యేక మౌంట్ నేమ్‌స్పేస్‌లో ఫైల్‌సిస్టమ్ వీక్షణను సృష్టించడానికి Codex bubblewrapను ఉపయోగిస్తుంది. ఇది సాండ్‌బాక్స్ అమలుకు కీలకం కాబట్టి, వినియోగదారు ఇన్‌స్టాల్ చేయకపోయినా అందుబాటులో ఉండేలా Codex తన సొంత bwrap కాపీని అందిస్తుంది. అయితే PATHలో అందుబాటులో ఉంటే, bwrap⁠(కొత్త విండోలో తెరుచుకుంటుంది) అనుకూల ఇన్‌స్టాలేషన్‌కే ప్రాధాన్యమిస్తుంది⁠(కొత్త విండోలో తెరుచుకుంటుంది). పరిశీలనలో, కొన్ని Linux పంపిణీలు డిఫాల్ట్‌గా యూజర్ నేమ్‌స్పేస్‌ల యాక్సెస్‌ను నిలిపివేస్తున్నట్లు⁠(కొత్త విండోలో తెరుచుకుంటుంది) తెలిసింది. కానీ సిస్టమ్ bwrapకు మినహాయింపు ఇస్తాయి.

sandbox-execలాగే, bwrap కూడా ముందుగా సాండ్‌బాక్స్ కాన్ఫిగరేషన్‌ను, ఆ తర్వాత దానిలో అమలు చేయాల్సిన ఆదేశాన్ని తీసుకుంటుంది. SBPL వంటి ప్రత్యేక కాన్ఫిగరేషన్ భాష బదులు, bwrap కాన్ఫిగరేషన్ కోసం విడివిడి ఫ్లాగ్‌లను ఉపయోగిస్తుంది. ఫైల్‌సిస్టమ్ వీక్షణను సృష్టించేందుకు Codex ఈ ఎంపికలను ఉపయోగిస్తుంది:

  • రాయగలిగే ఫైల్ లేదా డైరెక్టరీని నిర్దేశించేందుకు --bind

  • చదవడానికి మాత్రమే అనుమతించే ఫైల్ లేదా డైరెక్టరీని నిర్దేశించేందుకు --ro-bind

  • DIRకు యాక్సెస్‌ను నిరాకరించేందుకు --perms 000 --tmpfs DIR --remount-ro DIR

  • FILEకు యాక్సెస్‌ను నిరాకరించేందుకు --perms 000 --ro-bind-data FD FILE (ఇక్కడ FD అనేది /dev/nullకు తెరిచిన ఫైల్ డిస్క్రిప్టర్)

ఈ ఎంపికలతో నిరాకరణ గ్లాబ్‌లను వర్తింపజేసేందుకు, ప్రతి ఆదేశాన్ని ప్రారంభించే ముందు Codex వాటిని నిర్దిష్ట పాత్‌లుగా విస్తరిస్తుంది. కొత్తగా సరిపోలే పాత్‌లు ఆ ఆదేశపు సాండ్‌బాక్స్ పరిమితుల్లో ఆటోమేటిక్‌గా చేరవు.

హోస్ట్‌లో ఇతర రకాల వనరులను సాండ్‌బాక్స్ యాక్సెస్ చేయకుండా Codex --unshare-ipc, --unshare-pid వంటి ఎంపికలనూ నిర్దేశిస్తుంది. అందువల్ల bubblewrap ప్రభావం ఫైళ్లు కనిపించడానికే పరిమితం కాదు.

bubblewrap వాడేటప్పుడు, నెట్‌వర్కింగ్ నిలిపివేసినా లేదా కనెక్షన్లు నెట్‌వర్క్ ప్రాక్సీ ద్వారానే వెళ్లాల్సి ఉన్నా Codex --unshare-netను అందిస్తుంది. ఇది సాండ్‌బాక్స్ కోసం కొత్త నెట్‌వర్క్ నేమ్‌స్పేస్‌ను సృష్టిస్తుంది. తర్వాత ఆదేశానికి అందుబాటులో ఉండే నెట్‌వర్కింగ్ సిస్టమ్ కాల్స్, సాకెట్ కుటుంబాలపై seccomp-bpfతో అదనపు పరిమితులు విధిస్తాము.


ప్రత్యేకంగా,
seccompiler క్రేట్⁠(కొత్త విండోలో తెరుచుకుంటుంది)తో అవసరమైన ఫిల్టర్ల ఆధారంగా BPF ప్రోగ్రామ్‌ను అప్పటికప్పుడు కంపైల్ చేస్తాము⁠(కొత్త విండోలో తెరుచుకుంటుంది). పరిమితులు మొత్తం ప్రాసెస్ ట్రీకి సంక్రమించేలా దాన్ని సాండ్‌బాక్స్‌లోని లాంచర్ ప్రాసెస్‌కు వర్తింపజేస్తాము. అందువల్ల bwrap వినియోగదారు ఆదేశాన్ని నేరుగా నడపదు. తన కాన్ఫిగరేషన్ ఆర్గ్యుమెంట్లు, వాటి తర్వాత వినియోగదారు ఆదేశంతో codex-linux-sandbox లాంచర్‌ను నడుపుతుంది:

Bash

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

ఉన్నత అధికారాలు లేకుండానే seccomp ఫిల్టర్లను వర్తింపజేయడానికి, లాంచర్ Linuxలోని no_new_privs ఫ్లాగ్‌ను సెట్ చేస్తుంది⁠(కొత్త విండోలో తెరుచుకుంటుంది). ఈ ఫ్లాగ్ చైల్డ్ ప్రాసెస్‌లకు సంక్రమిస్తుంది. setuid ఎగ్జిక్యూటబుల్ వంటి మరో ప్రోగ్రామ్‌ను నడిపేటప్పుడు అవి అదనపు అధికారాలు పొందకుండా అడ్డుకుంటుంది.

seccomp ఫిల్టర్లు నెట్‌వర్క్ కాన్ఫిగరేషన్‌పై ఆధారపడతాయి. నెట్‌వర్క్ యాక్సెస్ నిలిపివేసినప్పుడు, connect(2), bind(2) వంటి పలు నెట్‌వర్క్ సంబంధిత సిస్టమ్ కాల్స్‌ను అడ్డుకుంటాము. అయితే సాండ్‌బాక్స్‌లో నెట్‌వర్క్ ప్రాక్సీని ప్రారంభించినప్పుడు, codex-linux-sandbox సృష్టించే TCP లిసనర్‌ను చేరుకునేందుకు IP సాకెట్‌లను అనుమతిస్తాము. కానీ స్వతంత్ర Unix డొమైన్ సాకెట్‌ల సృష్టిని డిఫాల్ట్‌గా అడ్డుకుంటాము; అవి అనుకోకుండా హోస్ట్ వనరులకు యాక్సెస్ కల్పించవచ్చు.

నెట్‌వర్క్ ప్రాక్సీకి కనెక్ట్ కావడం

సాండ్‌బాక్స్ కాన్ఫిగరేషన్‌కు నెట్‌వర్క్ ప్రాక్సీ అవసరమైతే, Codex హార్నెస్ ఒక ప్రాక్సీ ఇన్‌స్టాన్స్‌ను సృష్టిస్తుంది. ఒకే Codex థ్రెడ్‌లోని పలు codex-linux-sandbox పిలుపులు దానిని పునర్వినియోగించుకోవచ్చు. ప్రతి సాండ్‌బాక్స్ తన ప్రత్యేక నెట్‌వర్క్ నేమ్‌స్పేస్ నుంచి ఆ ఉమ్మడి ప్రాక్సీని చేరుకునే మార్గం అవసరం. Codex ఆ నేమ్‌స్పేస్‌లో లూప్‌బ్యాక్ TCP లిసనర్‌ను అందిస్తుంది. దాని కనెక్షన్లను అంగీకరించి ప్రాక్సీకి మళ్లించేలా సాండ్‌బాక్స్ వెలుపల ఒక ప్రాసెస్‌ను ఏర్పాటు చేస్తుంది.

కింది రేఖాచిత్రాలు ఒక ప్రాక్సీ ఎండ్‌పాయింట్ కోసం ఈ ఏర్పాటును చూపిస్తాయి. చివరి చిత్రంలో దాని గుండా వెళ్లే ఒక కనెక్షన్‌ను చూపించాము. bubblewrapను ప్రారంభించే ముందు, codex-linux-sandbox నియంత్రణ ఛానల్‌గా ఉపయోగించేందుకు Unix సాకెట్ జతను సృష్టించి, తనను తాను ఫోర్క్ చేసుకుంటుంది. చైల్డ్ ప్రాసెస్ run_host_bridge()ను నడిపి, ఆ ఛానల్ ద్వారా లిసనర్ ఫైల్ డిస్క్రిప్టర్ అందే వరకు వేచి ఉంటుంది:

Codex హార్నెస్ codex-linux-sandboxను ప్రారంభించడాన్ని చూపే రేఖాచిత్రం. అది Unix సాకెట్ నియంత్రణ ఛానల్ ద్వారా అనుసంధానమైన రిలే ప్రాసెస్‌ను ఫోర్క్ చేస్తుంది.

ఈ ఉదాహరణలో, పేరెంట్ ప్రాసెస్ execతో తన ప్రోగ్రామ్ ఇమేజ్ స్థానంలో bwrapను ఉంచుతుంది. ఇది సాండ్‌బాక్స్‌ను ఏర్పాటు చేసి, నియంత్రణ ఛానల్ ఫైల్ డిస్క్రిప్టర్‌ను అందిస్తూ, దానిలో codex-linux-sandbox --apply-seccomp-then-execను ప్రారంభిస్తుంది:

bwrap ఒక సాండ్‌బాక్స్ నెట్‌వర్క్ నేమ్‌స్పేస్‌ను సృష్టించి, దానిలో codex-linux-sandboxను ప్రారంభించడాన్ని చూపే రేఖాచిత్రం. సాండ్‌బాక్స్ వెలుపలి రిలే ప్రాసెస్‌కు Unix సాకెట్ నియంత్రణ ఛానల్ ఉంటుంది.

సాండ్‌బాక్స్ నెట్‌వర్క్ నేమ్‌స్పేస్‌లో, codex-linux-sandbox రెండో పిలుపు లూప్‌బ్యాక్ TCP లిసనర్‌ను సృష్టించి, సాకెట్ ద్వారా దాని ఫైల్ డిస్క్రిప్టర్‌ను అందిస్తుంది. లిసనర్ సాండ్‌బాక్స్ నెట్‌వర్క్ నేమ్‌స్పేస్‌తోనే అనుసంధానమై ఉంటుంది. దీంతో వెలుపల మిగిలిన చైల్డ్ ప్రాసెస్ సాండ్‌బాక్స్ ప్రోగ్రామ్‌ల కనెక్షన్లను అంగీకరిస్తూనే, తన అప్‌స్ట్రీమ్ కనెక్షన్లను హోస్ట్ నెట్‌వర్క్ నేమ్‌స్పేస్‌లో తెరవగలదు. బదిలీ తర్వాత రెండు ప్రాసెస్‌లూ తమ నియంత్రణ ఛానల్ డిస్క్రిప్టర్‌లను మూసివేస్తాయి. సాండ్‌బాక్స్ లోపలి ప్రాసెస్ తన లిసనర్ కాపీని మూసివేస్తుంది.

TCP లిసనర్ సిద్ధమయ్యాక, సాండ్‌బాక్స్‌లోని ప్రాసెస్ ఆ లిసనర్‌ను సూచించేలా HTTP_PROXYకి తగిన విలువను సెట్ చేస్తుంది⁠(కొత్త విండోలో తెరుచుకుంటుంది). సంబంధిత ఎన్విరాన్‌మెంట్ వేరియబుల్స్‌ను కూడా అలాగే సెట్ చేస్తుంది. తర్వాత, ఫోర్క్ చేసి వినియోగదారు ఆదేశాన్ని అమలు చేసే ముందు seccompను వర్తింపజేస్తుంది:

సాండ్‌బాక్స్‌లోని ప్రోగ్రామ్ లూప్‌బ్యాక్ TCP లిసనర్‌కు కనెక్ట్ కావడాన్ని చూపే రేఖాచిత్రం. వెలుపలి codex-linux-sandbox రిలే ట్రాఫిక్‌ను Codex నెట్‌వర్క్ ప్రాక్సీకి పంపుతుంది.

సాండ్‌బాక్స్ వెలుపలి ప్రాసెస్ లిసనర్‌ను తెరిచే ఉంచుతుంది. అంగీకరించిన ప్రతి కనెక్షన్‌కు, అది కాన్ఫిగర్ చేసిన ప్రాక్సీతో కనెక్షన్ తెరిచి, రెండు దిశల్లోనూ డేటాను పంపుతుంది.

ఈ అదనపు ఏర్పాటుతో ఆదేశానికి ప్రత్యేక లూప్‌బ్యాక్ ఇంటర్‌ఫేస్‌తో సహా సొంత నెట్‌వర్క్ నేమ్‌స్పేస్ లభిస్తుంది. macOSలో, హోస్ట్ లూప్‌బ్యాక్ ఇంటర్‌ఫేస్‌లో నిర్దేశించిన పోర్ట్‌లకు ఆదేశం నేరుగా కనెక్ట్ కావడానికి Seatbelt అనుమతిస్తుంది. Linuxలో మాత్రం, ఆదేశం తన ప్రత్యేక నేమ్‌స్పేస్‌లోని లిసనర్‌కు కనెక్ట్ అవుతుంది. సాండ్‌బాక్స్ వెలుపలి ప్రాసెస్ ఆ కనెక్షన్లను కాన్ఫిగర్ చేసిన ప్రాక్సీకి మళ్లిస్తుంది. డిస్క్రిప్టర్ బదిలీ వల్ల హోస్ట్ నెట్‌వర్క్ నేమ్‌స్పేస్‌ను ఆదేశానికి అందుబాటులో పెట్టకుండానే ఈ కనెక్షన్ సాధ్యమవుతుంది.

Windows

ఈ ఏడాది ప్రారంభంలో, మేము Windowsలో సాండ్‌బాక్సింగ్‌ను అమలు చేసి, ఆ ప్రయత్నాల గురించి రాశాము. ఆ తర్వాత, Microsoft సంస్థ Windows ఆపరేటింగ్ సిస్టమ్‌లో ప్రాసెస్ ఐసోలేషన్ కోసం కొత్త ఫీచర్లతో పాటు MXC అనే లైబ్రరీని విడుదల చేసింది. ప్రస్తుతం మా సాండ్‌బాక్స్ స్థానంలో MXC లైబ్రరీని ఉపయోగించే సాండ్‌బాక్స్‌ను ప్రవేశపెడుతున్నాము.

MXC అంటే ఏమిటి?

MXC (Microsoft eXecution Container) అనేది Microsoft అందించే సాండ్‌బాక్స్‌లో కోడ్‌ను అమలు చేసే వ్యవస్థ⁠(కొత్త విండోలో తెరుచుకుంటుంది). ఇది Windows, Linux, macOSలో పలు నియంత్రణ బ్యాక్‌ఎండ్‌లకు మద్దతిస్తుంది. అనుకూలమైన Windows పరికరాల్లో MXC ఆధారిత సాండ్‌బాక్స్‌కు Codex మద్దతిస్తుంది. అంతర్నిర్మిత ప్రాసెస్ ఐసోలేషన్‌తో వినియోగదారు ప్రస్తుత వాతావరణంలోనే ఆదేశాలను పరిమితం చేస్తుంది.

భద్రత, వినియోగ సౌలభ్యం మెరుగుపరచడంతో పాటు, మా ప్రస్తుత Windows సాండ్‌బాక్స్‌లోని ఈ పరిమితులను పరిష్కరించేందుకు MXCకి మారుతున్నాము:

  • సాండ్‌బాక్స్ ఏర్పాటుకు ఉన్నత/నిర్వాహక అనుమతులు అవసరం కావడం

  • ACL తనిఖీ, సెట్టింగ్ కార్యకలాపాలకు అధిక వనరులు/సమయం పట్టడం

  • హోస్ట్ యంత్రంలో సాండ్‌బాక్స్ ఏర్పాటు స్థితి శాశ్వతంగా మిగలడం, వీటితో సహా

    • ACLలు

    • ఫైర్‌వాల్ నియమాలు

    • సాండ్‌బాక్స్ వినియోగదారులు

    • నియంత్రణ వ్యవస్థ ఫైళ్లు

MXC ఒక JSON కాన్ఫిగరేషన్ స్కీమా⁠(కొత్త విండోలో తెరుచుకుంటుంది)ను అందిస్తుంది. ఆ స్కీమా ప్రకారం ఆదేశం, పని డైరెక్టరీ, వాతావరణం, అనుమతులతో అమలు అభ్యర్థనను రూపొందించేందుకు Codex MXC SDK⁠(కొత్త విండోలో తెరుచుకుంటుంది)ని ఉపయోగిస్తుంది. ఆ అనుమతులు ఫైల్‌సిస్టమ్, నెట్‌వర్క్ యాక్సెస్‌తో పాటు డెస్క్‌టాప్, క్లిప్‌బోర్డ్ వంటి Windows వనరులకూ వర్తిస్తాయి.

విధానాన్ని MXC అమలు పిలుపుగా మార్చడం

అనుకూలత, భద్రత మధ్య సమతుల్యత కోసం Codex పలు నియంత్రణలకు స్థిర సెట్టింగ్‌లను ఉపయోగిస్తుంది. ఇది రిజిస్ట్రీని చదవడానికి అనుమతిస్తుంది. ప్రారంభ సమయంలో PowerShellకు అవసరమైన Win32k, డెస్క్‌టాప్ యాక్సెస్‌ను కొనసాగిస్తుంది. క్లిప్‌బోర్డ్ యాక్సెస్, ఇన్‌పుట్ ఇంజెక్షన్, డెస్క్‌టాప్, సిస్టమ్ సెట్టింగ్‌ల నియంత్రణలు నిలిపివేయబడతాయి. చివరగా, ప్రత్యామ్నాయంగా హోస్ట్ ఫైల్‌సిస్టమ్ అనుమతులను మార్చే పద్ధతికి MXC మళ్లకుండా నిరోధిస్తాము.

అనుమతుల ప్రొఫైల్‌లోని ఫైల్‌సిస్టమ్, నెట్‌వర్క్ నియమాలను Codex MXC కాన్ఫిగరేషన్‌గా మారుస్తుంది. మునుపటి dev ప్రొఫైల్‌ను ఉపయోగిస్తూ, ఈ కింది పరిస్థితులను అనుకుందాం:

  • యంత్రంలో స్థానిక డ్రైవ్‌లు C:\, D:\, Z:\ మాత్రమే ఉన్నాయి.

  • పని ప్రదేశపు మూల డైరెక్టరీ, పని డైరెక్టరీ రెండూ C:\work\demo.

  • వినియోగదారు హోమ్ డైరెక్టరీ D:\Users\dev, కాబట్టి ~/build-cache అనేది D:\Users\dev\build-cacheను సూచిస్తుంది.

  • నిరాకరణ గ్లాబ్‌కు C:\work\demo\config\dev.env, C:\work\demo\config\prod.env మాత్రమే సరిపోతాయి.

దీనికి అనుగుణమైన MXC సెట్టింగ్‌లలో ఇవి ఉంటాయి:

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
}

డ్రైవ్ మూలానికి యాక్సెస్

MXC ఫైల్‌సిస్టమ్ విధానం డిఫాల్ట్‌గా యాక్సెస్‌ను నిరాకరిస్తుంది. అందువల్ల, ఈ ప్రొఫైల్ అనుమతించే విస్తృత పఠన యాక్సెస్ కోసం Codex స్థానిక డ్రైవ్ మూలాలకు చదవడానికి మాత్రమే అనుమతులు జోడిస్తుంది. వినియోగదారు ప్రస్తుత ఆపరేటింగ్ సిస్టమ్ అనుమతులకు లోబడి, ఈ అనుమతులు అన్ని ఉపస్థాయిలకూ వర్తిస్తాయి.

ఒక మినహాయింపు: డ్రైవ్ మూలానికి ఇచ్చే రాయగలిగే అనుమతులు ఉపస్థాయిలకు వర్తించవు. కాబట్టి Codex వాటిని డ్రైవ్‌లో ఇప్పటికే ఉన్న మొదటి స్థాయి అంశాలకూ విస్తరిస్తుంది.

పరస్పరం విరుద్ధమైన అనుమతులు

మరింత నిర్దిష్టమైన పాత్‌లు పైస్థాయి అనుమతులను అధిగమిస్తాయి. కాబట్టి C:\ చదవడానికి మాత్రమే ఉన్నా, దాని కింద C:\work\demoలో రాయవచ్చు. అదే సమయంలో C:\work\demo\.git చదవడానికి మాత్రమే ఉంటుంది.

వేర్వేరు పాత్ రూపాలు లేదా సిమ్‌లింక్/జంక్షన్ మారుపేర్లు ఒకే పాత్‌ను సూచిస్తే, MXC మరింత కఠినమైన అనుమతిని వర్తింపజేస్తుంది: చదవడం-రాయడం కంటే చదవడానికి మాత్రమే అనుమతికి, దానికంటే నిరాకరణకు ప్రాధాన్యం ఉంటుంది.

నిరాకరణ గ్లాబ్‌లు

MXC నిర్దిష్ట నిరాకరణ పాత్‌లను మాత్రమే తీసుకుంటుంది. కాబట్టి ప్రారంభానికి ముందు Codex నిరాకరణ గ్లాబ్‌లను సరిపోలే ఫైళ్లు, డైరెక్టరీలుగా విస్తరిస్తుంది. ఆదేశం నడుస్తున్నప్పుడు గ్లాబ్‌కు సరిపోలే కొత్త పాత్‌లు ఆటోమేటిక్‌గా చేరవు.

నెట్‌వర్క్ యాక్సెస్

*.openai.com వంటి డొమైన్ నియమాలను ముందుగా వివరించిన ఉమ్మడి Codex నెట్‌వర్క్ ప్రాక్సీ అమలు చేస్తుంది. Codex ఆ ప్రాక్సీని సాండ్‌బాక్స్ వెలుపల నడిపి, ముందుగా చెప్పిన ప్రామాణిక *_PROXY ఎన్విరాన్‌మెంట్ వేరియబుల్స్ ద్వారానే దాని చిరునామాలను ఆదేశానికి అందిస్తుంది. ప్రాక్సీ యాక్సెస్‌తో సహా హోస్ట్-లూప్‌బ్యాక్ కనెక్షన్లను అనుమతిస్తూనే, MXC నేరుగా బాహ్య కనెక్షన్లను అడ్డుకుంటుంది. ఇతర స్థానిక సేవలను చేరుకోవడం ఇంకా సాధ్యమే.

macOS, Linux, Windows అంతటా, అనుమతుల ప్రొఫైల్ కింద ఆదేశాలను ప్రారంభించడానికి హార్నెస్ ఒకే సాండ్‌బాక్స్ APIని ఉపయోగిస్తుంది. ఆ పరిమితులను వర్తింపజేయడానికి అవసరమైన ఏర్పాట్లను ఆయా ప్లాట్‌ఫామ్‌లకు ప్రత్యేకమైన అమలులు నిర్వహిస్తాయి.

Codex సాండ్‌బాక్స్ ఆధారంగా మరింత ముందుకు

కోడ్ రాయడం, అమలు చేయడం వల్ల ఏజెంట్లు సాఫ్ట్‌వేర్ అభివృద్ధికి మించిన సమస్యలనూ సరళంగా పరిష్కరించగలవు. ఫైల్‌సిస్టమ్, నెట్‌వర్క్ యాక్సెస్‌పై స్పష్టమైన పరిమితులతో, వినియోగదారు ప్రస్తుత వాతావరణంలోనే ఆ సామర్థ్యాన్ని వాడటానికి Codex సాండ్‌బాక్స్ వీలు కల్పిస్తుంది. ఇది హార్నెస్‌లో పునర్వినియోగించగల ప్రాథమిక భాగం. codex sandbox ఆదేశం దీన్ని మీరు స్వయంగా రూపొందించే సాధనాలకూ అందుబాటులో ఉంచుతుంది.

ఏజెంట్లు మరిన్ని పనులు చేపడుతున్న కొద్దీ, మరిన్ని సాధనాలు, వాతావరణాల్లో సాండ్‌బాక్సింగ్‌ను ఆచరణసాధ్యం చేయాలనుకుంటున్నాము. అంటే అనుమతుల కాన్ఫిగరేషన్‌ను సులభతరం చేయడం, మెరుగైన ఆపరేటింగ్ సిస్టమ్ రక్షణలు అందుబాటులోకి వచ్చినప్పుడు వాటిని ఉపయోగించుకోవడం. ఏజెంట్ల సామర్థ్యాలను విస్తరిస్తూనే, అవి దేనిని యాక్సెస్ చేయవచ్చనే నియంత్రణను ప్రజల చేతుల్లో ఉంచడమే మా లక్ష్యం.

రచయిత

OpenAI

కృతజ్ఞతలు

ఈ పోస్ట్‌కు సహకరించిన డేవిడ్ వీసెన్, చార్లీ వీమ్స్, వియత్ భలోడియా, ఫోటిస్ చాంట్జిస్‌లకు ప్రత్యేక కృతజ్ఞతలు.