OpenAI

၂၀၂၆ နိုဝင်ဘာ ၁၈

အင်ဂျင်နီယာနယ်ပယ်

Codex sandbox အတွင်းပိုင်း

သင်ထိန်းချုပ်သော ကန့်သတ်ချက်များဖြင့် သင့်စက်ပေါ်တွင် Codex က command များ လုပ်ဆောင်ပုံ။

နည်းပညာအဖွဲ့ဝင် Michael Bolin ရေးသားသည်

OpenAI တွင် အေးဂျင့်များကို ကာကွယ်ရန် အလွှာစုံကာကွယ်ရေး⁠(ဝင်းဒိုးအသစ်တွင် ဖွင့်မည်) နည်းလမ်းကို သုံးပါသည်။ လေ့ကျင့်သင်ကြားမှုနှင့် ရည်ရွယ်ချက်ကိုက်ညီရေးအတွက် ရင်းနှီးမြှုပ်နှံမှုများက အခြေခံကျသော်လည်း ပိုမိုကာကွယ်နိုင်ရန် အေးဂျင့်သုံး အကဲဖြတ်စမ်းသပ်မှု စနစ် Codex⁠(ဝင်းဒိုးအသစ်တွင် ဖွင့်မည်) တွင်လည်း လုပ်ဆောင်ချက်များ ထည့်သွင်းထားသည်။ Codex မကြာခဏလုပ်ဆောင်သည့် (အန္တရာယ်လည်းရှိနိုင်သည့်) အရာတစ်ခုမှာ သင့်ကွန်ပျူတာပေါ်၌ command များ လုပ်ဆောင်ခြင်းဖြစ်သည်။ ထို့ကြောင့် သင်ထိန်းချုပ်သော ဖိုင်စနစ်နှင့် ကွန်ရက်ကန့်သတ်ချက်များအတွင်း သင့်လက်ရှိပတ်ဝန်းကျင်၌ အလုပ်လုပ်နိုင်ရန် Codex sandbox ကို တည်ဆောက်ခဲ့သည်။

⁠(ဝင်းဒိုးအသစ်တွင် ဖွင့်မည်)sandbox⁠(ဝင်းဒိုးအသစ်တွင် ဖွင့်မည်) သည် ပရိုဂရမ်တစ်ခု အလုပ်လုပ်နေစဉ် သုံးစွဲနိုင်သည့်အရာများကို ကန့်သတ်ပေးသည်။ ဓာတ်ပုံများ စီစဉ်ရာတွင် command များက ~/Pictures ရှိ ဖိုင်များကို ဖတ်၍ပြင်နိုင်ရန် Codex sandbox ကို သတ်မှတ်ပြီး ဖိုင်တင်ပို့မှုတားရန် ကွန်ရက်သုံးစွဲခွင့်ကို ပိတ်ထားနိုင်သည်။ ကုဒ်ပြန်လည်သုံးသပ်ရာတွင် မူရင်းဖိုင်များကို ဖတ်ရန်သာထားပြီး အွန်လိုင်းလမ်းညွှန်စာတမ်းများကို သုံးခွင့်ပေးနိုင်သည်။ အသုံးပြုသူများသည် Codex session ၏ ဖိုင်စနစ်နှင့် ကွန်ရက်ကန့်သတ်ချက်များကို သတ်မှတ်ပေးသည့် ⁠(ဝင်းဒိုးအသစ်တွင် ဖွင့်မည်)ခွင့်ပြုချက်ပရိုဖိုင်များ⁠(ဝင်းဒိုးအသစ်တွင် ဖွင့်မည်) မှတစ်ဆင့် Codex sandbox ကို ပြင်ဆင်သတ်မှတ်သည်။

ဤဆောင်းပါးတွင် Codex sandbox ၏ မူလဆက်တင်များ နောက်ကွယ်မှ အပေးအယူများကို စတင်ဆွေးနွေးပြီး sandbox ဒီဇိုင်းနှင့် command များလုပ်ဆောင်ရန် အကဲဖြတ်စမ်းသပ်မှု စနစ်က ၎င်းကို အသုံးပြုပုံကို ရှင်းပြမည်။ အသုံးပြုသူများနှင့် လုပ်ငန်းများက ခွင့်ပြုချက်များကို လိုအပ်သလို ချိန်ညှိနိုင်ပုံ၊ ဆော့ဖ်ဝဲရေးသားသူများက ကိုယ်ပိုင်ကိရိယာများတွင် sandbox ကို ပြန်သုံးနိုင်ပုံတို့ကို ဖော်ပြမည်။ နောက်ဆုံးတွင် macOS၊ Linux နှင့် Windows တို့၌ ဤကန့်သတ်ချက်များကို အကောင်အထည်ဖော်ပုံကို လေ့လာမည်။

sandbox ၏ နယ်နိမိတ်များ ရွေးချယ်ခြင်း

Codex တွင် ကျွန်ုပ်တို့၏ သဘောထားမှာ အသုံးဝင်သောအလုပ်များ လုပ်နိုင်စေသည့် တစ်ချိန်တည်းတွင် ဘေးကင်းရေးဦးစားပေးသော မူလ sandbox ဆက်တင်များ သတ်မှတ်ရန်ဖြစ်သည်။ ဥပမာ၊ လုပ်ငန်းခွင် root အဖြစ် Git သိမ်းဆည်းရန်နေရာကို သုံးလျှင် အသင့်ပါသော :workspace ခွင့်ပြုချက်ပရိုဖိုင်သည်—

  • လုပ်ငန်းခွင်အတွင်း ရေးခွင့်ပေးသော်လည်း .git နှင့် .codex ကဲ့သို့ directory များကို ဖတ်ရန်သာ ထားသည်။ ထို့ကြောင့် Codex သည် ပြောင်းလဲမှုတိုင်းအတွက် ခွင့်တောင်းစရာမလိုဘဲ မူရင်းကုဒ်ကို ပြင်နိုင်သော်လည်း .codex/config.toml သို့မဟုတ် .git/hooks အောက်ရှိ Git hook များကို တိုက်ရိုက်မပြင်နိုင်ပါ။

  • အသုံးပြုသူ၏ လက်ရှိ OS ခွင့်ပြုချက်အတိုင်း ဖိုင်စနစ်ကို ကျယ်ကျယ်ပြန့်ပြန့် ဖတ်ခွင့်ပေးသည်။ compiler၊ runtime နှင့် build ကိရိယာများသည် သိမ်းဆည်းရန်နေရာပြင်ပရှိ SDK၊ library နှင့် ဆက်တင်များကို မှီခိုရသည်။ လုပ်ငန်းခွင်အတွင်းသာ ဖတ်ခွင့်ကန့်သတ်ပါက ပုံမှန်လုပ်ငန်းစဉ်များစွာ အလုပ်မလုပ်တော့ပါ။ အလဲအလှယ်အဖြစ် စက်၏ အခြားနေရာရှိ အရေးကြီးဖိုင်များ (ဥပမာ API key ပါသော config ဖိုင်များ) ကိုလည်း ဖတ်နိုင်နေဦးမည်။

  • ကွန်ရက်သုံးစွဲခွင့်ကို ပိတ်ထားသည်။ ဤသို့ ပိတ်ထားခြင်းက command ဖတ်နိုင်သော ဒေတာကို ခိုးထုတ်ရန်ကြိုးပမ်းမှုအပါအဝင် ပြင်ပဝန်ဆောင်မှုများသို့ တိုက်ရိုက်တင်ပို့ခြင်းကို တားသည်။ လိုအပ်သော ဆော့ဖ်ဝဲအစိတ်အပိုင်းများ ဒေါင်းလုဒ်လုပ်ခြင်းကဲ့သို့ သင့်လျော်သော လုပ်ဆောင်မှုများကိုလည်း တားသဖြင့် ထပ်ဆောင်းသုံးစွဲခွင့် လိုအပ်သည်။

ဤကန့်သတ်ချက်များက မသင့်လျော်သော အပြုအမူအမျိုးအစားများစွာကို တားသော်လည်း အန္တရာယ်ရှိသော လုပ်ဆောင်မှုများ ဖြစ်နိုင်သေးသည်။ ဥပမာ အေးဂျင့်က node_modules/prettier ကဲ့သို့ စက်တွင်းထည့်သွင်းထားသော package ထဲသို့ အန္တရာယ်ရှိကုဒ် ထည့်နိုင်သည်။ Git က node_modules ကို မကြာခဏ လျစ်လျူရှုထားသဖြင့် ထိုပြောင်းလဲမှုသည် git status တွင် မပေါ်နိုင်ပါ။ အသုံးပြုသူ၏ editor က ဖိုင်သိမ်းချိန်တွင် ထို Prettier ကို သုံးပါက ဖိုင်သိမ်းလိုက်ရုံဖြင့် Codex sandbox ပြင်ပ၌ အန္တရာယ်ရှိကုဒ် လုပ်ဆောင်သွားနိုင်သည်။ ထို့ကြောင့် အလွှာစုံကာကွယ်ရေးနည်းကို သုံးခြင်းဖြစ်သည်။ sandbox က command များ သုံးစွဲနိုင်သည့်အရာများကို ကန့်သတ်ပြီး လေ့ကျင့်သင်ကြားမှုနှင့် ရည်ရွယ်ချက်ကိုက်ညီရေးက ထိုသုံးစွဲခွင့်ကို အသုံးပြုသူ၏ ရည်ရွယ်ချက်အတိုင်း မော်ဒယ် အသုံးပြုနိုင်ရန် ကူညီသည်။

လုပ်ငန်းပတ်ဝန်းကျင်၌ sandbox ခွင့်ပြုချက်များ ချိန်ညှိခြင်းနှင့် အခြားကာကွယ်ရေးများနှင့် ပေါင်းစပ်ခြင်းအတွက် Codex လုံခြုံရေးလက်တွေ့လမ်းညွှန်⁠(ဝင်းဒိုးအသစ်တွင် ဖွင့်မည်) ကို ကြည့်ပါ။

sandbox ကို ဒီဇိုင်းဆွဲခြင်း

Virtual machine နှင့် container⁠(ဝင်းဒိုးအသစ်တွင် ဖွင့်မည်) တို့သည် sandbox ပြုလုပ်ရန် လူသုံးများသော နည်းလမ်းနှစ်ခုဖြစ်သော်လည်း Codex sandbox အတွက် ကွဲပြားသောနည်းလမ်းကို သုံးထားသည်။ သီးခြားခွဲထားရန် တွက်ချက်လုပ်ဆောင်မှုကို အခြားပတ်ဝန်းကျင်သို့ ရွှေ့မည့်အစား Codex သည် ပလက်ဖောင်းတစ်ခုစီ၏ sandbox စွမ်းရည်များဖြင့် အသုံးပြုသူ၏ လက်ရှိပတ်ဝန်းကျင်၌ လုပ်ဆောင်သော command များကို ကန့်သတ်သည်။

ဆော့ဖ်ဝဲရေးသားသူများစွာအတွက် ၎င်းတို့၏ လက်ပ်တော့သည် စိတ်ကြိုက်ပြင်ဆင်နိုင်သော ကိုယ်ပိုင်ရေးသားဖန်တီးရေးပတ်ဝန်းကျင် ဖြစ်သည်။ ထိုပတ်ဝန်းကျင်ကို Docker container ထဲတွင် ပြန်ဖန်တီးရန် အားထုတ်ရနိုင်ပြီး အချို့လုပ်ငန်းစဉ်များက host ပေါ်ရှိ ကိရိယာများကို မှီခိုနေဆဲဖြစ်သည်။

ဥပမာ Mac ပေါ်တွင် Codex ဖြင့် iOS အက်ပ်တစ်ခု ရေးသားခြင်းကို စဉ်းစားကြည့်ပါ။ Codex ကို Docker အတွင်း run ၍ sandbox ပြုလုပ်ပါက Mac ပေါ်တွင် တိုက်ရိုက်လုပ်ဆောင်သော ပရိုဂရမ်များပါဝင်သည့် iOS build toolchain ကို Codex မသုံးနိုင်သကဲ့သို့ ကုဒ်လုပ်ဆောင်ရန် iPhone simulator ကိုလည်း မဖွင့်နိုင်ပါ။ Docker အခြေပြုလုပ်ငန်းစဉ်က build နှင့် simulator လုပ်ဆောင်မှုများကို Mac host သို့ လွှဲပေးနိုင်သော်လည်း ၎င်းတို့သည် container sandbox ပြင်ပ၌ လုပ်ဆောင်မည်ဖြစ်သဖြင့် သီးခြားကန့်သတ်ချက်များ လိုအပ်မည်။ Codex အတွက်မူ လုပ်ဆောင်မည့်အလုပ်နှင့် အသင့်လျော်ဆုံးပတ်ဝန်းကျင်၌ အလုပ်လုပ်နိုင်ရန် OS အလိုက် sandbox နည်းပညာများတွင် အလေးထားရင်းနှီးမြှုပ်နှံကာ ရိုးရှင်းစွာ ထိန်းထားလိုပါသည်။

အကဲဖြတ်စမ်းသပ်မှု စနစ်က OS အလိုက် sandbox နည်းလမ်းများကို macOS၊ Windows နှင့် Linux အတွက် ဘုံ API တစ်ခုမှတစ်ဆင့် အသုံးပြုနိုင်စေသည်။ ဤ API သည် command တစ်ခုနှင့် ခွင့်ပြုချက်ပရိုဖိုင်တစ်ခုကို လက်ခံသည်။ ခွင့်ပြုချက်ပရိုဖိုင်က ကန့်သတ်ထားသော ကွန်ရက်သုံးစွဲခွင့်ပေးပါက ခေါ်ယူသူသည် ထိုကန့်သတ်ချက်များကို အကောင်အထည်ဖော်ရန် ကွန်ရက် proxy ပေးရမည်။

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:

ဤ function သည် sandbox ထဲတွင် process ကို စတင်ပြီး ၎င်းပြီးဆုံးသည်အထိ စောင့်ရန် အကဲဖြတ်စမ်းသပ်မှု စနစ်က သုံးနိုင်သည့် Child handle ကို ပြန်ပေးသည်။ child process တစ်ခုစီက parent ၏ sandbox ကန့်သတ်ချက်များကို ဆက်ခံသဖြင့် command က စတင်သော process tree တစ်ခုလုံးတွင် ထိုကန့်သတ်ချက်များ အကျုံးဝင်သည်။ မူရင်း process ပြီးနောက် ဆက်အလုပ်လုပ်နေသော ဆင့်ပွား process များပါ အကျုံးဝင်သည်။

အောက်ပါပုံသည် ဆက်တင်သတ်မှတ်ခြင်းမှ sandbox ထဲ၌ command လုပ်ဆောင်ခြင်းအထိ ဤအစိတ်အပိုင်းများ ချိတ်ဆက်ပုံကို ပြသည်။ နောက်အပိုင်းများတွင် အဆင့်တစ်ခုစီကို ရှင်းပြထားသည်။

လုပ်ငန်းစဉ်ပုံ—ဆက်တင်များနှင့် စီမံထိန်းချုပ်ထားသော လိုအပ်ချက်များက session ခွင့်ပြုချက်ပရိုဖိုင်ကို သတ်မှတ်သည်။ Codex အကဲဖြတ်စမ်းသပ်မှု စနစ်က macOS၊ Linux သို့မဟုတ် Windows ၏ ပလက်ဖောင်းအလိုက် sandbox ကန့်သတ်ချက်များအောက်တွင် command များ စတင်သည်။ child process များက ထိုကန့်သတ်ချက်များကို ဆက်ခံပြီး ရွေးချယ်အသုံးပြုနိုင်သော ကွန်ရက် proxy က domain စည်းမျဉ်းများကို အတည်ပြုကျင့်သုံးသည်။

အကဲဖြတ်စမ်းသပ်မှု စနစ်က sandbox ကို အသုံးချပုံ

Codex အေးဂျင့်၏ ထပ်ကျော့လုပ်ငန်းစဉ်ကို ဖြန့်ကြည့်ခြင်း တွင် ရှင်းပြထားသည့်အတိုင်း Codex အကဲဖြတ်စမ်းသပ်မှု စနစ်က မော်ဒယ်ထုတ်ပေးသော ကိရိယာခေါ်ယူမှုများကို လုပ်ဆောင်ရန် တာဝန်ယူသည်။ ကုဒ်ရေးသားမှုအတွက် အသုံးအများဆုံးကိရိယာမှာ shell ကိရိယာ ဖြစ်ပြီး Bash ကဲ့သို့ အပြန်အလှန်တုံ့ပြန်နိုင်သော shell တွင် အသုံးပြုသူလုပ်သကဲ့သို့ command များ လုပ်ဆောင်သည်။ လိုအပ်သောကာကွယ်မှုရရန် အကဲဖြတ်စမ်းသပ်မှု စနစ်က sandbox ကို အသုံးချပုံပြသဖို့ ဤနေရာတွင် တစ်ခေါက်တည်း ပြုလုပ်ခြင်းအတွက် ⁠(ဝင်းဒိုးအသစ်တွင် ဖွင့်မည်)exec_command⁠(ဝင်းဒိုးအသစ်တွင် ဖွင့်မည်) shell ကိရိယာ⁠(ဝင်းဒိုးအသစ်တွင် ဖွင့်မည်) ကို လေ့လာမည်။

ဤသည်မှာ Codex အကဲဖြတ်စမ်းသပ်မှု စနစ်က
exec_command ကိရိယာခေါ်ယူမှုကို sandbox မသုံးဘဲ လုပ်ဆောင်ပုံ၏ ရိုးရှင်းထားသောဗားရှင်းဖြစ်သည်။

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}

command ကို sandbox ထဲ၌ လုပ်ဆောင်ရန် အကဲဖြတ်စမ်းသပ်မှု စနစ်သည် subprocess.Popen() ခေါ်ယူမှုကို spawn_command_under_sandbox() ဖြင့် အစားထိုးသည်။ အကဲဖြတ်စမ်းသပ်မှု စနစ်က ခွင့်ပြုချက်ပရိုဖိုင်နှင့် လိုအပ်ပါက ကွန်ရက် proxy ကို ပေးသည်။

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 ကိရိယာက 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 သတ်မှတ်ထားပါက အကဲဖြတ်စမ်းသပ်မှု စနစ်သည် ထိုအလှည့်အတွက် မူလ sandbox ဆက်တင်ကို သုံးသည်။ with_additional_permissions က sandbox အတွင်း ပိုများသောသုံးစွဲခွင့်ကို တောင်းပြီး require_escalated က sandbox ပြင်ပ၌ လုပ်ဆောင်ရန် တောင်းသည်။ အကဲဖြတ်စမ်းသပ်မှု စနစ်က command မလုပ်ဆောင်မီ အသုံးပြုသူ၏ ဦးစားပေးသတ်မှတ်ချက်များအလိုက် တောင်းဆိုချက်ကို အကဲဖြတ်သည်။ (ဥပမာ Codex သည် အသုံးပြုသူကို တိုက်ရိုက်မေးနိုင်သကဲ့သို့ တောင်းဆိုချက်ကို အလိုအလျောက်သုံးသပ်မှု⁠(ဝင်းဒိုးအသစ်တွင် ဖွင့်မည်) သို့ ပို့နိုင်သည်။) လုပ်ဆောင်ခွင့်ရပါက Codex သည် မူရင်း ExecCommandToolCall မှ command argument များနှင့်အတူ သင့်လျော်သော permission_profile နှင့် network_proxy ကို perform_exec_command_with_sandboxing() သို့ ပေးပို့မည်။

shell ကိရိယာသည် spawn_command_under_sandbox() ကို အဓိကသုံးသူဖြစ်ပြီး အကဲဖြတ်စမ်းသပ်မှု စနစ်က စက်တွင်းဖိုင်များ ဖတ်ခြင်းနှင့် ပြင်ဆင်ခြင်းတို့အတွက်လည်း sandbox အခြေခံစနစ်ကို ပြန်သုံးသည်။ ပြန်လည်အသုံးချမှုသည် အကဲဖြတ်စမ်းသပ်မှု စနစ်ပြင်ပအထိ ရောက်ရှိသည်။ နောက်တွင်တွေ့ရမည့်အတိုင်း codex sandbox command ဖြင့် သင့်ကိရိယာများထဲ၌ sandbox အတွင်း command လုပ်ဆောင်မှုကို ထည့်သွင်းနိုင်သည်။ နောက်တစ်ဆင့်တွင် ခွင့်ပြုချက်ပရိုဖိုင်များ သတ်မှတ်ပုံကို လေ့လာမည်။

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 အတွက် ရေးခွင့်ထပ်ထည့်ပြီး လုပ်ငန်းခွင်ရှိ ဖိုင်များအပေါ် ကန့်သတ်ချက်များ ထပ်ချမှတ်သည်။ ဖိုင်စနစ် entry များက ဖတ်ရန်သာခွင့် (read)၊ ဖတ်ရေးခွင့် (write) ပေးနိုင်သကဲ့သို့ လုံးဝသုံးခွင့်ပိတ်ခြင်း (deny) လည်း လုပ်နိုင်သည်။

:workspace_roots table ဖြင့် စီမံကိန်း၏ လုပ်ငန်းခွင် root များအောက်မှ နှိုင်းရလမ်းကြောင်းများအတွက် စည်းမျဉ်းများ သတ်မှတ်နိုင်သည်။ မူလအတိုင်းဆိုလျှင် Codex CLI က အလုပ်လုပ်ရာ directory ကို တစ်ခုတည်းသော လုပ်ငန်းခွင် root အဖြစ် သုံးပြီး ChatGPT desktop အက်ပ်က စီမံကိန်း၏ မူရင်းကုဒ်ဖိုင်တွဲများကို သုံးသည်။ Codex သည် စည်းမျဉ်းတစ်ခုစီကို root တိုင်းတွင် အသုံးချသဖြင့် dev ရှိ .vscode entry ကြောင့် root တစ်ခုစီအောက်ရှိ .vscode directory ကို ဖတ်ရန်သာဖြစ်စေသည်။

ကိုယ်ပိုင်စည်းမျဉ်းများအပြင် dev က :workspace မှ အောက်ပါကာကွယ်မှုများကို ဆက်ခံသည်။

TOML

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

ကွန်ရက်ခွင့်ပြုချက်များ

Codex sandbox အတွက် ကွန်ရက်သတ်မှတ်ရာတွင် အကြမ်းဖျင်း ရွေးချယ်စရာ သုံးမျိုးရှိသည်။

  • ကွန်ရက်သုံးစွဲမှုအားလုံး ပိတ်ရန် (:workspace ပရိုဖိုင်၏ မူလဆက်တင်)

  • ကွန်ရက်ကို အပြည့်အဝ တိုက်ရိုက်သုံးခွင့်ပေးရန် (:danger-full-access ပရိုဖိုင်၏ မူလဆက်တင်)

  • ခွင့်ပြုချက်ပရိုဖိုင်အလိုက် မည်သည်ကို ဖြတ်သန်းခွင့်ပေးမည်ဟု ဆုံးဖြတ်သည့် proxy မှတစ်ဆင့်သာ ကွန်ရက်သုံးခွင့်ပေးရန်


dev ကို တိုက်ရိုက်ကွန်ရက်သုံးခွင့်ပေးရန် config.toml ၏ ထိပ်ဆုံးအဆင့်တွင် permissions.dev.network.enabled = true ဟု သတ်မှတ်ပါ။ ကွန်ရက် proxy ပိတ်ထားလျှင် ဤသတ်မှတ်ချက်က ကွန်ရက်ကို အပြည့်အဝ သုံးခွင့်ပေးသည်။

dev ကို သတ်မှတ်ထားသော domain များ၌သာ ကန့်သတ်ရန် ကွန်ရက် proxy ကို ဖွင့်ပြီး domain စည်းမျဉ်းများ သတ်မှတ်ပါ။

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

domain စည်းမျဉ်းများသည် အမည်အတိအကျနှင့် wildcard ပုံစံများကို ပံ့ပိုးပြီး အတိအလင်းငြင်းပယ်သည့် စည်းမျဉ်းများက ခွင့်ပြုသည့် စည်းမျဉ်းများထက် ဦးစားပေးခံရသည်။ အခြား domain များသို့ တောင်းဆိုချက်များသည် အောက်ပါ ကွန်ရက် proxy တွင် ဖော်ပြသည့်အတိုင်း အတည်ပြုချက်လိုအပ်သည် သို့မဟုတ် ပိတ်ပင်ခံရသည်။

ဆက်တင်များကို အလွှာလိုက်ထား၍ ကန့်သတ်ချက်များ ကျင့်သုံးခြင်း

အသုံးပြုသူတစ်ဦးချင်းက စီမံကိန်းများအားလုံးအတွက် မူလဆက်တင်များ သတ်မှတ်ပြီး ယုံကြည်ရသော စီမံကိန်းတစ်ခုအတွက် ၎င်းတို့ကို အစားထိုးသတ်မှတ်နိုင်သည်။ လုပ်ငန်းစီမံခန့်ခွဲသူများကလည်း အသုံးပြုသူများအတွက် မူလဆက်တင်များ သတ်မှတ်ပြီး ၎င်းတို့ပြင်နိုင်သည့် ဆက်တင်များကို ကန့်သတ်လိုနိုင်သည်။ Codex က အလွှာလိုက်ဆက်တင်များနှင့် စီမံထိန်းချုပ်ထားသော လိုအပ်ချက်များဖြင့် နှစ်မျိုးလုံးကို ပံ့ပိုးသည်။

ဆက်တင်ဦးစားပေးအစီအစဉ်⁠(ဝင်းဒိုးအသစ်တွင် ဖွင့်မည်) တွင် ဖော်ပြသည့်အတိုင်း Codex သည် config.toml ဖိုင်များစွာမှ ဆက်တင်များကို ပေါင်းစည်းသည်။ table များကို အတွင်းအဆင့်ဆင့်အထိ ပေါင်းစည်းပြီး တန်ဖိုးများ ဆန့်ကျင်ပါက ဦးစားပေးအဆင့်ပိုမြင့်သော ရင်းမြစ်၏တန်ဖိုးကို သုံးသည်။ array များကိုမူ တစ်ခုလုံး အစားထိုးသည်။

ထို့ကြောင့် ခွင့်ပြုချက်ပရိုဖိုင်များတွင် ဖိုင်စနစ်လမ်းကြောင်းနှင့် ကွန်ရက် domain များအတွက် table များ သုံးခြင်းဖြစ်သည်။ အဖွဲ့တစ်ဖွဲ့သည် ကိုယ်ပိုင်ဆက်တင်တွင် entry တစ်ခုချင်း ထည့်သွင်းခြင်း၊ အစားထိုးခြင်း ပြုလုပ်နိုင်ပြီး အဖွဲ့အစည်း၏ အခြေခံဆက်တင်ရှိ အခြား entry အားလုံး၏ ပြောင်းလဲမှုများကို အလိုအလျောက် ဆက်ခံနိုင်သည်။

TOML

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

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

စီမံခန့်ခွဲသူများက အသုံးပြုသူ၏ ဆက်တင်ရွေးချယ်မှုများကို ကန့်သတ်ရန် requirements.toml မှတစ်ဆင့် စီမံထိန်းချုပ်ထားသော လိုအပ်ချက်များ⁠(ဝင်းဒိုးအသစ်တွင် ဖွင့်မည်) ကိုလည်း ပေးနိုင်သည်။ ဤလိုအပ်ချက်များသည် စနစ်ဖိုင်များနှင့် cloud မှပေးသော မူဝါဒများအပါအဝင် ရင်းမြစ်မျိုးစုံမှ လာနိုင်သည်။ အသုံးများသော နည်းလမ်းမှာ လုပ်ငန်းအသုံးပြုသူ ရွေးချယ်နိုင်သည့် ခွင့်ပြုချက်ပရိုဖိုင်များကို ကန့်သတ်ရန် allowed_permission_profiles ကို သတ်မှတ်ခြင်းဖြစ်သည်။ ဥပမာ စီမံခန့်ခွဲသူက အောက်ပါ cloud လိုအပ်ချက်များကို သတ်မှတ်နိုင်သည်။

TOML

1
default_permissions = ":read-only"
2

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

cloud လိုအပ်ချက်များသည် /etc/codex/requirements.toml ရှိ စနစ်လိုအပ်ချက်ဖိုင်ထက် ဦးစားပေးခံရသဖြင့် ထိုဖိုင်ရှိ entry က အထက်တွင် အတိအလင်းသတ်မှတ်ထားသော ":danger-full-access" = false ကို မလွှမ်းမိုးနိုင်ပါ။ :workspace ကို မသတ်မှတ်ထားလျှင် အခြားလိုအပ်ချက်အလွှာက ထို entry ကို ပေးနိုင်သည်။ နောက်ဆုံးပေါင်းစည်းထားသော table တွင် entry က false ဖြစ်နေသော သို့မဟုတ် မပါဝင်သော ပရိုဖိုင်များကို သုံး၍မရပါ။

ဤခွဲခြားမှုကြောင့် အဖွဲ့အစည်းများက ကန့်သတ်ချက်များ ချမှတ်နိုင်ပြီး အသုံးပြုသူများက ထိုကန့်သတ်ချက်အတွင်း ဆက်တင်များကို စိတ်ကြိုက်ပြင်နိုင်သည်။ ရရှိလာသော ခွင့်ပြုချက်ပရိုဖိုင်များကို အကဲဖြတ်စမ်းသပ်မှု စနစ်က သုံးနိုင်သကဲ့သို့ နောက်တွင်တွေ့ရမည့်အတိုင်း command တစ်ခုသို့ တိုက်ရိုက်အသုံးချနိုင်သည်။

codex sandbox command ကို အသုံးပြုခြင်း

Codex CLI သည် Codex config တွင် သတ်မှတ်ထားသော ခွင့်ပြုချက်ပရိုဖိုင်အောက်၌ မည်သည့် command ကိုမဆို လွယ်ကူစွာလုပ်ဆောင်နိုင်ရန် sandbox command ကို ပံ့ပိုးသည်။ sandbox က ရည်ရွယ်ထားသော အပြုအမူကို တကယ်တားနိုင်ကြောင်း သေချာစေရန် ပရိုဖိုင်စမ်းသပ်ရာတွင် ၎င်းကို အသုံးများသည်။

ဥပမာ အောက်ပါ command သည် ဖိုင်သိမ်းချိန်တွင် အန္တရာယ်ရှိသော အလိုအလျောက်ပုံစံချကိရိယာကို လုပ်ဆောင်ရန် VS Code ကို သတ်မှတ်ဖို့ ကြိုးစားသည်။ .vscode ရှိပြီးသားဟု ယူဆပါက ထို directory သည် ဖတ်ရန်သာဖြစ်သဖြင့် အထက်ပါ dev ပရိုဖိုင်က ဤရေးသားမှုကို တားသင့်သည် (codex sandbox သည် မူလအတိုင်းဆိုလျှင် cwd ကို လုပ်ငန်းခွင် root အဖြစ် သတ်မှတ်သည်)။

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 command ဖြင့် အေးဂျင့် session နှင့် သီးခြားစီ Codex ၏ sandbox နည်းလမ်းကို သုံးနိုင်သည်။ သင့်ကိုယ်ပိုင်ကိရိယာများမှ စတင်သည့် command များကို ကန့်သတ်ရန် တူညီသော ဆက်တင်ဘာသာစကားနှင့် ပလက်ဖောင်းအလိုက် အကောင်အထည်ဖော်မှုကို သုံးနိုင်သည်။

ဥပမာ—MCP server ကို sandbox ထဲတွင် လုပ်ဆောင်ခြင်း

config.toml တွင် သတ်မှတ်ထားသော stdio MCP server အတွက် Codex အကဲဖြတ်စမ်းသပ်မှု စနစ်သည် server စတင်ရန် command ကို sandbox ထဲ ထည့်ရန် မကြိုးစားပါ။ ထို server အတွက် မည်သည့်ဖိုင်၊ ကွန်ရက်ဝန်ဆောင်မှု လိုအပ်သည်ကို Codex က ယုံကြည်စိတ်ချစွာ မခန့်မှန်းနိုင်သဖြင့် မူလ sandbox ပရိုဖိုင်တစ်ခု သုံးခြင်းက မှန်ကန်နေသော ဆက်တင်ကိုပင် အလုပ်မလုပ်စေနိုင်ပါ။

ဥပမာ @modelcontextprotocol/server-memory⁠(ဝင်းဒိုးအသစ်တွင် ဖွင့်မည်) MCP server ကို 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 command သည် sandbox ပြင်ပ၌ လုပ်ဆောင်သဖြင့် Codex သုံးနေသူနှင့် တူညီသော ခွင့်ပြုချက်များဖြင့် ဖိုင်ရေးခြင်း၊ ကွန်ရက်တောင်းဆိုခြင်း ပြုလုပ်နိုင်သည်။ ဤခွင့်ပြုချက်များမှာ များလွန်းသည်။ ပိုမိုကန့်သတ်ရန် memory-mcp အမည်ရှိ ခွင့်ပြုချက်ပရိုဖိုင်ကို သတ်မှတ်ပြီး မူရင်း npx command ကို codex sandbox --permission-profile memory-mcp ဖြင့် ဖုံးအုပ်ခေါ်ယူနိုင်သည်။ ထို့ကြောင့် server ရေးနိုင်သောနေရာ ကန့်သတ်ပြီး ကွန်ရက်သုံးစွဲမှုကို တားနိုင်သည်။

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"

server မစမီ ၎င်း၏ ဒေတာ directory ကို ဖန်တီးပြီး npm cache ထဲသို့ ဗားရှင်းပုံသေသတ်မှတ်ထားသော package ကို ထည့်ပါ။ ထို့နောက် ကွန်ရက်သုံးစွဲမှု ပိတ်ထားသော ပရိုဖိုင်အောက်တွင် npx --offline ဖြင့် server ကို စတင်နိုင်သည်။

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

package ကို cache ထဲ သိမ်းပြီးလျှင် Codex သည် ကွန်ရက်မသုံးဘဲ memory server ကို စတင်နိုင်ပြီး npm cache နှင့် server ၏ ဒေတာ directory ထဲတွင်သာ ရေးခွင့်ရှိမည်။

Codex sandbox အကောင်အထည်ဖော်ပုံ

sandbox အကောင်အထည်ဖော်မှုက ခွင့်ပြုချက်ပရိုဖိုင်ကို လည်ပတ်မှုစနစ်က အတည်ပြုကျင့်သုံးသော ကန့်သတ်ချက်များအဖြစ် ပြောင်းပေးသည်။ ကွန်ရက် proxy ၏ အဓိကတောင်းဆိုချက်ကိုင်တွယ်မှုနှင့် မူဝါဒယုတ္တိတို့ကို အဓိကလည်ပတ်မှုစနစ် သုံးခုလုံးတွင် မျှဝေသုံးသော်လည်း proxy ပြင်ဆင်မှုနှင့် sandbox ချိတ်ဆက်မှုက OS အလိုက် ကွဲပြားသည်။ မျှဝေသုံး proxy ကို ဦးစွာလေ့လာပြီးနောက် macOS၊ Linux နှင့် Windows အတွက် အကောင်အထည်ဖော်ပုံကို လေ့လာမည်။

ကွန်ရက် proxy

ခွင့်ပြုချက်ပရိုဖိုင်၏ ကွန်ရက်ကန့်သတ်ချက်များကို ကျင့်သုံးရန် အကဲဖြတ်စမ်းသပ်မှု စနစ်က ကွန်ရက် proxy ကို စတင်ပြီး ထို proxy သို့ ချိတ်ဆက်ခွင့်ပေးသော်လည်း ပြင်ပ host များသို့ တိုက်ရိုက်ချိတ်ဆက်မှု တားရန် sandbox ကို သတ်မှတ်သည်။ proxy က တောင်းဆိုချက်တစ်ခုစီကို ပရိုဖိုင်၏ domain စည်းမျဉ်းများနှင့် စစ်ဆေးကာ ရှေ့ဆက်ပို့သင့်မသင့် ဆုံးဖြတ်သည်။

Codex ကုဒ်သိမ်းဆည်းရာတွင် ကွန်ရက် proxy ကို codex-network-proxy⁠(ဝင်းဒိုးအသစ်တွင် ဖွင့်မည်) crate ထဲ၌ အကောင်အထည်ဖော်ထားသည်။ အကဲဖြတ်စမ်းသပ်မှု စနစ်က ၎င်းကို library အဖြစ် သုံးသော်လည်း သီးခြား CLI⁠(ဝင်းဒိုးအသစ်တွင် ဖွင့်မည်) အဖြစ်လည်း တည်ဆောက်နိုင်သည်။ ဖွင့်ထားလျှင် codex-network-proxy သည် မူလအတိုင်း HTTP proxy နှင့် SOCKS5 proxy နှစ်ခုလုံးကို စတင်သည်။ ဤ proxy လိပ်စာများကို environment variable များမှတစ်ဆင့် sandbox က စတင်ပေးသော process သို့ ပေးပို့သည်။ HTTP_PROXY၊ HTTPS_PROXY နှင့် ALL_PROXY ကဲ့သို့ စံ environment variable များအပြင် (PIP_PROXY ကဲ့သို့) လူသိများသော အက်ပ်အလိုက် environment variable များ⁠(ဝင်းဒိုးအသစ်တွင် ဖွင့်မည်) ကိုလည်း ထည့်ပေးသည်။ သို့သော် ပရိုဂရမ်အားလုံးက ဤ environment variable များကို မလိုက်နာကြပါ။ ပရိုဂရမ်က ပြင်ပ host သို့ တိုက်ရိုက်ချိတ်ဆက်ရန် ကြိုးစားပါက အောက်ပါ ပလက်ဖောင်းအလိုက်အပိုင်းများတွင် ဖော်ပြသည့်အတိုင်း လည်ပတ်မှုစနစ်၏ sandbox ကန့်သတ်ချက်များက တားသည်။

ခွင့်ပြုချက်ပရိုဖိုင်တွင် သတ်မှတ်ထားသော ကွန်ရက်ကန့်သတ်ချက်များကို အကောင်အထည်ဖော်ရန် ကွန်ရက် proxy က တာဝန်ယူသည်။ ဥပမာ ယခင်ပြထားသော dev ပရိုဖိုင်သည် *.openai.com သို့ တောင်းဆိုချက်များကို ခွင့်ပြုပြီး evil.example သို့ တောင်းဆိုချက်များကို အတိအလင်း ငြင်းပယ်သည်။ တောင်းဆိုချက်၏ domain သည် ခွင့်ပြုရန် သို့မဟုတ် ငြင်းပယ်ရန် စည်းမျဉ်းနှင့် မကိုက်ညီပါက proxy သည် တောင်းဆိုချက်ကို ခေတ္တရပ်၍ အတည်ပြုရန် အကဲဖြတ်စမ်းသပ်မှု စနစ်သို့ လွှဲပေးနိုင်သည်။ shell command ဥပမာကဲ့သို့ပင် Codex သည် အသုံးပြုသူကို တိုက်ရိုက်မေးနိုင်သကဲ့သို့ တောင်းဆိုချက်ကို အလိုအလျောက်သုံးသပ်မှု⁠(ဝင်းဒိုးအသစ်တွင် ဖွင့်မည်) သို့ ပို့နိုင်သည်။ ဆုံးဖြတ်ချက်ရလျှင် proxy သည် တောင်းဆိုချက်ကို ဆက်လုပ်ခွင့်ပေးသည် သို့မဟုတ် အမှားတုံ့ပြန်ချက်ဖြင့် ငြင်းပယ်သည်။

DNS ရှာဖွေမှုတစ်ခုကပင် hostname ထဲ၌ ကုဒ်သွင်းထားသော အချက်အလက်ကို ပေါက်ကြားစေနိုင်သဖြင့် ဤနေရာတွင် အစီအစဉ်က အရေးကြီးသည်။ ထို့ကြောင့် proxy သည် ခွင့်ပြုထားသည် သို့မဟုတ် အတည်ပြုထားသည်ဟု ဆုံးဖြတ်ပြီးမှသာ တောင်းဆိုထားသော hostname ၏ လိပ်စာကို ရှာသည်။ ကျယ်ပြန့်သော wildcard စည်းမျဉ်းများ သို့မဟုတ် DNS ဝန်ဆောင်မှုသုံးခွင့်ကြောင့် DNS အခြေပြုဒေတာခိုးထုတ်မှု ဖြစ်နိုင်သေးကြောင်း သတိပြုပါ။

macOS

macOS တွင် Codex သည် Apple ၏ kernel က အတည်ပြုကျင့်သုံးသော sandbox နည်းလမ်းဖြစ်သည့် Seatbelt⁠(ဝင်းဒိုးအသစ်တွင် ဖွင့်မည်) ကို သုံးသည်။ Seatbelt မူဝါဒများကို sandbox ကန့်သတ်ချက်များ ဖော်ပြရန် Scheme အခြေပြုဘာသာစကားဖြစ်သော Sandbox Profile Language (SBPL) ဖြင့် ရေးသားသည်။ Codex သည် macOS ၏ /usr/bin/sandbox-exec command မှတစ်ဆင့် Seatbelt ကို ခေါ်သည်။ codex sandbox ကဲ့သို့ပင် sandbox ကို ဖော်ပြသော option များနှင့် ၎င်းတို့နောက်၌ လုပ်ဆောင်မည့် command ကို လက်ခံသည်။

Bash

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

PROFILE သည် sandbox ဆက်တင်သတ်မှတ်သော entry များပါဝင်သည့် SBPL စာသားတစ်ခုဖြစ်သည်။ ဥပမာ အောက်ပါ SBPL ကုဒ်တိုသည် sandbox မူဝါဒအရ /dev/null နှင့် /dev/zero တို့ကို ဖတ်ရေးနိုင်စေသည်။

Scheme

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

sandbox ခေါ်ယူရာတွင် ကွန်ရက် proxy ကို ဖွင့်ထားပါက သင့်လျော်သော local port များသို့သာ ချိတ်ဆက်ရန် အောက်ပါကဲ့သို့ စည်းမျဉ်းများကို ပရိုဖိုင်ထဲ ထည့်ပေးသည်။

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 option များဖြင့် ဖြည့်ပေးသည်။

ကိုယ်ပိုင် sandbox API ကို အကောင်အထည်ဖော်ရန် Codex သည် အခြေခံမူဝါဒ⁠(ဝင်းဒိုးအသစ်တွင် ဖွင့်မည်) မှစ၍ sandbox-exec အတွက် argument စာရင်းကို တည်ဆောက်ပြီး⁠(ဝင်းဒိုးအသစ်တွင် ဖွင့်မည်) permission_profile နှင့် အခြားအခြေအနေအချက်အလက်များဖြင့် ပြင်ဆင်ကာ ပြည့်စုံသော Seatbelt ပရိုဖိုင်ကို ထုတ်ပေးသည်။ ရရှိသော ပရိုဖိုင်နှင့် ပူးတွဲ -D argument များက Seatbelt ကျင့်သုံးမည့် ကန့်သတ်ချက်များကို သတ်မှတ်ပြီး ကွန်ရက် proxy က ထပ်ဆောင်းကွန်ရက်စည်းမျဉ်းများကို ကျင့်သုံးသည်။ argument စာရင်းပြည့်စုံလျှင် sandbox-exec ကို ခေါ်ရန် လွယ်ကူသည်။

Apple က ပြင်ပအသုံးပြုသူများအတွက် ဤဘာသာစကား၏ စာတမ်းမထုတ်ပေးထားသဖြင့် မှန်ကန်သော SBPL ထုတ်ရန် ခက်ခဲသည်။ အမှန်ပင် man sandbox-exec တွင် The sandbox-exec command is DEPRECATED ဟု ဖော်ပြထားသည် (man 3 sandbox_init တွင် ဖော်ပြသော sandbox_init() library function လည်း အလားတူဖြစ်သည်)။ ဆက်မသုံးရန် သတိပေးထားသော်လည်း macOS သည် /usr/share/sandbox တွင် Seatbelt ပရိုဖိုင်များ ထည့်ပေးနေဆဲဖြစ်ပြီး Google Chrome နှင့် Chromium အပါအဝင်⁠(ဝင်းဒိုးအသစ်တွင် ဖွင့်မည်) ပြင်ပဆော့ဖ်ဝဲများက Seatbelt ကို ဆက်မှီခိုနေကြသည်။ ထို့ကြောင့် လက်ရှိခန့်မှန်းနိုင်သော အနာဂတ်ကာလအထိ Seatbelt ကို ဆက်သုံးရန် စီစဉ်ထားပါသည်။

Linux

Linux ပေါ်တွင် sandbox ဖန်တီးရန် Codex သည် သီးခြားပတ်ဝန်းကျင်များ တည်ဆောက်သည့် command-line ကိရိယာ bubblewrap⁠(ဝင်းဒိုးအသစ်တွင် ဖွင့်မည်) (bwrap) နှင့် system call များ စစ်ထုတ်သည့် Linux kernel နည်းလမ်း seccomp-bpf⁠(ဝင်းဒိုးအသစ်တွင် ဖွင့်မည်) ကို ပေါင်းသုံးသည်။ codex-linux-sandbox ဟုခေါ်သော အတွင်းသုံးအကူပရိုဂရမ်က ပြင်ဆင်မှုများကို ညှိနှိုင်းပေးသည်။ macOS ပေါ်ရှိ sandbox-exec ကဲ့သို့ပင် sandbox ဆက်တင်များနှင့် ၎င်းတို့နောက်၌ လုပ်ဆောင်မည့် command ကို လက်ခံသည်။

Bash

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

ဖိုင်စနစ်ခွဲခြားကန့်သတ်မှု သို့မဟုတ် proxy လမ်းကြောင်းသတ်မှတ်မှု လိုအပ်လျှင် codex-linux-sandbox က ကနဦး sandbox ပတ်ဝန်းကျင် ဖန်တီးရန် bwrap ကို ခေါ်သည်။ ထို့နောက် bwrap က ၎င်းအတွင်း၌ codex-linux-sandbox --apply-seccomp-then-exec ကို စတင်သည်။ ဤဒုတိယခေါ်ယူမှုက အသုံးပြုသူ၏ command မလုပ်ဆောင်မီ seccomp-bpf ဖြင့် ထပ်ဆောင်းကန့်သတ်ချက်များ အသုံးချသည်။

ကနဦး sandbox ပတ်ဝန်းကျင်ကို တည်ဆောက်ရန် Codex သည် bubblewrap ဖြင့် သီးခြား mount namespace ထဲ၌ ခွင့်ပြုချက်ပရိုဖိုင်၏ ဖိုင်စနစ်စည်းမျဉ်းများနှင့် ကိုက်ညီသော ဖိုင်စနစ်မြင်ကွင်းကို ဖန်တီးသည်။ ၎င်းသည် sandbox အတွက် အခြေခံကျသဖြင့် အသုံးပြုသူ မထည့်သွင်းထားလျှင် သုံးနိုင်ရန် Codex တွင် ကိုယ်ပိုင် bwrap မိတ္တူ ထည့်ပေးထားသည်။ သို့သော် PATH တွင် တွေ့ပါက လိုက်ဖက်ညီသော ထည့်သွင်းပြီးသားကို ဦးစားပေးသုံးသည်—⁠(ဝင်းဒိုးအသစ်တွင် ဖွင့်မည်)bwrap⁠(ဝင်းဒိုးအသစ်တွင် ဖွင့်မည်)။ လက်တွေ့တွင် အချို့ Linux ဖြန့်ချိမှုများက user namespace သုံးစွဲခွင့်ကို မူလအတိုင်း ပိတ်ထားသော်လည်း⁠(ဝင်းဒိုးအသစ်တွင် ဖွင့်မည်) စနစ်၏ bwrap ကို ခြွင်းချက်ပေးထားသည်။

sandbox-exec ကဲ့သို့ပင် bwrap သည် sandbox ဆက်တင်များနှင့် ၎င်းတို့နောက်တွင် sandbox အတွင်းလုပ်ဆောင်မည့် command ကို လက်ခံသည်။ SBPL ကဲ့သို့ သီးသန့် config ဘာသာစကားအစား bwrap က သတ်မှတ်ရန် flag တစ်ခုချင်းကို သုံးသည်။ ဖိုင်စနစ်မြင်ကွင်း ဖန်တီးရန် Codex က အောက်ပါ option များကို သုံးသည်။

  • ရေးနိုင်သော ဖိုင် သို့မဟုတ် directory သတ်မှတ်ရန် --bind

  • ဖတ်ရန်သာဖြစ်သော ဖိုင် သို့မဟုတ် directory သတ်မှတ်ရန် --ro-bind

  • DIR သုံးစွဲခွင့်ငြင်းပယ်ရန် --perms 000 --tmpfs DIR --remount-ro DIR

  • FILE သုံးစွဲခွင့်ငြင်းပယ်ရန် --perms 000 --ro-bind-data FD FILE (FD သည် /dev/null သို့ ဖွင့်ထားသော file descriptor ဖြစ်သည်)

ဤ option များဖြင့် ငြင်းပယ်ရန် glob များ အသုံးချရန် Codex က command တစ်ခုစီမစမီ ၎င်းတို့ကို တိကျသောလမ်းကြောင်းများအဖြစ် ဖြန့်ထုတ်သည်။ အသစ်ပေါ်လာသော ကိုက်ညီသည့်လမ်းကြောင်းများကို ထို command ၏ sandbox ကန့်သတ်ချက်များထဲသို့ အလိုအလျောက် မထည့်ပါ။

host ပေါ်ရှိ အခြားအရင်းအမြစ်အမျိုးအစားများကို sandbox မသုံးနိုင်ရန် Codex က --unshare-ipc နှင့် --unshare-pid ကဲ့သို့ option များလည်း သတ်မှတ်သည်။ ထို့ကြောင့် bubblewrap သည် ဖိုင်မြင်နိုင်မှုထက် ပိုမိုသက်ရောက်သည်။

bubblewrap သုံးရာတွင် ကွန်ရက်ပိတ်ထားလျှင် သို့မဟုတ် ချိတ်ဆက်မှုများသည် ကွန်ရက် proxy မှတစ်ဆင့် သွားရမည်ဆိုလျှင် Codex က --unshare-net ကို ပေးပို့သည်။ ၎င်းက sandbox အတွက် network namespace အသစ် ဖန်တီးမည်။ ထို့နောက် command သုံးနိုင်သည့် ကွန်ရက် system call များနှင့် socket family များကို seccomp-bpf ဖြင့် ထပ်မံကန့်သတ်သည်။


အတိအကျဆိုရလျှင်
seccompiler crate⁠(ဝင်းဒိုးအသစ်တွင် ဖွင့်မည်) ဖြင့် လိုအပ်သော filter များအလိုက် BPF ပရိုဂရမ်ကို လုပ်ဆောင်ချိန်၌ compile လုပ်ပြီး⁠(ဝင်းဒိုးအသစ်တွင် ဖွင့်မည်) sandbox ရှိ launcher process သို့ အသုံးချသည်။ ထို့ကြောင့် process tree တစ်ခုလုံးက ကန့်သတ်ချက်များကို ဆက်ခံသည်။ ထို့ကြောင့် bwrap သည် အသုံးပြုသူ၏ command ကို တိုက်ရိုက်မလုပ်ဆောင်ဘဲ codex-linux-sandbox launcher ကို ၎င်း၏ config argument များ၊ ထို့နောက် အသုံးပြုသူ၏ command တို့ဖြင့် လုပ်ဆောင်သည်။

Bash

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

အဆင့်မြင့်လုပ်ပိုင်ခွင့်မလိုဘဲ seccomp filter များ အသုံးချရန် launcher က Linux ၏ no_new_privs flag ကို သတ်မှတ်သည်⁠(ဝင်းဒိုးအသစ်တွင် ဖွင့်မည်)။ child process များက ဤ flag ကို ဆက်ခံပြီး setuid executable ကဲ့သို့ အခြားပရိုဂရမ်တစ်ခု လုပ်ဆောင်ချိန်တွင် ထပ်ဆောင်းလုပ်ပိုင်ခွင့် မရနိုင်အောင် တားသည်။

seccomp filter များသည် ကွန်ရက်ဆက်တင်များပေါ် မူတည်သည်။ ကွန်ရက်သုံးစွဲခွင့် ပိတ်ထားလျှင် connect(2) နှင့် bind(2) ကဲ့သို့ ကွန်ရက်ဆိုင်ရာ syscall အချို့ကို ပိတ်သည်။ sandbox တွင် ကွန်ရက် proxy ဖွင့်ထားလျှင်မူ codex-linux-sandbox ဖန်တီးသော TCP listener သို့ ရောက်နိုင်ရန် IP socket များကို ခွင့်ပြုသည်။ သို့သော် host အရင်းအမြစ်များကို မရည်ရွယ်ဘဲ သုံးနိုင်စေမည့် သီးခြား Unix domain socket များ ဖန်တီးမှုကို မူလအတိုင်း ပိတ်ထားသည်။

ကွန်ရက် proxy သို့ ချိတ်ဆက်ခြင်း

sandbox ဆက်တင်အရ ကွန်ရက် proxy လိုအပ်လျှင် Codex အကဲဖြတ်စမ်းသပ်မှု စနစ်သည် Codex thread တစ်ခုအတွင်း codex-linux-sandbox ခေါ်ယူမှုအကြိမ်ကြိမ်၌ ပြန်သုံးနိုင်သော proxy instance တစ်ခု ဖန်တီးသည်။ sandbox တစ်ခုစီသည် ၎င်း၏ သီးခြား network namespace မှ ထိုမျှဝေသုံး proxy သို့ ရောက်ရန် နည်းလမ်းလိုအပ်သည်။ Codex က ထို namespace အတွင်း loopback TCP listener ထည့်ပေးပြီး sandbox ပြင်ပ process တစ်ခုက ချိတ်ဆက်မှုများ လက်ခံ၍ proxy သို့ တစ်ဆင့်ပို့ရန် စီစဉ်သည်။

အောက်ပါပုံများက proxy အဆုံးမှတ်တစ်ခုအတွက် ဤအစီအစဉ်ကို ဖော်ပြပြီး နောက်ဆုံးပုံတွင် ၎င်းမှတစ်ဆင့် ချိတ်ဆက်မှုတစ်ခုကို ပြထားသည်။ bubblewrap မစမီ codex-linux-sandbox သည် ထိန်းချုပ်ရေးလမ်းကြောင်းအဖြစ် Unix socket တစ်စုံ ဖန်တီးပြီး မိမိကိုယ်ကို fork လုပ်သည်။ child process က run_host_bridge() ကို လုပ်ဆောင်ပြီး ထိုလမ်းကြောင်းမှ listener ၏ file descriptor ကို လက်ခံရန် စောင့်သည်။

Codex အကဲဖြတ်စမ်းသပ်မှု စနစ်က codex-linux-sandbox ကို စတင်ပြီး ၎င်းက Unix socket ထိန်းချုပ်ရေးလမ်းကြောင်းဖြင့် ချိတ်ထားသော တစ်ဆင့်ပို့ process ကို fork လုပ်ပုံ။

ဤဥပမာတွင် parent process က ၎င်း၏ program image ကို bwrap ဖြင့် အစားထိုးရန် exec ကို သုံးသည်။ ဤသို့ဖြင့် sandbox ကို သတ်မှတ်ပြီး ထိန်းချုပ်ရေးလမ်းကြောင်း၏ FD ကို ပေးပို့ကာ အတွင်း၌ codex-linux-sandbox --apply-seccomp-then-exec ကို စတင်သည်။

bwrap က sandbox network namespace ဖန်တီး၍ ၎င်းအတွင်း codex-linux-sandbox စတင်ပုံနှင့် sandbox ပြင်ပရှိ တစ်ဆင့်ပို့ process သို့ Unix socket ထိန်းချုပ်ရေးလမ်းကြောင်းဖြင့် ချိတ်ဆက်ပုံကို ပြသထားသော ပုံ။

sandbox ၏ network namespace အတွင်း ဒုတိယအကြိမ် ခေါ်ယူသော codex-linux-sandbox က loopback TCP listener ဖန်တီး၍ ၎င်း၏ file descriptor ကို socket မှတစ်ဆင့် ပေးပို့သည်။ listener သည် sandbox ၏ network namespace နှင့် ဆက်စပ်နေဆဲဖြစ်သည်။ ထို့ကြောင့် sandbox ပြင်ပ၌ ကျန်ခဲ့သော child process က sandbox အတွင်းပရိုဂရမ်များ၏ ချိတ်ဆက်မှုကို လက်ခံနိုင်ပြီး host ၏ network namespace တွင် အထက်ဘက်သို့ ဆက်ချိတ်နိုင်သည်။ လွှဲပေးပြီးနောက် process နှစ်ခုစလုံးက ထိန်းချုပ်ရေးလမ်းကြောင်း descriptor များကို ပိတ်ပြီး sandbox အတွင်း process က ၎င်း၏ listener မိတ္တူကို ပိတ်သည်။

TCP listener အဆင်သင့်ဖြစ်လျှင် sandbox အတွင်းရှိ process သည် ထို listener ကို ညွှန်ရန် HTTP_PROXY အတွက် သင့်လျော်သောတန်ဖိုးကို သတ်မှတ်ပြီး⁠(ဝင်းဒိုးအသစ်တွင် ဖွင့်မည်) သက်ဆိုင်ရာ environment variable များကိုလည်း သတ်မှတ်သည်။ ထို့နောက် fork လုပ်၍ အသုံးပြုသူ၏ command ကို မလုပ်ဆောင်မီ seccomp ကို အသုံးချသည်။

sandbox အတွင်းပရိုဂရမ်က loopback TCP listener သို့ ချိတ်ဆက်ပြီး ပြင်ပရှိ codex-linux-sandbox တစ်ဆင့်ပို့ process က ကွန်ရက်ဒေတာကို Codex ကွန်ရက် proxy သို့ ဆက်ပို့ပုံကို ပြထားသော ပုံ။

sandbox ပြင်ပရှိ process က listener ကို ဆက်ဖွင့်ထားသည်။ လက်ခံရရှိသော ချိတ်ဆက်မှုတစ်ခုစီအတွက် သတ်မှတ်ထားသည့် proxy သို့ ချိတ်ဆက်ပြီး ဒေတာကို နှစ်ဖက်စလုံးသို့ တစ်ဆင့်ပို့ပေးသည်။

ဤထပ်ဆောင်းလုပ်ငန်းစဉ်ကြောင့် command တွင် သီးခြား loopback interface ပါဝင်သော ကိုယ်ပိုင် network namespace ရှိလာသည်။ macOS တွင် Seatbelt က command ကို host ၏ loopback interface ပေါ်ရှိ သတ်မှတ်ထားသော port များသို့ တိုက်ရိုက်ချိတ်ဆက်ခွင့်ပြုသည်။ Linux တွင်မူ command သည် ၎င်း၏ သီးခြား namespace အတွင်းရှိ listener သို့ ချိတ်ဆက်ပြီး sandbox ပြင်ပရှိ process က ထိုချိတ်ဆက်မှုများကို သတ်မှတ်ထားသည့် proxy သို့ တစ်ဆင့်ပို့သည်။ descriptor လွှဲပေးခြင်းကြောင့် host ၏ network namespace ကို command အား မဖွင့်ပေးဘဲ ဤသို့ ချိတ်ဆက်နိုင်ခြင်းဖြစ်သည်။

Windows

ယခုနှစ်အစောပိုင်းတွင် Windows အတွက် sandbox ကို အကောင်အထည်ဖော်ခဲ့ပြီး ထိုကြိုးပမ်းမှုများအကြောင်း ရေးသားခဲ့သည်။ ထိုနောက် Microsoft သည် Windows လည်ပတ်မှုစနစ်အတွင်း process ခွဲခြားကန့်သတ်ရေး လုပ်ဆောင်ချက်အသစ်များနှင့်အတူ MXC ဟုခေါ်သော library ကို ထုတ်ဝေခဲ့သည်။ လက်ရှိ sandbox ကို MXC library အသုံးပြုသည့် sandbox ဖြင့် ယခု အစားထိုးနေပါသည်။

MXC ဆိုတာ ဘာလဲ။

MXC (Microsoft eXecution Container) သည် Windows၊ Linux နှင့် macOS တွင် ခွဲခြားကန့်သတ်ရေး backend အမျိုးမျိုးကို ပံ့ပိုးသော Microsoft ၏ sandbox အတွင်း ကုဒ်လုပ်ဆောင်ရေးစနစ်⁠(ဝင်းဒိုးအသစ်တွင် ဖွင့်မည်) ဖြစ်သည်။ Codex သည် ကိုက်ညီသော Windows စက်များတွင် MXC အခြေပြု sandbox ကို ပံ့ပိုးပြီး စနစ်ပါ process ခွဲခြားကန့်သတ်မှုဖြင့် အသုံးပြုသူ၏ လက်ရှိပတ်ဝန်းကျင်အတွင်း command များကို ကန့်သတ်သည်။

လုံခြုံရေးနှင့် အသုံးပြုရလွယ်ကူမှု ပိုကောင်းစေရန် MXC သို့ ပြောင်းရွှေ့နေပြီး လက်ရှိ Windows sandbox ၏ အောက်ပါကန့်သတ်ချက်များကိုလည်း ဖြေရှင်းနေပါသည်။

  • sandbox ပြင်ဆင်သတ်မှတ်ရန် အဆင့်မြင့်/admin လုပ်ပိုင်ခွင့် လိုအပ်ခြင်း

  • ACL စစ်ဆေးခြင်းနှင့် သတ်မှတ်ခြင်းတို့တွင် အရင်းအမြစ်များစွာသုံး၍ နှေးကွေးခြင်း

  • host စက်ပေါ်တွင် sandbox ပြင်ဆင်သတ်မှတ်မှုအခြေအနေ ကျန်ရှိနေခြင်း၊ ဥပမာ

    • ACL များ

    • Firewall စည်းမျဉ်းများ

    • Sandbox အသုံးပြုသူများ

    • ထိန်းချုပ်ရေးပိုင်း ဖိုင်များ

MXC က JSON ပြင်ဆင်သတ်မှတ်မှု စီမံချက်⁠(ဝင်းဒိုးအသစ်တွင် ဖွင့်မည်) ကို ပံ့ပိုးပေးသည်။ Codex သည် MXC SDK⁠(ဝင်းဒိုးအသစ်တွင် ဖွင့်မည်) ဖြင့် ထိုစီမံချက်နှင့်အညီ command၊ အလုပ်လုပ်ရာ directory၊ environment နှင့် ခွင့်ပြုချက်များ ပါဝင်သော လုပ်ဆောင်ရန် တောင်းဆိုချက်ကို တည်ဆောက်သည်။ ထိုခွင့်ပြုချက်များသည် ဖိုင်စနစ်နှင့် ကွန်ရက်သုံးစွဲမှုအပြင် desktop၊ clipboard ကဲ့သို့ Windows အရင်းအမြစ်များကိုပါ အကျုံးဝင်သည်။

မူဝါဒမှ MXC ခေါ်ယူမှုသို့ ပြောင်းလဲခြင်း

လိုက်ဖက်ညီမှုနှင့် လုံခြုံရေးကို ချိန်ညှိရန် Codex က ထိန်းချုပ်မှုအချို့အတွက် ပုံသေဆက်တင်များကို သုံးသည်။ registry ဖတ်ခွင့်ပြုထားပြီး PowerShell စတင်ချိန်တွင် လိုအပ်သော Win32k နှင့် desktop သုံးစွဲခွင့်ကို ထိန်းထားသည်။ clipboard သုံးစွဲမှု၊ input ထိုးသွင်းမှု၊ desktop နှင့် စနစ်ဆက်တင်များ ထိန်းချုပ်မှုတို့ကို ပိတ်ထားသည်။ နောက်ဆုံးတွင် MXC ကို အစားထိုးနည်းလမ်းအဖြစ် host ဖိုင်စနစ်ခွင့်ပြုချက်များ ပြင်ဆင်ခြင်းသို့ မပြောင်းနိုင်အောင် တားထားသည်။

Codex သည် ခွင့်ပြုချက်ပရိုဖိုင်၏ ဖိုင်စနစ်နှင့် ကွန်ရက်စည်းမျဉ်းများကို MXC ဆက်တင်များအဖြစ် ပြောင်းပေးသည်။ ယခင် dev ပရိုဖိုင်ကို သုံးပြီး အောက်ပါအတိုင်း ယူဆပါက—

  • စက်၏ local drive များမှာ C:\၊ D:\ နှင့် Z:\ တို့သာဖြစ်သည်။

  • လုပ်ငန်းခွင် root နှင့် အလုပ်လုပ်ရာ directory သည် C:\work\demo ဖြစ်သည်။

  • အသုံးပြုသူ၏ home directory သည် D:\Users\dev ဖြစ်သဖြင့် ~/build-cache သည် D:\Users\dev\build-cache ကို ညွှန်းသည်။

  • ငြင်းပယ်ရန် glob သည် 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
}

Drive root သုံးစွဲခွင့်

MXC ၏ ဖိုင်စနစ်မူဝါဒသည် မူလအတိုင်းဆိုလျှင် သုံးစွဲခွင့်ကို ငြင်းပယ်သည်။ ထို့ကြောင့် ဤပရိုဖိုင်က ခွင့်ပြုသော ကျယ်ပြန့်သည့် ဖတ်ခွင့်ရရန် Codex က local drive root များအတွက် ဖတ်ရန်သာ ခွင့်ပြုချက်များ ထည့်ပေးသည်။ ဤခွင့်ပြုချက်များသည် အသုံးပြုသူ၏ လက်ရှိ OS ခွင့်ပြုချက်အတိုင်း အဆင့်ဆင့်အောက်သို့ အကျုံးဝင်သည်။

သတိပြုရန်တစ်ချက်မှာ drive root အတွက် ရေးခွင့် သည် အောက်သို့ အဆင့်ဆင့် အကျုံးမဝင်သောကြောင့် Codex က drive အောက်ရှိ လက်ရှိ တိုက်ရိုက်ဖိုင်နှင့် ဖိုင်တွဲများအထိ ချဲ့ပေးသည်။

ဆန့်ကျင်နေသော ခွင့်ပြုချက်များ

ပိုတိကျသော လမ်းကြောင်းများက အထက်အဆင့်ခွင့်ပြုချက်များကို လွှမ်းမိုးသဖြင့် ဖတ်ရန်သာဖြစ်သော C:\ အောက်တွင် C:\work\demo ကို ရေးခွင့်ပေးပြီး C:\work\demo\.git ကိုမူ ဖတ်ရန်သာ ထားနိုင်သည်။

လမ်းကြောင်းစာလုံးပေါင်းကွဲများ သို့မဟုတ် symlink/junction အမည်ကွဲများက တစ်နေရာတည်းကို ညွှန်းပါက MXC က ပိုတင်းကျပ်သော ခွင့်ပြုချက်ကို သုံးသည်။ ငြင်းပယ်ခြင်းက ဖတ်ရန်သာခွင့်ထက်၊ ဖတ်ရန်သာခွင့်က ဖတ်ရေးခွင့်ထက် ဦးစားပေးခံရသည်။

ငြင်းပယ်ရန် glob များ

MXC သည် ငြင်းပယ်ရန် တိကျသောလမ်းကြောင်းများကိုသာ လက်ခံသဖြင့် Codex က မစတင်မီ ငြင်းပယ်ရန် glob များကို ကိုက်ညီသော ဖိုင်နှင့် directory များအဖြစ် ဖြန့်ထုတ်သည်။ command လုပ်ဆောင်နေစဉ် glob နှင့် ကိုက်ညီသော လမ်းကြောင်းအသစ်များကို အလိုအလျောက် မထည့်ပါ။

ကွန်ရက်သုံးစွဲခွင့်

*.openai.com ကဲ့သို့ domain စည်းမျဉ်းများကို အထက်ဖော်ပြပါ မျှဝေသုံး Codex ကွန်ရက် proxy က အတည်ပြုကျင့်သုံးသည်။ Codex သည် ထို proxy ကို sandbox ပြင်ပ၌ လုပ်ဆောင်ပြီး ၎င်း၏လိပ်စာများကို ယခင်ဖော်ပြခဲ့သော စံ *_PROXY environment variable များမှတစ်ဆင့် command သို့ ပေးသည်။ MXC က ပြင်ပသို့ တိုက်ရိုက်ချိတ်ဆက်မှုကို တားသော်လည်း proxy သုံးစွဲမှုအပါအဝင် host-loopback ချိတ်ဆက်မှုများကို ခွင့်ပြုသည်။ အခြားစက်တွင်းဝန်ဆောင်မှုများသို့လည်း ချိတ်ဆက်နိုင်နေဆဲဖြစ်သည်။

macOS၊ Linux နှင့် Windows တို့တွင် အကဲဖြတ်စမ်းသပ်မှု စနစ်က ခွင့်ပြုချက်ပရိုဖိုင်အောက်၌ command များ စတင်ရန် တူညီသော sandbox API ကို သုံးသည်။ ထိုကန့်သတ်ချက်များ အသုံးချရန် လိုအပ်သောပြင်ဆင်မှုကို ပလက်ဖောင်းအလိုက် အကောင်အထည်ဖော်မှုများက ကိုင်တွယ်သည်။

Codex sandbox ကို အခြေခံ၍ တည်ဆောက်ခြင်း

ကုဒ်ရေးသား၍ လုပ်ဆောင်နိုင်ခြင်းက အေးဂျင့်များကို ဆော့ဖ်ဝဲဖန်တီးရေးထက်ကျော်လွန်သော ပြဿနာများ ဖြေရှင်းရန် လိုက်လျောညီထွေရှိသော နည်းလမ်းပေးသည်။ Codex sandbox ဖြင့် ၎င်းတို့သည် ဖိုင်စနစ်နှင့် ကွန်ရက်သုံးစွဲမှုအတွက် တိကျသော ကန့်သတ်ချက်များနှင့်အတူ အသုံးပြုသူ၏ လက်ရှိပတ်ဝန်းကျင်၌ ထိုစွမ်းရည်ကို သုံးနိုင်သည်။ ၎င်းသည် အကဲဖြတ်စမ်းသပ်မှု စနစ်အတွင်း ပြန်သုံးနိုင်သော အခြေခံအစိတ်အပိုင်းဖြစ်ပြီး codex sandbox command ကြောင့် သင်ကိုယ်တိုင်တည်ဆောက်သော ကိရိယာများတွင်လည်း သုံးနိုင်သည်။

အေးဂျင့်များ အလုပ်ပိုလုပ်လာသည်နှင့်အမျှ ပိုများသော ကိရိယာနှင့် ပတ်ဝန်းကျင်များတွင် sandbox အသုံးပြုခြင်းကို လက်တွေ့ကျစေလိုပါသည်။ ဆိုလိုသည်မှာ ခွင့်ပြုချက်များကို ပိုလွယ်ကူစွာ သတ်မှတ်နိုင်စေရန်နှင့် ပိုကောင်းသော လည်ပတ်မှုစနစ်ကာကွယ်မှုများ ရလာသည်နှင့် အသုံးချရန်ဖြစ်သည်။ ကျွန်ုပ်တို့၏ ရည်မှန်းချက်မှာ အေးဂျင့်များ သုံးစွဲနိုင်သည့်အရာများကို လူများက ဆက်ထိန်းချုပ်နိုင်စေပြီး အေးဂျင့်များ လုပ်ဆောင်နိုင်သည့်အရာများကို ချဲ့ထွင်ရန်ဖြစ်သည်။

စာရေးသူများ

OpenAI

ကျေးဇူးတင်လွှာ

ဤဆောင်းပါးအတွက် ပါဝင်ကူညီပေးသော David Wiesen၊ Charlie Weems၊ Viyat Bhalodia နှင့် Fotis Chantzis တို့ကို အထူးကျေးဇူးတင်ပါသည်။