OpenAI

18 ਨਵੰਬਰ 2026

ਇੰਜੀਨੀਅਰਿੰਗ

Codex ਸੈਂਡਬਾਕਸ ਦੇ ਅੰਦਰ

Codex ਤੁਹਾਡੇ ਨਿਯੰਤਰਣ ਵਾਲੀਆਂ ਹੱਦਾਂ ਵਿੱਚ ਤੁਹਾਡੀ ਮਸ਼ੀਨ ਉੱਤੇ ਕਮਾਂਡਾਂ ਕਿਵੇਂ ਚਲਾਉਂਦਾ ਹੈ.

ਮਾਈਕਲ ਬੋਲਿਨ, ਤਕਨੀਕੀ ਸਟਾਫ਼ ਦੇ ਮੈਂਬਰ ਵੱਲੋਂ

OpenAI ਵਿੱਚ, ਅਸੀਂ ਏਜੰਟਾਂ ਦੀ ਸੁਰੱਖਿਆ ਲਈ ਬਹੁ-ਪਰਤੀ ਰੱਖਿਆ⁠(ਨਵੀਂ ਵਿੰਡੋ ਵਿੱਚ ਖੁੱਲ੍ਹਦਾ ਹੈ) ਦੀ ਪਹੁੰਚ ਅਪਣਾਉਂਦੇ ਹਾਂ. ਸਿਖਲਾਈ ਅਤੇ ਉਦੇਸ਼ਾਂ ਨਾਲ ਤਾਲਮੇਲ ਵਿੱਚ ਸਾਡਾ ਨਿਵੇਸ਼ ਇਸ ਯਤਨ ਦੀ ਬੁਨਿਆਦ ਹੈ. ਨਾਲ ਹੀ, ਅਸੀਂ ਵਾਧੂ ਸੁਰੱਖਿਆ ਲਈ ਆਪਣੇ ਏਜੰਟਿਕ ਜਾਂਚ-ਢਾਂਚੇ, Codex⁠(ਨਵੀਂ ਵਿੰਡੋ ਵਿੱਚ ਖੁੱਲ੍ਹਦਾ ਹੈ), ਵਿੱਚ ਵੀ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਲਾਗੂ ਕਰਦੇ ਹਾਂ. 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 ਕੰਟੇਨਰ ਵਿੱਚ ਬਣਾਉਣ ਲਈ ਮਿਹਨਤ ਲੱਗ ਸਕਦੀ ਹੈ, ਅਤੇ ਕੁਝ ਕਾਰਜ-ਪ੍ਰਵਾਹ ਫਿਰ ਵੀ ਹੋਸਟ ਉੱਤੇ ਚੱਲਦੇ ਸੰਦਾਂ ਉੱਤੇ ਨਿਰਭਰ ਰਹਿੰਦੇ ਹਨ.

ਮਿਸਾਲ ਵਜੋਂ, Mac ਉੱਤੇ iOS ਐਪ ਬਣਾਉਣ ਲਈ Codex ਵਰਤਣ ਬਾਰੇ ਸੋਚੋ. ਜੇ ਤੁਸੀਂ Codex ਨੂੰ Docker ਅੰਦਰ ਚਲਾ ਕੇ ਸੈਂਡਬਾਕਸ ਕਰੋ, ਤਾਂ Codex ਨਾ ਤਾਂ 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 ਸਿੱਧਾ ਵਰਤੋਂਕਾਰ ਨੂੰ ਪੁੱਛ ਸਕਦਾ ਹੈ ਜਾਂ ਬੇਨਤੀ ਆਟੋਮੈਟਿਕ ਸਮੀਖਿਆ⁠(ਨਵੀਂ ਵਿੰਡੋ ਵਿੱਚ ਖੁੱਲ੍ਹਦਾ ਹੈ) ਲਈ ਭੇਜ ਸਕਦਾ ਹੈ.) ਜੇ ਚਲਾਉਣ ਦੀ ਮਨਜ਼ੂਰੀ ਮਿਲੇ, ਤਾਂ Codex ਮੂਲ ExecCommandToolCall ਦੇ ਕਮਾਂਡ ਆਰਗੂਮੈਂਟਾਂ ਨਾਲ ਢੁਕਵੇਂ permission_profile ਅਤੇ network_proxy ਨੂੰ perform_exec_command_with_sandboxing() ਵਿੱਚ ਭੇਜੇਗਾ.

ਸ਼ੈੱਲ ਸੰਦ spawn_command_under_sandbox() ਦਾ ਮੁੱਖ ਵਰਤੋਂਕਾਰ ਹੈ. ਜਾਂਚ-ਢਾਂਚਾ ਆਪਣਾ ਸੈਂਡਬਾਕਸਿੰਗ ਬੁਨਿਆਦੀ ਢਾਂਚਾ ਸਥਾਨਕ ਫ਼ਾਈਲਾਂ ਪੜ੍ਹਨ ਅਤੇ ਸੋਧਣ ਵਰਗੀਆਂ ਕਾਰਵਾਈਆਂ ਲਈ ਵੀ ਮੁੜ ਵਰਤਦਾ ਹੈ. ਇਹ ਮੁੜ ਵਰਤੋਂ ਜਾਂਚ-ਢਾਂਚੇ ਤੋਂ ਬਾਹਰ ਵੀ ਸੰਭਵ ਹੈ: codex sandbox ਕਮਾਂਡ ਨਾਲ ਤੁਸੀਂ ਆਪਣੇ ਸੰਦਾਂ ਵਿੱਚ ਸੈਂਡਬਾਕਸ ਅੰਦਰ ਕਮਾਂਡਾਂ ਚਲਾਉਣ ਦੀ ਸਮਰੱਥਾ ਜੋੜ ਸਕਦੇ ਹੋ, ਜਿਵੇਂ ਅਸੀਂ ਅੱਗੇ ਦੇਖਾਂਗੇ. ਅੱਗੇ ਅਸੀਂ ਦੇਖਾਂਗੇ ਕਿ ਇਜਾਜ਼ਤ ਪ੍ਰੋਫ਼ਾਈਲਾਂ ਕਿਵੇਂ ਪਰਿਭਾਸ਼ਿਤ ਕੀਤੀਆਂ ਜਾਂਦੀਆਂ ਹਨ.

ਸੈਂਡਬਾਕਸ ਕੌਂਫਿਗਰ ਕਰਨਾ

ਨਾਂ ਵਾਲੀ ਇਜਾਜ਼ਤ ਪ੍ਰੋਫ਼ਾਈਲ ਨਾਲ ਤੁਸੀਂ ਵੱਖ-ਵੱਖ ਪ੍ਰੋਜੈਕਟਾਂ ਵਿੱਚ ਉਹੀ ਫ਼ਾਈਲ-ਸਿਸਟਮ ਅਤੇ ਨੈੱਟਵਰਕ ਪਾਬੰਦੀਆਂ ਮੁੜ ਵਰਤ ਸਕਦੇ ਹੋ. ਤੁਸੀਂ config.toml ਵਿੱਚ [permissions] ਹੇਠ ਆਪਣੀਆਂ ਪ੍ਰੋਫ਼ਾਈਲਾਂ ਪਰਿਭਾਸ਼ਿਤ ਕਰ ਸਕਦੇ ਹੋ. ਮਿਸਾਲ ਵਜੋਂ, ਹੇਠਾਂ dev ਨਾਂ ਦੀ ਪ੍ਰੋਫ਼ਾਈਲ ਪਰਿਭਾਸ਼ਿਤ ਹੈ, ਜੋ ਪਹਿਲਾਂ ਤੋਂ ਮੌਜੂਦ :workspace ਪ੍ਰੋਫ਼ਾਈਲ ਦਾ ਵਿਸਥਾਰ ਕਰਦੀ ਹੈ⁠(ਨਵੀਂ ਵਿੰਡੋ ਵਿੱਚ ਖੁੱਲ੍ਹਦਾ ਹੈ):

TOML

1
# Use the dev profile by default.
2
default_permissions = "dev"
3

4
[permissions.dev]
5
# This is displayed when /permissions is run in the Codex CLI.
6
description = "Development with extra read-only protections."
7

8
# A profile can be derived from an existing profile.
9
# Profiles starting with ":" are provided by Codex.
10
extends = ":workspace"
11

12
[permissions.dev.filesystem]
13
"~/build-cache" = "write"
14

15
[permissions.dev.filesystem.":workspace_roots"]
16
".devcontainer" = "read"
17
".vscode" = "read"
18
"**/*.env" = "deny"
19
"secrets" = "deny"

dev ਪ੍ਰੋਫ਼ਾਈਲ ~/build-cache ਵਿੱਚ ਲਿਖਣ ਦੀ ਪਹੁੰਚ ਜੋੜਦੀ ਹੈ ਅਤੇ ਕਾਰਜ-ਖੇਤਰ ਦੀਆਂ ਫ਼ਾਈਲਾਂ ਉੱਤੇ ਵਾਧੂ ਪਾਬੰਦੀਆਂ ਲਗਾਉਂਦੀ ਹੈ. ਫ਼ਾਈਲ-ਸਿਸਟਮ ਐਂਟਰੀਆਂ ਸਿਰਫ਼ ਪੜ੍ਹਨ ਦੀ ਪਹੁੰਚ (read), ਪੜ੍ਹਨ ਅਤੇ ਲਿਖਣ ਦੀ ਪਹੁੰਚ (write) ਦੇ ਸਕਦੀਆਂ ਹਨ ਜਾਂ ਪਹੁੰਚ ਪੂਰੀ ਤਰ੍ਹਾਂ ਰੋਕ ਸਕਦੀਆਂ ਹਨ (deny).

:workspace_roots ਸਾਰਣੀ ਨਾਲ ਤੁਸੀਂ ਪ੍ਰੋਜੈਕਟ ਦੇ ਕਾਰਜ-ਖੇਤਰ ਦੀਆਂ ਰੂਟਾਂ ਦੇ ਸਾਪੇਖ ਪਾਥਾਂ ਲਈ ਨਿਯਮ ਤੈਅ ਕਰ ਸਕਦੇ ਹੋ. ਮੂਲ ਰੂਪ ਵਿੱਚ, Codex ਦਾ ਕਮਾਂਡ-ਲਾਈਨ ਇੰਟਰਫੇਸ ਆਪਣੀ ਕਾਰਜ ਡਾਇਰੈਕਟਰੀ ਨੂੰ ਕਾਰਜ-ਖੇਤਰ ਦੀ ਇਕਲੌਤੀ ਰੂਟ ਮੰਨਦਾ ਹੈ, ਜਦਕਿ ChatGPT ਡੈਸਕਟਾਪ ਐਪ ਪ੍ਰੋਜੈਕਟ ਦੇ ਸਰੋਤ ਫੋਲਡਰ ਵਰਤਦੀ ਹੈ. Codex ਹਰ ਨਿਯਮ ਹਰ ਰੂਟ ਉੱਤੇ ਲਾਗੂ ਕਰਦਾ ਹੈ, ਇਸ ਲਈ dev ਦੀ .vscode ਐਂਟਰੀ ਹਰ ਰੂਟ ਹੇਠਲੀ .vscode ਡਾਇਰੈਕਟਰੀ ਨੂੰ ਸਿਰਫ਼ ਪੜ੍ਹਨਯੋਗ ਬਣਾਉਂਦੀ ਹੈ.

ਆਪਣੇ ਨਿਯਮਾਂ ਤੋਂ ਇਲਾਵਾ, 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 ਦਾ ਕਮਾਂਡ-ਲਾਈਨ ਇੰਟਰਫੇਸ sandbox ਕਮਾਂਡ ਦਿੰਦਾ ਹੈ, ਤਾਂ ਜੋ Codex ਕੌਂਫਿਗਰੇਸ਼ਨ ਵਿੱਚ ਪਰਿਭਾਸ਼ਿਤ ਇਜਾਜ਼ਤ ਪ੍ਰੋਫ਼ਾਈਲ ਅਧੀਨ ਕੋਈ ਵੀ ਕਮਾਂਡ ਚਲਾਈ ਜਾ ਸਕੇ. ਇਹ ਆਮ ਤੌਰ ’ਤੇ ਪ੍ਰੋਫ਼ਾਈਲ ਦੀ ਜਾਂਚ ਲਈ ਵਰਤੀ ਜਾਂਦੀ ਹੈ, ਤਾਂ ਜੋ ਯਕੀਨੀ ਬਣੇ ਕਿ ਸੈਂਡਬਾਕਸ ਉਹ ਵਿਹਾਰ ਰੋਕਦਾ ਹੈ ਜਿਸ ਨੂੰ ਰੋਕਣ ਲਈ ਇਹ ਬਣਾਇਆ ਗਿਆ ਹੈ.

ਮਿਸਾਲ ਵਜੋਂ, ਹੇਠਲੀ ਕਮਾਂਡ VS Code ਨੂੰ ਸੇਵ ਕਰਨ ਵੇਲੇ ਖ਼ਤਰਨਾਕ ਆਟੋ-ਫਾਰਮੈਟਰ ਚਲਾਉਣ ਲਈ ਕੌਂਫਿਗਰ ਕਰਨ ਦੀ ਕੋਸ਼ਿਸ਼ ਕਰਦੀ ਹੈ. ਜੇ .vscode ਪਹਿਲਾਂ ਹੀ ਮੌਜੂਦ ਹੈ, ਤਾਂ ਉੱਪਰ ਪਰਿਭਾਸ਼ਿਤ dev ਪ੍ਰੋਫ਼ਾਈਲ ਨੂੰ ਇਹ ਲਿਖਤ ਰੋਕਣੀ ਚਾਹੀਦੀ ਹੈ, ਕਿਉਂਕਿ ਉਹ ਡਾਇਰੈਕਟਰੀ ਸਿਰਫ਼ ਪੜ੍ਹਨਯੋਗ ਹੈ (codex sandbox ਮੂਲ ਰੂਪ ਵਿੱਚ cwd ਨੂੰ ਕਾਰਜ-ਖੇਤਰ ਦੀ ਰੂਟ ਮੰਨਦਾ ਹੈ):

Bash

1
codex sandbox --permission-profile dev -- \
2
bash -c 'cat > .vscode/settings.json' <<'JSON'
3
{
4
"prettier.prettierPath": "./node_modules/evil-prettier",
5
"[typescript]": {
6
"editor.defaultFormatter": "esbenp.prettier-vscode",
7
"editor.formatOnSave": true
8
}
9
}
10
JSON

ਵਾਕਈ, macOS ਉੱਤੇ ਇਹ ਇਸ ਸੁਨੇਹੇ ਨਾਲ ਅਸਫਲ ਹੁੰਦੀ ਹੈ:

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⁠(ਨਵੀਂ ਵਿੰਡੋ ਵਿੱਚ ਖੁੱਲ੍ਹਦਾ ਹੈ) ਕ੍ਰੇਟ ਵਿੱਚ ਲਾਗੂ ਕੀਤੀ ਗਈ ਹੈ. ਜਾਂਚ-ਢਾਂਚਾ ਇਸ ਨੂੰ ਲਾਇਬ੍ਰੇਰੀ ਵਜੋਂ ਵਰਤਦਾ ਹੈ, ਪਰ ਇਸ ਨੂੰ ਸੁਤੰਤਰ ਕਮਾਂਡ-ਲਾਈਨ ਇੰਟਰਫੇਸ⁠(ਨਵੀਂ ਵਿੰਡੋ ਵਿੱਚ ਖੁੱਲ੍ਹਦਾ ਹੈ) ਵਜੋਂ ਵੀ ਬਿਲਡ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ. ਚਾਲੂ ਹੋਣ ਉੱਤੇ, 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 ਦੀਆਂ ਨੀਤੀਆਂ ਸੈਂਡਬਾਕਸ ਪ੍ਰੋਫ਼ਾਈਲ ਭਾਸ਼ਾ (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 ਚਲਾਉਣਾ ਸੌਖਾ ਹੈ.

ਸਹੀ SBPL ਬਣਾਉਣਾ ਔਖਾ ਹੈ, ਕਿਉਂਕਿ Apple ਤੀਜੀਆਂ ਧਿਰਾਂ ਦੀ ਵਰਤੋਂ ਲਈ ਇਸ ਭਾਸ਼ਾ ਦਾ ਦਸਤਾਵੇਜ਼ੀ ਵੇਰਵਾ ਨਹੀਂ ਦਿੰਦਾ. ਅਸਲ ਵਿੱਚ, 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), ਜੋ ਅਲੱਗ ਵਾਤਾਵਰਨ ਬਣਾਉਣ ਦਾ ਕਮਾਂਡ-ਲਾਈਨ ਸੰਦ ਹੈ, ਅਤੇ seccomp-bpf⁠(ਨਵੀਂ ਵਿੰਡੋ ਵਿੱਚ ਖੁੱਲ੍ਹਦਾ ਹੈ), ਜੋ ਸਿਸਟਮ ਕਾਲਾਂ ਫ਼ਿਲਟਰ ਕਰਨ ਦੀ Linux ਕਰਨਲ ਵਿਵਸਥਾ ਹੈ. 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 ਨਾਲ ਵੱਖਰੇ ਮਾਊਂਟ ਨੇਮਸਪੇਸ ਵਿੱਚ ਫ਼ਾਈਲ-ਸਿਸਟਮ ਦਾ ਅਜਿਹਾ ਦ੍ਰਿਸ਼ ਬਣਾਉਂਦਾ ਹੈ ਜੋ ਇਜਾਜ਼ਤ ਪ੍ਰੋਫ਼ਾਈਲ ਦੇ ਫ਼ਾਈਲ-ਸਿਸਟਮ ਨਿਯਮਾਂ ਅਨੁਸਾਰ ਹੁੰਦਾ ਹੈ. ਇਹ ਸੈਂਡਬਾਕਸ ਦੀ ਕਾਰਜ-ਪ੍ਰਣਾਲੀ ਦੀ ਬੁਨਿਆਦ ਹੈ, ਇਸ ਲਈ ਜੇ ਵਰਤੋਂਕਾਰ ਨੇ bwrap ਸਥਾਪਤ ਨਾ ਕੀਤਾ ਹੋਵੇ ਤਾਂ Codex ਆਪਣੀ ਕਾਪੀ ਨਾਲ ਲਿਆਉਂਦਾ ਹੈ. ਪਰ ਉਪਲਬਧ ਹੋਣ ਉੱਤੇ ਇਹ PATH ਵਿੱਚ ਮਿਲੀ bwrap⁠(ਨਵੀਂ ਵਿੰਡੋ ਵਿੱਚ ਖੁੱਲ੍ਹਦਾ ਹੈ) ਦੀ ਅਨੁਕੂਲ ਸਥਾਪਨਾ ਨੂੰ ਤਰਜੀਹ ਦਿੰਦਾ ਹੈ⁠(ਨਵੀਂ ਵਿੰਡੋ ਵਿੱਚ ਖੁੱਲ੍ਹਦਾ ਹੈ). ਅਮਲ ਵਿੱਚ ਦੇਖਿਆ ਗਿਆ ਹੈ ਕਿ ਕੁਝ Linux ਡਿਸਟ੍ਰੀਬਿਊਸ਼ਨ ਮੂਲ ਰੂਪ ਵਿੱਚ ਵਰਤੋਂਕਾਰ ਨੇਮਸਪੇਸਾਂ ਤੱਕ ਪਹੁੰਚ ਬੰਦ ਰੱਖਦੀਆਂ ਹਨ⁠(ਨਵੀਂ ਵਿੰਡੋ ਵਿੱਚ ਖੁੱਲ੍ਹਦਾ ਹੈ), ਪਰ ਸਿਸਟਮ ਦੇ bwrap ਨੂੰ ਛੋਟ ਦਿੰਦੀਆਂ ਹਨ.

sandbox-exec ਵਾਂਗ, bwrap ਵੀ ਪਹਿਲਾਂ ਸੈਂਡਬਾਕਸ ਕੌਂਫਿਗਰੇਸ਼ਨ ਅਤੇ ਫਿਰ ਉਸ ਅੰਦਰ ਚਲਾਉਣ ਵਾਲੀ ਕਮਾਂਡ ਲੈਂਦਾ ਹੈ. SBPL ਵਰਗੀ ਖ਼ਾਸ ਕੌਂਫਿਗਰੇਸ਼ਨ ਭਾਸ਼ਾ ਦੀ ਬਜਾਏ, bwrap ਕੌਂਫਿਗਰੇਸ਼ਨ ਲਈ ਵੱਖ-ਵੱਖ ਫਲੈਗ ਵਰਤਦਾ ਹੈ. ਫ਼ਾਈਲ-ਸਿਸਟਮ ਦ੍ਰਿਸ਼ ਬਣਾਉਣ ਲਈ Codex ਇਹ ਵਿਕਲਪ ਵਰਤਦਾ ਹੈ:

  • ਲਿਖਣਯੋਗ ਫ਼ਾਈਲ ਜਾਂ ਡਾਇਰੈਕਟਰੀ ਨਿਰਧਾਰਤ ਕਰਨ ਲਈ --bind

  • ਸਿਰਫ਼ ਪੜ੍ਹਨਯੋਗ ਫ਼ਾਈਲ ਜਾਂ ਡਾਇਰੈਕਟਰੀ ਨਿਰਧਾਰਤ ਕਰਨ ਲਈ --ro-bind

  • DIR ਤੱਕ ਪਹੁੰਚ ਰੋਕਣ ਲਈ --perms 000 --tmpfs DIR --remount-ro DIR

  • FILE ਤੱਕ ਪਹੁੰਚ ਰੋਕਣ ਲਈ --perms 000 --ro-bind-data FD FILE (ਜਿੱਥੇ FD, /dev/null ਦਾ ਖੁੱਲ੍ਹਾ ਫ਼ਾਈਲ ਡਿਸਕ੍ਰਿਪਟਰ ਹੈ)

ਇਨ੍ਹਾਂ ਵਿਕਲਪਾਂ ਨਾਲ ਮਨਾਹੀ ਵਾਲੇ ਗਲੌਬ ਲਾਗੂ ਕਰਨ ਲਈ Codex ਹਰ ਕਮਾਂਡ ਸ਼ੁਰੂ ਕਰਨ ਤੋਂ ਪਹਿਲਾਂ ਉਨ੍ਹਾਂ ਨੂੰ ਖ਼ਾਸ ਪਾਥਾਂ ਵਿੱਚ ਵਿਸਥਾਰਦਾ ਹੈ. ਨਵੇਂ ਮੇਲ ਖਾਂਦੇ ਪਾਥ ਉਸ ਕਮਾਂਡ ਦੀਆਂ ਸੈਂਡਬਾਕਸ ਪਾਬੰਦੀਆਂ ਵਿੱਚ ਆਪਣੇ ਆਪ ਨਹੀਂ ਜੁੜਦੇ.

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) ਵਰਗੀਆਂ ਕਈ ਨੈੱਟਵਰਕ-ਸੰਬੰਧੀ ਸਿਸਟਮ ਕਾਲਾਂ ਰੋਕਦੇ ਹਾਂ. ਪਰ ਜਦੋਂ ਸੈਂਡਬਾਕਸ ਵਿੱਚ ਨੈੱਟਵਰਕ ਪ੍ਰੌਕਸੀ ਚਾਲੂ ਹੋਵੇ, ਅਸੀਂ IP ਸਾਕਟਾਂ ਦੀ ਇਜਾਜ਼ਤ ਦਿੰਦੇ ਹਾਂ ਤਾਂ ਜੋ codex-linux-sandbox ਦੇ ਬਣਾਏ TCP ਲਿਸਨਰ ਤੱਕ ਪਹੁੰਚਿਆ ਜਾ ਸਕੇ. ਹਾਲਾਂਕਿ, ਵੱਖਰੇ Unix ਡੋਮੇਨ ਸਾਕਟ ਬਣਾਉਣਾ ਮੂਲ ਰੂਪ ਵਿੱਚ ਰੋਕਦੇ ਹਾਂ, ਕਿਉਂਕਿ ਉਹ ਅਣਜਾਣੇ ਵਿੱਚ ਹੋਸਟ ਦੇ ਸਰੋਤਾਂ ਤੱਕ ਪਹੁੰਚ ਦੇ ਸਕਦੇ ਹਨ.

ਨੈੱਟਵਰਕ ਪ੍ਰੌਕਸੀ ਨਾਲ ਜੁੜਨਾ

ਜਦੋਂ ਸੈਂਡਬਾਕਸ ਕੌਂਫਿਗਰੇਸ਼ਨ ਲਈ ਨੈੱਟਵਰਕ ਪ੍ਰੌਕਸੀ ਲੋੜੀਂਦੀ ਹੋਵੇ, Codex ਜਾਂਚ-ਢਾਂਚਾ ਪ੍ਰੌਕਸੀ ਦੀ ਇੱਕ ਇਕਾਈ ਬਣਾਉਂਦਾ ਹੈ, ਜੋ ਇੱਕੋ Codex ਥ੍ਰੈੱਡ ਵਿੱਚ codex-linux-sandbox ਨੂੰ ਕਈ ਵਾਰ ਚਲਾਉਣ ਲਈ ਮੁੜ ਵਰਤੀ ਜਾ ਸਕਦੀ ਹੈ. ਹਰੇਕ ਸੈਂਡਬਾਕਸ ਨੂੰ ਆਪਣੇ ਅਲੱਗ ਨੈੱਟਵਰਕ ਨੇਮਸਪੇਸ ਤੋਂ ਉਸ ਸਾਂਝੀ ਪ੍ਰੌਕਸੀ ਤੱਕ ਪਹੁੰਚਣ ਦਾ ਢੰਗ ਚਾਹੀਦਾ ਹੈ. Codex ਉਸ ਨੇਮਸਪੇਸ ਅੰਦਰ ਲੂਪਬੈਕ TCP ਲਿਸਨਰ ਦਿੰਦਾ ਹੈ ਅਤੇ ਸੈਂਡਬਾਕਸ ਤੋਂ ਬਾਹਰਲੀ ਪ੍ਰਕਿਰਿਆ ਰਾਹੀਂ ਇਸ ਦੇ ਕਨੈਕਸ਼ਨ ਸਵੀਕਾਰ ਕਰਵਾ ਕੇ ਪ੍ਰੌਕਸੀ ਤੱਕ ਪਹੁੰਚਾਉਂਦਾ ਹੈ.

ਹੇਠਲੇ ਚਿੱਤਰ ਇੱਕ ਪ੍ਰੌਕਸੀ ਐਂਡਪੌਇੰਟ ਲਈ ਇਹ ਵਿਵਸਥਾ ਦਿਖਾਉਂਦੇ ਹਨ. ਆਖ਼ਰੀ ਚਿੱਤਰ ਵਿੱਚ ਇਸ ਰਾਹੀਂ ਜਾਣ ਵਾਲਾ ਇੱਕ ਕਨੈਕਸ਼ਨ ਦਿਖਾਇਆ ਗਿਆ ਹੈ. bubblewrap ਸ਼ੁਰੂ ਕਰਨ ਤੋਂ ਪਹਿਲਾਂ, codex-linux-sandbox ਨਿਯੰਤਰਣ ਚੈਨਲ ਵਜੋਂ Unix ਸਾਕਟਾਂ ਦੀ ਜੋੜੀ ਬਣਾਉਂਦਾ ਹੈ ਅਤੇ ਆਪਣੇ ਆਪ ਨੂੰ ਫੋਰਕ ਕਰਦਾ ਹੈ. ਅਧੀਨ ਪ੍ਰਕਿਰਿਆ run_host_bridge() ਚਲਾਉਂਦੀ ਹੈ ਅਤੇ ਉਸ ਚੈਨਲ ਰਾਹੀਂ ਲਿਸਨਰ ਦਾ ਫ਼ਾਈਲ ਡਿਸਕ੍ਰਿਪਟਰ ਮਿਲਣ ਦੀ ਉਡੀਕ ਕਰਦੀ ਹੈ:

ਚਿੱਤਰ ਵਿੱਚ Codex ਜਾਂਚ-ਢਾਂਚਾ codex-linux-sandbox ਸ਼ੁਰੂ ਕਰਦਾ ਹੈ, ਜੋ Unix ਸਾਕਟ ਨਿਯੰਤਰਣ ਚੈਨਲ ਰਾਹੀਂ ਜੁੜੀ ਰੀਲੇਅ ਪ੍ਰਕਿਰਿਆ ਨੂੰ ਫੋਰਕ ਕਰਦਾ ਹੈ.

ਇਸ ਉਦਾਹਰਨ ਵਿੱਚ, ਮੂਲ ਪ੍ਰਕਿਰਿਆ exec ਰਾਹੀਂ ਆਪਣੀ ਪ੍ਰੋਗਰਾਮ ਇਮੇਜ ਦੀ ਥਾਂ bwrap ਲਿਆਉਂਦੀ ਹੈ. ਇਹ ਸੈਂਡਬਾਕਸ ਸੈੱਟਅੱਪ ਕਰਦਾ ਹੈ ਅਤੇ ਉਸ ਅੰਦਰ codex-linux-sandbox --apply-seccomp-then-exec ਸ਼ੁਰੂ ਕਰਦਾ ਹੈ, ਨਾਲ ਹੀ ਨਿਯੰਤਰਣ ਚੈਨਲ ਦਾ ਫ਼ਾਈਲ ਡਿਸਕ੍ਰਿਪਟਰ ਅੱਗੇ ਦਿੰਦਾ ਹੈ:

ਚਿੱਤਰ ਵਿੱਚ bwrap ਸੈਂਡਬਾਕਸ ਨੈੱਟਵਰਕ ਨੇਮਸਪੇਸ ਬਣਾਉਂਦਾ ਹੈ ਅਤੇ ਉਸ ਅੰਦਰ codex-linux-sandbox ਸ਼ੁਰੂ ਕਰਦਾ ਹੈ. Unix ਸਾਕਟ ਨਿਯੰਤਰਣ ਚੈਨਲ ਇਸ ਨੂੰ ਸੈਂਡਬਾਕਸ ਤੋਂ ਬਾਹਰਲੀ ਰੀਲੇਅ ਪ੍ਰਕਿਰਿਆ ਨਾਲ ਜੋੜਦਾ ਹੈ.

ਸੈਂਡਬਾਕਸ ਦੇ ਨੈੱਟਵਰਕ ਨੇਮਸਪੇਸ ਅੰਦਰ, ਦੂਜੀ ਵਾਰ ਚੱਲਿਆ codex-linux-sandbox ਲੂਪਬੈਕ TCP ਲਿਸਨਰ ਬਣਾਉਂਦਾ ਹੈ ਅਤੇ ਉਸ ਦਾ ਫ਼ਾਈਲ ਡਿਸਕ੍ਰਿਪਟਰ ਸਾਕਟ ਰਾਹੀਂ ਭੇਜਦਾ ਹੈ. ਲਿਸਨਰ ਸੈਂਡਬਾਕਸ ਦੇ ਨੈੱਟਵਰਕ ਨੇਮਸਪੇਸ ਨਾਲ ਜੁੜਿਆ ਰਹਿੰਦਾ ਹੈ. ਇਸ ਨਾਲ ਬਾਹਰ ਰਹੀ ਅਧੀਨ ਪ੍ਰਕਿਰਿਆ ਸੈਂਡਬਾਕਸ ਅੰਦਰਲੇ ਪ੍ਰੋਗਰਾਮਾਂ ਦੇ ਕਨੈਕਸ਼ਨ ਸਵੀਕਾਰ ਕਰ ਸਕਦੀ ਹੈ ਅਤੇ ਆਪਣੇ ਅੱਗੇ ਦੇ ਕਨੈਕਸ਼ਨ ਹੋਸਟ ਦੇ ਨੈੱਟਵਰਕ ਨੇਮਸਪੇਸ ਵਿੱਚ ਖੋਲ੍ਹ ਸਕਦੀ ਹੈ. ਡਿਸਕ੍ਰਿਪਟਰ ਸੌਂਪਣ ਮਗਰੋਂ, ਦੋਵੇਂ ਪ੍ਰਕਿਰਿਆਵਾਂ ਆਪਣੇ ਨਿਯੰਤਰਣ-ਚੈਨਲ ਡਿਸਕ੍ਰਿਪਟਰ ਬੰਦ ਕਰਦੀਆਂ ਹਨ, ਅਤੇ ਸੈਂਡਬਾਕਸ ਅੰਦਰਲੀ ਪ੍ਰਕਿਰਿਆ ਲਿਸਨਰ ਦੀ ਆਪਣੀ ਕਾਪੀ ਬੰਦ ਕਰਦੀ ਹੈ.

TCP ਲਿਸਨਰ ਤਿਆਰ ਹੋਣ ਮਗਰੋਂ, ਸੈਂਡਬਾਕਸ ਅੰਦਰਲੀ ਪ੍ਰਕਿਰਿਆ HTTP_PROXY ਲਈ ਢੁਕਵਾਂ ਮੁੱਲ ਸੈੱਟ ਕਰਦੀ ਹੈ⁠(ਨਵੀਂ ਵਿੰਡੋ ਵਿੱਚ ਖੁੱਲ੍ਹਦਾ ਹੈ) ਅਤੇ ਸੰਬੰਧਿਤ ਵਾਤਾਵਰਨ ਵੇਰੀਏਬਲਾਂ ਨੂੰ ਉਸ ਲਿਸਨਰ ਵੱਲ ਨਿਰਦੇਸ਼ਿਤ ਕਰਦੀ ਹੈ. ਫਿਰ ਇਹ ਫੋਰਕ ਕਰਨ ਅਤੇ ਵਰਤੋਂਕਾਰ ਦੀ ਕਮਾਂਡ ਚਲਾਉਣ ਤੋਂ ਪਹਿਲਾਂ seccomp ਲਾਗੂ ਕਰਦੀ ਹੈ:

ਚਿੱਤਰ ਵਿੱਚ ਸੈਂਡਬਾਕਸ ਅੰਦਰਲਾ ਪ੍ਰੋਗਰਾਮ ਲੂਪਬੈਕ TCP ਲਿਸਨਰ ਨਾਲ ਜੁੜਦਾ ਹੈ, ਅਤੇ ਬਾਹਰਲਾ codex-linux-sandbox ਰੀਲੇਅ ਟ੍ਰੈਫ਼ਿਕ ਨੂੰ Codex ਨੈੱਟਵਰਕ ਪ੍ਰੌਕਸੀ ਤੱਕ ਪਹੁੰਚਾਉਂਦਾ ਹੈ.

ਸੈਂਡਬਾਕਸ ਤੋਂ ਬਾਹਰਲੀ ਪ੍ਰਕਿਰਿਆ ਲਿਸਨਰ ਨੂੰ ਖੁੱਲ੍ਹਾ ਰੱਖਦੀ ਹੈ. ਹਰੇਕ ਸਵੀਕਾਰ ਕੀਤੇ ਕਨੈਕਸ਼ਨ ਲਈ, ਇਹ ਕੌਂਫਿਗਰ ਕੀਤੀ ਪ੍ਰੌਕਸੀ ਨਾਲ ਕਨੈਕਸ਼ਨ ਖੋਲ੍ਹਦੀ ਹੈ ਅਤੇ ਦੋਵੇਂ ਦਿਸ਼ਾਵਾਂ ਵਿੱਚ ਡੇਟਾ ਪਹੁੰਚਾਉਂਦੀ ਹੈ.

ਇਹ ਵਾਧੂ ਵਿਵਸਥਾ ਕਮਾਂਡ ਨੂੰ ਆਪਣਾ ਨੈੱਟਵਰਕ ਨੇਮਸਪੇਸ ਦਿੰਦੀ ਹੈ, ਜਿਸ ਵਿੱਚ ਵੱਖਰਾ ਲੂਪਬੈਕ ਇੰਟਰਫੇਸ ਵੀ ਹੁੰਦਾ ਹੈ. macOS ਉੱਤੇ, Seatbelt ਕਮਾਂਡ ਨੂੰ ਹੋਸਟ ਦੇ ਲੂਪਬੈਕ ਇੰਟਰਫੇਸ ਦੀਆਂ ਨਿਰਧਾਰਤ ਪੋਰਟਾਂ ਨਾਲ ਸਿੱਧਾ ਜੁੜਨ ਦਿੰਦਾ ਹੈ. Linux ਉੱਤੇ, ਕਮਾਂਡ ਇਸ ਦੀ ਥਾਂ ਆਪਣੇ ਅਲੱਗ ਨੇਮਸਪੇਸ ਅੰਦਰਲੇ ਲਿਸਨਰ ਨਾਲ ਜੁੜਦੀ ਹੈ, ਅਤੇ ਸੈਂਡਬਾਕਸ ਤੋਂ ਬਾਹਰਲੀ ਪ੍ਰਕਿਰਿਆ ਉਹ ਕਨੈਕਸ਼ਨ ਕੌਂਫਿਗਰ ਕੀਤੀ ਪ੍ਰੌਕਸੀ ਤੱਕ ਪਹੁੰਚਾਉਂਦੀ ਹੈ. ਡਿਸਕ੍ਰਿਪਟਰ ਸੌਂਪਣ ਨਾਲ ਇਹ ਕਨੈਕਸ਼ਨ ਹੋਸਟ ਦਾ ਨੈੱਟਵਰਕ ਨੇਮਸਪੇਸ ਕਮਾਂਡ ਲਈ ਖੋਲ੍ਹੇ ਬਿਨਾਂ ਸੰਭਵ ਹੁੰਦਾ ਹੈ.

Windows

ਇਸ ਸਾਲ ਦੇ ਸ਼ੁਰੂ ਵਿੱਚ, ਅਸੀਂ Windows ਉੱਤੇ ਸੈਂਡਬਾਕਸਿੰਗ ਲਾਗੂ ਕੀਤੀ ਅਤੇ ਇਸ ਲਈ ਕੀਤੇ ਆਪਣੇ ਯਤਨਾਂ ਬਾਰੇ ਲਿਖਿਆ. ਉਸ ਤੋਂ ਬਾਅਦ, Microsoft ਨੇ Windows ਓਪਰੇਟਿੰਗ ਸਿਸਟਮ ਅੰਦਰ ਪ੍ਰਕਿਰਿਆਵਾਂ ਨੂੰ ਅਲੱਗ ਰੱਖਣ ਦੀਆਂ ਨਵੀਆਂ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਨਾਲ MXC ਨਾਂ ਦੀ ਲਾਇਬ੍ਰੇਰੀ ਜਾਰੀ ਕੀਤੀ ਹੈ. ਅਸੀਂ ਹੁਣ ਆਪਣਾ ਮੌਜੂਦਾ ਸੈਂਡਬਾਕਸ ਬਦਲ ਕੇ MXC ਲਾਇਬ੍ਰੇਰੀ ਵਰਤਣ ਵਾਲਾ ਸੈਂਡਬਾਕਸ ਲਿਆ ਰਹੇ ਹਾਂ.

MXC ਕੀ ਹੈ?

MXC (Microsoft eXecution Container), Microsoft ਦਾ ਸੈਂਡਬਾਕਸ ਵਿੱਚ ਕੋਡ ਚਲਾਉਣ ਵਾਲਾ ਸਿਸਟਮ⁠(ਨਵੀਂ ਵਿੰਡੋ ਵਿੱਚ ਖੁੱਲ੍ਹਦਾ ਹੈ) ਹੈ, ਜੋ Windows, Linux ਅਤੇ macOS ਉੱਤੇ ਕਈ ਸੀਮਾਬੰਦੀ ਬੈਕਐਂਡਾਂ ਦਾ ਸਮਰਥਨ ਕਰਦਾ ਹੈ. Codex ਅਨੁਕੂਲ Windows ਡਿਵਾਈਸਾਂ ਉੱਤੇ MXC-ਆਧਾਰਿਤ ਸੈਂਡਬਾਕਸ ਦਾ ਸਮਰਥਨ ਕਰਦਾ ਹੈ. ਇਹ ਸਿਸਟਮ ਦੀ ਮੂਲ ਪ੍ਰਕਿਰਿਆ-ਅਲੱਗੀਕਰਨ ਵਿਵਸਥਾ ਰਾਹੀਂ ਵਰਤੋਂਕਾਰ ਦੇ ਮੌਜੂਦਾ ਵਾਤਾਵਰਨ ਅੰਦਰ ਕਮਾਂਡਾਂ ਨੂੰ ਸੀਮਿਤ ਕਰਦਾ ਹੈ.

ਅਸੀਂ ਸੁਰੱਖਿਆ ਅਤੇ ਵਰਤੋਂ ਦੀ ਸਹੂਲਤ ਸੁਧਾਰਨ ਲਈ MXC ਵੱਲ ਬਦਲ ਰਹੇ ਹਾਂ, ਨਾਲ ਹੀ ਆਪਣੇ ਮੌਜੂਦਾ Windows ਸੈਂਡਬਾਕਸ ਦੀਆਂ ਕਈ ਕਮੀਆਂ ਦੂਰ ਕਰ ਰਹੇ ਹਾਂ:

  • ਸੈਂਡਬਾਕਸ ਸੈੱਟਅੱਪ ਲਈ ਉੱਚੇ/ਪ੍ਰਬੰਧਕੀ ਅਧਿਕਾਰਾਂ ਦੀ ਲੋੜ

  • 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

ਧੰਨਵਾਦ

ਇਸ ਪੋਸਟ ਵਿੱਚ ਯੋਗਦਾਨ ਲਈ ਡੇਵਿਡ ਵੀਜ਼ਨ, ਚਾਰਲੀ ਵੀਮਜ਼, ਵਿਯਤ ਭਲੋਡੀਆ ਅਤੇ ਫ਼ੋਟਿਸ ਚੈਂਟਜ਼ਿਸ ਦਾ ਵਿਸ਼ੇਸ਼ ਧੰਨਵਾਦ.