Sibuna पुस्तक 1.0.0-beta.3 दस्तावेज़
भाषा: हिन्दी
English简体中文한국어日本語EspañolDeutschहिन्दीالعربية
इस पृष्ठ पर

भाग IV: Sibuna प्रोटोकॉल

हम वायर प्रोटोकॉल को उसी रूप में निर्दिष्ट करते हैं जैसा वह लागू है: इंटरस्टिशियल का राउंड ट्रिप, स्टेटलेस चैलेंज रिकॉर्ड, समाधान के दोनों प्रारूप, सत्यापन का क्रम, एक-बार-उपयोग का प्रवर्तन, और सत्र कुकी।

चैलेंज का राउंड ट्रिप

आठ चरणों का एक चक्र: ब्राउज़र नेविगेशन, इंटरस्टिशियल (HTTP 200), GET /__sibuna/challenge.json?need=, स्टेटलेस id (पेलोड + टैग), WASM या JS प्रूवर के साथ Web Worker में हल, नॉनस या प्रमाण के साथ POST /__sibuna/verify, सत्यापन, spent set और MAC टोकन जारी करना, Set-Cookie और फिर रीलोड, और सत्र के साथ वापस नेविगेशन तक।
चित्र 5 चैलेंज का राउंड ट्रिप। बाईं ओर के चरण ब्राउज़र में चलते हैं, और दाईं ओर के चरण Sibuna में।
  1. वैध सत्र के बिना कोई नेविगेशन नीति इंजन तक पहुँचता है और CHALLENGE के रूप में वर्गीकृत होता है। चूँकि अनुरोध text/html स्वीकार करता है, डेमन इंटरस्टिशियल पेज और हेडर X-Sibuna-Status: CHALLENGE के साथ 200 उत्तर देता है; जो API क्लाइंट HTML स्वीकार नहीं करता, उसे JSON बॉडी के साथ 401 मिलता है, जिसका challenge URL लाने के लिए तैयार होता है। दोनों ही स्थितियों में रिस्पॉन्स एक आवश्यकता टिकट (requirement ticket) ले जाता है: इस निर्णय द्वारा माँगा गया चैलेंज (एल्गोरिदम, वर्क बिट्स, ओपनिंग) और नियम का हैश, जिसे इस क्लाइंट के लिए उसकी अपनी व्युत्पन्न कुंजी के तहत कुंजी-युक्त BLAKE3 टैग से सील किया जाता है, और जो एक चैलेंज अवधि तक वैध रहता है।

  2. इंटरस्टिशियल GET /__sibuna/challenge.json?path=<original URL>&need=<ticket> लाता है। वैध टिकट चैलेंज तय करता है: कार्य उस निर्णय से निश्चित होता है जिसने उसे माँगा था, किसी रिपोर्ट किए गए URL और fetch के अपने हेडर से दोबारा नहीं निकाला जाता, जो नेविगेशन के हेडर (Accept, Sec-Fetch-*) से अलग होते हैं। वैध टिकट के बिना (कोई API क्लाइंट जो URL को अनदेखा करता है, या अवधि से आगे खुला छोड़ा गया पेज) सर्वर रिपोर्ट किए गए URL का मूल्यांकन करता है, जिसे उसी फ़ंक्शन से पाथ और क्वेरी में बाँटा जाता है जो अनुरोध पंक्ति पढ़ता है, और पाथ को उसी सामान्य रूप में रखा जाता है जिसका प्रवेश उपयोग करता है (SID 0009); 8 KiB से लंबा URL 414 के साथ अस्वीकार किया जाता है, कभी छोटा नहीं किया जाता, और जिस पाथ का सामान्य रूप न हो वह 400 के साथ। टिकट केवल सलाह देता है: प्रवेश फिर भी सत्र के वर्क लेवल की जाँच करता है, इसलिए रीप्ले किया गया या जाली टिकट केवल अपने धारक का कार्य बढ़ा सकता है।

  3. रिस्पॉन्स चैलेंज रिकॉर्ड है:

    {"id":"AQEND...70 chars","algorithm":"posw","difficulty":13,"challenges":16,"expires_at":1757241234}
    

    hashcash के लिए difficulty बिट की संख्या है और challenges का मान 0 है।

  4. एक Web Worker इसे WebAssembly मॉड्यूल से हल करता है, या WebAssembly उपलब्ध न हो तो JavaScript प्रूवर से (भाग VII), और या तो यह पोस्ट करता है

    {"challenge_id":"...","nonce":"90766"}
    

    या यह

    {"challenge_id":"...","proof":"<base64url, 32(1 + t(n+1)) bytes>"}
    

    POST /__sibuna/verify पर।

  5. सफलता पर सर्वर Set-Cookie हेडर के साथ 200 {"status":"ok"} उत्तर देता है, और पेज अपना मूल स्थान दोबारा लोड करता है। बाद का हर अनुरोध कुकी ले जाता है और नीति मूल्यांकन से पहले ही प्रवेश पा जाता है।

स्टेटलेस चैलेंज रिकॉर्ड

pub fn create_challenge_with_spec(
    &self,
    client_ip: &[u8],
    user_agent: &[u8],
    now: u64,
    spec: ChallengeSpec,
    rule_hash: u64,
) -> Challenge {
    self.adaptive.observe(now.saturating_mul(1000));
    let effective = ChallengeSpec {
        difficulty: spec.difficulty.saturating_add(self.adaptive.bump()),
        ..spec
    };
    let fingerprint = self.fingerprint(client_ip, user_agent);
    let difficulty = effective.parameter();
    let challenges = match effective.algorithm {
        Algorithm::Hashcash => 0,
        Algorithm::Posw => effective.posw_challenges,
    };

    let mut payload = [0u8; ID_PAYLOAD_LEN];
    payload[0] = ID_VERSION;
    payload[1] = effective.algorithm.to_byte();
    payload[2] = difficulty;
    payload[3] = challenges;
    payload[4..12].copy_from_slice(&now.to_le_bytes());
    payload[12..20].copy_from_slice(&fingerprint.to_le_bytes());
    payload[20..28].copy_from_slice(&self.next_nonce(now, fingerprint).to_le_bytes());
    payload[28..36].copy_from_slice(&rule_hash.to_le_bytes());
    let mut raw = [0u8; ID_RAW_LEN];
    raw[..ID_PAYLOAD_LEN].copy_from_slice(&payload);
    raw[ID_PAYLOAD_LEN..].copy_from_slice(&self.challenge_tag(&payload));

    Challenge {
        id: encoded::encode(&raw),
        algorithm: effective.algorithm,
        difficulty,
        challenges,
        expires_at: now.saturating_add(u64::from(self.challenge_ttl)),
    }
}

पहचानकर्ता एक Encoded<70> है: टेक्स्ट ठीक उसकी लंबाई वाली ऐरे में रहता है, इसलिए चैलेंज जारी करने में कभी आवंटन नहीं होता। ChallengeSpec::parameter वर्क बिट्स को टियर की अपनी इकाई में बदलता है, Hashcash बिट (अधिकतम 64) या PoSW गहराई (difficulty - 3, 4 से 24 के बीच सीमित)।

तीन विवरण ध्यान देने योग्य हैं:

  • अनुकूली कठिनाई। कोऑर्डिनेटर तीन atomic में चैलेंज जारी होने की दर का exponentially weighted moving average रखता है। प्रति सेकंड 50 चैलेंज की आधार रेखा से ऊपर, दर के हर दोगुना होने पर एक वर्क बिट जुड़ता है, अधिकतम छह तक। बाढ़ घातीय रूप से अधिक चुकाती है, जबकि शांत ट्रैफ़िक आधार लागत पर ही रहता है।
  • नॉनस एक PRF आउटपुट है, जिसे चैलेंज कुंजी से एक काउंटर, घड़ी और फ़िंगरप्रिंट पर गणना करके निकाला जाता है। यह अद्वितीय (काउंटर) और अप्रत्याशित (कुंजी) है, इसलिए विरोधी उन पहचानकर्ताओं के लिए पहले से समाधान नहीं निकाल सकता जो उसे जारी नहीं किए गए, और हॉट पाथ entropy के लिए कभी ऑपरेटिंग सिस्टम को कॉल नहीं करता।
  • कठिनाई टैग के भीतर बँधी रहती है। क्लाइंट रिकॉर्ड संपादित करके कठिनाई कम नहीं कर सकता: किसी प्रमाण की जाँच से पहले ही टैग विफल हो जाएगा।

सत्यापन का क्रम और एक-बार उपयोग

pub fn verify_and_mint(
    &self,
    challenge_id: &[u8],
    solution: Solution<'_>,
    client_ip: &[u8],
    user_agent: &[u8],
    now: u64,
) -> Result<Verified, VerifyError> {
    let record = self.decode(challenge_id)?;
    let expires_at = record.issued_at.saturating_add(u64::from(self.challenge_ttl));
    if now > expires_at || record.issued_at > now.saturating_add(CLOCK_SKEW_SECONDS) {
        return Err(VerifyError::ChallengeExpired);
    }
    if record.fingerprint != self.fingerprint(client_ip, user_agent) {
        return Err(VerifyError::FingerprintMismatch);
    }
    check_solution(challenge_id, &record, solution)?;
    self.spent.mark_spent(&record.tag, expires_at, now).map_err(|error| match error {
        SpendError::DoubleSpend => VerifyError::DoubleSpendAttempt,
        SpendError::Full => VerifyError::StoreFull,
    })?;
    let work = WorkLevel {
        algorithm: record.algorithm.to_byte(),
        bits: record.algorithm.work_bits(record.difficulty),
    };
    Ok(Verified {
        token: self.mint_token(now, record.rule_hash, record.fingerprint, work),
        algorithm: record.algorithm,
        difficulty: record.difficulty,
        challenges: record.challenges,
        ttl_seconds: self.token_ttl,
    })
}

यह क्रम जानबूझकर है। टैग, आयु और बाइंडिंग स्थिर-समय जाँचें हैं जो किसी भी हैशिंग से पहले कचरे को अस्वीकार कर देती हैं। गलत प्रमाण को चैलेंज का उपभोग नहीं करना चाहिए, इसलिए spent set में तभी लिखा जाता है जब check_solution सफल हो। एक ही वैध समाधान का सत्यापन करने वाले दो थ्रेड mark_spent पर होड़ करते हैं; शार्ड लॉक उन्हें क्रम में लगाता है, ठीक एक जीतता है, और दूसरे को VerifyError::DoubleSpendAttempt मिलता है। शर्त issued_at > now + 60 (CLOCK_SKEW_SECONDS का मान 60 है) उन रिकॉर्ड को अस्वीकार करती है जिन्हें ऐसे नोड ने जारी किया जिसकी घड़ी एक मिनट से अधिक आगे चल रही है, क्योंकि अन्यथा वे किसी चैलेंज की अवधि बढ़ा देते।

त्रुटियाँ क्लाइंट तक Elm-शैली के निदान के साथ 400 के रूप में पहुँचती हैं (भाग X): हर VerifyError एक sibuna_core::errors::ErrorKind में बदलता है, जिसकी व्याख्या रिस्पॉन्स बॉडी होती है। end-to-end परीक्षण रिस्पॉन्स बॉडी में DOUBLE SPEND, FINGERPRINT MISMATCH, WRONG SOLUTION TYPE और MALFORMED CHALLENGE की पुष्टि करते हैं।