OpenAI

ನವೆಂಬರ್ 18, 2026

ಎಂಜಿನಿಯರಿಂಗ್

Codex ಸ್ಯಾಂಡ್‌ಬಾಕ್ಸ್‌ನ ಒಳನೋಟ

ನೀವು ನಿಯಂತ್ರಿಸುವ ಮಿತಿಗಳೊಂದಿಗೆ Codex ನಿಮ್ಮ ಯಂತ್ರದಲ್ಲಿ ಆಜ್ಞೆಗಳನ್ನು ಚಲಾಯಿಸುವ ವಿಧಾನ.

ಲೇಖಕರು: ಮೈಕೆಲ್ ಬೋಲಿನ್, ತಾಂತ್ರಿಕ ಸಿಬ್ಬಂದಿ ಸದಸ್ಯ

OpenAI ನಲ್ಲಿ, ಏಜೆಂಟ್‌ಗಳ ರಕ್ಷಣೆಗಾಗಿ ನಾವು ಬಹುಪದರ ರಕ್ಷಣೆಯ⁠(ಹೊಸ ಕಿಟಕಿಯಲ್ಲಿ ತೆರೆಯುತ್ತದೆ) ವಿಧಾನ ಅನುಸರಿಸುತ್ತೇವೆ. ತರಬೇತಿ ಮತ್ತು ಉದ್ದೇಶಾನುಸರಣೆಯ ಮೇಲಿನ ನಮ್ಮ ಹೂಡಿಕೆಗಳು ಈ ಪ್ರಯತ್ನದ ಅಡಿಪಾಯ. ಹೆಚ್ಚುವರಿ ರಕ್ಷಣೆಗಳಿಗಾಗಿ ನಮ್ಮ ಏಜೆಂಟ್ ಪೂರಕ ವ್ಯವಸ್ಥೆಯಾದ Codex⁠(ಹೊಸ ಕಿಟಕಿಯಲ್ಲಿ ತೆರೆಯುತ್ತದೆ) ನಲ್ಲಿಯೂ ಸೌಲಭ್ಯಗಳನ್ನು ಅಳವಡಿಸುತ್ತೇವೆ. ನಿಮ್ಮ ಕಂಪ್ಯೂಟರ್‌ನಲ್ಲಿ ಆಜ್ಞೆಗಳನ್ನು ಚಲಾಯಿಸುವುದು Codex ಮಾಡುವ ಸಾಮಾನ್ಯ (ಮತ್ತು ಅಪಾಯಕಾರಿ ಆಗಬಹುದಾದ) ಕೆಲಸಗಳಲ್ಲಿ ಒಂದು. ಹೀಗಾಗಿ, ನೀವು ನಿಯಂತ್ರಿಸುವ ಫೈಲ್‌ವ್ಯವಸ್ಥೆ ಮತ್ತು ನೆಟ್‌ವರ್ಕ್ ಮಿತಿಗಳೊಳಗೆ, ನಿಮ್ಮ ಹಾಲಿ ಪರಿಸರದಲ್ಲೇ Codex ಕೆಲಸ ಮಾಡಲು Codex ಸ್ಯಾಂಡ್‌ಬಾಕ್ಸ್ ನಿರ್ಮಿಸಿದ್ದೇವೆ.

ಒಂದು ⁠(ಹೊಸ ಕಿಟಕಿಯಲ್ಲಿ ತೆರೆಯುತ್ತದೆ)ಸ್ಯಾಂಡ್‌ಬಾಕ್ಸ್⁠(ಹೊಸ ಕಿಟಕಿಯಲ್ಲಿ ತೆರೆಯುತ್ತದೆ), ಪ್ರೋಗ್ರಾಂ ಚಲಿಸುವಾಗ ಯಾವುದನ್ನು ಪ್ರವೇಶಿಸಬಹುದು ಎಂಬುದನ್ನು ಮಿತಿಗೊಳಿಸುತ್ತದೆ. ಫೋಟೋಗಳನ್ನು ವ್ಯವಸ್ಥಿತಗೊಳಿಸುವ ಕೆಲಸಕ್ಕೆ, ~/Pictures ನಲ್ಲಿನ ಫೈಲ್‌ಗಳನ್ನು ಓದಲು ಮತ್ತು ಬದಲಿಸಲು ಆಜ್ಞೆಗಳಿಗೆ ಅವಕಾಶ ನೀಡಿ, ಅಪ್‌ಲೋಡ್ ತಡೆಯಲು ನೆಟ್‌ವರ್ಕ್ ಪ್ರವೇಶ ನಿರ್ಬಂಧಿಸುವಂತೆ Codex ಸ್ಯಾಂಡ್‌ಬಾಕ್ಸ್ ಕಾನ್ಫಿಗರ್ ಮಾಡಬಹುದು. ಕೋಡ್ ಪರಿಶೀಲನೆಗೆ, ಮೂಲ ಫೈಲ್‌ಗಳನ್ನು ಓದಲು ಮಾತ್ರ ಸೀಮಿತಗೊಳಿಸಿ ಆನ್‌ಲೈನ್ ದಸ್ತಾವೇಜುಗಳಿಗೆ ಪ್ರವೇಶ ನೀಡಬಹುದು. ಬಳಕೆದಾರರು ⁠(ಹೊಸ ಕಿಟಕಿಯಲ್ಲಿ ತೆರೆಯುತ್ತದೆ)ಅನುಮತಿ ಪ್ರೊಫೈಲ್‌ಗಳ⁠(ಹೊಸ ಕಿಟಕಿಯಲ್ಲಿ ತೆರೆಯುತ್ತದೆ) ಮೂಲಕ Codex ಸ್ಯಾಂಡ್‌ಬಾಕ್ಸ್ ಕಾನ್ಫಿಗರ್ ಮಾಡುತ್ತಾರೆ. ಇವು Codex ಸೆಷನ್‌ನ ಫೈಲ್‌ವ್ಯವಸ್ಥೆ ಮತ್ತು ನೆಟ್‌ವರ್ಕ್ ನಿರ್ಬಂಧಗಳನ್ನು ವ್ಯಾಖ್ಯಾನಿಸುತ್ತವೆ.

ಈ ಲೇಖನದಲ್ಲಿ ಮೊದಲು Codex ಸ್ಯಾಂಡ್‌ಬಾಕ್ಸ್‌ನ ಪೂರ್ವನಿಯೋಜಿತ ಆಯ್ಕೆಗಳ ಲಾಭ-ನಷ್ಟಗಳನ್ನು ನೋಡೋಣ. ನಂತರ ಅದರ ವಿನ್ಯಾಸ ಮತ್ತು ಆಜ್ಞೆಗಳನ್ನು ಚಲಾಯಿಸಲು ಪೂರಕ ವ್ಯವಸ್ಥೆ ಅದನ್ನು ಬಳಸುವ ವಿಧಾನ ವಿವರಿಸೋಣ. ಬಳಕೆದಾರರು ಮತ್ತು ಉದ್ಯಮಗಳು ಅನುಮತಿಗಳನ್ನು ತಮ್ಮ ಅಗತ್ಯಕ್ಕೆ ತಕ್ಕಂತೆ ಹೇಗೆ ಹೊಂದಿಸಬಹುದು, ಡೆವಲಪರ್‌ಗಳು ತಮ್ಮ ಉಪಕರಣಗಳಲ್ಲಿ ಸ್ಯಾಂಡ್‌ಬಾಕ್ಸ್ ಅನ್ನು ಹೇಗೆ ಮರುಬಳಸಬಹುದು ಎಂಬುದನ್ನು ತೋರಿಸುತ್ತೇವೆ. ಕೊನೆಯಲ್ಲಿ, macOS, Linux ಮತ್ತು Windows ನಲ್ಲಿ ಈ ನಿರ್ಬಂಧಗಳನ್ನು ಹೇಗೆ ಜಾರಿಗೊಳಿಸಲಾಗುತ್ತದೆ ಎಂಬುದನ್ನು ಪರಿಶೀಲಿಸೋಣ.

ಸ್ಯಾಂಡ್‌ಬಾಕ್ಸ್‌ನ ಗಡಿಗಳನ್ನು ಆಯ್ಕೆ ಮಾಡುವುದು

ಅರ್ಥಪೂರ್ಣ ಕೆಲಸಕ್ಕೆ ಅವಕಾಶ ನೀಡುತ್ತಲೇ, ಸ್ಯಾಂಡ್‌ಬಾಕ್ಸ್‌ಗೆ ಎಚ್ಚರಿಕೆಯ ಪೂರ್ವನಿಯೋಜಿತ ಮಿತಿಗಳನ್ನು ನಿಗದಿಪಡಿಸುವುದು Codex ನಲ್ಲಿ ನಮ್ಮ ತತ್ವ. ಉದಾಹರಣೆಗೆ, Git ರಿಪೊಸಿಟರಿಯನ್ನು ಕಾರ್ಯಕ್ಷೇತ್ರದ ಮೂಲವಾಗಿ ಬಳಸಿದಾಗ, ಅಂತರ್ನಿರ್ಮಿತ :workspace ಅನುಮತಿ ಪ್ರೊಫೈಲ್:

  • ಕಾರ್ಯಕ್ಷೇತ್ರದಲ್ಲಿ ಬರೆಯಲು ಅನುಮತಿಸುತ್ತದೆ; ಆದರೆ .git ಮತ್ತು .codex ನಂತಹ ಡೈರೆಕ್ಟರಿಗಳನ್ನು ಓದಲು ಮಾತ್ರ ಸೀಮಿತಗೊಳಿಸುತ್ತದೆ. ಇದರಿಂದ Codex ಪ್ರತಿ ಬದಲಾವಣೆಗೂ ಅನುಮತಿ ಕೇಳದೆ ಮೂಲ ಕೋಡ್ ಸಂಪಾದಿಸಬಹುದು. ಆದರೆ .codex/config.toml ಅಥವಾ .git/hooks ಅಡಿಯ Git ಹುಕ್‌ಗಳನ್ನು ನೇರವಾಗಿ ಬದಲಿಸಲಾಗದು.

  • ಬಳಕೆದಾರರ ಹಾಲಿ ಕಾರ್ಯವ್ಯವಸ್ಥೆ ಅನುಮತಿಗಳಿಗೆ ಒಳಪಟ್ಟು, ಫೈಲ್‌ವ್ಯವಸ್ಥೆಯನ್ನು ವ್ಯಾಪಕವಾಗಿ ಓದಲು ಅನುಮತಿಸುತ್ತದೆ. ಕಂಪೈಲರ್‌ಗಳು, ರನ್‌ಟೈಮ್‌ಗಳು ಮತ್ತು ಬಿಲ್ಡ್ ಉಪಕರಣಗಳು ರಿಪೊಸಿಟರಿಯ ಹೊರಗಿನ SDK ಗಳು, ಲೈಬ್ರರಿಗಳು ಮತ್ತು ಕಾನ್ಫಿಗರೇಶನ್ ಮೇಲೆ ಅವಲಂಬಿತವಾಗಿವೆ. ಓದುವಿಕೆಯನ್ನು ಕಾರ್ಯಕ್ಷೇತ್ರಕ್ಕೆ ಸೀಮಿತಗೊಳಿಸಿದರೆ ಹಲವು ಸಾಮಾನ್ಯ ಕಾರ್ಯಪ್ರವಾಹಗಳು ಕೆಲಸ ಮಾಡುವುದಿಲ್ಲ. ಇದರ ಅನಾನುಕೂಲವೆಂದರೆ ಯಂತ್ರದ ಬೇರೆಡೆ ಇರುವ ಸೂಕ್ಷ್ಮ ಫೈಲ್‌ಗಳನ್ನೂ ಓದಬಹುದಾಗಿರುತ್ತದೆ (ಉದಾಹರಣೆಗೆ API ಕೀಲಿಗಳಿರುವ ಕಾನ್ಫಿಗರೇಶನ್ ಫೈಲ್‌ಗಳು).

  • ನೆಟ್‌ವರ್ಕ್ ಪ್ರವೇಶವನ್ನು ನಿಷ್ಕ್ರಿಯಗೊಳಿಸುತ್ತದೆ. ಆಜ್ಞೆಯು ಓದಬಹುದಾದ ದತ್ತಾಂಶವನ್ನು ಕದಿಯುವ ಪ್ರಯತ್ನಗಳೂ ಸೇರಿದಂತೆ, ಬಾಹ್ಯ ಸೇವೆಗಳಿಗೆ ನೇರ ಅಪ್‌ಲೋಡ್‌ಗಳನ್ನು ಇದು ತಡೆಯುತ್ತದೆ. ಅಗತ್ಯ ಪ್ಯಾಕೇಜ್‌ಗಳನ್ನು ಡೌನ್‌ಲೋಡ್ ಮಾಡುವಂತಹ ಮಾನ್ಯ ಕಾರ್ಯಗಳನ್ನೂ ಇದು ತಡೆಯುತ್ತದೆ; ಅವಕ್ಕೆ ಹೆಚ್ಚುವರಿ ಪ್ರವೇಶ ಬೇಕಾಗುತ್ತದೆ.

ಈ ನಿರ್ಬಂಧಗಳು ಹಲವು ಬಗೆಯ ದುರ್ವರ್ತನೆಯನ್ನು ತಡೆಯುತ್ತವೆ. ಆದರೂ ಹಾನಿಕಾರಕ ಕ್ರಿಯೆಗಳು ಸಾಧ್ಯವಿವೆ. ಉದಾಹರಣೆಗೆ, ಸ್ಥಳೀಯವಾಗಿ ಸ್ಥಾಪಿಸಿದ node_modules/prettier ನಂತಹ ಪ್ಯಾಕೇಜ್‌ಗೆ ಏಜೆಂಟ್ ದುರುದ್ದೇಶಪೂರಿತ ಕೋಡ್ ಸೇರಿಸಬಹುದು. Git ಸಾಮಾನ್ಯವಾಗಿ node_modules ಅನ್ನು ಕಡೆಗಣಿಸುವುದರಿಂದ, ಇಂತಹ ಬದಲಾವಣೆ git status ನಲ್ಲಿ ಕಾಣಿಸದಿರಬಹುದು. ಉಳಿಸುವಾಗ ಬಳಕೆದಾರರ ಸಂಪಾದಕವು ಆ Prettier ಪ್ರತಿಯನ್ನು ಚಲಾಯಿಸಿದರೆ, ಕೇವಲ ಫೈಲ್ ಉಳಿಸುವುದರಿಂದಲೇ ದುರುದ್ದೇಶಪೂರಿತ ಕೋಡ್ Codex ಸ್ಯಾಂಡ್‌ಬಾಕ್ಸ್‌ನ ಹೊರಗೆ ಚಲಿಸಬಹುದು. ಇದಕ್ಕಾಗಿಯೇ ನಾವು ಬಹುಪದರ ರಕ್ಷಣೆ ಅನುಸರಿಸುತ್ತೇವೆ: ಸ್ಯಾಂಡ್‌ಬಾಕ್ಸ್ ಆಜ್ಞೆಗಳ ಪ್ರವೇಶವನ್ನು ಮಿತಿಗೊಳಿಸುತ್ತದೆ; ತರಬೇತಿ ಮತ್ತು ಉದ್ದೇಶಾನುಸರಣೆಯು ಆ ಪ್ರವೇಶವನ್ನು ಬಳಕೆದಾರರ ಉದ್ದೇಶಕ್ಕೆ ತಕ್ಕಂತೆ ಬಳಸಲು ಮಾಡೆಲ್‌ಗೆ ನೆರವಾಗುತ್ತವೆ.

ಉದ್ಯಮ ಪರಿಸರದಲ್ಲಿ ಸ್ಯಾಂಡ್‌ಬಾಕ್ಸ್ ಅನುಮತಿಗಳನ್ನು ಹೊಂದಿಸುವುದು ಮತ್ತು ಇತರ ರಕ್ಷಣೆಗಳೊಂದಿಗೆ ಸಂಯೋಜಿಸುವುದರ ಬಗ್ಗೆ ಮಾರ್ಗದರ್ಶನಕ್ಕಾಗಿ Codex ಭದ್ರತಾ ಕೈಪಿಡಿ⁠(ಹೊಸ ಕಿಟಕಿಯಲ್ಲಿ ತೆರೆಯುತ್ತದೆ) ನೋಡಿ.

ಸ್ಯಾಂಡ್‌ಬಾಕ್ಸ್ ವಿನ್ಯಾಸ

ವರ್ಚುವಲ್ ಯಂತ್ರಗಳು ಮತ್ತು ಕಂಟೇನರ್‌ಗಳು⁠(ಹೊಸ ಕಿಟಕಿಯಲ್ಲಿ ತೆರೆಯುತ್ತದೆ) ಸ್ಯಾಂಡ್‌ಬಾಕ್ಸಿಂಗ್‌ಗೆ ಬಳಸುವ ಎರಡು ಜನಪ್ರಿಯ ವಿಧಾನಗಳು. ಆದರೆ Codex ಸ್ಯಾಂಡ್‌ಬಾಕ್ಸ್‌ಗೆ ನಾವು ಬೇರೆಯದೇ ವಿಧಾನ ಅನುಸರಿಸುತ್ತೇವೆ. ಪ್ರತ್ಯೇಕೀಕರಣಕ್ಕಾಗಿ ಗಣನೆಯನ್ನು ಬೇರೆ ಪರಿಸರಕ್ಕೆ ವರ್ಗಾಯಿಸುವ ಬದಲು, ಬಳಕೆದಾರರ ಹಾಲಿ ಪರಿಸರದಲ್ಲಿ ಚಲಿಸುವ ಆಜ್ಞೆಗಳನ್ನು ನಿರ್ಬಂಧಿಸಲು Codex ಆಯಾ ಪ್ಲಾಟ್‌ಫಾರ್ಮ್‌ನ ಸ್ಯಾಂಡ್‌ಬಾಕ್ಸಿಂಗ್ ಸೌಲಭ್ಯಗಳನ್ನು ಬಳಸುತ್ತದೆ.

ಹಲವು ಡೆವಲಪರ್‌ಗಳಿಗೆ ಅವರ ಲ್ಯಾಪ್‌ಟಾಪ್, ಇಚ್ಛೆಯಂತೆ ಬದಲಿಸಬಹುದಾದ ವೈಯಕ್ತಿಕ ಅಭಿವೃದ್ಧಿ ಪರಿಸರವಾಗಿದೆ. ಆ ಪರಿಸರವನ್ನು Docker ಕಂಟೇನರ್‌ನಲ್ಲಿ ಮರುಸೃಷ್ಟಿಸಲು ಶ್ರಮ ಬೇಕಾಗಬಹುದು. ಕೆಲವು ಕಾರ್ಯಪ್ರವಾಹಗಳು ಹೋಸ್ಟ್‌ನಲ್ಲಿ ಚಲಿಸುವ ಉಪಕರಣಗಳನ್ನೇ ಅವಲಂಬಿಸಿರುತ್ತವೆ.

ಉದಾಹರಣೆಗೆ, Mac ನಲ್ಲಿ iOS ಆ್ಯಪ್ ಅಭಿವೃದ್ಧಿಪಡಿಸಲು Codex ಬಳಸುವುದನ್ನು ಪರಿಗಣಿಸಿ. Codex ಅನ್ನು Docker ಒಳಗೆ ಚಲಾಯಿಸಿ ಸ್ಯಾಂಡ್‌ಬಾಕ್ಸ್ ಮಾಡಲು ನಿರ್ಧರಿಸಿದರೆ, ಸ್ಥಳೀಯ Mac ಕಾರ್ಯಗತ ಫೈಲ್‌ಗಳಿಂದ ಕೂಡಿದ iOS ಬಿಲ್ಡ್ ಉಪಕರಣ ಸರಣಿಯನ್ನು ಅದು ಚಲಾಯಿಸಲಾಗದು. ಕೋಡ್ ಚಲಾಯಿಸಲು iPhone ಸಿಮ್ಯುಲೇಟರ್ ಅನ್ನೂ ಆರಂಭಿಸಲಾಗದು. Docker ಆಧಾರಿತ ಕಾರ್ಯಪ್ರವಾಹವು ಬಿಲ್ಡ್ ಮತ್ತು ಸಿಮ್ಯುಲೇಟರ್ ಕಾರ್ಯಗಳನ್ನು Mac ಹೋಸ್ಟ್‌ಗೆ ವಹಿಸಬಹುದು. ಆದರೆ ಅವು ಕಂಟೇನರ್‌ನ ಸ್ಯಾಂಡ್‌ಬಾಕ್ಸ್ ಹೊರಗೆ ಚಲಿಸುವುದರಿಂದ, ಅವಕ್ಕೆ ಪ್ರತ್ಯೇಕ ನಿರ್ಬಂಧಗಳು ಬೇಕಾಗುತ್ತವೆ. Codex ಗಾಗಿ, ಕಾರ್ಯವ್ಯವಸ್ಥೆಗೆ ನಿರ್ದಿಷ್ಟವಾದ ಸ್ಯಾಂಡ್‌ಬಾಕ್ಸಿಂಗ್‌ನಲ್ಲಿ ಹೆಚ್ಚಿನ ಹೂಡಿಕೆ ಮಾಡಿ ವ್ಯವಸ್ಥೆಯನ್ನು ಸರಳವಾಗಿಡಲು ಬಯಸುತ್ತೇವೆ. ಇದರಿಂದ Codex ಕೈಯಲ್ಲಿರುವ ಕೆಲಸಕ್ಕೆ ಅತ್ಯಂತ ಸೂಕ್ತ ಪರಿಸರದಲ್ಲೇ ಚಲಿಸಬಹುದು.

ಪೂರಕ ವ್ಯವಸ್ಥೆಯು ಈ ಕಾರ್ಯವ್ಯವಸ್ಥೆ-ನಿರ್ದಿಷ್ಟ ಸ್ಯಾಂಡ್‌ಬಾಕ್ಸಿಂಗ್ ವಿಧಾನಗಳನ್ನು macOS, Windows ಮತ್ತು Linux ನಲ್ಲಿ ಒಂದೇ ಸಾಮಾನ್ಯ API ಮೂಲಕ ಒದಗಿಸುತ್ತದೆ. ಈ API ಒಂದು ಆಜ್ಞೆ ಮತ್ತು ಅನುಮತಿ ಪ್ರೊಫೈಲ್ ಸ್ವೀಕರಿಸುತ್ತದೆ. ಅನುಮತಿ ಪ್ರೊಫೈಲ್ ಸೀಮಿತ ನೆಟ್‌ವರ್ಕ್ ಪ್ರವೇಶ ನೀಡಿದರೆ, ಆ ಮಿತಿಗಳನ್ನು ಜಾರಿಗೊಳಿಸಲು ಕರೆ ಮಾಡುವ ಘಟಕ ನೆಟ್‌ವರ್ಕ್ ಪ್ರಾಕ್ಸಿ ಒದಗಿಸಬೇಕು:

Python

1
# This is a simplified version of the actual API.
2
def spawn_command_under_sandbox(
3
program_and_args: list[str],
4
cwd: Path,
5
env: dict[str, str],
6
permission_profile: PermissionProfile,
7
network_proxy: NetworkProxy | None,
8
) -> Child:

ಈ ಫಂಕ್ಷನ್ ಸ್ಯಾಂಡ್‌ಬಾಕ್ಸ್‌ನಲ್ಲಿ ಪ್ರಕ್ರಿಯೆ ಆರಂಭಿಸಿ, Child ಹ್ಯಾಂಡಲ್ ಹಿಂದಿರುಗಿಸುತ್ತದೆ. ಪ್ರಕ್ರಿಯೆ ಮುಗಿಯುವವರೆಗೆ ಕಾಯಲು ಪೂರಕ ವ್ಯವಸ್ಥೆ ಅದನ್ನು ಬಳಸಬಹುದು. ಪ್ರತಿ ಚೈಲ್ಡ್ ಪ್ರಕ್ರಿಯೆಯೂ ತನ್ನ ಪೇರೆಂಟ್‌ನ ಸ್ಯಾಂಡ್‌ಬಾಕ್ಸ್ ನಿರ್ಬಂಧಗಳನ್ನು ಪಡೆಯುತ್ತದೆ. ಹೀಗಾಗಿ ಆಜ್ಞೆ ಆರಂಭಿಸಿದ ಇಡೀ ಪ್ರಕ್ರಿಯಾ ವೃಕ್ಷಕ್ಕೆ ಅವು ಅನ್ವಯಿಸುತ್ತವೆ; ಮೂಲ ಪ್ರಕ್ರಿಯೆ ಮುಗಿದ ಬಳಿಕವೂ ಚಲಿಸುವ ವಂಶಜ ಪ್ರಕ್ರಿಯೆಗಳಿಗೂ ಅನ್ವಯಿಸುತ್ತವೆ.

ಕಾನ್ಫಿಗರೇಶನ್‌ನಿಂದ ಸ್ಯಾಂಡ್‌ಬಾಕ್ಸ್‌ನಲ್ಲಿ ಆಜ್ಞೆ ಚಲಾಯಿಸುವವರೆಗೆ ಈ ಭಾಗಗಳು ಹೇಗೆ ಒಟ್ಟಿಗೆ ಕೆಲಸ ಮಾಡುತ್ತವೆ ಎಂಬುದನ್ನು ಕೆಳಗಿನ ಚಿತ್ರ ತೋರಿಸುತ್ತದೆ. ಮುಂದಿನ ವಿಭಾಗಗಳು ಪ್ರತಿ ಹಂತವನ್ನೂ ವಿವರಿಸುತ್ತವೆ.

ಪ್ರವಾಹ ಚಿತ್ರ: ಕಾನ್ಫಿಗರೇಶನ್ ಮತ್ತು ನಿರ್ವಹಿತ ಅವಶ್ಯಕತೆಗಳು ಸೆಷನ್‌ನ ಅನುಮತಿ ಪ್ರೊಫೈಲ್ ವ್ಯಾಖ್ಯಾನಿಸುತ್ತವೆ; Codex ಪೂರಕ ವ್ಯವಸ್ಥೆಯು macOS, Linux ಅಥವಾ Windows ನಲ್ಲಿ ಪ್ಲಾಟ್‌ಫಾರ್ಮ್-ನಿರ್ದಿಷ್ಟ ಸ್ಯಾಂಡ್‌ಬಾಕ್ಸ್ ನಿರ್ಬಂಧಗಳ ಅಡಿಯಲ್ಲಿ ಆಜ್ಞೆಗಳನ್ನು ಆರಂಭಿಸುತ್ತದೆ. ಚೈಲ್ಡ್ ಪ್ರಕ್ರಿಯೆಗಳಿಗೆ ಆ ನಿರ್ಬಂಧಗಳು ವರ್ಗವಾಗುತ್ತವೆ; ಐಚ್ಛಿಕ ನೆಟ್‌ವರ್ಕ್ ಪ್ರಾಕ್ಸಿ ಡೊಮೇನ್ ನಿಯಮಗಳನ್ನು ಜಾರಿಗೊಳಿಸುತ್ತದೆ.

ಪೂರಕ ವ್ಯವಸ್ಥೆ ಸ್ಯಾಂಡ್‌ಬಾಕ್ಸ್ ಬಳಸುವ ವಿಧಾನ

Codex ಏಜೆಂಟ್ ಚಕ್ರದ ಒಳನೋಟ ಲೇಖನದಲ್ಲಿ ವಿವರಿಸಿದಂತೆ, ಮಾಡೆಲ್ ರಚಿಸುವ ಉಪಕರಣ ಕರೆಗಳನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸುವ ಹೊಣೆ Codex ಪೂರಕ ವ್ಯವಸ್ಥೆಯದು. ಕೋಡಿಂಗ್ ಕೆಲಸಗಳಿಗೆ ಹೆಚ್ಚು ಬಳಕೆಯಾಗುವುದು ಶೆಲ್ ಉಪಕರಣ. Bash ನಂತಹ ಸಂವಾದಾತ್ಮಕ ಶೆಲ್‌ನಲ್ಲಿ ಬಳಕೆದಾರರು ಮಾಡುವಂತೆಯೇ ಇದು ಆಜ್ಞೆಗಳನ್ನು ಚಲಾಯಿಸುತ್ತದೆ. ಅಪೇಕ್ಷಿತ ರಕ್ಷಣೆಗಳನ್ನು ಸಾಧಿಸಲು ಪೂರಕ ವ್ಯವಸ್ಥೆ ಸ್ಯಾಂಡ್‌ಬಾಕ್ಸ್ ಬಳಸುವ ವಿಧಾನ ತೋರಿಸಲು, ಇಲ್ಲಿ ವನ್-ಶಾಟ್ ⁠(ಹೊಸ ಕಿಟಕಿಯಲ್ಲಿ ತೆರೆಯುತ್ತದೆ)exec_command⁠(ಹೊಸ ಕಿಟಕಿಯಲ್ಲಿ ತೆರೆಯುತ್ತದೆ) ಶೆಲ್ ಉಪಕರಣವನ್ನು⁠(ಹೊಸ ಕಿಟಕಿಯಲ್ಲಿ ತೆರೆಯುತ್ತದೆ) ಪರಿಶೀಲಿಸೋಣ.

ಸ್ಯಾಂಡ್‌ಬಾಕ್ಸಿಂಗ್ ಇಲ್ಲದೆ Codex ಪೂರಕ ವ್ಯವಸ್ಥೆಯು exec_command ಉಪಕರಣ ಕರೆಯನ್ನು ಹೇಗೆ ನಿರ್ವಹಿಸುತ್ತದೆ ಎಂಬುದರ ಸರಳೀಕೃತ ರೂಪ ಇಲ್ಲಿದೆ:

Python

1
# Illustrative implementation of the exec_command tool call.
2

3
class ExecCommandToolCall:
4
cmd: str
5
workdir: str | None = None
6
shell: str | None = None
7
login: bool = True
8
timeout_ms: int = 10_000
9

10

11
def perform_exec_command(tool_call: ExecCommandToolCall):
12
program_and_args = [
13
tool_call.shell or os.environ.get("SHELL") or "/bin/sh",
14
"-lc" if tool_call.login else "-c",
15
tool_call.cmd,
16
]
17
child = subprocess.Popen(
18
program_and_args,
19
# workdir defaults to the turn's cwd, assumed here to be the process cwd.
20
cwd=Path(tool_call.workdir or ".").absolute(),
21
stdout=subprocess.PIPE,
22
stderr=subprocess.STDOUT,
23
)
24
output, exit_code = collect_output(child, timeout_ms=tool_call.timeout_ms)
25
return {"output": output, "exit_code": exit_code}

ಆಜ್ಞೆಯನ್ನು ಸ್ಯಾಂಡ್‌ಬಾಕ್ಸ್‌ನಲ್ಲಿ ಚಲಾಯಿಸಲು, ಪೂರಕ ವ್ಯವಸ್ಥೆ subprocess.Popen() ಕರೆಯ ಬದಲು spawn_command_under_sandbox() ಬಳಸುತ್ತದೆ. ಪೂರಕ ವ್ಯವಸ್ಥೆ ಅನುಮತಿ ಪ್ರೊಫೈಲ್ ಮತ್ತು ಅಗತ್ಯವಿದ್ದಾಗ ನೆಟ್‌ವರ್ಕ್ ಪ್ರಾಕ್ಸಿ ಒದಗಿಸುತ್ತದೆ:

Python

1
# Honoring the exec_command tool call while enforcing sandbox constraints.
2

3
def perform_exec_command_with_sandboxing(
4
tool_call: ExecCommandToolCall,
5
permission_profile: PermissionProfile,
6
network_proxy: NetworkProxy | None,
7
):
8
# ...build program_and_args as in the previous example...
9
child = spawn_command_under_sandbox(
10
program_and_args=program_and_args,
11
cwd=Path(tool_call.workdir or ".").absolute(),
12
env=os.environ.copy(),
13
permission_profile=permission_profile,
14
network_proxy=network_proxy,
15
)
16
output, exit_code = collect_output(child, timeout_ms=tool_call.timeout_ms)
17
return {"output": output, "exit_code": exit_code}

ನಿರ್ದಿಷ್ಟ ಆಜ್ಞೆಗೆ ಬೇರೆ ಅನುಮತಿಗಳನ್ನು ಕೇಳಲು exec_command ಉಪಕರಣ ಮಾಡೆಲ್‌ಗೆ ಅವಕಾಶ ನೀಡುತ್ತದೆ. ಆದರೆ ವಿನಂತಿಯನ್ನು ಅನುಮೋದಿಸಬೇಕೇ ಎಂಬುದನ್ನು ಪೂರಕ ವ್ಯವಸ್ಥೆ ನಿರ್ಧರಿಸುತ್ತದೆ:

Python

1
class ExecCommandToolCall:
2
# ...command-related fields...
3

4
# Per-command sandbox override. Defaults to "use_default".
5
sandbox_permissions: Literal[
6
"use_default",
7
"with_additional_permissions",
8
"require_escalated",
9
] = "use_default"
10

11
# User-facing approval question; only for "require_escalated".
12
justification: str | None = None
13

14
# Expand network or filesystem access; only for "with_additional_permissions".
15
# AdditionalPermissions supports fine-grained options.
16
additional_permissions: AdditionalPermissions | None = None

use_default ಸೂಚಿಸಿದಾಗ, ಪೂರಕ ವ್ಯವಸ್ಥೆ ಆ ಸುತ್ತಿನ ಪೂರ್ವನಿಯೋಜಿತ ಸ್ಯಾಂಡ್‌ಬಾಕ್ಸ್ ಕಾನ್ಫಿಗರೇಶನ್ ಬಳಸುತ್ತದೆ. with_additional_permissions ಸ್ಯಾಂಡ್‌ಬಾಕ್ಸ್‌ನೊಳಗೆ ಹೆಚ್ಚಿನ ಪ್ರವೇಶ ಕೋರುತ್ತದೆ; require_escalated ಅದರ ಹೊರಗೆ ಚಲಾಯಿಸಲು ಕೋರುತ್ತದೆ. ಆಜ್ಞೆ ಚಲಾಯಿಸುವ ಮೊದಲು, ಪೂರಕ ವ್ಯವಸ್ಥೆ ಬಳಕೆದಾರರ ಆದ್ಯತೆಗಳ ಆಧಾರದಲ್ಲಿ ವಿನಂತಿಯನ್ನು ಮೌಲ್ಯಮಾಪನ ಮಾಡುತ್ತದೆ. (ಉದಾಹರಣೆಗೆ, Codex ನೇರವಾಗಿ ಬಳಕೆದಾರರನ್ನು ಕೇಳಬಹುದು ಅಥವಾ ವಿನಂತಿಯನ್ನು ಸ್ವಯಂಚಾಲಿತ ಪರಿಶೀಲನೆಗೆ⁠(ಹೊಸ ಕಿಟಕಿಯಲ್ಲಿ ತೆರೆಯುತ್ತದೆ) ಕಳುಹಿಸಬಹುದು.) ಚಲಾಯಿಸಲು ಅನುಮೋದನೆ ಸಿಕ್ಕರೆ, ಮೂಲ 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 ಡೈರೆಕ್ಟರಿಯನ್ನು ಓದಲು ಮಾತ್ರ ಸೀಮಿತಗೊಳಿಸುತ್ತದೆ.

ತನ್ನದೇ ನಿಯಮಗಳ ಜೊತೆಗೆ dev, :workspace ನಿಂದ ಈ ರಕ್ಷಣೆಗಳನ್ನು ಪಡೆಯುತ್ತದೆ:

TOML

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

ನೆಟ್‌ವರ್ಕ್ ಅನುಮತಿಗಳು

Codex ಸ್ಯಾಂಡ್‌ಬಾಕ್ಸ್‌ನ ನೆಟ್‌ವರ್ಕ್ ಕಾನ್ಫಿಗರ್ ಮಾಡಲು ಮುಖ್ಯವಾಗಿ ಮೂರು ಆಯ್ಕೆಗಳಿವೆ:

  • ಎಲ್ಲಾ ನೆಟ್‌ವರ್ಕ್ ಪ್ರವೇಶ ನಿಷ್ಕ್ರಿಯಗೊಳಿಸುವುದು (:workspace ಪ್ರೊಫೈಲ್‌ನ ಪೂರ್ವನಿಯೋಜಿತ ಆಯ್ಕೆ)

  • ಪೂರ್ಣ, ನೇರ ನೆಟ್‌ವರ್ಕ್ ಪ್ರವೇಶ ಸಕ್ರಿಯಗೊಳಿಸುವುದು (:danger-full-access ಪ್ರೊಫೈಲ್‌ನ ಪೂರ್ವನಿಯೋಜಿತ ಆಯ್ಕೆ)

  • ನೆಟ್‌ವರ್ಕ್ ಪ್ರವೇಶವನ್ನು ಪ್ರಾಕ್ಸಿಗೆ ಸೀಮಿತಗೊಳಿಸುವುದು; ಅನುಮತಿ ಪ್ರೊಫೈಲ್ ಆಧರಿಸಿ ಯಾವುದನ್ನು ಹಾದುಹೋಗಲು ಬಿಡಬೇಕೆಂದು ಪ್ರಾಕ್ಸಿ ನಿರ್ಧರಿಸುತ್ತದೆ


dev ಗೆ ನೇರ ನೆಟ್‌ವರ್ಕ್ ಪ್ರವೇಶ ನೀಡಲು, config.toml ನ ಉನ್ನತ ಹಂತದಲ್ಲಿ permissions.dev.network.enabled = true ಹೊಂದಿಸಿ. ನೆಟ್‌ವರ್ಕ್ ಪ್ರಾಕ್ಸಿ ನಿಷ್ಕ್ರಿಯವಾಗಿದ್ದಾಗ ಇದು ಪೂರ್ಣ ನೆಟ್‌ವರ್ಕ್ ಪ್ರವೇಶ ನೀಡುತ್ತದೆ.

dev ಅನ್ನು ನಿರ್ದಿಷ್ಟ ಡೊಮೇನ್‌ಗಳಿಗೆ ಸೀಮಿತಗೊಳಿಸಲು, ನೆಟ್‌ವರ್ಕ್ ಪ್ರಾಕ್ಸಿ ಸಕ್ರಿಯಗೊಳಿಸಿ ಅದರ ಡೊಮೇನ್ ನಿಯಮಗಳನ್ನು ಕಾನ್ಫಿಗರ್ ಮಾಡಿ:

TOML

1
[permissions.dev.network]
2
enabled = true
3

4
[permissions.dev.network.domains]
5
"*.openai.com" = "allow"
6
# Allow requests to local services by hostname or by IPv4/IPv6 loopback address.
7
"localhost" = "allow"
8
"127.0.0.1" = "allow"
9
"::1" = "allow"
10
"evil.example" = "deny"
11

12
[features]
13
# If neither local config nor managed requirements enable the proxy,
14
# this profile allows direct network access; domain rules are not enforced.
15
network_proxy = true

ಡೊಮೇನ್ ನಿಯಮಗಳು ನಿಖರ ಹೆಸರುಗಳು ಮತ್ತು ವೈಲ್ಡ್‌ಕಾರ್ಡ್ ಮಾದರಿಗಳನ್ನು ಬೆಂಬಲಿಸುತ್ತವೆ. ಅನುಮತಿ ನಿಯಮಗಳಿಗಿಂತ ಸ್ಪಷ್ಟ ನಿರಾಕರಣೆ ನಿಯಮಗಳಿಗೆ ಆದ್ಯತೆ ಇರುತ್ತದೆ. ಕೆಳಗಿನ ನೆಟ್‌ವರ್ಕ್ ಪ್ರಾಕ್ಸಿ ವಿಭಾಗದಲ್ಲಿ ವಿವರಿಸಿರುವಂತೆ, ಇತರ ಡೊಮೇನ್‌ಗಳ ವಿನಂತಿಗಳಿಗೆ ಅನುಮೋದನೆ ಬೇಕಾಗುತ್ತದೆ ಅಥವಾ ಅವುಗಳನ್ನು ತಡೆಯಲಾಗುತ್ತದೆ.

ಪದರಗಳಲ್ಲಿ ಕಾನ್ಫಿಗರೇಶನ್ ಮತ್ತು ಮಿತಿಗಳ ಜಾರಿ

ವೈಯಕ್ತಿಕ ಬಳಕೆದಾರರು ಎಲ್ಲಾ ಯೋಜನೆಗಳಿಗೆ ಅನ್ವಯಿಸುವ ಪೂರ್ವನಿಯೋಜಿತ ಸೆಟ್ಟಿಂಗ್‌ಗಳನ್ನು ಕಾನ್ಫಿಗರ್ ಮಾಡಬಹುದು; ನಿರ್ದಿಷ್ಟ ವಿಶ್ವಾಸಾರ್ಹ ಯೋಜನೆಗಾಗಿ ಅವನ್ನು ಬದಲಿಸಬಹುದು. ಉದ್ಯಮ ನಿರ್ವಾಹಕರು ತಮ್ಮ ಬಳಕೆದಾರರಿಗೆ ಪೂರ್ವನಿಯೋಜಿತ ಸೆಟ್ಟಿಂಗ್‌ಗಳನ್ನು ಕಾನ್ಫಿಗರ್ ಮಾಡಲು ಮತ್ತು ಅವರು ಬದಲಿಸಬಹುದಾದ ಸೆಟ್ಟಿಂಗ್‌ಗಳನ್ನು ಮಿತಿಗೊಳಿಸಲು ಬಯಸಬಹುದು. ಪದರಯುಕ್ತ ಕಾನ್ಫಿಗರೇಶನ್ ಮತ್ತು ನಿರ್ವಹಿತ ಅವಶ್ಯಕತೆಗಳ ಮೂಲಕ Codex ಎರಡನ್ನೂ ಬೆಂಬಲಿಸುತ್ತದೆ.

ಕಾನ್ಫಿಗರೇಶನ್ ಆದ್ಯತೆ,⁠(ಹೊಸ ಕಿಟಕಿಯಲ್ಲಿ ತೆರೆಯುತ್ತದೆ) ವಿಭಾಗದಲ್ಲಿ ವಿವರಿಸಿದಂತೆ, Codex ಹಲವು config.toml ಫೈಲ್‌ಗಳ ಸೆಟ್ಟಿಂಗ್‌ಗಳನ್ನು ವಿಲೀನಗೊಳಿಸುತ್ತದೆ. ಕೋಷ್ಟಕಗಳನ್ನು ಎಲ್ಲಾ ಉಪಹಂತಗಳಲ್ಲೂ ವಿಲೀನಗೊಳಿಸಲಾಗುತ್ತದೆ. ಮೌಲ್ಯಗಳು ಸಂಘರ್ಷಿಸಿದಾಗ, ಹೆಚ್ಚಿನ ಆದ್ಯತೆಯ ಮೂಲದ ಮೌಲ್ಯ ಆಯ್ಕೆಯಾಗುತ್ತದೆ. ಅರೇಗಳನ್ನು ಸಂಪೂರ್ಣವಾಗಿ ಬದಲಿಸಲಾಗುತ್ತದೆ.

ಅದಕ್ಕಾಗಿಯೇ ಅನುಮತಿ ಪ್ರೊಫೈಲ್‌ಗಳು ಫೈಲ್‌ವ್ಯವಸ್ಥೆ ಪಥಗಳು ಮತ್ತು ನೆಟ್‌ವರ್ಕ್ ಡೊಮೇನ್‌ಗಳಿಗೆ ಕೋಷ್ಟಕಗಳನ್ನು ಬಳಸುತ್ತವೆ. ಒಂದು ತಂಡವು ತನ್ನ ಕಾನ್ಫಿಗರೇಶನ್‌ನಲ್ಲಿ ಪ್ರತ್ಯೇಕ ನಮೂದುಗಳನ್ನು ಸೇರಿಸಬಹುದು ಅಥವಾ ಬದಲಿಸಬಹುದು. ಸಂಸ್ಥೆಯ ಮೂಲ ಕಾನ್ಫಿಗರೇಶನ್‌ನ ಇತರ ಎಲ್ಲಾ ನಮೂದುಗಳ ಬದಲಾವಣೆಗಳು ಸ್ವಯಂಚಾಲಿತವಾಗಿ ಅದಕ್ಕೆ ಅನ್ವಯಿಸುತ್ತವೆ:

TOML

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

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

ಬಳಕೆದಾರರ ಕಾನ್ಫಿಗರೇಶನ್ ಆಯ್ಕೆಗಳನ್ನು ಮಿತಿಗೊಳಿಸಲು, ನಿರ್ವಾಹಕರು requirements.toml ಮೂಲಕ ನಿರ್ವಹಿತ ಅವಶ್ಯಕತೆಗಳನ್ನೂ⁠(ಹೊಸ ಕಿಟಕಿಯಲ್ಲಿ ತೆರೆಯುತ್ತದೆ) ಒದಗಿಸಬಹುದು. ಈ ಅವಶ್ಯಕತೆಗಳು ವ್ಯವಸ್ಥೆಯ ಫೈಲ್‌ಗಳು ಮತ್ತು ಕ್ಲೌಡ್ ಒದಗಿಸುವ ನೀತಿ ಸೇರಿದಂತೆ ಹಲವು ಮೂಲಗಳಿಂದ ಬರಬಹುದು. ಉದ್ಯಮ ಬಳಕೆದಾರರು ಆಯ್ಕೆ ಮಾಡಬಹುದಾದ ಅನುಮತಿ ಪ್ರೊಫೈಲ್‌ಗಳನ್ನು ಮಿತಿಗೊಳಿಸಲು allowed_permission_profiles ಸೂಚಿಸುವುದು ಒಂದು ಸಾಮಾನ್ಯ ಬಳಕೆ. ಉದಾಹರಣೆಗೆ, ನಿರ್ವಾಹಕರು ಈ ಕ್ಲೌಡ್ ಅವಶ್ಯಕತೆಗಳನ್ನು ಸೂಚಿಸಬಹುದು:

TOML

1
default_permissions = ":read-only"
2

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

/etc/codex/requirements.toml ನಲ್ಲಿನ ವ್ಯವಸ್ಥೆಯ ಅವಶ್ಯಕತೆಗಳಿಗಿಂತ ಕ್ಲೌಡ್ ಅವಶ್ಯಕತೆಗಳಿಗೆ ಆದ್ಯತೆ ಇರುತ್ತದೆ. ಹೀಗಾಗಿ ಆ ಫೈಲ್‌ನ ನಮೂದು, ಮೇಲಿನ ಸ್ಪಷ್ಟ ":danger-full-access" = false ಅನ್ನು ಮೀರಿಸಲಾಗದು. :workspace ಅನ್ನು ಸೂಚಿಸದೆ ಬಿಟ್ಟರೆ, ಮತ್ತೊಂದು ಅವಶ್ಯಕತೆಗಳ ಪದರ ಆ ನಮೂದು ಒದಗಿಸಬಹುದು. ಅಂತಿಮ ವಿಲೀನ ಕೋಷ್ಟಕದಲ್ಲಿ ನಮೂದು ಇಲ್ಲದ ಅಥವಾ false ಇರುವ ಪ್ರೊಫೈಲ್‌ಗಳು ಲಭ್ಯವಿರುವುದಿಲ್ಲ.

ಈ ಪ್ರತ್ಯೇಕತೆಯಿಂದ ಸಂಸ್ಥೆಗಳು ಮಿತಿಗಳನ್ನು ಜಾರಿಗೊಳಿಸಬಹುದು; ಬಳಕೆದಾರರು ಆ ಮಿತಿಗಳೊಳಗೆ ತಮ್ಮ ಕಾನ್ಫಿಗರೇಶನ್ ಹೊಂದಿಸಿಕೊಳ್ಳಬಹುದು. ಹೀಗೆ ದೊರೆತ ಅನುಮತಿ ಪ್ರೊಫೈಲ್‌ಗಳನ್ನು ಪೂರಕ ವ್ಯವಸ್ಥೆ ಬಳಸಬಹುದು ಅಥವಾ ನೇರವಾಗಿ ಆಜ್ಞೆಗೆ ಅನ್ವಯಿಸಬಹುದು. ಅದನ್ನು ಮುಂದೆ ನೋಡೋಣ.

codex sandbox ಆಜ್ಞೆ ಬಳಸುವುದು

Codex ಕಾನ್ಫಿಗರೇಶನ್‌ನಲ್ಲಿ ವ್ಯಾಖ್ಯಾನಿಸಿದ ಅನುಮತಿ ಪ್ರೊಫೈಲ್ ಅಡಿಯಲ್ಲಿ ಯಾವುದೇ ಆಜ್ಞೆ ಚಲಾಯಿಸಲು Codex 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 sandbox ಆಜ್ಞೆಯು ಏಜೆಂಟ್ ಸೆಷನ್‌ನಿಂದ ಸ್ವತಂತ್ರವಾಗಿ Codex ನ ಸ್ಯಾಂಡ್‌ಬಾಕ್ಸಿಂಗ್ ವ್ಯವಸ್ಥೆಯನ್ನು ಬಳಸಲು ಅವಕಾಶ ನೀಡುತ್ತದೆ. ನಿಮ್ಮದೇ ಉಪಕರಣಗಳು ಆರಂಭಿಸುವ ಆಜ್ಞೆಗಳನ್ನು ನಿರ್ಬಂಧಿಸಲು ಅದೇ ಕಾನ್ಫಿಗರೇಶನ್ ಭಾಷೆ ಮತ್ತು ಪ್ಲಾಟ್‌ಫಾರ್ಮ್-ನಿರ್ದಿಷ್ಟ ಜಾರಿ ವಿಧಾನ ಬಳಸಬಹುದು.

ಉದಾಹರಣೆ: MCP ಸರ್ವರ್ ಅನ್ನು ಸ್ಯಾಂಡ್‌ಬಾಕ್ಸ್‌ನಲ್ಲಿ ಚಲಾಯಿಸುವುದು

config.toml ನಲ್ಲಿ ಕಾನ್ಫಿಗರ್ ಮಾಡಲಾದ stdio MCP ಸರ್ವರ್ ಆರಂಭಿಸುವ ಆಜ್ಞೆಯನ್ನು ಸ್ಯಾಂಡ್‌ಬಾಕ್ಸ್‌ನಲ್ಲಿ ಚಲಾಯಿಸಲು Codex ಪೂರಕ ವ್ಯವಸ್ಥೆ ಪ್ರಯತ್ನಿಸುವುದಿಲ್ಲ. ಆ ಸರ್ವರ್‌ಗೆ ಯಾವ ಫೈಲ್‌ಗಳು ಅಥವಾ ನೆಟ್‌ವರ್ಕ್ ಸೇವೆಗಳು ಬೇಕೆಂದು Codex ವಿಶ್ವಾಸಾರ್ಹವಾಗಿ ಊಹಿಸಲಾಗದು. ಹೀಗಾಗಿ ಪೂರ್ವನಿಯೋಜಿತ ಸ್ಯಾಂಡ್‌ಬಾಕ್ಸ್ ಪ್ರೊಫೈಲ್ ಅನ್ವಯಿಸಿದರೆ, ಮಾನ್ಯ ಕಾನ್ಫಿಗರೇಶನ್ ಕೂಡ ಕೆಲಸ ಮಾಡದಿರಬಹುದು.

ಉದಾಹರಣೆಗೆ, Codex ಜೊತೆ ಬಳಸಲು @modelcontextprotocol/server-memory⁠(ಹೊಸ ಕಿಟಕಿಯಲ್ಲಿ ತೆರೆಯುತ್ತದೆ) MCP ಸರ್ವರ್ ಕಾನ್ಫಿಗರ್ ಮಾಡುವ ಪ್ರಮಾಣಿತ ವಿಧಾನ ಹೀಗಿದೆ:

TOML

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

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

ಈ npx ಆಜ್ಞೆ ಸ್ಯಾಂಡ್‌ಬಾಕ್ಸ್ ಇಲ್ಲದೆ ಚಲಿಸುವುದರಿಂದ, Codex ಚಲಾಯಿಸುವ ಬಳಕೆದಾರರಷ್ಟೇ ಅನುಮತಿಗಳೊಂದಿಗೆ ಫೈಲ್ ಬರೆಯಬಹುದು, ನೆಟ್‌ವರ್ಕ್ ವಿನಂತಿ ಮಾಡಬಹುದು. ಇದು ಅಗತ್ಯಕ್ಕಿಂತ ಹೆಚ್ಚಿನ ಅನುಮತಿ ನೀಡುತ್ತದೆ. ಇದನ್ನು ನಿರ್ಬಂಧಿಸಲು memory-mcp ಎಂಬ ಅನುಮತಿ ಪ್ರೊಫೈಲ್ ವ್ಯಾಖ್ಯಾನಿಸಬಹುದು. ಬಳಿಕ ಮೂಲ npx ಆಜ್ಞೆಯನ್ನು codex sandbox --permission-profile memory-mcp ಮೂಲಕ ಚಲಾಯಿಸಿ, ಸರ್ವರ್ ಬರೆಯಬಹುದಾದ ಸ್ಥಳಗಳನ್ನು ಮಿತಿಗೊಳಿಸಬಹುದು ಮತ್ತು ನೆಟ್‌ವರ್ಕ್ ಪ್ರವೇಶ ತಡೆಯಬಹುದು:

TOML

1
[permissions.memory-mcp.filesystem]
2
# Allow broad reads for Node.js/npm dependencies and configuration.
3
":root" = "read"
4
"~/.npm" = "write"
5
"~/mcp-data" = "write"
6

7
[permissions.memory-mcp.network]
8
enabled = false
9

10
[mcp_servers.memory]
11
command = "codex"
12
args = [
13
"sandbox",
14
"--permission-profile",
15
"memory-mcp",
16
"--",
17
"npx",
18
"--offline",
19
"@modelcontextprotocol/server-memory@1.0.0"
20
]
21

22
[mcp_servers.memory.env]
23
MEMORY_FILE_PATH = "~/mcp-data/memory.jsonl"

ಸರ್ವರ್ ಆರಂಭಿಸುವ ಮೊದಲು, ಅದರ ದತ್ತಾಂಶ ಡೈರೆಕ್ಟರಿ ರಚಿಸಿ, ನಿಗದಿತ ಆವೃತ್ತಿಯ ಪ್ಯಾಕೇಜ್ ಅನ್ನು npm ಕ್ಯಾಶ್‌ನಲ್ಲಿ ಇರಿಸಿ. ಇದರಿಂದ ನೆಟ್‌ವರ್ಕ್ ಪ್ರವೇಶ ನಿಷ್ಕ್ರಿಯಗೊಳಿಸುವ ಪ್ರೊಫೈಲ್ ಅಡಿಯಲ್ಲಿ npx --offline ಸರ್ವರ್ ಆರಂಭಿಸಬಹುದು:

Bash

1
# The sandbox can write to this folder, but it cannot create it.
2
mkdir -p ~/mcp-data
3

4
# Installing the MCP server requires network access.
5
npx -y --package=@modelcontextprotocol/server-memory@1.0.0 -c true

ಪ್ಯಾಕೇಜ್ ಕ್ಯಾಶ್‌ನಲ್ಲಿದ್ದ ಬಳಿಕ, ನೆಟ್‌ವರ್ಕ್ ಪ್ರವೇಶವಿಲ್ಲದೆ Codex ಮೆಮೊರಿ ಸರ್ವರ್ ಆರಂಭಿಸಬಹುದು. ಬರೆಯುವಿಕೆ npm ಕ್ಯಾಶ್ ಮತ್ತು ಸರ್ವರ್‌ನ ದತ್ತಾಂಶ ಡೈರೆಕ್ಟರಿಗೆ ಸೀಮಿತವಾಗಿರುತ್ತದೆ.

Codex ಸ್ಯಾಂಡ್‌ಬಾಕ್ಸ್ ಅಳವಡಿಕೆ

ಸ್ಯಾಂಡ್‌ಬಾಕ್ಸ್ ಅಳವಡಿಕೆಯು ಅನುಮತಿ ಪ್ರೊಫೈಲ್ ಅನ್ನು ಕಾರ್ಯವ್ಯವಸ್ಥೆ ಜಾರಿಗೊಳಿಸುವ ನಿರ್ಬಂಧಗಳಾಗಿ ಪರಿವರ್ತಿಸುತ್ತದೆ. ನೆಟ್‌ವರ್ಕ್ ಪ್ರಾಕ್ಸಿಯ ಮೂಲ ವಿನಂತಿ ನಿರ್ವಹಣೆ ಮತ್ತು ನೀತಿ ತರ್ಕವು ಮೂರೂ ಪ್ರಮುಖ ಕಾರ್ಯವ್ಯವಸ್ಥೆಗಳಲ್ಲಿ ಒಂದೇ ಆಗಿರುತ್ತದೆ. ಆದರೆ ಪ್ರಾಕ್ಸಿ ಸೆಟಪ್ ಮತ್ತು ಸ್ಯಾಂಡ್‌ಬಾಕ್ಸ್‌ನೊಂದಿಗಿನ ಸಂಯೋಜನೆ ಆಯಾ ಕಾರ್ಯವ್ಯವಸ್ಥೆಗೆ ನಿರ್ದಿಷ್ಟವಾಗಿರುತ್ತವೆ. ಮೊದಲು ಹಂಚಿಕೆಯ ಪ್ರಾಕ್ಸಿಯನ್ನು, ನಂತರ macOS, Linux ಮತ್ತು Windows ಅಳವಡಿಕೆಗಳನ್ನು ಪರಿಶೀಲಿಸೋಣ.

ನೆಟ್‌ವರ್ಕ್ ಪ್ರಾಕ್ಸಿ

ಅನುಮತಿ ಪ್ರೊಫೈಲ್‌ನ ನೆಟ್‌ವರ್ಕ್ ನಿರ್ಬಂಧಗಳನ್ನು ಜಾರಿಗೊಳಿಸಲು, ಪೂರಕ ವ್ಯವಸ್ಥೆ ನೆಟ್‌ವರ್ಕ್ ಪ್ರಾಕ್ಸಿ ಆರಂಭಿಸುತ್ತದೆ. ಬಾಹ್ಯ ಹೋಸ್ಟ್‌ಗಳಿಗೆ ನೇರ ಸಂಪರ್ಕ ತಡೆಯುತ್ತಲೇ ಪ್ರಾಕ್ಸಿಗೆ ಸಂಪರ್ಕಿಸಲು ಅವಕಾಶ ನೀಡುವಂತೆ ಸ್ಯಾಂಡ್‌ಬಾಕ್ಸ್ ಕಾನ್ಫಿಗರ್ ಮಾಡುತ್ತದೆ. ಪ್ರತಿ ವಿನಂತಿಯನ್ನು ಮುಂದಕ್ಕೆ ಕಳುಹಿಸಬೇಕೇ ಎಂದು ನಿರ್ಧರಿಸಲು, ಪ್ರಾಕ್ಸಿ ಅದನ್ನು ಪ್ರೊಫೈಲ್‌ನ ಡೊಮೇನ್ ನಿಯಮಗಳೊಂದಿಗೆ ಪರಿಶೀಲಿಸುತ್ತದೆ.

Codex ರಿಪೊಸಿಟರಿಯಲ್ಲಿ ನೆಟ್‌ವರ್ಕ್ ಪ್ರಾಕ್ಸಿಯನ್ನು codex-network-proxy⁠(ಹೊಸ ಕಿಟಕಿಯಲ್ಲಿ ತೆರೆಯುತ್ತದೆ) ಕ್ರೇಟ್‌ನಲ್ಲಿ ಅಳವಡಿಸಲಾಗಿದೆ. ಪೂರಕ ವ್ಯವಸ್ಥೆ ಅದನ್ನು ಲೈಬ್ರರಿಯಾಗಿ ಬಳಸುತ್ತದೆ; ಅದನ್ನು ಸ್ವತಂತ್ರ CLI ಆಗಿಯೂ⁠(ಹೊಸ ಕಿಟಕಿಯಲ್ಲಿ ತೆರೆಯುತ್ತದೆ) ನಿರ್ಮಿಸಬಹುದು. ಸಕ್ರಿಯಗೊಳಿಸಿದಾಗ, codex-network-proxy ಪೂರ್ವನಿಯೋಜಿತವಾಗಿ HTTP ಪ್ರಾಕ್ಸಿ ಮತ್ತು SOCKS5 ಪ್ರಾಕ್ಸಿ ಎರಡನ್ನೂ ಆರಂಭಿಸುತ್ತದೆ. ಸ್ಯಾಂಡ್‌ಬಾಕ್ಸ್ ಆರಂಭಿಸಿದ ಪ್ರಕ್ರಿಯೆಗೆ ಈ ಪ್ರಾಕ್ಸಿ ವಿಳಾಸಗಳನ್ನು ಪರಿಸರ ಚರಗಳ ಮೂಲಕ ತಿಳಿಸಲಾಗುತ್ತದೆ. HTTP_PROXY, HTTPS_PROXY ಮತ್ತು ALL_PROXY ನಂತಹ ಪ್ರಮಾಣಿತ ಪರಿಸರ ಚರಗಳ ಜೊತೆಗೆ, ಹಲವು ಪರಿಚಿತ ಅಪ್ಲಿಕೇಶನ್-ನಿರ್ದಿಷ್ಟ ಪರಿಸರ ಚರಗಳನ್ನೂ⁠(ಹೊಸ ಕಿಟಕಿಯಲ್ಲಿ ತೆರೆಯುತ್ತದೆ) (ಉದಾಹರಣೆಗೆ PIP_PROXY) ಸೇರಿಸಲಾಗುತ್ತದೆ. ಎಲ್ಲಾ ಪ್ರೋಗ್ರಾಂಗಳೂ ಈ ಪರಿಸರ ಚರಗಳನ್ನು ಪಾಲಿಸುವುದಿಲ್ಲ ಎಂಬುದು ನಿಜ. ಪ್ರೋಗ್ರಾಂ ಬಾಹ್ಯ ಹೋಸ್ಟ್‌ಗೆ ನೇರ ಸಂಪರ್ಕಿಸಲು ಪ್ರಯತ್ನಿಸಿದರೆ, ಕೆಳಗಿನ ಪ್ಲಾಟ್‌ಫಾರ್ಮ್-ನಿರ್ದಿಷ್ಟ ವಿಭಾಗಗಳಲ್ಲಿ ವಿವರಿಸಿದಂತೆ, ಕಾರ್ಯವ್ಯವಸ್ಥೆಯ ಸ್ಯಾಂಡ್‌ಬಾಕ್ಸ್ ನಿರ್ಬಂಧಗಳು ಅದನ್ನು ತಡೆಯುತ್ತವೆ.

ಅನುಮತಿ ಪ್ರೊಫೈಲ್‌ನಲ್ಲಿ ವ್ಯಾಖ್ಯಾನಿಸಿದ ನೆಟ್‌ವರ್ಕ್ ನಿರ್ಬಂಧಗಳನ್ನು ಜಾರಿಗೊಳಿಸುವ ಹೊಣೆ ನೆಟ್‌ವರ್ಕ್ ಪ್ರಾಕ್ಸಿಯದು. ಉದಾಹರಣೆಗೆ, ಹಿಂದೆ ತೋರಿಸಿದ dev ಪ್ರೊಫೈಲ್ *.openai.com ಗೆ ವಿನಂತಿಗಳನ್ನು ಅನುಮತಿಸುತ್ತದೆ; evil.example ಗೆ ವಿನಂತಿಗಳನ್ನು ಸ್ಪಷ್ಟವಾಗಿ ನಿರಾಕರಿಸುತ್ತದೆ. ವಿನಂತಿಯ ಡೊಮೇನ್ ಯಾವುದೇ ಅನುಮತಿ ಅಥವಾ ನಿರಾಕರಣೆ ನಿಯಮಕ್ಕೆ ಹೊಂದಿಕೆಯಾಗದಿದ್ದರೆ, ಪ್ರಾಕ್ಸಿ ವಿನಂತಿಯನ್ನು ತಾತ್ಕಾಲಿಕವಾಗಿ ತಡೆಹಿಡಿದು, ಅನುಮೋದನೆಗಾಗಿ ಪೂರಕ ವ್ಯವಸ್ಥೆಗೆ ವಹಿಸಬಹುದು. ಶೆಲ್ ಆಜ್ಞೆಯ ಉದಾಹರಣೆಯಂತೆ, Codex ನೇರವಾಗಿ ಬಳಕೆದಾರರನ್ನು ಕೇಳಬಹುದು ಅಥವಾ ವಿನಂತಿಯನ್ನು ಸ್ವಯಂಚಾಲಿತ ಪರಿಶೀಲನೆಗೆ⁠(ಹೊಸ ಕಿಟಕಿಯಲ್ಲಿ ತೆರೆಯುತ್ತದೆ) ಕಳುಹಿಸಬಹುದು. ನಿರ್ಧಾರ ದೊರೆತ ಬಳಿಕ, ಪ್ರಾಕ್ಸಿ ವಿನಂತಿ ಮುಂದುವರಿಯಲು ಅವಕಾಶ ನೀಡುತ್ತದೆ ಅಥವಾ ದೋಷ ಪ್ರತಿಕ್ರಿಯೆಯೊಂದಿಗೆ ನಿರಾಕರಿಸುತ್ತದೆ.

ಇಲ್ಲಿ ಕ್ರಮ ಮುಖ್ಯ: DNS ಹುಡುಕಾಟ ಕೂಡ ಹೋಸ್ಟ್ ಹೆಸರಿನಲ್ಲಿ ಎನ್‌ಕೋಡ್ ಮಾಡಿದ ಮಾಹಿತಿ ಸೋರಿಕೆಗೆ ಕಾರಣವಾಗಬಹುದು. ಹೀಗಾಗಿ ಅನುಮತಿ ಅಥವಾ ಅನುಮೋದನೆ ಇದೆ ಎಂದು ನಿರ್ಧರಿಸಿದ ಬಳಿಕವೇ, ಪ್ರಾಕ್ಸಿ ವಿನಂತಿಸಿದ ಹೋಸ್ಟ್ ಹೆಸರಿನ ವಿಳಾಸ ಪತ್ತೆಹಚ್ಚುತ್ತದೆ. ವ್ಯಾಪಕ ವೈಲ್ಡ್‌ಕಾರ್ಡ್ ನಿಯಮಗಳು ಅಥವಾ DNS ಸೇವೆಗಳ ಪ್ರವೇಶವು DNS ಆಧಾರಿತ ದತ್ತಾಂಶ ಕಳವಿಗೆ ಇನ್ನೂ ಅವಕಾಶ ನೀಡಬಹುದು ಎಂಬುದನ್ನು ಗಮನಿಸಿ.

macOS

macOS ನಲ್ಲಿ, Codex Seatbelt⁠(ಹೊಸ ಕಿಟಕಿಯಲ್ಲಿ ತೆರೆಯುತ್ತದೆ) ಬಳಸುತ್ತದೆ. ಇದು Apple ನ ಕರ್ನಲ್ ಜಾರಿಗೊಳಿಸುವ ಸ್ಯಾಂಡ್‌ಬಾಕ್ಸಿಂಗ್ ವ್ಯವಸ್ಥೆ. Seatbelt ನೀತಿಗಳನ್ನು Sandbox Profile Language (SBPL) ನಲ್ಲಿ ಬರೆಯಲಾಗುತ್ತದೆ. ಇದು ಸ್ಯಾಂಡ್‌ಬಾಕ್ಸ್ ನಿರ್ಬಂಧಗಳನ್ನು ವಿವರಿಸಲು ಬಳಸುವ Scheme ಆಧಾರಿತ ಭಾಷೆ. Codex, macOS ನ /usr/bin/sandbox-exec ಆಜ್ಞೆಯ ಮೂಲಕ Seatbelt ಅನ್ನು ಕರೆಯುತ್ತದೆ. codex sandbox ನಂತೆಯೇ, ಇದು ಮೊದಲು ಸ್ಯಾಂಡ್‌ಬಾಕ್ಸ್ ವಿವರಿಸುವ ಆಯ್ಕೆಗಳನ್ನು, ನಂತರ ಚಲಾಯಿಸಬೇಕಾದ ಆಜ್ಞೆಯನ್ನು ಸ್ವೀಕರಿಸುತ್ತದೆ:

Bash

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

PROFILE ಎಂಬುದು ಸ್ಯಾಂಡ್‌ಬಾಕ್ಸ್ ಕಾನ್ಫಿಗರ್ ಮಾಡುವ ನಮೂದುಗಳನ್ನು ಒಳಗೊಂಡ SBPL ಸ್ಟ್ರಿಂಗ್. ಉದಾಹರಣೆಗೆ, ಕೆಳಗಿನ SBPL ತುಣುಕು ಸ್ಯಾಂಡ್‌ಬಾಕ್ಸ್ ನೀತಿಯ ಅಡಿಯಲ್ಲಿ /dev/null ಮತ್ತು /dev/zero ಅನ್ನು ಓದಲು ಮತ್ತು ಬರೆಯಲು ಅವಕಾಶ ನೀಡುತ್ತದೆ:

Scheme

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

ಸ್ಯಾಂಡ್‌ಬಾಕ್ಸ್ ಕರೆಯ ಭಾಗವಾಗಿ ನೆಟ್‌ವರ್ಕ್ ಪ್ರಾಕ್ಸಿ ಸಕ್ರಿಯವಾದಾಗ, ಸಂಪರ್ಕಗಳನ್ನು ಸೂಕ್ತ ಸ್ಥಳೀಯ ಪೋರ್ಟ್‌ಗಳಿಗೆ ಸೀಮಿತಗೊಳಿಸಲು ಈ ರೀತಿಯ ನಿಯಮಗಳನ್ನು ಪ್ರೊಫೈಲ್‌ಗೆ ಸೇರಿಸಲಾಗುತ್ತದೆ:

Scheme

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

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


Codex ನ ಮೂಲ ಪ್ರೊಫೈಲ್
(deny default) ನಿಂದ ಆರಂಭವಾಗುತ್ತದೆ. ಹೀಗಾಗಿ ಸ್ಪಷ್ಟ ಅನುಮತಿ ನೀಡದ ಹೊರತು ಹೊರಹೋಗುವ ಸಂಪರ್ಕಗಳು ನಿರ್ಬಂಧಿತವಾಗಿರುತ್ತವೆ.

ಕೊನೆಯದಾಗಿ, SBPL ನಲ್ಲಿ (param) ಬಳಸಿ ಪ್ಲೇಸ್‌ಹೋಲ್ಡರ್‌ಗಳನ್ನು ಸೇರಿಸಬಹುದು:

Scheme

1
; Pass -DWRITABLE_ROOT_0=/path/to/dir to specify a folder that cannot be removed.
2
(deny file-write-unlink
3
(require-all
4
(literal (param "WRITABLE_ROOT_0"))
5
(vnode-type DIRECTORY)))

ಅವುಗಳನ್ನು sandbox-exec ಗೆ ನೀಡಿದ -Dkey=value ಆಯ್ಕೆಗಳ ಮೌಲ್ಯಗಳಿಂದ ತುಂಬಲಾಗುತ್ತದೆ.

ತನ್ನ ಸ್ಯಾಂಡ್‌ಬಾಕ್ಸ್ API ಅಳವಡಿಸಲು, Codex ಮೂಲ ನೀತಿಯಿಂದ⁠(ಹೊಸ ಕಿಟಕಿಯಲ್ಲಿ ತೆರೆಯುತ್ತದೆ) ಆರಂಭಿಸಿ sandbox-exec ಗೆ ಆರ್ಗ್ಯುಮೆಂಟ್‌ಗಳ ಪಟ್ಟಿ ರೂಪಿಸುತ್ತದೆ⁠(ಹೊಸ ಕಿಟಕಿಯಲ್ಲಿ ತೆರೆಯುತ್ತದೆ). ಬಳಿಕ permission_profile ಮತ್ತು ಇತರ ಸಂದರ್ಭವನ್ನು ಬಳಸಿ ಅದನ್ನು ತಿದ್ದಿ, ಸಂಪೂರ್ಣ Seatbelt ಪ್ರೊಫೈಲ್ ರಚಿಸುತ್ತದೆ. ಹೀಗೆ ದೊರೆತ ಪ್ರೊಫೈಲ್ ಮತ್ತು ಅದರ ಜೊತೆಗಿನ -D ಆರ್ಗ್ಯುಮೆಂಟ್‌ಗಳು Seatbelt ಜಾರಿಗೊಳಿಸುವ ನಿರ್ಬಂಧಗಳನ್ನು ಕಾನ್ಫಿಗರ್ ಮಾಡುತ್ತವೆ. ನೆಟ್‌ವರ್ಕ್ ಪ್ರಾಕ್ಸಿ ಹೆಚ್ಚುವರಿ ನೆಟ್‌ವರ್ಕ್ ನಿಯಮಗಳನ್ನು ಜಾರಿಗೊಳಿಸುತ್ತದೆ. ಆರ್ಗ್ಯುಮೆಂಟ್‌ಗಳ ಸಂಪೂರ್ಣ ಪಟ್ಟಿ ಸಿದ್ಧವಾದ ಬಳಿಕ, sandbox-exec ಕರೆಯುವುದು ಸರಳ.

Apple ಈ ಭಾಷೆಯ ಮೂರನೇ ಪಕ್ಷದ ಬಳಕೆಗೆ ದಸ್ತಾವೇಜು ಒದಗಿಸದ ಕಾರಣ, ಸರಿಯಾದ SBPL ರಚಿಸುವುದು ಸವಾಲಿನ ಕೆಲಸ. ವಾಸ್ತವವಾಗಿ, man sandbox-exec ನಲ್ಲಿ The sandbox-exec command is DEPRECATED ಎಂದು ಹೇಳಲಾಗಿದೆ (man 3 sandbox_init ನಲ್ಲಿ ದಾಖಲಿಸಿದ sandbox_init() ಲೈಬ್ರರಿ ಫಂಕ್ಷನ್ ಕೂಡ ಬಳಕೆಯಿಂದ ಹೊರಗುಳಿಸಲಾಗಿದೆ). ಬಳಕೆಯಿಂದ ಹೊರಗುಳಿಸಿದ ಎಚ್ಚರಿಕೆಯಿದ್ದರೂ, macOS ಇನ್ನೂ /usr/share/sandbox ನಲ್ಲಿ Seatbelt ಪ್ರೊಫೈಲ್‌ಗಳನ್ನು ಒದಗಿಸುತ್ತದೆ. Google Chrome ಮತ್ತು Chromium ಸೇರಿದಂತೆ⁠(ಹೊಸ ಕಿಟಕಿಯಲ್ಲಿ ತೆರೆಯುತ್ತದೆ) ಮೂರನೇ ಪಕ್ಷದ ಸಾಫ್ಟ್‌ವೇರ್‌ಗಳು Seatbelt ಅವಲಂಬಿಸುವುದನ್ನು ಮುಂದುವರಿಸಿವೆ. ಹೀಗಾಗಿ ಸದ್ಯಕ್ಕೆ Seatbelt ಬಳಕೆಯನ್ನು ಮುಂದುವರಿಸುವ ಯೋಜನೆ ನಮ್ಮದು.

Linux

Linux ನಲ್ಲಿ ಸ್ಯಾಂಡ್‌ಬಾಕ್ಸ್ ರಚಿಸಲು Codex ಎರಡು ವ್ಯವಸ್ಥೆಗಳನ್ನು ಒಟ್ಟಿಗೆ ಬಳಸುತ್ತದೆ: ಪ್ರತ್ಯೇಕ ಪರಿಸರ ನಿರ್ಮಿಸುವ ಆಜ್ಞಾ-ಸಾಲಿನ ಉಪಕರಣ bubblewrap⁠(ಹೊಸ ಕಿಟಕಿಯಲ್ಲಿ ತೆರೆಯುತ್ತದೆ) (bwrap) ಮತ್ತು ಸಿಸ್ಟಮ್ ಕರೆಗಳನ್ನು ಫಿಲ್ಟರ್ ಮಾಡುವ Linux ಕರ್ನಲ್ ವ್ಯವಸ್ಥೆ seccomp-bpf⁠(ಹೊಸ ಕಿಟಕಿಯಲ್ಲಿ ತೆರೆಯುತ್ತದೆ). codex-linux-sandbox ಎಂಬ ಆಂತರಿಕ ಸಹಾಯಕ ಸೆಟಪ್ ಅನ್ನು ಸಮನ್ವಯಗೊಳಿಸುತ್ತದೆ. macOS ನ sandbox-exec ನಂತೆಯೇ, ಇದು ಮೊದಲು ಸ್ಯಾಂಡ್‌ಬಾಕ್ಸ್ ಕಾನ್ಫಿಗರೇಶನ್, ಬಳಿಕ ಚಲಾಯಿಸಬೇಕಾದ ಆಜ್ಞೆಯನ್ನು ಸ್ವೀಕರಿಸುತ್ತದೆ:

Bash

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

ಫೈಲ್‌ವ್ಯವಸ್ಥೆ ಪ್ರತ್ಯೇಕೀಕರಣ ಅಥವಾ ಪ್ರಾಕ್ಸಿ ಮೂಲಕ ಮಾರ್ಗನಿರ್ದೇಶನ ಅಗತ್ಯವಾದಾಗ, ಆರಂಭಿಕ ಸ್ಯಾಂಡ್‌ಬಾಕ್ಸ್ ಪರಿಸರ ರಚಿಸಲು codex-linux-sandbox, bwrap ಅನ್ನು ಕರೆಯುತ್ತದೆ. ನಂತರ bwrap ಅದರೊಳಗೆ codex-linux-sandbox --apply-seccomp-then-exec ಅನ್ನು ಆರಂಭಿಸುತ್ತದೆ. ಈ ಎರಡನೇ ಕರೆಯು ಬಳಕೆದಾರರ ಆಜ್ಞೆ ಚಲಾಯಿಸುವ ಮೊದಲು ಹೆಚ್ಚುವರಿ ನಿರ್ಬಂಧಗಳನ್ನು ಅನ್ವಯಿಸಲು seccomp-bpf ಬಳಸುತ್ತದೆ.

ಆರಂಭಿಕ ಸ್ಯಾಂಡ್‌ಬಾಕ್ಸ್ ಪರಿಸರ ನಿರ್ಮಿಸಲು, Codex bubblewrap ಬಳಸಿ ಪ್ರತ್ಯೇಕ ಮೌಂಟ್ ನೇಮ್‌ಸ್ಪೇಸ್‌ನಲ್ಲಿ ಫೈಲ್‌ವ್ಯವಸ್ಥೆಯ ನೋಟ ರಚಿಸುತ್ತದೆ. ಅದು ಅನುಮತಿ ಪ್ರೊಫೈಲ್‌ನ ಫೈಲ್‌ವ್ಯವಸ್ಥೆ ನಿಯಮಗಳನ್ನು ಪ್ರತಿಬಿಂಬಿಸುತ್ತದೆ. ಇದು ಸ್ಯಾಂಡ್‌ಬಾಕ್ಸ್ ಅಳವಡಿಕೆಗೆ ಮೂಲಭೂತವಾದ್ದರಿಂದ, ಬಳಕೆದಾರರು ಸ್ಥಾಪಿಸದಿದ್ದರೆ ಬಳಸಲು Codex ತನ್ನದೇ bwrap ಪ್ರತಿಯನ್ನು ಒಳಗೊಂಡಿರುತ್ತದೆ. ಆದರೆ PATH ನಲ್ಲಿ ದೊರೆತರೆ, bwrap⁠(ಹೊಸ ಕಿಟಕಿಯಲ್ಲಿ ತೆರೆಯುತ್ತದೆ) ನ ಹೊಂದಾಣಿಕೆಯ ಸ್ಥಾಪನೆಗೆ ಆದ್ಯತೆ ನೀಡುತ್ತದೆ⁠(ಹೊಸ ಕಿಟಕಿಯಲ್ಲಿ ತೆರೆಯುತ್ತದೆ). ಪ್ರಾಯೋಗಿಕವಾಗಿ, ಕೆಲವು Linux ವಿತರಣೆಗಳು ಬಳಕೆದಾರ ನೇಮ್‌ಸ್ಪೇಸ್‌ಗಳ ಪ್ರವೇಶವನ್ನು ಪೂರ್ವನಿಯೋಜಿತವಾಗಿ ನಿಷ್ಕ್ರಿಯಗೊಳಿಸುತ್ತವೆ⁠(ಹೊಸ ಕಿಟಕಿಯಲ್ಲಿ ತೆರೆಯುತ್ತದೆ), ಆದರೆ ವ್ಯವಸ್ಥೆಯ bwrap ಗೆ ವಿನಾಯಿತಿ ನೀಡುತ್ತವೆ.

sandbox-exec ನಂತೆಯೇ, bwrap ಮೊದಲು ಸ್ಯಾಂಡ್‌ಬಾಕ್ಸ್ ಕಾನ್ಫಿಗರೇಶನ್, ಬಳಿಕ ಅದರೊಳಗೆ ಚಲಾಯಿಸಬೇಕಾದ ಆಜ್ಞೆಯನ್ನು ಸ್ವೀಕರಿಸುತ್ತದೆ. SBPL ನಂತಹ ವಿಶೇಷ ಕಾನ್ಫಿಗರೇಶನ್ ಭಾಷೆಗೆ ಬದಲಾಗಿ, bwrap ಪ್ರತ್ಯೇಕ ಫ್ಲ್ಯಾಗ್‌ಗಳನ್ನು ಬಳಸುತ್ತದೆ. ಫೈಲ್‌ವ್ಯವಸ್ಥೆಯ ನೋಟ ರಚಿಸಲು Codex ಈ ಆಯ್ಕೆಗಳನ್ನು ಬಳಸುತ್ತದೆ:

  • ಬರೆಯಬಹುದಾದ ಫೈಲ್ ಅಥವಾ ಡೈರೆಕ್ಟರಿ ಸೂಚಿಸಲು --bind

  • ಓದಲು ಮಾತ್ರ ಅವಕಾಶವಿರುವ ಫೈಲ್ ಅಥವಾ ಡೈರೆಕ್ಟರಿ ಸೂಚಿಸಲು --ro-bind

  • DIR ಗೆ ಪ್ರವೇಶ ನಿರಾಕರಿಸಲು --perms 000 --tmpfs DIR --remount-ro DIR

  • FILE ಗೆ ಪ್ರವೇಶ ನಿರಾಕರಿಸಲು --perms 000 --ro-bind-data FD FILE (ಇಲ್ಲಿ FD ಎಂದರೆ /dev/null ಗೆ ತೆರೆದಿರುವ ಫೈಲ್ ಡಿಸ್ಕ್ರಿಪ್ಟರ್)

ಈ ಆಯ್ಕೆಗಳ ಮೂಲಕ ನಿರಾಕರಣೆ ಗ್ಲಾಬ್‌ಗಳನ್ನು ಅನ್ವಯಿಸಲು, ಪ್ರತಿ ಆಜ್ಞೆ ಆರಂಭಿಸುವ ಮೊದಲು Codex ಅವುಗಳನ್ನು ನಿರ್ದಿಷ್ಟ ಪಥಗಳಾಗಿ ವಿಸ್ತರಿಸುತ್ತದೆ. ಹೊಸದಾಗಿ ಹೊಂದಿಕೆಯಾಗುವ ಪಥಗಳು ಆ ಆಜ್ಞೆಯ ಸ್ಯಾಂಡ್‌ಬಾಕ್ಸ್ ನಿರ್ಬಂಧಗಳಿಗೆ ಸ್ವಯಂಚಾಲಿತವಾಗಿ ಸೇರುವುದಿಲ್ಲ.

ಹೋಸ್ಟ್‌ನ ಇತರ ಸಂಪನ್ಮೂಲಗಳನ್ನು ಸ್ಯಾಂಡ್‌ಬಾಕ್ಸ್ ಪ್ರವೇಶಿಸದಂತೆ ತಡೆಯಲು Codex --unshare-ipc ಮತ್ತು --unshare-pid ಆಯ್ಕೆಗಳನ್ನೂ ಸೂಚಿಸುತ್ತದೆ. ಹೀಗಾಗಿ bubblewrap ಪರಿಣಾಮವು ಫೈಲ್ ಗೋಚರತೆಗೆ ಮಾತ್ರ ಸೀಮಿತವಲ್ಲ.

bubblewrap ಬಳಸುವಾಗ, ನೆಟ್‌ವರ್ಕ್ ನಿಷ್ಕ್ರಿಯವಾಗಿದ್ದರೆ ಅಥವಾ ಸಂಪರ್ಕಗಳು ನೆಟ್‌ವರ್ಕ್ ಪ್ರಾಕ್ಸಿ ಮೂಲಕವೇ ಹೋಗಬೇಕಿದ್ದರೆ Codex --unshare-net ನೀಡುತ್ತದೆ. ಇದು ಸ್ಯಾಂಡ್‌ಬಾಕ್ಸ್‌ಗೆ ಹೊಸ ನೆಟ್‌ವರ್ಕ್ ನೇಮ್‌ಸ್ಪೇಸ್ ರಚಿಸುತ್ತದೆ. ನಂತರ ಆಜ್ಞೆಗೆ ಲಭ್ಯವಿರುವ ನೆಟ್‌ವರ್ಕ್ ಸಿಸ್ಟಮ್ ಕರೆಗಳು ಮತ್ತು ಸಾಕೆಟ್ ಕುಟುಂಬಗಳಿಗೆ ಹೆಚ್ಚುವರಿ ನಿರ್ಬಂಧ ಅನ್ವಯಿಸಲು seccomp-bpf ಬಳಸುತ್ತೇವೆ.


ನಿರ್ದಿಷ್ಟವಾಗಿ,
seccompiler ಕ್ರೇಟ್⁠(ಹೊಸ ಕಿಟಕಿಯಲ್ಲಿ ತೆರೆಯುತ್ತದೆ) ಬಳಸಿ ಅಪೇಕ್ಷಿತ ಫಿಲ್ಟರ್‌ಗಳ ಆಧಾರದಲ್ಲಿ ಚಾಲನೆಯ ವೇಳೆಯೇ BPF ಪ್ರೋಗ್ರಾಂ ಕಂಪೈಲ್ ಮಾಡುತ್ತೇವೆ⁠(ಹೊಸ ಕಿಟಕಿಯಲ್ಲಿ ತೆರೆಯುತ್ತದೆ). ನಂತರ ಅದನ್ನು ಸ್ಯಾಂಡ್‌ಬಾಕ್ಸ್‌ನ ಲಾಂಚರ್ ಪ್ರಕ್ರಿಯೆಗೆ ಅನ್ವಯಿಸುತ್ತೇವೆ. ಹೀಗಾಗಿ ಇಡೀ ಪ್ರಕ್ರಿಯಾ ವೃಕ್ಷಕ್ಕೆ ನಿರ್ಬಂಧಗಳು ವರ್ಗವಾಗುತ್ತವೆ. ಆದ್ದರಿಂದ bwrap ಬಳಕೆದಾರರ ಆಜ್ಞೆಯನ್ನು ನೇರವಾಗಿ ಚಲಾಯಿಸದೆ, ತನ್ನ ಕಾನ್ಫಿಗರೇಶನ್ ಆರ್ಗ್ಯುಮೆಂಟ್‌ಗಳು ಮತ್ತು ಬಳಿಕ ಬಳಕೆದಾರರ ಆಜ್ಞೆಯೊಂದಿಗೆ codex-linux-sandbox ಲಾಂಚರ್ ಚಲಾಯಿಸುತ್ತದೆ:

Bash

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

ಉನ್ನತ ಸವಲತ್ತುಗಳಿಲ್ಲದೆ seccomp ಫಿಲ್ಟರ್‌ಗಳನ್ನು ಅನ್ವಯಿಸಲು, ಲಾಂಚರ್ Linux ನ no_new_privs ಫ್ಲ್ಯಾಗ್ ಹೊಂದಿಸುತ್ತದೆ⁠(ಹೊಸ ಕಿಟಕಿಯಲ್ಲಿ ತೆರೆಯುತ್ತದೆ). ಈ ಫ್ಲ್ಯಾಗ್ ಚೈಲ್ಡ್ ಪ್ರಕ್ರಿಯೆಗಳಿಗೆ ವರ್ಗವಾಗುತ್ತದೆ. ಅವು setuid ಕಾರ್ಯಗತ ಫೈಲ್‌ನಂತಹ ಮತ್ತೊಂದು ಪ್ರೋಗ್ರಾಂ ಚಲಾಯಿಸುವಾಗ ಹೆಚ್ಚುವರಿ ಸವಲತ್ತು ಪಡೆಯುವುದನ್ನು ಇದು ತಡೆಯುತ್ತದೆ.

seccomp ಫಿಲ್ಟರ್‌ಗಳು ನೆಟ್‌ವರ್ಕ್ ಕಾನ್ಫಿಗರೇಶನ್ ಅವಲಂಬಿಸಿರುತ್ತವೆ. ನೆಟ್‌ವರ್ಕ್ ಪ್ರವೇಶ ನಿಷ್ಕ್ರಿಯವಾಗಿದ್ದಾಗ, connect(2) ಮತ್ತು bind(2) ನಂತಹ ಹಲವು ನೆಟ್‌ವರ್ಕ್ ಸಂಬಂಧಿತ ಸಿಸ್ಟಮ್ ಕರೆಗಳನ್ನು ತಡೆಯುತ್ತೇವೆ. ಆದರೆ ಸ್ಯಾಂಡ್‌ಬಾಕ್ಸ್‌ನಲ್ಲಿ ನೆಟ್‌ವರ್ಕ್ ಪ್ರಾಕ್ಸಿ ಸಕ್ರಿಯವಾಗಿದ್ದಾಗ, codex-linux-sandbox ರಚಿಸಿದ TCP ಲಿಸನರ್ ತಲುಪಲು IP ಸಾಕೆಟ್‌ಗಳಿಗೆ ಅವಕಾಶ ನೀಡುತ್ತೇವೆ. ಸ್ವತಂತ್ರ Unix ಡೊಮೇನ್ ಸಾಕೆಟ್‌ಗಳು ಹೋಸ್ಟ್ ಸಂಪನ್ಮೂಲಗಳಿಗೆ ಅನುದ್ದೇಶಿತ ಪ್ರವೇಶ ನೀಡಬಹುದಾದ್ದರಿಂದ, ಅವುಗಳ ರಚನೆಯನ್ನು ಪೂರ್ವನಿಯೋಜಿತವಾಗಿ ತಡೆಯುತ್ತೇವೆ.

ನೆಟ್‌ವರ್ಕ್ ಪ್ರಾಕ್ಸಿಗೆ ಸಂಪರ್ಕಿಸುವುದು

ಸ್ಯಾಂಡ್‌ಬಾಕ್ಸ್ ಕಾನ್ಫಿಗರೇಶನ್‌ಗೆ ನೆಟ್‌ವರ್ಕ್ ಪ್ರಾಕ್ಸಿ ಅಗತ್ಯವಾದಾಗ, Codex ಪೂರಕ ವ್ಯವಸ್ಥೆ ಪ್ರಾಕ್ಸಿಯ ಒಂದು ನಿದರ್ಶನ ರಚಿಸುತ್ತದೆ. ಅದೇ Codex ಥ್ರೆಡ್‌ನಲ್ಲಿನ ಹಲವು codex-linux-sandbox ಕರೆಗಳಲ್ಲಿ ಅದನ್ನು ಮರುಬಳಸಬಹುದು. ಪ್ರತಿ ಸ್ಯಾಂಡ್‌ಬಾಕ್ಸ್‌ಗೂ ತನ್ನ ಪ್ರತ್ಯೇಕ ನೆಟ್‌ವರ್ಕ್ ನೇಮ್‌ಸ್ಪೇಸ್‌ನಿಂದ ಆ ಹಂಚಿಕೆಯ ಪ್ರಾಕ್ಸಿ ತಲುಪುವ ಮಾರ್ಗ ಬೇಕು. Codex ಆ ನೇಮ್‌ಸ್ಪೇಸ್‌ನಲ್ಲಿ ಲೂಪ್‌ಬ್ಯಾಕ್ TCP ಲಿಸನರ್ ಒದಗಿಸುತ್ತದೆ. ಅದರ ಸಂಪರ್ಕಗಳನ್ನು ಸ್ಯಾಂಡ್‌ಬಾಕ್ಸ್‌ನ ಹೊರಗಿನ ಪ್ರಕ್ರಿಯೆ ಸ್ವೀಕರಿಸಿ ಪ್ರಾಕ್ಸಿಗೆ ರವಾನಿಸುವಂತೆ ವ್ಯವಸ್ಥೆ ಮಾಡುತ್ತದೆ.

ಕೆಳಗಿನ ಚಿತ್ರಗಳು ಒಂದು ಪ್ರಾಕ್ಸಿ ಎಂಡ್‌ಪಾಯಿಂಟ್‌ಗಾಗಿ ಈ ವ್ಯವಸ್ಥೆಯನ್ನು ತೋರಿಸುತ್ತವೆ. ಕೊನೆಯ ಚಿತ್ರದಲ್ಲಿ ಅದರ ಮೂಲಕ ಸಾಗುವ ಒಂದು ಸಂಪರ್ಕವಿದೆ. bubblewrap ಆರಂಭಿಸುವ ಮೊದಲು, codex-linux-sandbox ನಿಯಂತ್ರಣ ಚಾನಲ್‌ಗಾಗಿ Unix ಸಾಕೆಟ್ ಜೋಡಿ ರಚಿಸಿ, ತನ್ನನ್ನೇ ಫೋರ್ಕ್ ಮಾಡಿಕೊಳ್ಳುತ್ತದೆ. ಚೈಲ್ಡ್ ಪ್ರಕ್ರಿಯೆಯು run_host_bridge() ಚಲಾಯಿಸಿ, ಆ ಚಾನಲ್ ಮೂಲಕ ಲಿಸನರ್‌ನ ಫೈಲ್ ಡಿಸ್ಕ್ರಿಪ್ಟರ್ ಸ್ವೀಕರಿಸಲು ಕಾಯುತ್ತದೆ:

Codex ಪೂರಕ ವ್ಯವಸ್ಥೆಯು codex-linux-sandbox ಆರಂಭಿಸುವ ಚಿತ್ರ. ಅದು Unix ಸಾಕೆಟ್ ನಿಯಂತ್ರಣ ಚಾನಲ್ ಮೂಲಕ ಸಂಪರ್ಕಿತ ರವಾನೆ ಪ್ರಕ್ರಿಯೆಯನ್ನು ಫೋರ್ಕ್ ಮಾಡುತ್ತದೆ.

ಈ ಉದಾಹರಣೆಯಲ್ಲಿ, ಪೇರೆಂಟ್ ಪ್ರಕ್ರಿಯೆಯು exec ಬಳಸಿ ತನ್ನ ಪ್ರೋಗ್ರಾಂ ಇಮೇಜ್ ಅನ್ನು bwrap ನಿಂದ ಬದಲಿಸುತ್ತದೆ. ಇದು ಸ್ಯಾಂಡ್‌ಬಾಕ್ಸ್ ಸಿದ್ಧಪಡಿಸಿ, ನಿಯಂತ್ರಣ ಚಾನಲ್‌ನ FD ಅನ್ನು ಮುಂದಕ್ಕೆ ಒದಗಿಸುತ್ತಾ ಅದರೊಳಗೆ codex-linux-sandbox --apply-seccomp-then-exec ಆರಂಭಿಸುತ್ತದೆ:

bwrap ಸ್ಯಾಂಡ್‌ಬಾಕ್ಸ್ ನೆಟ್‌ವರ್ಕ್ ನೇಮ್‌ಸ್ಪೇಸ್ ರಚಿಸಿ, ಅದರೊಳಗೆ codex-linux-sandbox ಆರಂಭಿಸುವ ಚಿತ್ರ. ಸ್ಯಾಂಡ್‌ಬಾಕ್ಸ್‌ನ ಹೊರಗಿನ ರವಾನೆ ಪ್ರಕ್ರಿಯೆಗೆ Unix ಸಾಕೆಟ್ ನಿಯಂತ್ರಣ ಚಾನಲ್ ಸಂಪರ್ಕವಿದೆ.

ಸ್ಯಾಂಡ್‌ಬಾಕ್ಸ್‌ನ ನೆಟ್‌ವರ್ಕ್ ನೇಮ್‌ಸ್ಪೇಸ್‌ನಲ್ಲಿ, codex-linux-sandbox ನ ಎರಡನೇ ಕರೆ ಲೂಪ್‌ಬ್ಯಾಕ್ TCP ಲಿಸನರ್ ರಚಿಸಿ ಅದರ ಫೈಲ್ ಡಿಸ್ಕ್ರಿಪ್ಟರ್ ಅನ್ನು ಸಾಕೆಟ್ ಮೂಲಕ ರವಾನಿಸುತ್ತದೆ. ಲಿಸನರ್ ಸ್ಯಾಂಡ್‌ಬಾಕ್ಸ್‌ನ ನೆಟ್‌ವರ್ಕ್ ನೇಮ್‌ಸ್ಪೇಸ್‌ನೊಂದಿಗೆ ಸಂಬಂಧ ಉಳಿಸಿಕೊಳ್ಳುತ್ತದೆ. ಇದರಿಂದ ಹೊರಗೇ ಉಳಿದ ಚೈಲ್ಡ್ ಪ್ರಕ್ರಿಯೆ ಸ್ಯಾಂಡ್‌ಬಾಕ್ಸ್‌ನ ಪ್ರೋಗ್ರಾಂಗಳ ಸಂಪರ್ಕಗಳನ್ನು ಸ್ವೀಕರಿಸಬಹುದು; ತನ್ನ ಮುಂದಿನ ಸಂಪರ್ಕಗಳನ್ನು ಹೋಸ್ಟ್‌ನ ನೆಟ್‌ವರ್ಕ್ ನೇಮ್‌ಸ್ಪೇಸ್‌ನಲ್ಲಿ ತೆರೆಯಬಹುದು. ಹಸ್ತಾಂತರದ ನಂತರ ಎರಡೂ ಪ್ರಕ್ರಿಯೆಗಳು ತಮ್ಮ ನಿಯಂತ್ರಣ ಚಾನಲ್ ಡಿಸ್ಕ್ರಿಪ್ಟರ್‌ಗಳನ್ನು ಮುಚ್ಚುತ್ತವೆ. ಸ್ಯಾಂಡ್‌ಬಾಕ್ಸ್‌ನೊಳಗಿನ ಪ್ರಕ್ರಿಯೆ ತನ್ನ ಲಿಸನರ್ ಪ್ರತಿಯನ್ನೂ ಮುಚ್ಚುತ್ತದೆ.

TCP ಲಿಸನರ್ ಸಿದ್ಧವಾದ ಬಳಿಕ, ಸ್ಯಾಂಡ್‌ಬಾಕ್ಸ್‌ನೊಳಗಿನ ಪ್ರಕ್ರಿಯೆಯು ಆ ಲಿಸನರ್‌ಗೆ ಸೂಚಿಸುವಂತೆ HTTP_PROXY ಚರಕ್ಕೆ ಸೂಕ್ತ ಮೌಲ್ಯವನ್ನು ಹೊಂದಿಸುತ್ತದೆ⁠(ಹೊಸ ಕಿಟಕಿಯಲ್ಲಿ ತೆರೆಯುತ್ತದೆ); ಸಂಬಂಧಿತ ಪರಿಸರ ಚರಗಳನ್ನೂ ಹೊಂದಿಸುತ್ತದೆ. ನಂತರ, ಪ್ರಕ್ರಿಯೆಯನ್ನು ಫೋರ್ಕ್ ಮಾಡಿ ಬಳಕೆದಾರರ ಆಜ್ಞೆಯನ್ನು ಚಲಾಯಿಸುವ ಮೊದಲು seccomp ಅನ್ನು ಅನ್ವಯಿಸುತ್ತದೆ:

ಸ್ಯಾಂಡ್‌ಬಾಕ್ಸ್‌ನ ಪ್ರೋಗ್ರಾಂ ಲೂಪ್‌ಬ್ಯಾಕ್ TCP ಲಿಸನರ್‌ಗೆ ಸಂಪರ್ಕಿಸುವ ಚಿತ್ರ. ಹೊರಗಿನ codex-linux-sandbox ರವಾನೆ ಪ್ರಕ್ರಿಯೆಯು ದತ್ತಾಂಶ ಹರಿವನ್ನು Codex ನೆಟ್‌ವರ್ಕ್ ಪ್ರಾಕ್ಸಿಗೆ ಕಳುಹಿಸುತ್ತದೆ.

ಸ್ಯಾಂಡ್‌ಬಾಕ್ಸ್‌ನ ಹೊರಗಿನ ಪ್ರಕ್ರಿಯೆಯು ಲಿಸನರ್ ಅನ್ನು ತೆರೆದಿಡುತ್ತದೆ. ಸ್ವೀಕರಿಸಿದ ಪ್ರತಿ ಸಂಪರ್ಕಕ್ಕೂ, ಅದು ಕಾನ್ಫಿಗರ್ ಮಾಡಲಾದ ಪ್ರಾಕ್ಸಿಗೆ ಸಂಪರ್ಕ ತೆರೆಯುತ್ತದೆ ಮತ್ತು ಎರಡೂ ದಿಕ್ಕುಗಳಲ್ಲಿ ದತ್ತಾಂಶವನ್ನು ರವಾನಿಸುತ್ತದೆ.

ಈ ಹೆಚ್ಚುವರಿ ವ್ಯವಸ್ಥೆಯು ಆಜ್ಞೆಗೆ ಪ್ರತ್ಯೇಕ ಲೂಪ್‌ಬ್ಯಾಕ್ ಇಂಟರ್‌ಫೇಸ್ ಒಳಗೊಂಡ ತನ್ನದೇ ನೆಟ್‌ವರ್ಕ್ ನೇಮ್‌ಸ್ಪೇಸ್ ನೀಡುತ್ತದೆ. macOS ನಲ್ಲಿ, ಹೋಸ್ಟ್‌ನ ಲೂಪ್‌ಬ್ಯಾಕ್ ಇಂಟರ್‌ಫೇಸ್‌ನ ನಿರ್ದಿಷ್ಟ ಪೋರ್ಟ್‌ಗಳಿಗೆ ನೇರವಾಗಿ ಸಂಪರ್ಕಿಸಲು Seatbelt ಆಜ್ಞೆಗೆ ಅವಕಾಶ ನೀಡುತ್ತದೆ. Linux ನಲ್ಲಿ, ಆಜ್ಞೆಯು ತನ್ನ ಪ್ರತ್ಯೇಕ ನೇಮ್‌ಸ್ಪೇಸ್‌ನೊಳಗಿನ ಲಿಸನರ್‌ಗೆ ಸಂಪರ್ಕಿಸುತ್ತದೆ. ಸ್ಯಾಂಡ್‌ಬಾಕ್ಸ್‌ನ ಹೊರಗಿನ ಪ್ರಕ್ರಿಯೆಯು ಆ ಸಂಪರ್ಕಗಳನ್ನು ಕಾನ್ಫಿಗರ್ ಮಾಡಲಾದ ಪ್ರಾಕ್ಸಿಗೆ ರವಾನಿಸುತ್ತದೆ. ಡಿಸ್ಕ್ರಿಪ್ಟರ್ ಹಸ್ತಾಂತರದಿಂದಾಗಿ, ಹೋಸ್ಟ್‌ನ ನೆಟ್‌ವರ್ಕ್ ನೇಮ್‌ಸ್ಪೇಸ್ ಅನ್ನು ಆಜ್ಞೆಗೆ ತೆರೆದಿಡದೆ ಈ ಸಂಪರ್ಕ ಸಾಧ್ಯವಾಗುತ್ತದೆ.

Windows

ಈ ವರ್ಷದ ಆರಂಭದಲ್ಲಿ, ನಾವು Windows ನಲ್ಲಿ ಸ್ಯಾಂಡ್‌ಬಾಕ್ಸಿಂಗ್ ಅಳವಡಿಸಿ, ಆ ಪ್ರಯತ್ನಗಳ ಬಗ್ಗೆ ಬರೆದಿದ್ದೆವು. ಅಂದಿನಿಂದ, Microsoft ಸಂಸ್ಥೆಯು Windows ಕಾರ್ಯವ್ಯವಸ್ಥೆಯಲ್ಲಿ ಪ್ರಕ್ರಿಯೆಗಳನ್ನು ಪ್ರತ್ಯೇಕಿಸುವ ಹೊಸ ಸೌಲಭ್ಯಗಳ ಜೊತೆಗೆ MXC ಎಂಬ ಲೈಬ್ರರಿಯನ್ನು ಬಿಡುಗಡೆ ಮಾಡಿದೆ. ಈಗ ನಾವು ಹಾಲಿ ಸ್ಯಾಂಡ್‌ಬಾಕ್ಸ್ ಬದಲಿಗೆ MXC ಲೈಬ್ರರಿ ಬಳಸುವ ಸ್ಯಾಂಡ್‌ಬಾಕ್ಸ್ ಅಳವಡಿಸುತ್ತಿದ್ದೇವೆ.

MXC ಎಂದರೇನು?

MXC (Microsoft eXecution Container) ಎಂಬುದು Microsoft ನ ಸ್ಯಾಂಡ್‌ಬಾಕ್ಸ್‌ನಲ್ಲಿ ಕೋಡ್ ಚಲಾಯಿಸುವ ವ್ಯವಸ್ಥೆ⁠(ಹೊಸ ಕಿಟಕಿಯಲ್ಲಿ ತೆರೆಯುತ್ತದೆ). ಇದು Windows, Linux ಮತ್ತು macOS ನಲ್ಲಿ ಹಲವು ಪ್ರತ್ಯೇಕೀಕರಣ ಬ್ಯಾಕ್‌ಎಂಡ್‌ಗಳನ್ನು ಬೆಂಬಲಿಸುತ್ತದೆ. ಹೊಂದಾಣಿಕೆಯ Windows ಸಾಧನಗಳಲ್ಲಿ Codex, MXC ಆಧಾರಿತ ಸ್ಯಾಂಡ್‌ಬಾಕ್ಸ್ ಬೆಂಬಲಿಸುತ್ತದೆ. ಇದು ಸ್ಥಳೀಯ ಪ್ರಕ್ರಿಯೆ ಪ್ರತ್ಯೇಕೀಕರಣವನ್ನು ಬಳಸಿ, ಬಳಕೆದಾರರ ಹಾಲಿ ಪರಿಸರದಲ್ಲೇ ಆಜ್ಞೆಗಳನ್ನು ನಿರ್ಬಂಧಿಸುತ್ತದೆ.

ನಮ್ಮ ಹಾಲಿ 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

ಕೃತಜ್ಞತೆಗಳು

ಈ ಲೇಖನಕ್ಕೆ ಕೊಡುಗೆ ನೀಡಿದ ಡೇವಿಡ್ ವೀಸೆನ್, ಚಾರ್ಲಿ ವೀಮ್ಸ್, ವಿಯತ್ ಭಲೋಡಿಯಾ ಮತ್ತು ಫೋಟಿಸ್ ಚಾಂಟ್ಜಿಸ್ ಅವರಿಗೆ ವಿಶೇಷ ಧನ್ಯವಾದಗಳು.