🛡️ सैंडबॉक्स्ड अनट्रस्टेड कोड एक्ज़ीक्यूशन रनर

अविश्वसनीय कोड का कर्नेल-प्रवर्तित निष्पादन — प्रत्येक पेलोड cgroups v2, namespaces, seccomp-BPF और एक रीड-ओनली rootfs द्वारा कैद, और प्रत्येक रन PostgreSQL में ऑडिट किया गया।

python · javascript · bash → 5-सेकंड, 128 MB, 0.5-कोर, 32-PID, 512 KB-आउटपुट जेल

अवलोकन

उस कोड के लिए एक सुरक्षा-सुदृढ़ निष्पादन सेवा जिस पर आप भरोसा नहीं करते। कॉलर एक छोटे REST API के माध्यम से स्रोत सबमिट करते हैं; डेमॉन प्रत्येक पेलोड को एक अस्थायी कर्नेल जेल में प्रजनन करता है जहाँ Linux कर्नेल स्वयं — एप्लिकेशन लॉजिक नहीं — नियंत्रण की गारंटी देता है:

प्रक्रिया फ़ाइलसिस्टम से बच नहीं सकती (रीड-ओनली rootfs पर pivot_root),
यह नेटवर्क या होस्ट से बात नहीं कर सकती (निजी namespaces + lo डाउन + seccomp socket को मारता है),
यह मशीन को समाप्त नहीं कर सकती (cgroups v2 मेमोरी/CPU/PID सीमाएँ),
यह अपने बजट से अधिक नहीं जी सकती (5 s वॉल-क्लॉक वॉचडॉग), और
प्रत्येक परिणाम — उल्लंघनों सहित — एक अपरिवर्तनीय ऑडिट ट्रेल में दर्ज होता है।

मुख्य विशेषताएँ

🧱 गहन रक्षा — छह Linux namespaces (PID · MOUNT · NET · IPC · UTS · USER), एक सख्त seccomp-BPF allowlist, cgroups v2 संसाधन जेल, और 16 MB tmpfs स्क्रैच स्पेस के साथ एक रीड-ओनली pivot_root फ़ाइलसिस्टम।
⚡ सब-सेकंड शुरुआत — 3-सेकंड के acquire टाइमआउट के साथ 16 निष्पादन स्लॉट का वार्म पूल प्रति-अनुरोध कोल्ड-स्टार्ट लागत से बचता है जबकि समवर्तीता को सीमित करता है।
⏱️ निर्धारक सीमाएँ — कठोर 5 s वॉल-क्लॉक टाइमआउट, 128 MB मेमोरी सीमा (स्वैप अक्षम, तत्काल OOM किल), 0.5 CPU कोर, pids.max = 32 फोर्क-बम प्रतिरक्षा, और stdout/stderr पर 512 KB आउटपुट सीमाएँ।
📜 पूर्ण निष्पादन ऑडिट — एग्ज़िट कोड, वॉल टाइम, शिखर मेमोरी, CPU समय, ट्रंकेशन फ़्लैग, और सुरक्षा घटनाएँ अतुल्यकालिक रूप से PostgreSQL (execution_runs) में लिखी जाती हैं।
🧪 आक्रमण-स्तरीय परीक्षण सूट — फोर्क बम, नेटवर्क एस्केप, मेमोरी OOM, टाइमआउट वॉचडॉग, और समवर्तीता तनाव के लिए समर्पित एकीकरण परीक्षण, जो वास्तविक कर्नेल के विरुद्ध एक विशेषाधिकार प्राप्त कंटेनर के अंदर चलाए जा सकते हैं।

सिस्टम आर्किटेक्चर

flowchart LR
    CLI["👤 API Client<br/><i>tenant / CI job</i>"]

    subgraph CP["🔐 Trusted Control Plane — Go daemon"]
        API["Ingestion Daemon<br/><i>net/http :8080</i>"]
        POOL["Warm Runner Pool<br/><i>16 slots · 3 s cap</i>"]
        RUN["Process Runner<br/><i>watchdog + pipes</i>"]
        ISO["Kernel Isolation<br/><i>cgroups v2 · namespaces · seccomp-BPF</i>"]
    end

    subgraph JAIL["⛓️ Ephemeral Kernel Jail — untrusted"]
        INIT["sandbox_init<br/><i>exec trampoline</i>"]
        GUEST["💀 Untrusted Code<br/><i>python · node · bash</i>"]
    end

    PG[("🗄️ PostgreSQL 16<br/><i>execution_runs</i>")]
    RD[("📮 Redis 7 Queue<br/><i>sandbox:jobs</i>")]

    CLI -->|"POST /api/v1/execute"| API
    API -->|"validate + acquire"| POOL
    POOL -->|"spawn + limits"| RUN
    RUN -.->|"apply jail"| ISO
    ISO ==>|"seccomp · pivot_root"| GUEST
    RUN -->|"fork / exec"| INIT
    INIT -->|"syscall.Exec"| GUEST
    RUN -.->|"stdout / stderr ≤ 512 KB"| POOL
    API -.->|"async audit INSERT"| PG
    RD -.->|"BRPop drain · worker module"| POOL

    style JAIL fill:#2a1215,stroke:#f87171,stroke-width:2px
    style CP fill:#0d1b2a,stroke:#38bdf8,stroke-width:1px

घटक विभाजन

घटक	जिम्मेदारी	स्रोत
Ingestion Daemon	REST सतह: `POST /api/v1/execute` + `/health`; अनुरोध सत्यापन; async ऑडिट उत्सर्जन	`cmd/server/main.go`
Warm Runner Pool	Semaphore-सीमित निष्पादन स्लॉट (16) 3 s acquire टाइमआउट के साथ → `503`-शैली थकावट बैकप्रेशर	`internal/runner/pool.go`
Process Runner	भाषा कमांड बनाता है, cgroup संलग्न करता है, truncating writers के माध्यम से पाइप स्ट्रीम करता है, 5 s वॉचडॉग लागू करता है, cgroup मेट्रिक्स एकत्र करता है, परिणामों को वर्गीकृत करता है	`internal/runner/process.go`
Kernel Isolation	cgroups v2 लिमिटर (`memory.max`, `cpu.max`, `pids.max`), namespace फ़्लैग (`CLONE_NEWPID/NET/NS/IPC/UTS/USER`), seccomp-BPF फ़िल्टर कंपाइलर	`internal/isolation/`
sandbox_init	चाइल्ड ट्रैम्पोलिन: केवल-पढ़ने योग्य `pivot_root` + tmpfs `/dev`/`/tmp`, नेटवर्क वियोजन (`lo` down), seccomp लागू करें, फिर लक्ष्य का `syscall.Exec`	`cmd/sandbox_init/main.go`
Untrusted Code	अतिथि पेलोड। होस्ट डिवाइस हटाए गए, `/proc` छिपा हुआ (`hidepid=2`), सभी गैर-अनुमत सिसकॉल मारे गए	`runtimes/` rootfs इमेजेस
PostgreSQL 16	प्रत्येक रन का टिकाऊ ऑडिट लॉग, सुरक्षा उल्लंघनों सहित	`migrations/001_init_sandbox_schema.sql`
Redis 7	`sandbox:jobs` कतार + `BRPop` वर्कर जो पूल में ड्रेन करता है (मॉड्यूल कार्यान्वित, अभी तक डेमॉन में वायर्ड नहीं — ज्ञात सीमाएँ देखें)	`internal/queue/redis_consumer.go`

विश्वास सीमाएँ

सीमा	यह किसे अलग करती है	प्रवर्तन
Client ↔ Daemon	कंट्रोल प्लेन से अप्रमाणित पेलोड सबमिशन	स्कीमा सत्यापन (`tenant_id`, `language`, `code`)
Control plane ↔ Jail	विश्वसनीय Go कोड बनाम शत्रुतापूर्ण पेलोड	निजी नेमस्पेस में `fork`; `pivot_root`; seccomp inherit-on-exec
Jail ↔ Kernel limits	अतिथि संसाधन खपत बनाम होस्ट क्षमता	cgroups v2 `memory.max=128MB`, `swap.max=0`, `cpu.max="50000 100000"`, `pids.max=32`
Jail ↔ Network	कोई भी बहिर्गमन या होस्ट-साइड पहुँच	निजी `NET` नेमस्पेस, `lo` down, `socket` सिसकॉल मारा गया

🔍 इस आरेख का एक इंटरैक्टिव, थीम-जागरूक संस्करण (PNG/SVG निर्यात के साथ) docs/archify/ में साक्ष्य-समर्थित उम्मीदवारों से तैयार किया गया है।

निष्पादन जीवनचक्र — अनुरोध से ऑडिट तक

sequenceDiagram
    autonumber
    participant C as Client
    participant A as REST API
    participant P as Warm Pool
    participant R as Process Runner
    participant I as sandbox_init
    participant G as Untrusted Code
    participant DB as PostgreSQL

    C->>A: POST /api/v1/execute
    A->>P: acquire slot · 16 max, 3 s timeout
    P->>R: Run(req, limits)
    R->>I: fork under CLONE_NEWPID·NET·NS·IPC·UTS·USER
    R->>R: create cgroup scope → attach PID<br/>128 MB · 0.5 CPU · 32 PIDs
    I->>I: pivot_root RO rootfs · lo down · seccomp-BPF
    I->>G: syscall.Exec target interpreter
    G-->>R: stdout / stderr via pipes (512 KB cap)
    R->>R: watchdog: SIGKILL at 5 s → exit 137
    R-->>P: result + cgroup metrics (peak mem, CPU)
    P-->>A: ExecutionResult
    A-->>C: 200 JSON
    A-)DB: async audit INSERT (non-blocking)

चरण-दर-चरण:

सबसे लोकप्रिय

sandboxed-untrusted-code-execution-runner