როგორ მუშაობს Codex-ის სენდბოქსი
როგორ ასრულებს Codex ბრძანებებს თქვენს კომპიუტერზე თქვენ მიერ დადგენილი შეზღუდვებით.
OpenAI-ში აგენტების დასაცავად მრავალშრიანი დაცვის(იხსნება ახალ ფანჯარაში) მიდგომას ვიყენებთ. ამ ძალისხმევის საფუძველი მოდელების წვრთნასა და მიზნებთან შესაბამისობაში ჩადებული რესურსებია, თუმცა დამატებითი დაცვის ფუნქციებს ჩვენს აგენტურ სარტყელშიც, Codex(იხსნება ახალ ფანჯარაში)-ში, ვნერგავთ. Codex-ის ერთ-ერთი ყველაზე ხშირი და პოტენციურად სარისკო მოქმედება თქვენს კომპიუტერზე ბრძანებების შესრულებაა. ამიტომ შევქმენით Codex-ის სენდბოქსი, რათა მან თქვენს არსებულ გარემოში, თქვენ მიერ განსაზღვრული ფაილური სისტემისა და ქსელის შეზღუდვებით იმუშაოს.
სენდბოქსი(იხსნება ახალ ფანჯარაში) (იხსნება ახალ ფანჯარაში)ზღუდავს პროგრამის წვდომას რესურსებზე მუშაობის დროს. ფოტოების დასალაგებლად შეგიძლიათ Codex-ის სენდბოქსში ბრძანებებს ~/Pictures-ის ფაილების წაკითხვისა და შეცვლის უფლება მისცეთ, ქსელზე წვდომა კი დაბლოკოთ, რათა ატვირთვა თავიდან აიცილოთ. კოდის მიმოხილვისთვის შეგიძლიათ ონლაინდოკუმენტაციაზე წვდომა დაუშვათ, საწყისი კოდის ფაილები კი მხოლოდ წაკითხვადი დატოვოთ. მომხმარებლები Codex-ის სენდბოქსს (იხსნება ახალ ფანჯარაში)ნებართვების პროფილებით(იხსნება ახალ ფანჯარაში) აწყობენ. ეს პროფილები Codex-ის სესიისთვის ფაილური სისტემისა და ქსელის შეზღუდვებს განსაზღვრავს.
ამ სტატიაში ჯერ Codex-ის სენდბოქსის ნაგულისხმევი პარამეტრების არჩევისას გათვალისწინებულ კომპრომისებს განვიხილავთ, შემდეგ კი მის აგებულებასა და ბრძანებების შესასრულებლად სარტყლის მიერ მის გამოყენებას ავხსნით. ვაჩვენებთ, როგორ შეუძლიათ მომხმარებლებსა და ორგანიზაციებს ნებართვების საკუთარ საჭიროებებზე მორგება, დეველოპერებს კი — სენდბოქსის საკუთარ ხელსაწყოებში გამოყენება. ბოლოს განვიხილავთ ამ შეზღუდვების აღსრულებას macOS-ზე, Linux-სა და Windows-ზე.
Codex-ში ჩვენი პრინციპია სენდბოქსისთვის ფრთხილი ნაგულისხმევი პარამეტრების შერჩევა, რომლებიც სასარგებლო სამუშაოს შესრულებას მაინც შესაძლებელს ხდის. მაგალითად, როცა სამუშაო სივრცის ფესვი Git რეპოზიტორიუმია, ჩაშენებული :workspace ნებართვების პროფილი:
უშვებს სამუშაო სივრცეში ჩაწერას, თუმცა ისეთ საქაღალდეებს, როგორიცაა
.gitდა.codex, მხოლოდ წაკითხვადად ტოვებს. ეს Codex-ს კოდის რედაქტირების საშუალებას აძლევს ყოველი ცვლილებისთვის ნებართვის მოთხოვნის გარეშე, თუმცა კრძალავს.codex/config.toml-ის ან.git/hooks-ში არსებული Git ჰუკების პირდაპირ შეცვლას.უშვებს ფაილური სისტემის ფართო წაკითხვას, ოპერაციულ სისტემაში მომხმარებლის არსებული უფლებების ფარგლებში. კომპილატორები, შესრულების გარემოები და აწყობის ხელსაწყოები რეპოზიტორიუმის გარეთ არსებულ SDK-ებს, ბიბლიოთეკებსა და კონფიგურაციას ეყრდნობა. წაკითხვის მხოლოდ სამუშაო სივრცით შემოფარგვლა ბევრ ჩვეულებრივ სამუშაო პროცესს დაარღვევდა. კომპრომისი ისაა, რომ კომპიუტერის სხვა ადგილებში არსებული სენსიტიური ფაილებიც შეიძლება წაკითხვადი დარჩეს, მაგალითად, API გასაღებების შემცველი კონფიგურაციის ფაილები.
თიშავს ქსელზე წვდომას. ეს გარე სერვისებზე პირდაპირ ატვირთვას ბლოკავს, მათ შორის იმ მონაცემების გატანის მცდელობასაც, რომელთა წაკითხვაც ბრძანებას შეუძლია. ამასთან, იბლოკება ლეგიტიმური ოპერაციებიც, მაგალითად, დამოკიდებულებების ჩამოტვირთვა, რასაც დამატებითი წვდომა სჭირდება.
ეს შეზღუდვები არასასურველი ქმედებების ფართო სპექტრს აღკვეთს, თუმცა საზიანო მოქმედებები მაინც შესაძლებელია. მაგალითად, აგენტმა შეიძლება მავნე კოდი ჩასვას ლოკალურად დაყენებულ პაკეტში, როგორიცაა node_modules/prettier. ასეთი ცვლილება შესაძლოა git status-ში არ გამოჩნდეს, რადგან Git ხშირად უგულებელყოფს node_modules-ს. თუ მომხმარებლის რედაქტორი შენახვისას Prettier-ის ამ ასლს უშვებს, მხოლოდ ფაილის შენახვამაც შეიძლება მავნე კოდი Codex-ის სენდბოქსის გარეთ შეასრულოს. ამიტომ ვიყენებთ მრავალშრიან დაცვას: სენდბოქსი ზღუდავს ბრძანებების წვდომას, ხოლო წვრთნა და მიზნებთან შესაბამისობა მოდელს ეხმარება, ეს წვდომა მომხმარებლის განზრახვის შესაბამისად გამოიყენოს.
კორპორაციულ გარემოში სენდბოქსის ნებართვების მორგებისა და სხვა დამცავ ზომებთან შეთავსების მითითებები იხილეთ Codex-ის უსაფრთხოების პრაქტიკულ სახელმძღვანელოში(იხსნება ახალ ფანჯარაში).
ვირტუალური მანქანები და კონტეინერები(იხსნება ახალ ფანჯარაში) სენდბოქსის შექმნის ორი პოპულარული მექანიზმია, თუმცა Codex-ის სენდბოქსში სხვა მიდგომას ვიყენებთ. გამოთვლების იზოლაციისთვის ცალკე გარემოში გადატანის ნაცვლად, Codex თითოეული პლატფორმის სენდბოქსის მექანიზმებით ზღუდავს მომხმარებლის არსებულ გარემოში გაშვებულ ბრძანებებს.
ბევრი დეველოპერისთვის ლეპტოპი ინდივიდუალურად მორგებული დეველოპერული გარემოა, რომლის შეცვლაც ნებისმიერ დროს შეუძლია. ამ გარემოს Docker კონტეინერში გამეორება შეიძლება შრომატევადი იყოს, ზოგი სამუშაო პროცესი კი მაინც ჰოსტზე გაშვებულ ხელსაწყოებზეა დამოკიდებული.
მაგალითად, განვიხილოთ Codex-ით Mac-ზე iOS აპის შექმნა. თუ Codex-ის იზოლაციისთვის მას Docker-ში გაუშვებდით, ის ვერც Mac-ის მშობლიური პროგრამებისგან შემდგარ iOS-ის აწყობის ხელსაწყოთა ნაკრებს გამოიყენებდა და ვერც კოდის გასაშვებად iPhone-ის სიმულატორს ჩართავდა. Docker-ზე დაფუძნებულ პროცესს შეეძლებოდა აწყობისა და სიმულატორის ოპერაციების Mac ჰოსტისთვის გადაბარება, თუმცა ისინი კონტეინერის სენდბოქსის გარეთ შესრულდებოდა და ცალკე შეზღუდვები დასჭირდებოდა. Codex-ისთვის სიმარტივეს ვამჯობინებთ და დიდ რესურსს ვდებთ თითოეული ოპერაციული სისტემის სენდბოქსის მექანიზმებში, რათა Codex-მა კონკრეტული ამოცანისთვის ყველაზე შესაფერის გარემოში იმუშაოს.
სარტყელი ამ სისტემურ მექანიზმებს macOS-ზე, Windows-სა და Linux-ზე საერთო API-ით გვაწვდის. ეს API იღებს ბრძანებასა და ნებართვების პროფილს. თუ პროფილი შეზღუდულ ქსელურ წვდომას უშვებს, გამომძახებელმა ამ შეზღუდვების აღსასრულებლად ქსელური პროქსი უნდა მიაწოდოს:
ეს ფუნქცია პროცესს სენდბოქსში უშვებს და აბრუნებს Child ჰენდლს, რომლის მეშვეობითაც სარტყელს პროცესის დასრულების ლოდინი შეუძლია. ყოველი შვილობილი პროცესი მშობლის სენდბოქსის შეზღუდვებს მემკვიდრეობით იღებს. ამიტომ ისინი ბრძანებით შექმნილი პროცესების მთელ ხეზე ვრცელდება, იმ შთამომავლებზეც კი, რომლებიც საწყისი პროცესის დასრულების შემდეგ აგრძელებენ მუშაობას.
შემდეგი დიაგრამა აჩვენებს, როგორ უკავშირდება ეს კომპონენტები ერთმანეთს — კონფიგურაციიდან სენდბოქსში ბრძანების გაშვებამდე. მომდევნო განყოფილებებში თითოეულ ეტაპს ავხსნით.

როგორც სტატიაში „Codex-ის აგენტის ციკლის დეტალური განხილვა“ ავხსენით, Codex-ის სარტყელი მოდელის მიერ გენერირებული ხელსაწყოების გამოძახებების შესრულებაზეა პასუხისმგებელი. პროგრამირების ამოცანებისთვის ყველაზე ხშირად გამოიყენება შელის ხელსაწყო, რომელიც ბრძანებებს ისე ასრულებს, როგორც მომხმარებელი ინტერაქტიულ შელში, მაგალითად Bash-ში. აქ განვიხილავთ ერთჯერად (იხსნება ახალ ფანჯარაში)exec_command(იხსნება ახალ ფანჯარაში) შელის ხელსაწყოს(იხსნება ახალ ფანჯარაში), რათა ვაჩვენოთ, როგორ იყენებს სარტყელი სენდბოქსს საჭირო დაცვის უზრუნველსაყოფად.
ეს გამარტივებული ვერსია აჩვენებს, როგორ შეასრულებდა Codex-ის სარტყელი exec_command ხელსაწყოს გამოძახებას სენდბოქსის გარეშე:
ბრძანების სენდბოქსში გასაშვებად სარტყელი subprocess.Popen()-ის გამოძახებას spawn_command_under_sandbox()-ით ანაცვლებს. სარტყელი აწვდის ნებართვების პროფილს და, საჭიროებისამებრ, ქსელურ პროქსის:
exec_command ხელსაწყო მოდელს ცალკეული ბრძანებისთვის განსხვავებული ნებართვების მოთხოვნის საშუალებასაც აძლევს, თუმცა მის დაკმაყოფილებას სარტყელი წყვეტს:
თუ მითითებულია use_default, სარტყელი მიმდინარე სვლისთვის სენდბოქსის ნაგულისხმევ კონფიგურაციას იყენებს. with_additional_permissions სენდბოქსში გაფართოებულ წვდომას ითხოვს, require_escalated კი — მის გარეთ შესრულებას. ბრძანების შესრულებამდე სარტყელი მოთხოვნას მომხმარებლის პრეფერენციების მიხედვით აფასებს. (მაგალითად, Codex-მა შეიძლება პირდაპირ მომხმარებელს ჰკითხოს ან მოთხოვნა ავტომატურ შემოწმებაზე(იხსნება ახალ ფანჯარაში) გაგზავნოს.) თუ შესრულება დამტკიცდა, Codex შესაბამის permission_profile-სა და network_proxy-ს გადასცემს perform_exec_command_with_sandboxing()-ს საწყისი ExecCommandToolCall-ის ბრძანების არგუმენტებთან ერთად.
spawn_command_under_sandbox()-ს ძირითადად შელის ხელსაწყო იყენებს. სარტყელი სენდბოქსის იმავე ინფრასტრუქტურას იყენებს ისეთი ოპერაციებისთვისაც, როგორიცაა ლოკალური ფაილების წაკითხვა და შეცვლა. ეს ხელახალი გამოყენება სარტყლის ფარგლებსაც სცდება: codex sandbox ბრძანებით შეგიძლიათ სენდბოქსში ბრძანებების შესრულება საკუთარ ხელსაწყოებში ჩართოთ, როგორც ამას მოგვიანებით ვნახავთ. შემდეგ განვიხილავთ, როგორ განისაზღვრება ნებართვების პროფილები.
სახელდებული ნებართვების პროფილი სხვადასხვა პროექტში ფაილური სისტემისა და ქსელის ერთნაირი შეზღუდვების გამოყენების საშუალებას გაძლევთ. საკუთარი პროფილები შეგიძლიათ config.toml-ის [permissions] განყოფილებაში განსაზღვროთ. მაგალითად, ქვემოთ განისაზღვრება პროფილი dev, რომელიც ჩაშენებულ :workspace პროფილს აფართოებს(იხსნება ახალ ფანჯარაში):
dev პროფილი ამატებს ~/build-cache-ში ჩაწერის უფლებას და სამუშაო სივრცის ფაილებზე დამატებით შეზღუდვებს აწესებს. ფაილური სისტემის ჩანაწერებმა შეიძლება დაუშვას მხოლოდ წაკითხვა (read), წაკითხვა და ჩაწერა (write) ან წვდომა სრულად დაბლოკოს (deny).
:workspace_roots ცხრილი საშუალებას გაძლევთ, გზების წესები პროექტის სამუშაო სივრცის ძირეულ საქაღალდეებთან მიმართებით განსაზღვროთ. ნაგულისხმევად Codex CLI სამუშაო საქაღალდეს სამუშაო სივრცის ერთადერთ ფესვად იყენებს, ChatGPT‑ის დესკტოპაპი კი — პროექტის საწყისი კოდის საქაღალდეებს. Codex თითოეულ წესს ყველა ფესვზე ავრცელებს, ამიტომ dev-ში არსებული .vscode ჩანაწერი ყოველი ფესვის ქვეშ .vscode საქაღალდეს მხოლოდ წაკითხვადს ხდის.
საკუთარი წესების გარდა, dev მემკვიდრეობით იღებს :workspace-ის შემდეგ დამცავ ზომებს:
Codex-ის სენდბოქსის ქსელის კონფიგურაციისთვის ძირითადად სამი ვარიანტია:
ქსელზე წვდომის სრულად გამორთვა (ნაგულისხმევი
:workspaceპროფილისთვის)ქსელზე სრული, პირდაპირი წვდომის ჩართვა (ნაგულისხმევი
:danger-full-accessპროფილისთვის)ქსელზე წვდომის მხოლოდ პროქსით დაშვება, რომელიც ნებართვების პროფილით წყვეტს, რა გაატაროს
dev-ისთვის პირდაპირი ქსელური წვდომის მისაცემად config.toml-ის ზედა დონეზე მიუთითეთ permissions.dev.network.enabled = true. თუ ქსელური პროქსი გამორთულია, ეს ქსელზე სრულ წვდომას იძლევა.
dev-ის დომენების გარკვეული ნაკრებით შესაზღუდად ჩართეთ ქსელური პროქსი და დააკონფიგურირეთ მისი დომენის წესები:
დომენის წესებში შეიძლება ზუსტი სახელებისა და ჩანაცვლების სიმბოლოებიანი შაბლონების გამოყენება. აშკარად მითითებულ აკრძალვის წესებს დაშვების წესებზე უპირატესობა აქვს. სხვა დომენებზე მოთხოვნებს თანხმობა სჭირდება ან ისინი იბლოკება, როგორც ქვემოთ, ქსელური პროქსის განყოფილებაშია აღწერილი.
ცალკეულ მომხმარებლებს შეუძლიათ ყველა პროექტისთვის ნაგულისხმევი პარამეტრები განსაზღვრონ და კონკრეტული სანდო პროექტისთვის შეცვალონ. ორგანიზაციის ადმინისტრატორებსაც შეიძლება სურდეთ მომხმარებლებისთვის ნაგულისხმევი პარამეტრების განსაზღვრა და იმის შეზღუდვა, თუ რისი შეცვლა შეუძლიათ მათ. Codex ორივეს მხარს უჭერს მრავალფენიანი კონფიგურაციითა და მართვადი მოთხოვნებით.
როგორც კონფიგურაციის პრიორიტეტულობის(იხსნება ახალ ფანჯარაში) განყოფილებაშია აღწერილი, Codex რამდენიმე config.toml ფაილის პარამეტრებს აერთიანებს. ცხრილები რეკურსიულად ერთიანდება; მნიშვნელობების კონფლიქტისას უპირატესობა უფრო მაღალი პრიორიტეტის წყაროს ენიჭება. მასივები მთლიანად ჩანაცვლდება.
სწორედ ამიტომ იყენებს ნებართვების პროფილები ცხრილებს ფაილური სისტემის გზებისა და ქსელის დომენებისთვის. გუნდს შეუძლია საკუთარ კონფიგურაციაში ცალკეული ჩანაწერები დაამატოს ან შეცვალოს, ორგანიზაციის საბაზისო კონფიგურაციის სხვა ჩანაწერების ცვლილებები კი ავტომატურად მიიღოს:
ადმინისტრატორებს შეუძლიათ requirements.toml-ით მართვადი მოთხოვნებიც(იხსნება ახალ ფანჯარაში) მიაწოდონ, რათა მომხმარებლების კონფიგურაციის არჩევანი შეზღუდონ. ეს მოთხოვნები შეიძლება რამდენიმე წყაროდან მოდიოდეს, მათ შორის სისტემური ფაილებიდან და ღრუბლიდან მოწოდებული პოლიტიკიდან. ხშირი გამოყენებაა allowed_permission_profiles-ის მითითება იმ ნებართვების პროფილების შესაზღუდად, რომელთა არჩევაც ორგანიზაციის მომხმარებელს შეუძლია. მაგალითად, ადმინისტრატორს შეუძლია შემდეგი ღრუბლოვანი მოთხოვნები მიუთითოს:
ღრუბლოვან მოთხოვნებს უპირატესობა ექნება სისტემური მოთხოვნების ფაილთან, /etc/codex/requirements.toml-თან შედარებით. ამიტომ ამ ფაილის ჩანაწერი ზემოთ აშკარად მითითებულ ":danger-full-access" = false-ს ვერ შეცვლის. თუ :workspace მითითებული არ არის, ამ ჩანაწერის მოწოდება მოთხოვნების სხვა ფენას შეუძლია. პროფილები, რომელთა ჩანაწერია false ან რომლებიც საბოლოო გაერთიანებულ ცხრილში არ არის, მიუწვდომელია.
ასეთი გამიჯვნა ორგანიზაციებს შეზღუდვების აღსრულების საშუალებას აძლევს, მომხმარებლებს კი — ამ ფარგლებში კონფიგურაციის მორგებისას თავისუფლებას უტოვებს. მიღებული ნებართვების პროფილები სარტყელმა შეიძლება გამოიყენოს ან პირდაპირ ბრძანებას მიესადაგოს, როგორც ამას შემდეგ ვნახავთ.
Codex CLI-ის sandbox ბრძანებით შეგიძლიათ ნებისმიერი ბრძანება Codex-ის კონფიგურაციაში განსაზღვრული ნებართვების პროფილით გაუშვათ. მას ხშირად პროფილის შესამოწმებლად იყენებენ, რათა დარწმუნდნენ, რომ სენდბოქსი მისთვის განსაზღვრულ არასასურველ ქცევას ნამდვილად ბლოკავს.
მაგალითად, შემდეგი ბრძანება ცდილობს VS Code ისე დააკონფიგურიროს, რომ შენახვისას მავნე ავტომატური ფორმატერი გაეშვას. თუ .vscode უკვე არსებობს, ზემოთ განსაზღვრულმა dev პროფილმა ეს ჩაწერა უნდა დაბლოკოს, რადგან საქაღალდე მხოლოდ წაკითხვადია (codex sandbox ნაგულისხმევად cwd-ს სამუშაო სივრცის ფესვად მიიჩნევს):
მართლაც, macOS-ზე მცდელობა შემდეგი შეცდომით სრულდება:
codex sandbox ბრძანება Codex-ის სენდბოქსის მექანიზმს აგენტის სესიისგან დამოუკიდებლად ხელმისაწვდომს ხდის. შეგიძლიათ იგივე კონფიგურაციის ენა და პლატფორმის სპეციფიკური აღსრულების მექანიზმები საკუთარი ხელსაწყოებით გაშვებული ბრძანებების შესაზღუდად გამოიყენოთ.
config.toml-ში მითითებული stdio MCP სერვერის შემთხვევაში Codex-ის სარტყელი სერვერის გასაშვებ ბრძანებას სენდბოქსში მოქცევას არ უპირებს. Codex საიმედოდ ვერ ადგენს, რომელი ფაილები ან ქსელური სერვისები სჭირდება სერვერს, ამიტომ ნაგულისხმევი სენდბოქსის პროფილის გამოყენებამ შეიძლება გამართული კონფიგურაცია დაარღვიოს.
მაგალითად, Codex-თან გამოსაყენებლად @modelcontextprotocol/server-memory(იხსნება ახალ ფანჯარაში) MCP სერვერის სტანდარტული კონფიგურაცია ასეთია:
რადგან ეს npx ბრძანება სენდბოქსის გარეთ სრულდება, მას ფაილების ჩაწერა და ქსელური მოთხოვნების გაგზავნა Codex-ის გამშვები მომხმარებლის უფლებებით შეუძლია, რაც ზედმეტად ფართო წვდომაა. მის შესაზღუდად შეგვიძლია განვსაზღვროთ ნებართვების პროფილი memory-mcp და საწყისი npx ბრძანება გავუშვათ codex sandbox --permission-profile memory-mcp-ის მეშვეობით. ასე შევზღუდავთ სერვერის ჩაწერის ადგილებს და ქსელზე წვდომას ავუკრძალავთ:
სერვერის გაშვებამდე შექმენით მისი მონაცემთა საქაღალდე და npm ქეშში პაკეტის ფიქსირებული ვერსია მოათავსეთ. ეს npx --offline-ს საშუალებას მისცემს, სერვერი ქსელზე წვდომის ამკრძალავი პროფილით გაუშვას:
პაკეტის ქეშში მოთავსების შემდეგ Codex მეხსიერების სერვერს ქსელზე წვდომის გარეშე გაუშვებს, ჩაწერა კი მხოლოდ npm ქეშსა და სერვერის მონაცემთა საქაღალდეში იქნება დაშვებული.
სენდბოქსის რეალიზაცია ნებართვების პროფილს ოპერაციული სისტემის მიერ აღსრულებად შეზღუდვებად გარდაქმნის. ქსელური პროქსის მოთხოვნების დამუშავებისა და პოლიტიკის ძირითადი ლოგიკა სამივე მთავარ ოპერაციულ სისტემაში საერთოა, ხოლო მისი მოწყობა და სენდბოქსთან ინტეგრაცია კონკრეტულ სისტემაზეა დამოკიდებული. ჯერ საერთო პროქსის განვიხილავთ, შემდეგ კი — macOS-ის, Linux-ისა და Windows-ის რეალიზაციებს.
პროფილის ქსელური შეზღუდვების აღსასრულებლად სარტყელი ქსელურ პროქსის უშვებს და სენდბოქსს ისე აწყობს, რომ მასთან კავშირი დაუშვას, გარე ჰოსტებთან პირდაპირი კავშირები კი დაბლოკოს. პროქსი თითოეულ მოთხოვნას პროფილის დომენის წესებთან ამოწმებს და წყვეტს, გადაამისამართოს თუ არა ის.
Codex-ის რეპოზიტორიუმში ქსელური პროქსი რეალიზებულია codex-network-proxy(იხსნება ახალ ფანჯარაში) პაკეტში, რომელსაც სარტყელი ბიბლიოთეკად იყენებს. ის შეიძლება დამოუკიდებელ CLI-დაც(იხსნება ახალ ფანჯარაში) აიწყოს. ჩართვისას codex-network-proxy ნაგულისხმევად უშვებს როგორც HTTP, ისე SOCKS5 პროქსის. ამ პროქსების მისამართები სენდბოქსის მიერ გაშვებულ პროცესს გარემოს ცვლადებით გადაეცემა. სტანდარტულ გარემოს ცვლადებთან — HTTP_PROXY, HTTPS_PROXY და ALL_PROXY — ერთად ემატება რამდენიმე ცნობილი აპლიკაციის სპეციფიკური გარემოს ცვლადიც(იხსნება ახალ ფანჯარაში), მაგალითად PIP_PROXY. თუმცა ყველა პროგრამა ამ გარემოს ცვლადებს არ ითვალისწინებს. თუ პროგრამა გარე ჰოსტთან პირდაპირ დაკავშირებას შეეცდება, მას ოპერაციული სისტემის სენდბოქსის შეზღუდვები დაბლოკავს, როგორც ქვემოთ, პლატფორმების შესაბამის განყოფილებებშია აღწერილი.
ნებართვების პროფილში განსაზღვრულ ქსელურ შეზღუდვებს ქსელური პროქსი აღასრულებს. მაგალითად, ზემოთ ნაჩვენები dev პროფილი უშვებს მოთხოვნებს *.openai.com-ზე და აშკარად კრძალავს მათ evil.example-ზე. როცა მოთხოვნის სამიზნე დომენი არც დაშვების და არც აკრძალვის წესს არ ემთხვევა, პროქსის შეუძლია მოთხოვნა შეაჩეროს და დასამტკიცებლად სარტყელს გადასცეს. შელის ბრძანების მაგალითის მსგავსად, Codex-მა შეიძლება პირდაპირ მომხმარებელს ჰკითხოს ან მოთხოვნა ავტომატურ შემოწმებაზე(იხსნება ახალ ფანჯარაში) გაგზავნოს. გადაწყვეტილების მიღების შემდეგ პროქსი მოთხოვნას ან გაატარებს, ან უარყოფს და შეცდომის პასუხს დააბრუნებს.
აქ თანმიმდევრობა მნიშვნელოვანია, რადგან DNS ძიებამაც კი შეიძლება ჰოსტის სახელში კოდირებული ინფორმაცია გაამჟღავნოს. ამიტომ პროქსი მოთხოვნილი ჰოსტის სახელს მხოლოდ მას შემდეგ გარდაქმნის მისამართად, რაც დაადგენს, რომ ის დაშვებული ან დამტკიცებულია. გაითვალისწინეთ: ჩანაცვლების სიმბოლოებიანი ფართო წესები ან DNS სერვისებზე წვდომა მაინც შეიძლება იძლეოდეს DNS-ით მონაცემების გატანის საშუალებას.
macOS-ზე Codex იყენებს Seatbelt(იხსნება ახალ ფანჯარაში)-ს — Apple-ის სენდბოქსის მექანიზმს, რომლის შეზღუდვებსაც ბირთვი აღასრულებს. Seatbelt-ის პოლიტიკები იწერება Sandbox Profile Language-ზე (SBPL) — Scheme-ზე დაფუძნებულ ენაზე, რომელიც სენდბოქსის შეზღუდვებს აღწერს. Codex Seatbelt-ს macOS-ის /usr/bin/sandbox-exec ბრძანებით იძახებს. codex sandbox-ის მსგავსად, ის ჯერ სენდბოქსის აღმწერ პარამეტრებს იღებს, შემდეგ კი — გასაშვებ ბრძანებას:
PROFILE არის SBPL სტრიქონი, რომელიც სენდბოქსის კონფიგურაციის ჩანაწერებს შეიცავს. მაგალითად, შემდეგი SBPL ფრაგმენტი სენდბოქსის პოლიტიკაში /dev/null-სა და /dev/zero-ს წაკითხვასა და ჩაწერას უშვებს:
როცა სენდბოქსის გამოძახებისას ქსელური პროქსი ჩართულია, პროფილს ქვემოთ მოცემულის მსგავსი წესები ემატება, რათა კავშირები შესაბამისი ლოკალური პორტებით შემოიფარგლოს:
Codex-ის საბაზისო პროფილი იწყება (deny default)-ით, ამიტომ გამავალი კავშირები დაბლოკილია, თუ აშკარად არ არის დაშვებული.
ამასთან, SBPL შეიძლება (param)-ის მეშვეობით ჩანაცვლებად ველებს შეიცავდეს:
მათ მნიშვნელობებს sandbox-exec-ისთვის გადაცემული -Dkey=value პარამეტრები ავსებს.
საკუთარი სენდბოქსის API-ის რეალიზაციისთვის Codex საბაზისო პოლიტიკიდან(იხსნება ახალ ფანჯარაში) იწყებს და sandbox-exec-ისთვის არგუმენტების სიას ადგენს(იხსნება ახალ ფანჯარაში). შემდეგ permission_profile-ითა და სხვა კონტექსტით ავსებს მას და Seatbelt-ის სრულ პროფილს ქმნის. მიღებული პროფილი და თანმხლები -D არგუმენტები Seatbelt-ის მიერ აღსასრულებელ შეზღუდვებს განსაზღვრავს, ქსელური პროქსი კი დამატებით ქსელურ წესებს აღასრულებს. არგუმენტების სრული სიის შედგენის შემდეგ sandbox-exec-ის გამოძახება მარტივია.
სწორი SBPL-ის გენერაცია რთულია, რადგან Apple ამ ენის მესამე მხარეებისთვის განკუთვნილ დოკუმენტაციას არ აქვეყნებს. მართლაც, man sandbox-exec-ში წერია The sandbox-exec command is DEPRECATED (მოძველებულადაა მონიშნული ბიბლიოთეკის ფუნქცია sandbox_init()-ც, რომლის დოკუმენტაციაა man 3 sandbox_init). ამ გაფრთხილების მიუხედავად, macOS-ს Seatbelt-ის პროფილები კვლავ მოჰყვება /usr/share/sandbox-ში, მესამე მხარის პროგრამები კი, მათ შორის Google Chrome და Chromium(იხსნება ახალ ფანჯარაში), კვლავ Seatbelt-ს ეყრდნობა. ამიტომ უახლოეს მომავალშიც Seatbelt-ის გამოყენების გაგრძელებას ვგეგმავთ.
Linux-ზე სენდბოქსის შესაქმნელად Codex ერთობლივად იყენებს bubblewrap(იხსნება ახალ ფანჯარაში)-ს (bwrap) — იზოლირებული გარემოების შექმნის ბრძანების სტრიქონის ხელსაწყოს — და seccomp-bpf(იხსნება ახალ ფანჯარაში)-ს, Linux-ის ბირთვის მექანიზმს სისტემური გამოძახებების გასაფილტრად. მოწყობის პროცესს კოორდინაციას უწევს შიდა დამხმარე პროგრამა codex-linux-sandbox. macOS-ის sandbox-exec-ის მსგავსად, ის იღებს სენდბოქსის კონფიგურაციას, შემდეგ კი — გასაშვებ ბრძანებას:
როცა ფაილური სისტემის იზოლაცია ან პროქსით მარშრუტიზაციაა საჭირო, 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— მხოლოდ წაკითხვადი ფაილის ან საქაღალდის მისათითებლად--perms 000 --tmpfs DIR --remount-ro DIR—DIR-ზე წვდომის ასაკრძალად--perms 000 --ro-bind-data FD FILE—FILE-ზე წვდომის ასაკრძალად (სადაცFDარის/dev/null-ის გახსნილი ფაილის დესკრიპტორი)
ამ პარამეტრებით აკრძალვის glob შაბლონების გამოსაყენებლად Codex მათ ყოველი ბრძანების გაშვებამდე კონკრეტულ გზებად გარდაქმნის. ახალი შესაბამისი გზები ამ ბრძანების სენდბოქსის შეზღუდვებს ავტომატურად არ ემატება.
Codex ასევე უთითებს ისეთ პარამეტრებს, როგორიცაა --unshare-ipc და --unshare-pid, რათა სენდბოქსს ჰოსტის სხვა ტიპის რესურსებზე წვდომა შეუზღუდოს. ამგვარად, bubblewrap მხოლოდ ფაილების ხილვადობაზე არ მოქმედებს.
bubblewrap-ის გამოყენებისას Codex გადასცემს --unshare-net-ს, თუ ქსელი გამორთულია ან კავშირები ქსელურ პროქსიზე უნდა გავიდეს. ეს სენდბოქსისთვის ახალ ქსელურ სახელთა სივრცეს ქმნის. შემდეგ seccomp-bpf-ით დამატებით ვზღუდავთ ბრძანებისთვის ხელმისაწვდომ ქსელურ სისტემურ გამოძახებებსა და სოკეტების ოჯახებს.
კერძოდ, seccompiler პაკეტით(იხსნება ახალ ფანჯარაში) სასურველი ფილტრების მიხედვით დინამიკურად ვაკომპილირებთ BPF პროგრამას(იხსნება ახალ ფანჯარაში) და სენდბოქსის გამშვებ პროცესს ვუსადაგებთ, რათა შეზღუდვები პროცესების მთელმა ხემ მემკვიდრეობით მიიღოს. ამგვარად, bwrap მომხმარებლის ბრძანებას კი არ უშვებს, არამედ codex-linux-sandbox გამშვებს — ჯერ მისი კონფიგურაციის არგუმენტებით, შემდეგ კი მომხმარებლის ბრძანებით:
გაზრდილი პრივილეგიების გარეშე seccomp ფილტრების გამოსაყენებლად გამშვები ააქტიურებს Linux-ის no_new_privs ალამს(იხსნება ახალ ფანჯარაში). ამ ალამს შვილობილი პროცესებიც იღებენ. ის მათ სხვა პროგრამის, მაგალითად setuid შესრულებადი ფაილის გაშვებისას დამატებითი პრივილეგიების მოპოვებას უკრძალავს.
seccomp ფილტრები ქსელის კონფიგურაციაზეა დამოკიდებული. როცა ქსელზე წვდომა გამორთულია, ვბლოკავთ ქსელთან დაკავშირებულ რამდენიმე სისტემურ გამოძახებას, მაგალითად connect(2)-სა და bind(2)-ს. თუმცა, როცა სენდბოქსში ქსელური პროქსი ჩართულია, ვუშვებთ IP სოკეტებს, რათა codex-linux-sandbox-ის მიერ შექმნილი TCP მსმენელი ხელმისაწვდომი იყოს. დამოუკიდებელი Unix დომენის სოკეტების შექმნას კი ნაგულისხმევად ვბლოკავთ, რადგან მათ შეიძლება უნებლიეთ დაუშვან ჰოსტის რესურსებზე წვდომა.
როცა სენდბოქსის კონფიგურაცია ქსელურ პროქსის მოითხოვს, Codex-ის სარტყელი ქმნის პროქსის ერთ ეგზემპლარს, რომელიც Codex-ის იმავე საუბარში codex-linux-sandbox-ის მრავალ გამოძახებაზე შეიძლება გამოიყენოს. თითოეულ სენდბოქსს თავისი იზოლირებული ქსელური სახელთა სივრციდან ამ საერთო პროქსისთან დაკავშირების გზა სჭირდება. Codex ამ სივრცეში loopback TCP მსმენელს ქმნის, ხოლო სენდბოქსის გარეთ არსებულ პროცესს მისი კავშირების მიღებასა და პროქსისთვის გადაცემას აკისრებს.
ქვემოთ მოცემული დიაგრამები ამ მოწყობას პროქსის ერთი საბოლოო წერტილისთვის აჩვენებს. ბოლო დიაგრამაზე მასში გამავალი ერთი კავშირია ნაჩვენები. bubblewrap-ის გაშვებამდე codex-linux-sandbox მართვის არხისთვის Unix სოკეტების წყვილს ქმნის და საკუთარ პროცესს განშტოებს. შვილობილი პროცესი უშვებს run_host_bridge()-ს და ამ არხით მსმენელის ფაილის დესკრიპტორის მიღებას ელოდება:
ამ მაგალითში მშობელი პროცესი exec-ით თავისი პროგრამის მეხსიერების ასლს bwrap-ით ანაცვლებს. ის აწყობს სენდბოქსს და მასში უშვებს codex-linux-sandbox --apply-seccomp-then-exec-ს, რომელსაც მართვის არხის ფაილის დესკრიპტორსაც (FD) გადასცემს:
სენდბოქსის ქსელურ სახელთა სივრცეში codex-linux-sandbox-ის მეორე გამოძახება ქმნის loopback TCP მსმენელს და მის ფაილის დესკრიპტორს სოკეტით გადასცემს. მსმენელი სენდბოქსის ქსელურ სახელთა სივრცესთან რჩება დაკავშირებული. ამიტომ გარეთ დარჩენილ შვილობილ პროცესს შეუძლია სენდბოქსის პროგრამების კავშირები მიიღოს, ხოლო შემდგომი კავშირები ჰოსტის ქსელურ სახელთა სივრცეში გახსნას. გადაცემის შემდეგ ორივე პროცესი ხურავს მართვის არხის დესკრიპტორებს, სენდბოქსის შიდა პროცესი კი — მსმენელის საკუთარ ასლსაც.
როცა TCP მსმენელი მზადაა, სენდბოქსის შიდა პროცესი HTTP_PROXY-ს შესაბამის მნიშვნელობას ანიჭებს(იხსნება ახალ ფანჯარაში) და მასთან დაკავშირებულ გარემოს ცვლადებსაც ამ მსმენელზე მიმართავს. შემდეგ, პროცესის განშტოებამდე და მომხმარებლის ბრძანების შესრულებამდე, ააქტიურებს seccomp-ს:
სენდბოქსის გარეთ არსებული პროცესი მსმენელს ღიას ტოვებს. ყოველი მიღებული კავშირისთვის ის უკავშირდება მითითებულ პროქსის და მონაცემებს ორივე მიმართულებით გადასცემს.
ეს დამატებითი მექანიზმი ბრძანებას საკუთარ ქსელურ სახელთა სივრცეს აძლევს, ცალკე loopback ინტერფეისით. macOS-ზე Seatbelt ბრძანებას ჰოსტის loopback ინტერფეისის მითითებულ პორტებთან პირდაპირ დაკავშირების საშუალებას აძლევს. Linux-ზე კი ბრძანება თავის იზოლირებულ სახელთა სივრცეში არსებულ მსმენელს უკავშირდება, სენდბოქსის გარე პროცესი კი ამ კავშირებს მითითებულ პროქსის გადასცემს. დესკრიპტორის გადაცემა ამ კავშირს ისე უზრუნველყოფს, რომ ბრძანებას ჰოსტის ქსელურ სახელთა სივრცეზე წვდომა არ ეძლევა.
წლის დასაწყისში Windows-ზე სენდბოქსი დავნერგეთ და ამ მიმართულებით გაწეული სამუშაოს შესახებ დავწერეთ. მას შემდეგ Microsoft-მა გამოუშვა ბიბლიოთეკა MXC და Windows-ის ოპერაციულ სისტემაში პროცესების იზოლაციის ახალი ფუნქციები. ამჟამად არსებულ სენდბოქსს MXC ბიბლიოთეკაზე დაფუძნებული სენდბოქსით ვცვლით.
MXC (Microsoft eXecution Container) არის Microsoft-ის სენდბოქსში კოდის შესრულების სისტემა(იხსნება ახალ ფანჯარაში), რომელიც Windows-ზე, Linux-სა და macOS-ზე იზოლაციის რამდენიმე მექანიზმს უჭერს მხარს. თავსებად Windows მოწყობილობებზე Codex მხარს უჭერს MXC-ზე დაფუძნებულ სენდბოქსს და პროცესების ჩაშენებულ იზოლაციას იყენებს მომხმარებლის არსებულ გარემოში ბრძანებების შესაზღუდად.
MXC-ზე გადავდივართ უსაფრთხოებისა და მოხერხებულობის გასაუმჯობესებლად და Windows-ის არსებული სენდბოქსის რამდენიმე შეზღუდვის მოსახსნელად:
სენდბოქსის მოსაწყობად გაზრდილი/ადმინისტრატორის უფლებების საჭიროება
ACL-ის შემოწმებისა და დაყენების რესურსტევადი/ნელი ოპერაციები
ჰოსტზე მუდმივად შენარჩუნებული სენდბოქსის კონფიგურაცია, მათ შორის:
წვდომის კონტროლის სიები (ACL)
ქსელური ეკრანის წესები
სენდბოქსის მომხმარებლები
მართვის ფენის ფაილები
MXC გვთავაზობს კონფიგურაციის JSON სქემას(იხსნება ახალ ფანჯარაში). Codex MXC SDK(იხსნება ახალ ფანჯარაში)-ით ქმნის ამ სქემის შესაბამის შესრულების მოთხოვნას, რომელიც შეიცავს ბრძანებას, სამუშაო საქაღალდეს, გარემოსა და ნებართვებს. ეს ნებართვები მოიცავს ფაილურ სისტემასა და ქსელზე წვდომას, ასევე Windows-ის რესურსებს, როგორიცაა სამუშაო მაგიდა და ბუფერი.
თავსებადობისა და უსაფრთხოების დასაბალანსებლად Codex რამდენიმე კონტროლისთვის ფიქსირებულ პარამეტრებს იყენებს. ის უშვებს რეესტრის წაკითხვას და ინარჩუნებს Win32k-სა და სამუშაო მაგიდაზე წვდომას, რაც PowerShell-ს გაშვებისას სჭირდება. ბუფერზე წვდომა, შეყვანის ინექცია და სამუშაო მაგიდისა თუ სისტემური პარამეტრების მართვა გამორთულია. ამასთან, MXC-ს ეკრძალება ალტერნატიულ გზად ჰოსტის ფაილური სისტემის ნებართვების შეცვლის გამოყენება.
Codex ნებართვების პროფილის ფაილური სისტემისა და ქსელის წესებს MXC-ის კონფიგურაციად გარდაქმნის. გამოვიყენოთ წინა dev პროფილი და დავუშვათ, რომ:
C:\,D:\დაZ:\კომპიუტერის ერთადერთი ლოკალური დისკებია.სამუშაო სივრცის ძირეული და სამუშაო საქაღალდეა
C:\work\demo.მომხმარებლის საწყისი საქაღალდეა
D:\Users\dev, ამიტომ~/build-cacheშეესაბამება გზასD:\Users\dev\build-cache.აკრძალვის glob შაბლონს მხოლოდ
C:\work\demo\config\dev.envდაC:\work\demo\config\prod.envშეესაბამება.
MXC-ის შესაბამისი პარამეტრები მოიცავდა შემდეგს:
MXC-ის ფაილური სისტემის პოლიტიკა ნაგულისხმევად კრძალავს წვდომას. ამიტომ Codex ლოკალური დისკების ძირეულ საქაღალდეებს მხოლოდ წაკითხვის ნებართვებს უმატებს, რათა ამ პროფილით დაშვებული ფართო წაკითხვის წვდომა უზრუნველყოს. ეს ნებართვები რეკურსიულად ვრცელდება, ოპერაციულ სისტემაში მომხმარებლის არსებული უფლებების ფარგლებში.
ერთი ნიუანსი: დისკის ძირეულ საქაღალდეზე ჩაწერის ნებართვები რეკურსიულად არ ვრცელდება, ამიტომ Codex მათ დისკის უშუალოდ ქვემდებარე არსებულ ელემენტებზეც ავრცელებს.
უფრო კონკრეტული გზის ნებართვა ზედა საქაღალდის ნებართვას გადაწონის. ამიტომ მხოლოდ წაკითხვადი C:\-ის ქვეშ C:\work\demo შეიძლება ჩაწერას უშვებდეს, ხოლო C:\work\demo\.git მხოლოდ წაკითხვადი დარჩეს.
როცა გზის სხვადასხვა ჩაწერა ან სიმბოლური ბმულის/junction-ის ალტერნატიული სახელები ერთსა და იმავე გზას აღნიშნავს, MXC უფრო მკაცრ ნებართვას იყენებს: აკრძალვა გადაწონის მხოლოდ წაკითხვას, ეს უკანასკნელი კი — წაკითხვა-ჩაწერას.
MXC მხოლოდ კონკრეტულ აკრძალულ გზებს იღებს, ამიტომ Codex გაშვებამდე აკრძალვის glob შაბლონებს შესაბამისი ფაილებისა და საქაღალდეების გზებად გარდაქმნის. ბრძანების შესრულებისას glob შაბლონის შესაბამისი ახალი გზები ავტომატურად არ ემატება.
დომენის წესებს, მაგალითად *.openai.com-ს, ზემოთ აღწერილი Codex-ის საერთო ქსელური პროქსი აღასრულებს. Codex ამ პროქსის სენდბოქსის გარეთ უშვებს და მის მისამართებს ბრძანებას ზემოთ ნახსენები სტანდარტული *_PROXY გარემოს ცვლადებით გადასცემს. MXC ბლოკავს პირდაპირ გარე კავშირებს, თუმცა უშვებს ჰოსტის loopback კავშირებს, მათ შორის პროქსიზე წვდომას. სხვა ლოკალური სერვისებიც ხელმისაწვდომი რჩება.
macOS-ზე, Linux-სა და Windows-ზე სარტყელი ერთსა და იმავე სენდბოქსის API-ს იყენებს ნებართვების პროფილით ბრძანებების გასაშვებად. შეზღუდვების დასაწესებლად საჭირო გარემოს მოწყობას პლატფორმის სპეციფიკური რეალიზაციები უზრუნველყოფს.
კოდის წერა და შესრულება აგენტებს ამოცანების გადაჭრის მოქნილ გზას აძლევს, პროგრამული უზრუნველყოფის შემუშავების ფარგლებს გარეთაც. Codex-ის სენდბოქსი მათ ამ შესაძლებლობის მომხმარებლის არსებულ გარემოში გამოყენების საშუალებას აძლევს, ფაილურ სისტემასა და ქსელზე წვდომის მკაფიო შეზღუდვებით. ეს სარტყლის მრავალჯერ გამოსაყენებელი საბაზისო კომპონენტია, codex sandbox ბრძანება კი მას თქვენსავე შექმნილ ხელსაწყოებშიც ხელმისაწვდომს ხდის.
აგენტების ამოცანების ზრდასთან ერთად, გვინდა, სენდბოქსის გამოყენება მეტი ხელსაწყოსა და გარემოსთვის პრაქტიკული გავხადოთ. ამისთვის საჭიროა ნებართვების გამართვის გამარტივება და ოპერაციული სისტემების გაუმჯობესებული დამცავი მექანიზმების გამოყენება მათი ხელმისაწვდომობისთანავე. ჩვენი მიზანია, გავაფართოოთ აგენტების შესაძლებლობები ისე, რომ მათ წვდომაზე კონტროლი ადამიანებს შეუნარჩუნდეთ.


