OpenAI

Codex സാൻഡ്ബോക്സിനുള്ളിൽ

നിങ്ങൾ നിയന്ത്രിക്കുന്ന പരിധികളോടെ Codex നിങ്ങളുടെ മെഷീനിൽ കമാൻഡുകൾ പ്രവർത്തിപ്പിക്കുന്ന വിധം.

എഴുതിയത് മൈക്കൽ ബോളിൻ, സാങ്കേതിക വിഭാഗം അംഗം

ഏജന്റുകളെ സംരക്ഷിക്കാൻ OpenAI-യിൽ ഞങ്ങൾ ബഹുതല പ്രതിരോധ⁠(പുതിയ വിൻഡോയിൽ തുറക്കുന്നു) സമീപനം സ്വീകരിക്കുന്നു. പരിശീലനത്തിലും അലൈൻമെന്റിലുമുള്ള നിക്ഷേപങ്ങളാണ് ഈ ശ്രമത്തിന്റെ അടിത്തറ. അധിക സംരക്ഷണത്തിനായി ഞങ്ങളുടെ ഏജന്റിക് ഹാർനെസായ 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 ഉപയോഗിക്കുന്നത് പരിഗണിക്കുക. Docker-നുള്ളിൽ പ്രവർത്തിപ്പിച്ച് Codex-നെ സാൻഡ്ബോക്സിലാക്കിയാൽ, തനത് Mac എക്സിക്യൂട്ടബിളുകളടങ്ങുന്ന iOS ബിൽഡ് ടൂൾശൃംഖല പ്രവർത്തിപ്പിക്കാനോ കോഡ് പ്രവർത്തിപ്പിക്കാൻ iPhone സിമുലേറ്റർ തുറക്കാനോ Codex-ന് കഴിയില്ല. Docker അധിഷ്ഠിത പ്രവർത്തനക്രമത്തിന് ബിൽഡുകളും സിമുലേറ്റർ പ്രവർത്തനങ്ങളും Mac ഹോസ്റ്റിനെ ഏൽപ്പിക്കാം. പക്ഷേ അവ കണ്ടെയ്നറിന്റെ സാൻഡ്ബോക്സിനു പുറത്തായതിനാൽ പ്രത്യേക നിയന്ത്രണങ്ങൾ വേണ്ടിവരും. ഓപ്പറേറ്റിങ് സിസ്റ്റത്തിനനുസരിച്ചുള്ള സാൻഡ്ബോക്സിങ്ങിൽ വലിയ നിക്ഷേപം നടത്തി കാര്യങ്ങൾ ലളിതമാക്കാനാണ് ഞങ്ങൾ താൽപര്യപ്പെടുന്നത്. ഇതിലൂടെ ജോലിക്ക് ഏറ്റവും അനുയോജ്യമായ പരിതസ്ഥിതിയിൽ 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 എന്നിവ Codex, 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 CLI അതിന്റെ പ്രവർത്തന ഡയറക്ടറി ഏക പ്രവർത്തനമേഖലാ റൂട്ടായി ഉപയോഗിക്കുന്നു. 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 ക്രമീകരണത്തിൽ നിർവചിച്ച അനുമതി പ്രൊഫൈലിനുകീഴിൽ ഏതു കമാൻഡും പ്രവർത്തിപ്പിക്കാൻ Codex CLI ഒരു 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-ൽ ഇത് പരാജയപ്പെടുമ്പോൾ ലഭിക്കുന്നത്:

Plain text

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

ഏജന്റ് സെഷനിൽനിന്ന് സ്വതന്ത്രമായി Codex-ന്റെ സാൻഡ്ബോക്സിങ് സംവിധാനം codex sandbox കമാൻഡ് ലഭ്യമാക്കുന്നു. സ്വന്തം ടൂളുകൾ ആരംഭിക്കുന്ന കമാൻഡുകൾ നിയന്ത്രിക്കാൻ ഇതേ ക്രമീകരണ ഭാഷയും പ്ലാറ്റ്ഫോം-നിർദിഷ്ട നിർവഹണ സംവിധാനവും ഉപയോഗിക്കാം.

ഉദാഹരണം: 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-ൽ, Apple-ന്റെ കെർണൽ നടപ്പാക്കുന്ന സാൻഡ്ബോക്സിങ് സംവിധാനമായ Seatbelt⁠(പുതിയ വിൻഡോയിൽ തുറക്കുന്നു) Codex ഉപയോഗിക്കുന്നു. സാൻഡ്ബോക്സ് നിയന്ത്രണങ്ങൾ വിവരിക്കാനുള്ള Scheme അധിഷ്ഠിത ഭാഷയായ Sandbox Profile Language (SBPL)-ലാണ് Seatbelt നയങ്ങൾ എഴുതുന്നത്. macOS-ന്റെ /usr/bin/sandbox-exec കമാൻഡിലൂടെ Codex, Seatbelt വിളിക്കുന്നു. codex sandbox പോലെ, ഇത് സാൻഡ്ബോക്സ് വിവരിക്കുന്ന ഓപ്ഷനുകളും തുടർന്ന് പ്രവർത്തിപ്പിക്കേണ്ട കമാൻഡും സ്വീകരിക്കുന്നു:

Bash

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

സാൻഡ്ബോക്സ് ക്രമീകരിക്കുന്ന എൻട്രികൾ അടങ്ങിയ SBPL സ്ട്രിങ്ങാണ് PROFILE. ഉദാഹരണത്തിന്, താഴെയുള്ള 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) ഉപയോഗിച്ചാണ് തുടങ്ങുന്നത്. അതിനാൽ വ്യക്തമായി അനുവദിക്കാത്ത പുറത്തേക്കുള്ള കണക്ഷനുകൾ തടയപ്പെടും.

അവസാനമായി, (param) ഉപയോഗിക്കുന്ന സ്ഥാനസൂചകങ്ങൾ SBPL-ൽ ഉൾക്കൊള്ളിക്കാം:

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 അവയെ നിർദിഷ്ട പാതകളായി വിപുലീകരിക്കുന്നു. പുതുതായി പൊരുത്തപ്പെടുന്ന പാതകൾ ആ കമാൻഡിന്റെ സാൻഡ്ബോക്സ് നിയന്ത്രണങ്ങളിലേക്ക് സ്വയം ചേർക്കപ്പെടില്ല.

ഹോസ്റ്റിലെ മറ്റു വിഭവങ്ങളിലേക്ക് സാൻഡ്ബോക്സിന്റെ ആക്സസ് തടയാൻ --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-linux-sandbox വിളികളിൽ പുനരുപയോഗിക്കാവുന്ന ഒരു പ്രോക്സി ഇൻസ്റ്റൻസ് Codex ഹാർനെസ് സൃഷ്ടിക്കുന്നു. ഓരോ സാൻഡ്ബോക്സിനും സ്വന്തം ഒറ്റപ്പെട്ട നെറ്റ്‌വർക്ക് നെയിംസ്പേസിൽനിന്ന് ആ പങ്കിട്ട പ്രോക്സിയിലെത്താനുള്ള വഴി വേണം. 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-ൽ സാൻഡ്ബോക്സിങ് നടപ്പാക്കി; ആ ശ്രമങ്ങളെക്കുറിച്ച് എഴുതുകയും ചെയ്തു. അതിനുശേഷം, Windows ഓപ്പറേറ്റിങ് സിസ്റ്റത്തിൽ പ്രോസസുകളെ ഒറ്റപ്പെടുത്താനുള്ള പുതിയ സവിശേഷതകൾക്കൊപ്പം Microsoft, MXC എന്ന ലൈബ്രറി പുറത്തിറക്കി. നിലവിലെ സാൻഡ്ബോക്സിനുപകരം MXC ലൈബ്രറി ഉപയോഗിക്കുന്ന സാൻഡ്ബോക്സിലേക്ക് ഞങ്ങൾ മാറിക്കൊണ്ടിരിക്കുകയാണ്.

എന്താണ് MXC?

MXC (Microsoft eXecution Container), Windows, Linux, macOS എന്നിവയിലെ വിവിധ ഒറ്റപ്പെടുത്തൽ ബാക്കെൻഡുകൾ പിന്തുണയ്ക്കുന്ന Microsoft-ന്റെ സാൻഡ്ബോക്സിൽ കോഡ് പ്രവർത്തിപ്പിക്കുന്ന സംവിധാനമാണ്⁠(പുതിയ വിൻഡോയിൽ തുറക്കുന്നു). അനുയോജ്യമായ 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

നന്ദി

ഈ ലേഖനത്തിലേക്ക് സംഭാവന നൽകിയ ഡേവിഡ് വീസൻ, ചാർലി വീംസ്, വിയത് ഭലോഡിയ, ഫോട്ടിസ് ചാന്റ്സിസ് എന്നിവർക്ക് പ്രത്യേക നന്ദി.