कंगारू

secp256k1 पर एलिप्टिक कर्व डिस्क्रीट लघुगणक समस्या (ECDLP) को हल करने के लिए GPU-त्वरित पोलार्ड का कंगारू एल्गोरिदम।

विशेषताएँ

• 🖥️ क्रॉस-प्लेटफ़ॉर्म GPU — wgpu के माध्यम से Vulkan (AMD, NVIDIA, Intel), Metal (Apple Silicon), DX12 (Windows)
• 🦀 शुद्ध Rust + WGSL — कोई CUDA निर्भरता नहीं, कम्प्यूट शेडर्स रनटाइम पर संकलित होते हैं
• ⚡ विशिष्ट बिंदु (Distinguished Points) — स्वचालित-ट्यून किए गए DP बिट्स के साथ कुशल टक्कर पहचान
• 🔄 निषेध मानचित्र (Negation map) — साइकिल गार्ड के साथ Y-समता निर्देशित वॉक के माध्यम से ~1.29× गति वृद्धि
• 🦘 बहु-सेट कंगारू — उच्च टक्कर संभावना के लिए टेम, वाइल्ड1, वाइल्ड2 झुंड
• 🎯 मॉड्यूलर बाधाएँ — यदि k ≡ R (mod M), तो खोज स्थान को कारक M से कम करें
• ⚙️ स्वचालित अंशांकन — स्टार्टअप पर GPU डिस्पैच टाइमिंग और वर्कग्रुप आकार ट्यून किया जाता है
• 📊 अंतर्निहित बेंचमार्क — हार्डवेयर परीक्षण के लिए --benchmark, परिणाम रिकॉर्ड करने के लिए --save-benchmarks
• 📦 डेटा प्रदाता — प्लग करने योग्य पहेली स्रोत (बिटकॉइन पहेलियों के लिए boha एकीकरण)
• 💻 CPU फॉलबैक — परीक्षण और तुलना के लिए शुद्ध CPU सॉल्वर

यह प्रोजेक्ट क्यों?

अधिकांश मौजूदा कंगारू कार्यान्वयन (JeanLucPons/Kangaroo, RCKangaroo, आदि) केवल CUDA के माध्यम से NVIDIA GPU का समर्थन करते हैं। यह कार्यान्वयन WebGPU/wgpu का उपयोग करता है जो Vulkan, Metal और DX12 के माध्यम से क्रॉस-प्लेटफ़ॉर्म GPU कम्प्यूट प्रदान करता है।

स्थापना

Arch Linux (AUR)

paru -S kangaroo

Cargo

cargo install kangaroo

स्रोत से

git clone https://github.com/oritwoen/kangaroo
cd kangaroo
cargo build --release

boha प्रदाता के साथ

cargo build --release --features boha

उपयोग

kangaroo --pubkey <PUBKEY> --start <START> --range <BITS>

तर्क

या तो --target या --pubkey आवश्यक है।

उदाहरण

डेटा प्रदाता (boha) का उपयोग करना:

# Solve puzzle using boha data (auto: pubkey, start, range)
kangaroo --target boha:b1000/66

# Override range (search smaller subset)
kangaroo --target boha:b1000/66 --range 60

# List available puzzles
kangaroo --list-providers

मैन्युअल पैरामीटर:

kangaroo \
    --pubkey 03a2efa402fd5268400c77c20e574ba86409ededee7c4020e4b9f0edbee53de0d4 \
    --start 8000000000 \
    --range 40

मॉड्यूलर बाधा के साथ (k ≡ 37 mod 60):

kangaroo \
    --pubkey 03a2efa402fd5268400c77c20e574ba86409ededee7c4020e4b9f0edbee53de0d4 \
    --start 8000000000 \
    --range 40 \
    --mod-step 3c \
    --mod-start 25

यह खोज स्थान को ~60× तक कम करता है। तब उपयोगी जब आंशिक कुंजी संरचना ज्ञात हो (जैसे, पूर्वानुमानित चरण पैटर्न के साथ उत्पन्न कुंजी)।

यह कैसे काम करता है

पोलार्ड का कंगारू एल्गोरिदम O(√n) समय में असतत लघुगणक समस्या को हल करता है जहाँ n खोज सीमा है। यह इस प्रकार काम करता है:

1. टेम कंगारू एक ज्ञात बिंदु से शुरू होते हैं और यादृच्छिक छलांग लगाते हैं
2. वाइल्ड कंगारू लक्ष्य सार्वजनिक कुंजी से शुरू होते हैं और उसी प्रकार की छलांग लगाते हैं
3. जब एक वाइल्ड और टेम कंगारू एक ही बिंदु (टक्कर) पर पहुँचते हैं, तो हम निजी कुंजी की गणना कर सकते हैं

विशिष्ट बिंदु (DP) अनुकूलन: सभी देखे गए बिंदुओं को संग्रहीत करने के बजाय, हम केवल उन बिंदुओं को संग्रहीत करते हैं जिनके x-निर्देशांक में अग्रणी शून्य बिट्स की एक विशिष्ट संख्या होती है। यह मेमोरी उपयोग को नाटकीय रूप से कम करता है जबकि टक्कर का पता लगाने की अनुमति देता है।

प्रदर्शन

अपेक्षित संक्रियाएँ: ~2^(range_bits/2)

फ़ाइलों को छुए बिना अपने हार्डवेयर का परीक्षण करने के लिए kangaroo --benchmark चलाएँ। BENCHMARKS.md को अपडेट करने के लिए kangaroo --benchmark --save-benchmarks का उपयोग करें।

उपयोग के मामले

इसके लिए उपयोगी नहीं:

• पूर्ण 256-बिट कुंजी खोज (गणितीय रूप से असंभव)
• BIP39 पासफ्रेज़ ब्रूट-फोर्स (इसके बजाय शब्दकोश हमले का उपयोग करें)
• आंशिक कुंजी जानकारी के बिना पहेलियाँ

लाइब्रेरी उपयोग

use kangaroo::{KangarooSolver, GpuContext, GpuBackend, parse_pubkey, parse_hex_u256, verify_key};

fn main() -> anyhow::Result<()> {
    let pubkey = parse_pubkey("03...")?;
    let start = parse_hex_u256("8000000000")?;

    let ctx = pollster::block_on(GpuContext::new(0, GpuBackend::Auto))?;
    let mut solver = KangarooSolver::new(
        ctx,
        pubkey.clone(),
        start,
        40,  // range_bits
        12,  // dp_bits
        1024, // num_kangaroos
    )?;

    loop {
        if let Some(key) = solver.step()? {
            if verify_key(&key, &pubkey) {
                println!("Found: {}", hex::encode(&key));
                break;
            }
        }
    }

    Ok(())
}

डेटा प्रदाता

कंगारू पहेली स्रोतों के लिए बाहरी डेटा प्रदाताओं का समर्थन करता है। प्रदाता पबकी, कुंजी सीमा और अन्य पहेली मेटाडेटा प्रदान करते हैं।

boha (वैकल्पिक सुविधा)

boha बिटकॉइन पहेली लेनदेन (b1000) सहित क्रिप्टो पहेली डेटा प्रदान करता है।

boha समर्थन के साथ बनाएँ:

cargo build --release --features boha

उपयोग:

# Solve specific puzzle
kangaroo --target boha:b1000/66

# List solvable puzzles (unsolved with known pubkey)
kangaroo --list-providers

प्रदाता सीमा ओवरराइड को मान्य करता है - आप पहेली की कुंजी सीमा के बाहर खोज नहीं कर सकते।

आर्किटेक्चर

src/
├── main.rs              # CLI प्रवेश बिंदु
├── lib.rs               # लाइब्रेरी प्रवेश + Args + run()
├── solver.rs            # GPU सॉल्वर समन्वय
├── cli.rs               # CLI उपयोगिताएँ (ट्रेसिंग, प्रोग्रेस बार)
├── benchmark.rs         # अंतर्निहित बेंचमार्क सूट
├── modular.rs           # मॉड्यूलर बाधा रूपांतरण
├── math.rs              # 256-बिट अंकगणित, DP मास्क जनरेशन
├── convert.rs           # GPU↔CPU के लिए लिंब/बाइट रूपांतरण
├── provider/
│   ├── mod.rs           # प्रदाता सिस्टम इंटरफ़ेस
│   └── boha.rs          # boha प्रदाता (सुविधा-गेटेड)
├── cpu/
│   ├── cpu_solver.rs    # शुद्ध CPU सॉल्वर (परीक्षण/तुलना)
│   ├── dp_table.rs      # विशिष्ट बिंदु टक्कर का पता लगाना
│   └── init.rs          # कंगारू प्रारंभिकीकरण + जंप टेबल
├── crypto/
│   └── mod.rs           # k256/secp256k1 रैपर
├── gpu/
│   ├── pipeline.rs      # कम्प्यूट पाइपलाइन सेटअप
│   └── buffers.rs       # GPU बफ़र प्रबंधन
├── gpu_crypto/
│   ├── context.rs       # GPU संदर्भ + बैकएंड चयन
│   └── shaders/         # WGSL शेडर लाइब्रेरी
│       ├── field.wgsl   # secp256k1 फ़ील्ड अंकगणित
│       └── curve.wgsl   # जैकोबियन बिंदु संचालन
└── shaders/
    └── kangaroo_affine.wgsl  # मुख्य कंगारू कम्प्यूट शेडर

आवश्यकताएँ

• Rust 1.70+
• Vulkan-सक्षम GPU (AMD, NVIDIA, Intel) या Metal (macOS)
• Linux पर AMD RADV के साथ, Mesa 25.x या नया आवश्यक है (पुराने Mesa संस्करण WGSL डायनामिक इंडेक्सिंग पर क्रैश हो सकते हैं)
• GPU ड्राइवर स्थापित

लाइसेंस

MIT लाइसेंस - विवरण के लिए LICENSE देखें।

संबंधित प्रोजेक्ट

• JeanLucPons/Kangaroo - CUDA कार्यान्वयन (केवल NVIDIA)
• RCKangaroo - CUDA कार्यान्वयन (केवल NVIDIA)
• boha - क्रिप्टो पहेलियाँ और पुरस्कार डेटा लाइब्रेरी