gate0

एक छोटा, ऑडिट करने योग्य, समाप्त होने वाला, नियतिवादी माइक्रो-पॉलिसी इंजन।

Gate0 क्यों?

मैंने Gate0 इसलिए बनाया क्योंकि मैं प्रोडक्शन में RegEx-आधारित पॉलिसियों को डीबग करते-करते थक गया था। मैं कुछ ऐसा चाहता था जो उबाऊ, सीमाबद्ध और क्रैश होना असंभव हो। यदि आप एक लचीला, सामान्य-उद्देश्य वाला पॉलिसी इंजन चाहते हैं, तो आपको OPA का उपयोग करना चाहिए। यदि आप एक ऐसा पॉलिसी इंजन चाहते हैं जो सुरक्षा-महत्वपूर्ण मार्गों के लिए sub-50µs मूल्यांकन और शून्य आवंटन पर बेंचमार्क करता है, तो आपको Gate0 चाहिए।

सुरक्षा मॉडल

Gate0 उच्च-आश्वासन वातावरण के लिए डिज़ाइन किया गया है जहाँ पॉलिसी मूल्यांकन नियतिवादी और संसाधन-सीमाबद्ध होना चाहिए। भेद्यता रिपोर्ट करने के लिए सुरक्षा नीति देखें और पूर्ण खतरा मॉडल तथा यांत्रिक गारंटियों के लिए सुरक्षा मॉडल देखें।

आर्किटेक्चर

Gate0 एक रैखिक, Deny-Overrides मूल्यांकन रणनीति का उपयोग करता है। प्रत्येक नियम में एक Target (फास्ट-पाथ मैच) और एक वैकल्पिक Condition (गहरा तर्क) होता है।

+----------+       +-------------+       +--------+
| Ephemera | ----> | GateBridge  | ----> | Gate0  |
| (Legacy) |       | (Normalize) |       | (Core) |
+----------+       +-------------+       +--------+
     |                    ^
     |                    |
     +----(Shadow Log)----+

सत्यापन

Gate0 की शुद्धता और सुरक्षा यांत्रिक रूप से सत्यापित की जाती है: कोर लॉजिक और एज केस को कवर करने वाले यूनिट टेस्ट, सैकड़ों जेनरेट किए गए परिदृश्यों के साथ proptest के माध्यम से प्रॉपर्टी-आधारित टेस्टिंग, और पैनिक-फ्री और UB-फ्री संचालन के लिए MIRI सत्यापन। बाउंडेड टर्मिनेशन सुनिश्चित करने के लिए सबसे खराब स्थिति वाले इनपुट का परीक्षण किया जाता है।

cargo test
cargo +nightly miri test --lib

सुरक्षा और लागत मॉडल

Gate0 का मूल्यांकनकर्ता मूल्यांकन के दौरान शून्य हीप आवंटन की गारंटी देने के लिए फिक्स्ड-साइज़, स्टैक-आवंटित बफर का उपयोग करता है। डिफ़ॉल्ट कार्यान्वयन अप्रयुक्त स्लॉट को इनिशियलाइज़ करने से बचने के लिए MaybeUninit का उपयोग करता है, जिसके परिणामस्वरूप O(capacity) के बजाय O(used) इनिशियलाइज़ेशन लागत होती है।

असुरक्षित कोड एक ही मॉड्यूल (fixed_stack.rs) में सीमित है, जिसमें सीधे इनवेरिएंट हैं: तत्व 0..len इनिशियलाइज़ होते हैं, तत्व len..N नहीं होते। सभी असुरक्षित पथ MIRI के साथ सत्यापित होते हैं।

उन उपयोगकर्ताओं के लिए जो शून्य असुरक्षित कोड पसंद करते हैं, Gate0 safe-stack फीचर फ्लैग के पीछे SafeFixedStack प्रदान करता है। यह वैरिएंट T: Default + Copy के साथ [T; N] का उपयोग करता है और सभी स्लॉट को अग्रिम रूप से इनिशियलाइज़ करता है। ट्रेडऑफ़ प्रत्येक मूल्यांकन कॉल पर O(capacity) इनिशियलाइज़ेशन है।

cargo build --features safe-stack

दोनों कार्यान्वयन समान सेमेन्टिक्स और मूल्यांकन के दौरान समान शून्य-आवंटन गारंटी प्रदान करते हैं। विकल्प प्रदर्शन (O(used)) और पूर्ण सुरक्षा (O(capacity)) के बीच है। bool जैसे सस्ते Default प्रकारों वाले छोटे स्टैक के लिए, अंतर नगण्य है।

एकीकरण आर्किटेक्चर

Gate0 को एक बड़े होस्ट एप्लिकेशन के भीतर पॉलिसी निर्णय बिंदु (PDP) के रूप में कार्य करने के लिए डिज़ाइन किया गया है। नियतिवाद और सख्त सीमाओं को बनाए रखने के लिए, Gate0 I/O, नेटवर्किंग, या ऑब्जेक्ट लाइफसाइकल को संभालता नहीं है।

अनुशंसित एकीकरण पैटर्न चिंताओं को तीन परतों में अलग करता है। होस्ट एप्लिकेशन (API गेटवे, SSH सर्वर, आदि) स्थिति, पहचान और साइड इफेक्ट्स का प्रबंधन करता है। एक एडेप्टर परत इस जटिल स्थिति को उन प्रिमिटिव्स में सामान्यीकृत करती है जिन्हें Gate0 समझता है (स्ट्रिंग्स, बूल, इंट्स)। Gate0 समतल संदर्भ का विशुद्ध रूप से मूल्यांकन करता है और एक Decision लौटाता है।

Host Application (User Request)
        │
        ▼
  [Adapter Layer]  →  Pre-computes context (time, IP ranges, MFA status)
        │              Converts "complex" to "primitive"
        ▼
  [Gate0 Engine]   →  Pure evaluation (0 allocations, bounded stack)
        │
        ▼
  Decision::Allow / Deny

यह पृथक्करण बताता है कि Gate0 में IP रेंज जाँच या regex जैसे जटिल मैचर क्यों शामिल नहीं हैं। एडेप्टर परत डोमेन-विशिष्ट तर्क को संभालती है और Gate0 को पूर्व-गणना किए गए बूलियन या स्ट्रिंग एट्रिब्यूट्स प्रस्तुत करती है। Gate0 छोटा, ऑडिट करने योग्य और नियतिवादी रहता है।

उदाहरण

use gate0::{Policy, Rule, Target, Request, ReasonCode};

let policy = Policy::builder()
    .rule(Rule::allow(Target::any(), ReasonCode(1)))
    .build()?;

let decision = policy.evaluate(&Request::new("alice", "read", "doc"))?;
assert!(decision.is_allow());

उदाहरण

examples/ निर्देशिका में सामान्य Gate0 उपयोग पैटर्न प्रदर्शित करने वाले उदाहरण परिदृश्य हैं:

SaaS API: मानक RBAC/मल्टी-टेनेंसी लॉजिक। Zero Trust Network: MFA और लोकेशन जाँच के साथ विशेषता-आधारित एक्सेस नियंत्रण (ABAC)। Complex Overrides: Deny-Overrides संघर्ष समाधान का प्रदर्शन।

इन्हें चलाएँ:

cargo run --example saas_api
cargo run --example zero_trust_network
cargo run --example complex_overrides

सीमाएँ

Gate0 जानबूझकर पूर्वानुमेय और प्रदर्शनशील बने रहने के लिए सीमित है।

कोई जटिल मैचर नहीं: पूर्ण बिट-मास्क CIDR या उन्नत Regex जैसा तर्क एडेप्टर परत की जिम्मेदारी है। Gate0 पूर्व-संसाधित प्रिमिटिव्स का मूल्यांकन करता है।

कोई नेटिव मल्टीथ्रेडिंग नहीं: Python के लिए वर्तमान FFI कार्यान्वयन थ्रेड-सेफ़ नहीं है। उच्च-समवर्ती उपयोगकर्ताओं को मल्टीप्रोसेसिंग का उपयोग करना चाहिए या चरण 4 FFI स्थिरीकरण की प्रतीक्षा करनी चाहिए जो वैश्विक लॉक को संबोधित करेगा।

कोई ओवरलैपिंग निर्णय नहीं: एक प्रभाव वर्ग (Allow/Deny) के भीतर, केवल पहला मेल खाने वाला नियम लौटाया जाता है। संघर्ष समाधान सख्ती से क्रम-निर्भर है।

सामुदायिक एक्सटेंशन

निम्नलिखित प्रोजेक्ट विशेष उपयोग के मामलों के लिए Gate0 इंजन का विस्तार करते हैं।

gate0_dsl: hardliner66 द्वारा विकसित Gate0 के लिए एक Rust-नेटिव डोमेन-विशिष्ट भाषा। यह कोड में सीधे पॉलिसी परिभाषित करने के लिए एक स्वच्छ और पठनीय सिंटैक्स प्रदान करने हेतु Rust मैक्रोज़ का लाभ उठाती है। कार्यान्वयन और दस्तावेज़ीकरण आप hardliner66/gate0_dsl पर पा सकते हैं।

लाइसेंस

MIT