सैंडबॉक्स2 के साथ शुरू करें

इस पेज पर, Sandbox2 की मदद से अपना सैंडबॉक्स एनवायरमेंट बनाने का तरीका बताया गया है. आपको सैंडबॉक्स नीति तय करने का तरीका बताया जाएगा. साथ ही, कुछ ऐडवांस, लेकिन सामान्य बदलावों के बारे में भी बताया जाएगा. यहां दी गई जानकारी को गाइड के तौर पर इस्तेमाल करें. साथ ही, हेडर फ़ाइलों में दिए गए उदाहरण और कोड के दस्तावेज़ भी देखें.

1. सैंडबॉक्स एक्ज़ीक्यूटर का तरीका चुनना

सैंडबॉक्सिंग की प्रोसेस, एक्ज़ीक्यूटर (सैंडबॉक्स एक्ज़ीक्यूटर देखें) से शुरू होती है. यह सैंडबॉक्सी को चलाने के लिए ज़िम्मेदार होता है. executor.h हेडर फ़ाइल में, इस काम के लिए ज़रूरी एपीआई मौजूद होता है. यह एपीआई बहुत आसान है. इसकी मदद से, अपनी ज़रूरत के हिसाब से सबसे सही विकल्प चुना जा सकता है. नीचे दिए गए सेक्शन में, तीन अलग-अलग तरीकों के बारे में बताया गया है. इनमें से कोई भी तरीका चुना जा सकता है.

पहला तरीका: स्टैंड-अलोन – पहले से चालू सैंडबॉक्सिंग के साथ बाइनरी को लागू करना

सैंडबॉक्सिंग का इस्तेमाल करने का यह सबसे आसान तरीका है. अगर आपको किसी ऐसे पूरे बाइनरी को सैंडबॉक्स करना है जिसका सोर्स कोड आपके पास नहीं है, तो हमारा सुझाव है कि आप इस तरीके का इस्तेमाल करें. सैंडबॉक्सिंग का इस्तेमाल करने का यह सबसे सुरक्षित तरीका भी है, क्योंकि इसमें सैंडबॉक्स न किए गए किसी भी तरीके से शुरुआत नहीं की जाती है. इससे, बुरे असर से बचा जा सकता है.

यहां दिए गए कोड स्निपेट में, हम सैंडबॉक्स किए जाने वाले बाइनरी के पाथ के बारे में बताते हैं. साथ ही, उन आर्ग्युमेंट के बारे में बताते हैं जिन्हें हमें execve syscall को पास करना है. जैसा कि आप executor.h हेडर फ़ाइल में देख सकते हैं, हम envp के लिए कोई वैल्यू तय नहीं करते हैं. इसलिए, पैरंट प्रोसेस से एनवायरमेंट को कॉपी करते हैं. याद रखें कि पहला आर्ग्युमेंट हमेशा उस प्रोग्राम का नाम होता है जिसे एक्ज़ीक्यूट करना है. साथ ही, हमारा स्निपेट किसी अन्य आर्ग्युमेंट को तय नहीं करता.

इस एक्ज़ीक्यूटर तरीके के उदाहरणों में, static और tool शामिल हैं.

#include "sandboxed_api/sandbox2/executor.h"

std::string path = "path/to/binary";
std::vector<std::string> args = {path};  // args[0] will become the sandboxed
                                         // process' argv[0], typically the
                                         // path to the binary.
auto executor = absl::make_unique<sandbox2::Executor>(path, args);

दूसरा तरीका: Sandbox2 Forkserver – एक्ज़ीक्यूटर को बताएं कि सैंडबॉक्स कब करना है

इस तरीके से, शुरू होने के दौरान सैंडबॉक्स से बाहर रहने की सुविधा मिलती है. इसके बाद, ::sandbox2::Client::SandboxMeHere() को कॉल करके, सैंडबॉक्स में शामिल होने का समय चुना जा सकता है. इसमें आपको कोड में यह तय करना होता है कि आपको सैंडबॉक्सिंग कब शुरू करनी है. साथ ही, यह सिंगल-थ्रेड होना चाहिए. इसकी वजह जानने के लिए, अक्सर पूछे जाने वाले सवाल पढ़ें.

यहां दिए गए कोड स्निपेट में, हम उसी कोड का इस्तेमाल करते हैं जो ऊपर दिए गए पहले तरीके में बताया गया है. हालांकि, प्रोग्राम को शुरू करने के दौरान, उसे अनसैंडबॉक्स तरीके से चलाने के लिए, हम set_enable_sandbox_before_exec(false) को कॉल करते हैं.

#include "sandboxed_api/sandbox2/executor.h"

std::string path = "path/to/binary";
std::vector<std::string> args = {path};
auto executor = absl::make_unique<sandbox2::Executor>(path, args);
executor->set_enable_sandbox_before_exec(false);

एग्ज़ीक्यूटर के पास अब एक बंद सैंडबॉक्स है. यह तब तक बंद रहेगा, जब तक सैंडबॉक्स किए गए प्रोग्राम से सूचना नहीं मिलती. इसलिए, हमें ::sandbox2::Client का एक इंस्टेंस बनाना होगा. साथ ही, एग्ज़ीक्यूटर और सैंडबॉक्स किए गए प्रोग्राम के बीच कम्यूनिकेशन सेट अप करना होगा. इसके बाद, एग्ज़ीक्यूटर को सूचना देनी होगी कि हमारा शुरू करने का प्रोसेस पूरा हो गया है. साथ ही, हमें sandbox2_client.SandboxMeHere() को कॉल करके, सैंडबॉक्सिंग शुरू करनी होगी.

// main() of sandboxee
int main(int argc, char** argv) {
  gflags::ParseCommandLineFlags(&argc, &argv, false);

  // Set-up the sandbox2::Client object, using a file descriptor (1023).
  sandbox2::Comms comms(sandbox2::Comms::kSandbox2ClientCommsFD);
  sandbox2::Client sandbox2_client(&comms);
  // Enable sandboxing from here.
  sandbox2_client.SandboxMeHere();
  …

इस एक्ज़ीक्यूटर तरीके का एक उदाहरण crc4 है. इसमें crc4bin.cc सैंडबॉक्सी है और यह एक्ज़ीक्यूटर (crc4sandbox.cc) को सूचना देता है कि इसे सैंडबॉक्स में कब शामिल होना चाहिए.

तीसरा तरीका: कस्टम फ़ोर्कसर्वर – एक बाइनरी तैयार करें, फ़ोर्क के अनुरोधों का इंतज़ार करें, और सैंडबॉक्स को अपने हिसाब से कॉन्फ़िगर करें

इस मोड की मदद से, किसी बाइनरी को शुरू किया जा सकता है, उसे सैंडबॉक्सिंग के लिए तैयार किया जा सकता है, और बाइनरी के लाइफ़साइकल के किसी खास समय पर, उसे एक्ज़ीक्यूटर के लिए उपलब्ध कराया जा सकता है.

एक्ज़ीक्यूटर, आपके बाइनरी को फ़ोर्क करने का अनुरोध भेजेगा. इससे fork() (::sandbox2::ForkingClient::EnterForkLook() के ज़रिए) होगा. नई प्रोसेस, ::sandbox2::Client::SandboxMeHere() के साथ सैंडबॉक्स करने के लिए तैयार होगी.

#include "sandboxed_api/sandbox2/executor.h"

// Start the custom ForkServer
std::string path = "path/to/binary";
std::vector<std::string> args = {path};
auto fork_executor = absl::make_unique<sandbox2::Executor>(path, args);
fork_executor->StartForkServer();

// Initialize Executor with Comms channel to the ForkServer
auto executor = absl::make_unique<sandbox2::Executor>(
    fork_executor->ipc()->GetComms());

ध्यान रखें कि यह मोड काफ़ी जटिल है और सिर्फ़ कुछ खास मामलों में लागू होता है. उदाहरण के लिए, जब आपके पास मेमोरी की ज़रूरतें सीमित हों. आपको सीओडब्ल्यू से फ़ायदा मिलेगा, लेकिन नुकसान यह है कि इसमें कोई असली एएसएलआर नहीं है. सैंडबॉक्स का इस्तेमाल करने का एक और उदाहरण तब होता है, जब सैंडबॉक्स में मौजूद प्रोग्राम को शुरू करने में ज़्यादा समय लगता है और सीपीयू का ज़्यादा इस्तेमाल होता है. इसे अविश्वसनीय डेटा को प्रोसेस करने से पहले चलाया जा सकता है.

एग्ज़ीक्यूटर के इस तरीके का उदाहरण देखने के लिए, custom_fork देखें.

2. सैंडबॉक्स की नीति बनाना

एग्ज़ीक्यूटर मिलने के बाद, आपको सैंडबॉक्स के लिए सैंडबॉक्स नीति तय करनी होगी. ऐसा न होने पर, सैंडबॉक्सी को सिर्फ़ डिफ़ॉल्ट सिस्कॉल नीति से सुरक्षित किया जाता है.

सैंडबॉक्स नीति का मकसद, सैंडबॉक्स किए गए प्रोग्राम के लिए सिस्टम कॉल और आर्ग्युमेंट को सीमित करना है. साथ ही, उन फ़ाइलों को सीमित करना है जिन्हें सैंडबॉक्स किया गया प्रोग्राम ऐक्सेस कर सकता है. आपको उस कोड के लिए ज़रूरी syscalls के बारे में पूरी जानकारी होनी चाहिए जिसे आपको सैंडबॉक्स करना है. सिस्टम कॉल को मॉनिटर करने का एक तरीका है, Linux के कमांड-लाइन टूल strace की मदद से कोड को चलाना.

सिस्टम कॉल की सूची मिलने के बाद, नीति तय करने के लिए PolicyBuilder का इस्तेमाल किया जा सकता है.

PolicyBuilder में कई सुविधाजनक और हेल्पर फ़ंक्शन होते हैं. इनकी मदद से, कई सामान्य कार्रवाइयां की जा सकती हैं. इनमें से कई कार्रवाइयां, DefaultPolicyBuilder() में पहले से शामिल हैं. यहां दी गई सूची में, उपलब्ध फ़ंक्शन का सिर्फ़ एक छोटा सा हिस्सा शामिल है:

  • प्रोसेस स्टार्टअप के लिए, किसी भी syscall को अनुमति वाली सूची में शामिल करें:
    • AllowStaticStartup();
    • AllowDynamicStartup();
  • किसी भी open/read/write* syscall को अनुमति वाली सूची में जोड़ें:
    • AllowOpen();
    • AllowRead();
    • AllowWrite();
  • एग्ज़िट/ऐक्सेस/स्टेट से जुड़े किसी भी syscall को अनुमति वाली सूची में शामिल करें:
    • AllowExit();
    • AllowStat();
    • AllowAccess();
  • स्लीप/टाइम से जुड़े किसी भी syscall को अनुमति वाली सूची में शामिल करें:
    • AllowTime();
    • AllowSleep();

ये सुविधा फ़ंक्शन, किसी भी काम के syscall को अनुमति वाली सूची में शामिल करते हैं. इसका फ़ायदा यह है कि एक ही नीति का इस्तेमाल अलग-अलग आर्किटेक्चर पर किया जा सकता है. हालांकि, कुछ सिसकॉल उपलब्ध नहीं हैं. उदाहरण के लिए, ARM64 में OPEN सिसकॉल नहीं है. हालांकि, इसमें सुरक्षा से जुड़ा थोड़ा जोखिम है. ऐसा इसलिए, क्योंकि इसमें ज़रूरत से ज़्यादा सिसकॉल चालू किए जा सकते हैं. उदाहरण के लिए, AllowOpen() की मदद से, सैंडबॉक्स किया गया ऐप्लिकेशन, open से जुड़े किसी भी syscall को कॉल कर सकता है. अगर आपको सिर्फ़ एक syscall को अनुमति वाली सूची में शामिल करना है, तो AllowSyscall(); का इस्तेमाल करें. एक से ज़्यादा syscall को अनुमति वाली सूची में शामिल करने के लिए, AllowSyscalls() का इस्तेमाल करें.

अब तक यह नीति, सिर्फ़ syscall आइडेंटिफ़ायर की जांच करती है. अगर आपको नीति को और मज़बूत करना है और ऐसी नीति तय करनी है जिसमें सिर्फ़ खास आर्ग्युमेंट वाले syscall की अनुमति हो, तो आपको AddPolicyOnSyscall() या AddPolicyOnSyscalls() का इस्तेमाल करना होगा. ये फ़ंक्शन, सिर्फ़ सिसकॉल आईडी को आर्ग्युमेंट के तौर पर नहीं लेते हैं. ये Linux कर्नल से bpf हेल्पर मैक्रो का इस्तेमाल करके, रॉ सेस्कॉम्प-बीपीएफ़ फ़िल्टर भी लेते हैं. बीपीएफ़ के बारे में ज़्यादा जानकारी के लिए, कर्नेल दस्तावेज़ देखें. अगर आपको बार-बार बीपीएफ़ कोड लिखना पड़ता है और आपको लगता है कि इसका इस्तेमाल रैपर के तौर पर किया जाना चाहिए, तो सुविधा के लिए अनुरोध करें.

सिस्टम कॉल से जुड़े फ़ंक्शन के अलावा, PolicyBuilder फ़ाइल सिस्टम से जुड़े कई फ़ंक्शन भी उपलब्ध कराता है. जैसे, सैंडबॉक्स में किसी फ़ाइल/डायरेक्ट्री को बाइंड-माउंट करने के लिए, AddFile() या AddDirectory(). AddTmpfs() हेल्पर का इस्तेमाल, सैंडबॉक्स में कुछ समय के लिए फ़ाइल स्टोरेज जोड़ने के लिए किया जा सकता है.

AddLibrariesForBinary() एक खास तौर पर उपयोगी फ़ंक्शन है, जो बाइनरी के लिए ज़रूरी लाइब्रेरी और लिंकर जोड़ता है.

हालांकि, अनुमति वाली सूची में शामिल करने के लिए, सिस्टम कॉल की पहचान करने का काम अब भी मैन्युअल तरीके से करना पड़ता है. उन syscalls के साथ एक नीति बनाएं जिनकी ज़रूरत आपके बाइनरी को है. इसके बाद, इसे सामान्य वर्कलोड के साथ चलाएं. उल्लंघन का पता चलने पर, syscall को अनुमति वाली सूची में शामिल करें और प्रोसेस को दोहराएं. अगर आपको किसी ऐसे उल्लंघन का पता चलता है जिसे अनुमति वाली सूची में शामिल करना जोखिम भरा हो सकता है और प्रोग्राम गड़बड़ियों को ठीक से मैनेज करता है, तो BlockSyscallWithErrno() का इस्तेमाल करके गड़बड़ी का मैसेज दिखाया जा सकता है.

यहां दिए गए उदाहरण में, sandbox2::PolicyBuilder को सीधे तौर पर बनाया गया है, ताकि write और mprotect आर्ग्युमेंट को सीमित करने और openat को ब्लॉक करने का तरीका दिखाया जा सके. हालांकि, DefaultPolicyBuilder() इसकी अनुमति देता है:

#include "sandboxed_api/sandbox2/policy.h"
#include "sandboxed_api/sandbox2/policybuilder.h"
#include "sandboxed_api/sandbox2/util/bpf_helper.h"

std::unique_ptr<sandbox2::Policy> CreatePolicy() {
  return sandbox2::PolicyBuilder()
    .AllowSyscall(__NR_read)  // See also AllowRead()
    .AllowTime()              // Allow time, gettimeofday and clock_gettime
    .AddPolicyOnSyscall(__NR_write, {
        ARG(0),        // fd is the first argument of write (argument #0)
        JEQ(1, ALLOW), // allow write only on fd 1
        KILL,          // kill if not fd 1
    })
    .AddPolicyOnSyscall(__NR_mprotect, {
        ARG_32(2), // prot is a 32-bit wide argument, so it's OK to use *_32
                   // macro here
        JNE32(PROT_READ | PROT_WRITE, KILL), // prot must be the RW, otherwise
                                             // kill the process
        ARG(1), // len is a 64-bit argument
        JNE(0x1000, KILL),  // Allow single page syscalls only, otherwise kill
                            // the process
        ALLOW,              // Allow for the syscall to proceed, if prot and
                            // size match
    })
    // Allow the openat() syscall but always return "not found".
    .BlockSyscallWithErrno(__NR_openat, ENOENT)
    .BuildOrDie();
}

3. सीमाएं घटाना या बढ़ाना

सैंडबॉक्स की नीति, सैंडबॉक्सी को कुछ खास सिस्टम कॉल करने से रोकती है. इससे हमले की जगह कम हो जाती है. हालांकि, हमलावर अब भी किसी प्रोसेस को अनिश्चित समय तक चलाकर या रैम और अन्य संसाधनों को खत्म करके, अनचाहे असर डाल सकता है.

इस खतरे से निपटने के लिए, Sandboxee को डिफ़ॉल्ट रूप से, एक्ज़ीक्यूशन की तय सीमाओं के तहत चलाया जाता है. अगर इन डिफ़ॉल्ट सीमाओं की वजह से, आपके प्रोग्राम को सही तरीके से लागू करने में समस्याएं आ रही हैं, तो sandbox2::Limits क्लास का इस्तेमाल करके इनमें बदलाव किया जा सकता है. इसके लिए, एक्ज़ीक्यूटर ऑब्जेक्ट पर limits() को कॉल करें.

यहां दिए गए कोड स्निपेट में, सीमा में बदलाव करने के कुछ उदाहरण दिए गए हैं. सभी उपलब्ध विकल्पों को limits.h हेडर फ़ाइल में दर्ज किया गया है.

// Restrict the address space size of the sandboxee to 4 GiB.
executor->limits()->set_rlimit_as(4ULL << 30);
// Kill sandboxee with SIGXFSZ if it writes more than 1 GiB to the filesystem.
executor->limits()->set_rlimit_fsize(1ULL << 30);
// Number of file descriptors which can be used by the sandboxee.
executor->limits()->set_rlimit_nofile(1ULL << 10);
// The sandboxee is not allowed to create core files.
executor->limits()->set_rlimit_core(0);
// Maximum 300s of real CPU time.
executor->limits()->set_rlimit_cpu(300);
// Maximum 120s of wall time.
executor->limits()->set_walltime_limit(absl::Seconds(120));

sandbox2::Limits क्लास के इस्तेमाल का उदाहरण देखने के लिए, उदाहरण के तौर पर दिया गया टूल देखें.

4. सैंडबॉक्स को चलाना

पिछले सेक्शन में, आपने सैंडबॉक्स एनवायरमेंट, नीति, एक्ज़ीक्यूटर, और सैंडबॉक्सी तैयार किए थे. अगला चरण, Sandbox2 ऑब्जेक्ट बनाना और उसे चलाना है.

सिंक्रोनस तरीके से चलाना

सैंडबॉक्स को सिंक्रोनस तरीके से चलाया जा सकता है. इससे, नतीजा मिलने तक प्रोसेस को ब्लॉक किया जा सकता है. यहां दिए गए कोड स्निपेट में, Sandbox2 ऑब्जेक्ट को इंस्टैंटिएट करने और उसे सिंक्रोनस तरीके से लागू करने का तरीका दिखाया गया है. ज़्यादा जानकारी वाले उदाहरण के लिए, static देखें.

#include "sandboxed_api/sandbox2/sandbox2.h"

sandbox2::Sandbox2 s2(std::move(executor), std::move(policy));
sandbox2::Result result = s2.Run();  // Synchronous
LOG(INFO) << "Result of sandbox execution: " << result.ToString();

एसिंक्रोनस तरीके से चलाएं

सैंडबॉक्स को एसिंक्रोनस तरीके से भी चलाया जा सकता है. इससे, नतीजे मिलने तक कोई रुकावट नहीं आती. उदाहरण के लिए, यह सैंडबॉक्स किए गए प्रोसेस के साथ कम्यूनिकेट करते समय काम आता है. यहां दिए गए कोड स्निपेट में, इस्तेमाल का यह उदाहरण दिखाया गया है. ज़्यादा जानकारी वाले उदाहरण देखने के लिए, crc4 और tool देखें.

#include "sandboxed_api/sandbox2/sandbox2.h"

sandbox2::Sandbox2 s2(std::move(executor), std::move(policy));
if (s2.RunAsync()) {
  // Communicate with sandboxee, use s2.Kill() to kill it if needed
  // ...
}
Sandbox2::Result result = s2.AwaitResult();
LOG(INFO) << "Final execution status: " << result.ToString();

5. सैंडबॉक्स में शामिल व्यक्ति या कंपनी से संपर्क करना

डिफ़ॉल्ट रूप से, एक्ज़ीक्यूटर, फ़ाइल डिस्क्रिप्टर के ज़रिए सैंडबॉक्सी से कम्यूनिकेट कर सकता है. आपको बस इतना ही करना होगा. उदाहरण के लिए, अगर आपको सैंडबॉक्स किए गए प्रोग्राम के साथ कोई फ़ाइल शेयर करनी है या सैंडबॉक्स किए गए प्रोग्राम का स्टैंडर्ड आउटपुट पढ़ना है.

हालांकि, आपको एक्ज़ीक्यूटर और सैंडबॉक्स किए गए प्रोग्राम के बीच, कम्यूनिकेशन के लिए ज़्यादा जटिल लॉजिक की ज़रूरत पड़ सकती है. Comms API (comms.h हेडर फ़ाइल देखें) का इस्तेमाल करके, पूर्णांक, स्ट्रिंग, बाइट बफ़र, प्रोटोबफ़ या फ़ाइल डिस्क्रिप्टर भेजे जा सकते हैं.

फ़ाइल डिस्क्रिप्टर शेयर करना

इंटर-प्रोसेस कम्यूनिकेशन एपीआई (ipc.h देखें) का इस्तेमाल करके, MapFd() या ReceiveFd() का इस्तेमाल किया जा सकता है:

  • एग्ज़ीक्यूटर से सैंडबॉक्स किए गए प्रोग्राम में फ़ाइल डिस्क्रिप्टर को मैप करने के लिए, MapFd() का इस्तेमाल करें. इसका इस्तेमाल, एक्ज़ीक्यूटर से खोली गई फ़ाइल को शेयर करने के लिए किया जा सकता है, ताकि उसे सैंडबॉक्स में इस्तेमाल किया जा सके. इसका एक उदाहरण static में देखा जा सकता है.

    // The executor opened /proc/version and passes it to the sandboxee as stdin
    executor->ipc()->MapFd(proc_version_fd, STDIN_FILENO);
    
  • socketpair एंडपॉइंट बनाने के लिए, ReceiveFd() का इस्तेमाल करें. इसका इस्तेमाल, सैंडबॉक्स किए गए प्रोग्राम के स्टैंडर्ड आउटपुट या स्टैंडर्ड गड़बड़ियों को पढ़ने के लिए किया जा सकता है. इसके इस्तेमाल का एक उदाहरण, टूल में देखा जा सकता है.

    // The executor receives a file descriptor of the sandboxee stdout
    int recv_fd1 = executor->ipc())->ReceiveFd(STDOUT_FILENO);
    

Comms API का इस्तेमाल करना

Sandbox2, comms एपीआई उपलब्ध कराता है. यह एक्ज़ीक्यूटर और सैंडबॉक्स के बीच पूर्णांक, स्ट्रिंग या बाइट बफ़र शेयर करने का एक आसान तरीका है. यहां कुछ कोड स्निपेट दिए गए हैं. इन्हें crc4 के उदाहरण में देखा जा सकता है.

Comms API का इस्तेमाल शुरू करने के लिए, आपको सबसे पहले Sandbox2 ऑब्जेक्ट से comms ऑब्जेक्ट पाना होगा:

sandbox2::Comms* comms = s2.comms();

comms ऑब्जेक्ट उपलब्ध होने के बाद, Send* फ़ैमिली के किसी एक फ़ंक्शन का इस्तेमाल करके, सैंडबॉक्स किए गए प्रोग्राम को डेटा भेजा जा सकता है. crc4 उदाहरण में, comms API के इस्तेमाल का उदाहरण देखा जा सकता है. नीचे दिए गए कोड स्निपेट में, उस उदाहरण का एक अंश दिखाया गया है. एक्ज़ीक्यूटर, SendBytes(buf, size) के साथ unsigned char buf[size] भेजता है:

if (!(comms->SendBytes(static_cast<const uint8_t*>(buf), sz))) {
  /* handle error */
}

सैंडबॉक्स से डेटा पाने के लिए, Recv* फ़ंक्शन में से किसी एक का इस्तेमाल करें. नीचे दिया गया कोड स्निपेट, crc4 के उदाहरण का एक अंश है. एक्ज़ीक्यूटर को 32-बिट के बिना हस्ताक्षर किए गए पूर्णांक में चेकसम मिलता है: uint32_t crc4;

if (!(comms->RecvUint32(&crc4))) {
  /* handle error */
}

बफ़र के साथ डेटा शेयर करना

डेटा शेयर करने का एक और तरीका है, बफ़र एपीआई का इस्तेमाल करना. इससे बड़ी मात्रा में डेटा शेयर किया जा सकता है. साथ ही, एक्ज़ीक्यूटर और सैंडबॉक्स के बीच डेटा की कॉपी भेजने और पाने में होने वाले खर्च से बचा जा सकता है.

एक्ज़ीक्यूटर, साइज़ और पास किए जाने वाले डेटा के हिसाब से या सीधे तौर पर फ़ाइल डिस्क्रिप्टर से बफ़र बनाता है. इसके बाद, वह इसे सैंडबॉक्सी को पास करता है. इसके लिए, वह एक्ज़ीक्यूटर में comms->SendFD() और सैंडबॉक्सी में comms->RecvFD() का इस्तेमाल करता है.

यहां दिए गए कोड स्निपेट में, एक्ज़ीक्यूटर की साइड देखी जा सकती है. सैंडबॉक्स, एसिंक्रोनस तरीके से चलता है और सैंडबॉक्स किए गए प्रोग्राम के साथ बफ़र के ज़रिए डेटा शेयर करता है:

// start the sandbox asynchronously
s2.RunAsync();

// instantiate the comms object
sandbox2::Comms* comms = s2.comms();

// random buffer data we want to send
constexpr unsigned char buffer_data[] = /* random data */;
constexpr unsigned int buffer_dataLen = 34;

// create sandbox2 buffer
absl::StatusOr<std::unique_ptr<sandbox2::Buffer>> buffer =
     sandbox2::Buffer::CreateWithSize(1ULL << 20 /* 1Mib */);
std::unique_ptr<sandbox2::Buffer> buffer_ptr = std::move(buffer).value();

// point to the sandbox2 buffer and fill with data
uint8_t* buf = buffer_ptr‑>data();
memcpy(buf, buffer_data, buffer_data_len);

// send the data to the sandboxee
comms‑>SendFd(buffer_ptr‑>fd());

सैंडबॉक्स किए गए प्रोग्राम की तरफ़, आपको एक बफ़र ऑब्जेक्ट भी बनाना होगा. साथ ही, एक्ज़ीक्यूटर से भेजे गए फ़ाइल डिस्क्रिप्टर से डेटा को पढ़ना होगा:

// establish the communication with the executor
int fd;
comms.RecvFD(&fd);

// create the buffer
absl::StatusOr<std::unique_ptr<sandbox2::Buffer>> buffer =
     sandbox2::Buffer::createFromFd(fd);

// get the data
auto buffer_ptr = std::move(buffer).value();
uint8_t* buf = buffer_ptr‑>data();

/* work with the buf object */

6. सैंडबॉक्स से बाहर निकलना

सैंडबॉक्स को चलाने के तरीके के आधार पर (यह चरण देखें), आपको सैंडबॉक्स को बंद करने का तरीका बदलना होगा. इसलिए, आपको सैंडबॉक्सी को भी बंद करना होगा.

सिंक्रोनस तरीके से चल रहे सैंडबॉक्स से बाहर निकलना

अगर सैंडबॉक्स को सिंक्रोनस तरीके से चलाया जा रहा है, तो Run फ़ंक्शन सिर्फ़ तब वैल्यू देगा, जब Sandboxee का काम पूरा हो जाएगा. इसलिए, खाता बंद करने के लिए कोई अतिरिक्त चरण पूरा करने की ज़रूरत नहीं है. यहां दिए गए कोड स्निपेट में इस स्थिति के बारे में बताया गया है:

Sandbox2::Result result = s2.Run();
LOG(INFO) << "Final execution status: " << result.ToString();

एसिंक्रोनस तरीके से चल रहे सैंडबॉक्स से बाहर निकलना

अगर सैंडबॉक्स एसिंक्रोनस तरीके से चल रहा है, तो उसे बंद करने के लिए दो विकल्प उपलब्ध हैं. सबसे पहले, सैंडबॉक्स के पूरा होने का इंतज़ार करें और एक्ज़ीक्यूशन की फ़ाइनल स्थिति पाएं:

sandbox2::Result result = s2.AwaitResult();
LOG(INFO) << "Final execution status: " << result.ToString();

इसके अलावा, आपके पास किसी भी समय Sandboxee को बंद करने का विकल्प होता है. हालांकि, हमारा सुझाव है कि आप AwaitResult() को कॉल करें. ऐसा इसलिए, क्योंकि हो सकता है कि इस बीच Sandboxee किसी अन्य वजह से बंद हो जाए:

s2.Kill();
sandbox2::Result result = s2.AwaitResult();
LOG(INFO) << "Final execution status: " << result.ToString();

7. टेस्ट

किसी भी अन्य कोड की तरह, आपके सैंडबॉक्स इंटिग्रेशन की जांच होनी चाहिए. सैंडबॉक्स टेस्ट का मकसद, प्रोग्राम की सही तरीके से जांच करना नहीं है. इसके बजाय, यह देखना है कि सैंडबॉक्स किया गया प्रोग्राम, सैंडबॉक्स के नियमों के उल्लंघन जैसी समस्याओं के बिना चल सकता है या नहीं. इससे यह भी पक्का होता है कि सैंडबॉक्स की नीति सही है.

सैंडबॉक्स किए गए प्रोग्राम की जांच उसी तरह की जाती है जिस तरह उसे प्रोडक्शन में चलाया जाता है. इसमें वे आर्ग्युमेंट और इनपुट फ़ाइलें शामिल होती हैं जिन्हें वह आम तौर पर प्रोसेस करता है.

ये टेस्ट, शेल टेस्ट या सब प्रोसेस का इस्तेमाल करके किए जाने वाले C++ टेस्ट जितने आसान हो सकते हैं. प्रेरणा पाने के लिए, उदाहरण देखें.

नतीजा

यहां तक पढ़ने के लिए धन्यवाद. हमें उम्मीद है कि आपको हमारी गाइड पसंद आई होगी. साथ ही, अब आपको अपने उपयोगकर्ताओं को सुरक्षित रखने के लिए, सैंडबॉक्स बनाने में मदद मिलेगी.

सैंडबॉक्स और नीतियां बनाना एक मुश्किल काम है. इसमें छोटी-छोटी गड़बड़ियां होने की संभावना होती है. हमारा सुझाव है कि आप किसी सुरक्षा विशेषज्ञ से अपनी नीति और कोड की समीक्षा कराएं. इससे आपको अपने खाते को सुरक्षित रखने में मदद मिलेगी.