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 கொக்கிகளை நேரடியாக மாற்ற முடியாது.

  • பயனருக்கு ஏற்கெனவே உள்ள இயக்க முறைமை அனுமதிகளுக்கு உட்பட்டு, கோப்பு முறைமையைப் பரவலாகப் படிக்க அனுமதிக்கிறது. நிரல் தொகுப்பிகள், இயக்கச் சூழல்கள், உருவாக்கக் கருவிகள் ஆகியவை ரிபாசிட்டரிக்கு வெளியே உள்ள மென்பொருள் உருவாக்கக் கருவித்தொகுப்புகள், நூலகங்கள், கட்டமைப்பு அமைப்புகள் ஆகியவற்றைச் சார்ந்துள்ளன. பணிச்சூழலுக்குள் மட்டுமே படிக்கலாம் எனக் கட்டுப்படுத்தினால், பல வழக்கமான பணிப்பாய்வுகள் செயல்படாது. இதன் மறுபக்கம் என்னவென்றால், கணினியின் பிற இடங்களில் உள்ள முக்கியமான கோப்புகளையும் படிக்க முடியும்; எடுத்துக்காட்டாக, API விசைகள் அடங்கிய கட்டமைப்புக் கோப்புகள்.

  • வலையமைப்பு அணுகலை முடக்குகிறது. கட்டளையால் படிக்கக்கூடிய தரவை வெளியே கடத்தும் முயற்சிகள் உட்பட, வெளிப்புறச் சேவைகளுக்கு நேரடியாகப் பதிவேற்றுவதை இது தடுக்கிறது. சார்புத் தொகுப்புகளைப் பதிவிறக்குவது போன்ற முறையான செயல்பாடுகளையும் இது தடுக்கிறது; அவற்றுக்குக் கூடுதல் அணுகல் தேவை.

இந்தக் கட்டுப்பாடுகள் பல வகையான தவறான செயல்பாடுகளைத் தடுத்தாலும், தீங்கு விளைவிக்கும் செயல்கள் இன்னும் சாத்தியமே. எடுத்துக்காட்டாக, உள்ளகமாக நிறுவப்பட்ட node_modules/prettier போன்ற தொகுப்பில் ஏஜென்ட் தீங்கிழைக்கும் நிரலைச் சேர்க்கக்கூடும். Git பெரும்பாலும் node_modules கோப்பகத்தைப் புறக்கணிப்பதால், அத்தகைய மாற்றம் git status இல் தெரியாமல் போகலாம். பயனரின் திருத்தி, சேமிக்கும்போது அந்த Prettier பிரதியை இயக்கினால், ஒரு கோப்பைச் சேமிப்பது மட்டுமே கூட Codex சாண்ட்பாக்ஸுக்கு வெளியே தீங்கிழைக்கும் நிரலை இயக்கிவிடலாம். இதனால்தான் பல அடுக்குப் பாதுகாப்பு அணுகுமுறையைப் பின்பற்றுகிறோம்: கட்டளைகள் எவற்றை அணுகலாம் என்பதைச் சாண்ட்பாக்ஸ் கட்டுப்படுத்துகிறது; அந்த அணுகலைப் பயனரின் நோக்கத்திற்கு ஏற்ப மாடல் பயன்படுத்தப் பயிற்சியும் நோக்கச் சீரமைப்பும் உதவுகின்றன.

நிறுவனச் சூழலில் சாண்ட்பாக்ஸ் அனுமதிகளைத் தேவைக்கேற்ப மாற்றி, மற்ற பாதுகாப்புகளுடன் இணைப்பதற்கான வழிகாட்டுதலுக்கு Codex பாதுகாப்புச் செய்முறை வழிகாட்டியைப்⁠(புதிய சாளரத்தில் திறக்கும்) பார்க்கவும்.

சாண்ட்பாக்ஸை வடிவமைத்தல்

மெய்நிகர் இயந்திரங்களும் கொள்கலன்களும்⁠(புதிய சாளரத்தில் திறக்கும்) சாண்ட்பாக்ஸ் உருவாக்கப் பரவலாகப் பயன்படுத்தப்படும் இரு வழிமுறைகள். ஆனால் Codex சாண்ட்பாக்ஸில் வேறொரு அணுகுமுறையைப் பின்பற்றுகிறோம். தனிமைப்படுத்துவதற்காகக் கணக்கீட்டை வேறு சூழலுக்கு மாற்றுவதற்குப் பதிலாக, பயனரின் தற்போதைய சூழலில் இயங்கும் கட்டளைகளைக் கட்டுப்படுத்த ஒவ்வொரு தளத்தின் சாண்ட்பாக்ஸ் வசதிகளையும் Codex பயன்படுத்துகிறது.

பல உருவாக்குநர்களுக்கு, அவர்களின் மடிக்கணினியே விரும்பியபோது மாற்றிக்கொள்ளக்கூடிய தனிப்பயன் உருவாக்கச் சூழலாக இருக்கிறது. அதே சூழலை Docker கொள்கலனில் மீண்டும் உருவாக்க முயற்சி தேவைப்படலாம். மேலும், சில பணிப்பாய்வுகள் முதன்மைக் கணினியில் இயங்கும் கருவிகளையே இன்னும் சார்ந்துள்ளன.

எடுத்துக்காட்டாக, Mac இல் iOS செயலியை உருவாக்க Codex ஐப் பயன்படுத்துவதைக் கருதுவோம். Docker க்குள் Codex ஐ இயக்கி சாண்ட்பாக்ஸில் வைக்க முடிவுசெய்தால், 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 கைப்பிடியைத் திருப்பியளிக்கிறது. ஒவ்வொரு சேய்ச் செயல்முறையும் அதன் தாய்ச் செயல்முறையின் சாண்ட்பாக்ஸ் கட்டுப்பாடுகளை மரபாகப் பெறுகிறது. எனவே, கட்டளை தொடங்கிய முழுச் செயல்முறை மரத்திற்கும் அவை பொருந்தும்; அசல் செயல்முறை முடிந்த பிறகும் இயங்கும் வழித்தோன்றல் செயல்முறைகளுக்கும் இது பொருந்தும்.

கட்டமைப்பிலிருந்து சாண்ட்பாக்ஸில் கட்டளையை இயக்குவது வரை, இந்தக் கூறுகள் எவ்வாறு இணைந்து செயல்படுகின்றன என்பதைப் பின்வரும் வரைபடம் காட்டுகிறது. அடுத்து வரும் பகுதிகள் ஒவ்வொரு நிலையையும் விளக்குகின்றன.

பாய்வு வரைபடம்: கட்டமைப்பும் நிர்வகிக்கப்படும் தேவைகளும் அமர்வின் அனுமதி சுயவிவரத்தை வரையறுக்கின்றன. macOS, Linux அல்லது Windows இல் தளம் சார்ந்த சாண்ட்பாக்ஸ் கட்டுப்பாடுகளின்கீழ் Codex சூழல் பணி அமைவு கட்டளைகளைத் தொடங்குகிறது. சேய்ச் செயல்முறைகள் அந்தக் கட்டுப்பாடுகளை மரபாகப் பெறுகின்றன; விருப்பத்திற்கேற்ப பயன்படுத்தப்படும் வலையமைப்புப் பதிலி களப்பெயர் விதிகளை அமல்படுத்துகிறது.

சூழல் பணி அமைவு சாண்ட்பாக்ஸை எவ்வாறு பயன்படுத்துகிறது

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 பயனரிடம் நேரடியாகக் கேட்கலாம் அல்லது கோரிக்கையை தானியங்கு மதிப்பாய்வுக்கு⁠(புதிய சாளரத்தில் திறக்கும்) அனுப்பலாம்.) இயக்க ஒப்புதல் கிடைத்தால், அசல் ExecCommandToolCall இன் கட்டளை அளவுருக்களுடன், உரிய permission_profile மற்றும் network_proxy ஆகியவற்றை perform_exec_command_with_sandboxing() க்கு Codex வழங்கும்.

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 கோப்பகத்தைப் படிக்க மட்டுமே அனுமதிக்கிறது.

தனது சொந்த விதிகளுடன், :workspace இலிருந்து பின்வரும் பாதுகாப்புகளையும் dev மரபாகப் பெறுகிறது:

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 ஆதரிக்கிறது.

கட்டமைப்பு முன்னுரிமை,⁠(புதிய சாளரத்தில் திறக்கும்) பகுதியில் விவரித்துள்ளபடி, பல config.toml கோப்புகளிலிருந்து அமைப்புகளை Codex ஒன்றிணைக்கிறது. அட்டவணைகள் உட்பொதிந்த நிலைகள் அனைத்திலும் ஒன்றிணைக்கப்படுகின்றன. மதிப்புகள் முரண்பட்டால், அதிக முன்னுரிமையுள்ள மூலத்தின் மதிப்பு ஏற்கப்படுகிறது. அணிகள் முழுமையாக மாற்றப்படுகின்றன.

இதனால்தான் அனுமதி சுயவிவரங்கள், கோப்பு முறைமைப் பாதைகளுக்கும் வலையமைப்புக் களப்பெயர்களுக்கும் அட்டவணைகளைப் பயன்படுத்துகின்றன. ஒரு குழு தனது கட்டமைப்பில் தனிப்பட்ட பதிவுகளைச் சேர்க்கலாம் அல்லது மாற்றி அமைக்கலாம். நிறுவனத்தின் அடிப்படைக் கட்டமைப்பில் உள்ள மற்ற எல்லாப் பதிவுகளின் மாற்றங்களையும் தானாகப் பெறலாம்:

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 கட்டமைப்பில் வரையறுக்கப்பட்ட அனுமதி சுயவிவரத்தின்கீழ் எந்தக் கட்டளையையும் இயக்க உதவும் sandbox கட்டளையை Codex கட்டளைவரி இடைமுகம் வழங்குகிறது. சுயவிவரத்தைச் சோதிக்கவும், தடுக்க வேண்டிய செயல்பாட்டைச் சாண்ட்பாக்ஸ் உண்மையில் தடுக்கிறதா என்பதை உறுதிசெய்யவும் இது பொதுவாகப் பயன்படுத்தப்படுகிறது.

எடுத்துக்காட்டாக, சேமிக்கும்போது தீங்கிழைக்கும் தானியங்கு வடிவமைப்பியை இயக்குமாறு 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 ஆல் நம்பகமாக ஊகிக்க முடியாது. எனவே, இயல்புநிலை சாண்ட்பாக்ஸ் சுயவிவரத்தைப் பயன்படுத்துவது, மற்றபடி சரியாக இயங்கும் கட்டமைப்பைச் செயலிழக்கச் செய்யக்கூடும்.

எடுத்துக்காட்டாக, @modelcontextprotocol/server-memory⁠(புதிய சாளரத்தில் திறக்கும்) MCP சேவையகத்தை Codex உடன் பயன்படுத்துவதற்கான வழக்கமான கட்டமைப்பு பின்வருமாறு:

TOML

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

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

இந்த 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 இல், Apple இன் கருவால் அமல்படுத்தப்படும் சாண்ட்பாக்ஸ் வழிமுறையான Seatbelt⁠(புதிய சாளரத்தில் திறக்கும்) ஐ Codex பயன்படுத்துகிறது. Seatbelt கொள்கைகள், சாண்ட்பாக்ஸ் கட்டுப்பாடுகளை விவரிப்பதற்கான Scheme அடிப்படையிலான Sandbox Profile Language (SBPL) மொழியில் எழுதப்படுகின்றன. 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 ஐச் செயலாக்க, ஒரு அடிப்படைக் கொள்கையிலிருந்து⁠(புதிய சாளரத்தில் திறக்கும்) தொடங்கி, sandbox-exec க்கான அளவுருப் பட்டியலை Codex உருவாக்குகிறது⁠(புதிய சாளரத்தில் திறக்கும்). பின்னர் 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 இல் சாண்ட்பாக்ஸை உருவாக்க, தனிமைப்படுத்தப்பட்ட சூழல்களை அமைக்கும் கட்டளைவரிக் கருவியான bubblewrap⁠(புதிய சாளரத்தில் திறக்கும்) (bwrap) மற்றும் முறைமை அழைப்புகளை வடிகட்டும் Linux கரு வழிமுறையான seccomp-bpf⁠(புதிய சாளரத்தில் திறக்கும்) ஆகியவற்றை Codex இணைத்துப் பயன்படுத்துகிறது. 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 ஐப் பயன்படுத்துகிறது.

அந்தத் தொடக்க சாண்ட்பாக்ஸ் சூழலை உருவாக்க, அனுமதி சுயவிவரத்தின் கோப்பு முறைமை விதிகளைப் பிரதிபலிக்கும் கோப்பு முறைமைக் காட்சியைத் தனியான ஏற்றப் பெயர்வெளியில் bubblewrap மூலம் Codex உருவாக்குகிறது. சாண்ட்பாக்ஸ் செயலாக்கத்திற்கு இது அடிப்படை என்பதால், பயனர் நிறுவியிருக்காத நிலைக்காக bwrap இன் சொந்தப் பிரதியை Codex உடன் வழங்குகிறோம். இருப்பினும், 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 விரிவாக்குகிறது. புதிதாக உருவாகும் பொருந்தக்கூடிய பாதைகள், அந்தக் கட்டளையின் சாண்ட்பாக்ஸ் கட்டுப்பாடுகளில் தானாகச் சேர்க்கப்படாது.

முதன்மைக் கணினியின் பிற வகை வளங்களைச் சாண்ட்பாக்ஸ் அணுகுவதைத் தடுக்க, --unshare-ipc, --unshare-pid போன்ற விருப்பங்களையும் Codex குறிப்பிடுகிறது. எனவே, 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 பலமுறை அழைக்கப்படும்போதும் இதை மீண்டும் பயன்படுத்தலாம். ஒவ்வொரு சாண்ட்பாக்ஸும் தனது தனிமைப்படுத்தப்பட்ட வலையமைப்புப் பெயர்வெளியிலிருந்து அந்தப் பகிரப்பட்ட பதிலியை அணுக ஒரு வழி தேவை. அந்தப் பெயர்வெளிக்குள் ஒரு மீள்சுழற்சி TCP இணைப்பு ஏற்பியை Codex வழங்குகிறது. அதன் இணைப்புகளை ஏற்று, பதிலிக்கு அனுப்பச் சாண்ட்பாக்ஸுக்கு வெளியே ஒரு செயல்முறையையும் ஏற்பாடு செய்கிறது.

பின்வரும் வரைபடங்கள் ஒரு பதிலி எண்ட்பாயிண்டுக்கான இந்த ஏற்பாட்டைக் காட்டுகின்றன. இறுதி வரைபடம் அதன் வழியாகச் செல்லும் ஓர் இணைப்பைக் காட்டுகிறது. bubblewrap ஐத் தொடங்குவதற்கு முன், கட்டுப்பாட்டுத் தடமாகச் செயல்பட ஒரு Unix சாக்கெட் ஜோடியை codex-linux-sandbox உருவாக்கி, தன்னிலிருந்து ஒரு சேய்ச் செயல்முறையைப் பிரிக்கிறது. சேய்ச் செயல்முறை 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 இல் சாண்ட்பாக்ஸ் வசதியைச் செயல்படுத்தி, அதற்கான எங்கள் முயற்சிகள் குறித்து எழுதினோம். அதன் பிறகு, Windows இயக்க முறைமையில் செயல்முறைகளைத் தனிமைப்படுத்துவதற்கான புதிய வசதிகளுடன், MXC என்ற நூலகத்தையும் Microsoft வெளியிட்டுள்ளது. தற்போதுள்ள எங்கள் சாண்ட்பாக்ஸுக்குப் பதிலாக, 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

நன்றியுரை

இந்தப் பதிவுக்குப் பங்களித்த டேவிட் வீசன், சார்லி வீம்ஸ், வியத் பலோடியா, ஃபோட்டிஸ் சான்ட்சிஸ் ஆகியோருக்குச் சிறப்பு நன்றி.