deadends/legionLegion एक Zero-Knowledge Authentication Fabric है जो गोपनीयता के लिए निर्मित है।
हार्डवेयर-बद्ध डिवाइस रिंग सिग्नेचर के साथ सत्य ज़ीरो-नॉलेज प्रमाणीकरण
Legion एक पासवर्डरहित ज़ीरो-नॉलेज प्रमाणीकरण प्रणाली है जो साबित करती है कि आप अपनी पहचान बताए बिना अधिकृत हैं।
केवल अपने फिंगरप्रिंट + 24-शब्द रिकवरी वाक्यांश (MetaMask की तरह) का उपयोग करके प्रमाणीकरण करें। कोई उपयोगकर्ता नाम नहीं, कोई पासवर्ड नहीं, कोई सर्वर-साइड रहस्य नहीं।
git clone https://github.com/deadends/legion.git cd legion
chmod +x scripts/install.sh && ./scripts/install.sh
scripts\install.bat
**बस इतना ही!** अपने ब्राउज़र में http://localhost खोलें।
### क्या इंस्टॉल होता है
- ✅ Redis (सेशन स्टोरेज)
- ✅ Legion Server (ZK प्रूफ वेरीफायर)
- ✅ Frontend (WASM क्लाइंट)
- ✅ Nginx (रिवर्स प्रॉक्सी)
**प्रदर्शन**: रजिस्ट्रेशन ~5s, प्रमाणीकरण ~2min (k=14 प्रूफ जनरेशन)
---
### मैन्युअल सेटअप (Docker के बिना)
<details>
<summary>मैन्युअल इंस्टॉलेशन विस्तार से देखने के लिए क्लिक करें</summary>```bash
# 1. Install Redis
# macOS: brew install redis && redis-server
# Ubuntu: sudo apt install redis && redis-server
# Windows: https://redis.io/docs/install/install-redis/install-redis-on-windows/
# 2. Run server (terminal 1)
cd legion-server
cargo run --release --features redis
# 3. Build frontend (terminal 2)
cd wasm-client
wasm-pack build --target web --release
python3 -m http.server 8000
# 4. Open http://localhost:8000
उत्पादन परिनियोजन के लिए, देखें DEPLOYMENT.md
परीक्षण हार्डवेयर: Lenovo IdeaPad 3 - Intel Core i3 11th Gen
नोट: प्रदर्शन हार्डवेयर विशिष्टताओं के आधार पर भिन्न हो सकता है।
विवरण:
विवरण:
महत्वपूर्ण: पैराम्स जनरेशन और keygen एक बार की लागतें हैं जिन्हें कैश किया जा सकता है। एक बार कैश हो जाने पर, k मान के आधार पर सत्यापन में केवल ~108-967ms लगते हैं। वर्तमान कार्यान्वयन अभी तक पैराम्स को कैश नहीं करता है।
पुराने बेंचमार्क से धीमा क्यों? यह passwordless circuit अब एक के बजाय दो Merkle ट्री (user + device) सत्यापित करता है, जो वास्तविक डिवाइस-स्तरीय गुमनामी प्रदान करता है (1-of-1024 डिवाइस प्रति उपयोगकर्ता)।
📖 विस्तृत चरण-दर-चरण प्रमाणीकरण प्रवाह और क्रिप्टोग्राफ़िक विवरणों के लिए, देखें ARCHITECTURE_FLOW.md
┌─────────────────────────────────────────────────────────────────────────┐ │ CLIENT (Browser + WASM) │ ├─────────────────────────────────────────────────────────────────────────┤ │ ┌────────────────┐ ┌─────────────────┐ ┌──────────────────────────┐ │ │ │ UI Layer │ │ WASM Prover │ │ Local Storage │ │ │ │ (Vanilla JS) │ │ (Rust→WASM) │ │ (IndexedDB) │ │ │ ├────────────────┤ ├─────────────────┤ ├──────────────────────────┤ │ │ │ • Registration │ │ • Blake3 Hash │ │ • Full Merkle Tree │ │ │ │ • Login Form │ │ • BIP-39 Derive │ │ • Device Trees │ │ │ │ • Session UI │ │ • Halo2 Prover │ │ • WebAuthn Credentials │ │ │ │ • Tree Sync │ │ • Merkle Proof │ │ • Tree Version Cache │ │ │ └────────────────┘ │ • Ring Sigs │ └──────────────────────────┘ │ │ └─────────────────┘ │ │ ┌──────────────────────────────────────────────────────────────────┐ │ │ │ Hardware Security (WebAuthn Level 2) │ │ │ ├──────────────────────────────────────────────────────────────────┤ │ │ │ • TPM 2.0 / Secure Enclave • FIDO2 Authenticator │ │ │ │ • Device Private Key (ECDSA) • Biometric/Touch Required │ │ │ └──────────────────────────────────────────────────────────────────┘ │ └────────────────────────────────┬────────────────────────────────────────┘ │ HTTPS/TLS 1.3 │ (Encrypted Channel) ▼ ┌──────────────────────────────────────────────────────────────────────────┐ │ LEGION SERVER (Rust/Axum) │ ├──────────────────────────────────────────────────────────────────────────┤ │ ┌─────────────────────────────────────────────────────────────────┐ │ │ │ API Layer (Axum) │ │ │ ├─────────────────────────────────────────────────────────────────┤ │ │ │ POST /api/register-blind │ Blind registration │ │ │ │ GET /api/download-tree │ Download full Merkle tree │ │ │ │ POST /api/verify-anonymous-proof │ Verify ZK proof │ │ │ │ POST /api/verify-session │ Session validation │ │ │ │ POST /api/webauthn/* │ WebAuthn endpoints │ │ │ │ GET /health │ Health check │ │ │ └─────────────────────────────────────────────────────────────────┘ │ │ │ │ │ ┌─────────────────────────────────────────────────────────────────┐ │ │ │ Business Logic Layer │ │ │ ├─────────────────────────────────────────────────────────────────┤ │ │ │ • Blind Registration │ • Tree Synchronization │ │ │ │ • ZK Proof Verifier │ • Nullifier Tracker (replay) │ │ │ │ • Session Manager │ • Linkability Tag Validator │ │ │ │ • WebAuthn Service │ • Timestamp Validator (±10min) │ │ │ │ • Device Revocation │ • Rate Limiter (5/hour) │ │ │ └─────────────────────────────────────────────────────────────────┘ │ │ │ │ │ ┌─────────────────────────────────────────────────────────────────┐ │ │ │ Cryptographic Layer │ │ │ ├─────────────────────────────────────────────────────────────────┤ │ │ │ • Halo2 Verifier (PLONK) │ • Poseidon Hash (ZK-friendly) │ │ │ │ • Blake3 (credential) │ • BIP-39 (recovery phrase) │ │ │ │ • Merkle Tree (2^20) │ • Device Trees (2^10 per user) │ │ │ │ • Ring Signature Verify │ • WebAuthn Signature Verify │ │ │ └─────────────────────────────────────────────────────────────────┘ │ └────────────────────────┬──────────────────────┬──────────────────────────┘ │ │ ▼ ▼ ┌────────────────────────┐ ┌───────────────────────────┐ │ Redis (In-Memory) │ │ RocksDB (Persistent) │ ├────────────────────────┤ ├───────────────────────────┤ │ • Session Tokens │ │ • Merkle Tree Leaves │ │ • Linkability Tags │ │ • Device Trees │ │ • Spent Nullifiers │ │ • Nullifier History │ │ • Rate Limit Counters │ │ • WebAuthn Credentials │ │ TTL: 1 hour │ │ • Revoked Devices │ └────────────────────────┘ └───────────────────────────┘
### प्रमाणीकरण प्रवाह (सरलीकृत)```
┌─────────────┐ ┌──────────────┐
│ Client │ │ Server │
│ (Browser) │ │ (Verifier) │
└──────┬──────┘ └──────┬───────┘
│ │
│ 1. Generate 24-word recovery phrase (BIP-39) │
│ → 256-bit entropy (like MetaMask) │
│ → User writes down on paper │
│ │
│ 2. Derive account_id from phrase (Blake3) │
│ account_id = Blake3("LEGION_ACCOUNT_V2" || bip39_seed) │
│ → Deterministic, no server interaction │
│ │
│ 3. Hash account_id for tree leaf (Poseidon) │
│ credential_hash = Poseidon(account_id) │
│ │
│ 4. Blind registration (TRUE zero-knowledge) ────►│
│ → Sends ONLY credential_hash (no phrase/identity) │
│ → Server adds to tree, returns tree_index │
│ ◄────│ {tree_index: 114}
│ │
│ 5. Download full Merkle tree (one-time sync) ────►│
│ → Client stores entire tree in IndexedDB │
│ → Enables TRUE zero-knowledge (no server queries) │
│ ◄────│ {tree_data: [all leaves],
│ │ merkle_root, version}
│ │
│ 6. Generate WebAuthn key (TPM/Secure Enclave) │
│ → Fingerprint prompt creates hardware-bound key │
│ → device_pubkey (ECDSA P-256, non-exportable) │
│ → Stored in TPM 2.0 / Secure Enclave │
│ │
│ 7. Register device in device tree ────►│
│ → device_commitment = Blake3(credential_id) │
│ → Server converts to valid field element if needed │
│ → Server adds to user's device tree (1 of 1024 slots) │
│ ◄────│ {device_position: 0,
│ │ device_tree_root}
│ │
│ 8. LOGIN: Touch fingerprint to authenticate │
│ → WebAuthn verifies hardware-bound key │
│ → Decrypts recovery phrase from local storage │
│ → Re-derives account_id from phrase │
│ │
│ 9. Fetch device Merkle proof ────►│
│ → Sends account_id (derived from phrase) │
│ → Server returns device tree path │
│ ◄────│ {device_path: [siblings],
│ │ device_root}
│ │
│ 10. Compute user Merkle proof CLIENT-SIDE │
│ → Uses local tree from IndexedDB │
│ → Computes path for tree_index │
│ → Server NEVER learns which user! │
│ │
│ 11. Compute nullifier (replay protection) │
│ nullifier = Poseidon(account_id || challenge) │
│ → ONE-TIME USE: Different every login │
│ → Prevents proof replay attacks │
│ │
│ 12. Compute linkability tag (session binding) │
│ linkability_tag = Blake3(device_pubkey || nullifier) │
│ ⚠️ Binds session to specific device+user │
│ │
│ 13. Generate ZK proof (Halo2 PLONK, ~2min for k=14) │
│ Proves in zero-knowledge: │
│ ✓ User exists in Merkle tree (1 of 2^20) │
│ ✓ Device exists in device tree (1 of 2^10) │
│ ✓ account_id hashes to credential_hash │
│ ✓ Nullifier computed correctly │
│ ✓ Timestamp is fresh │
│ WITHOUT revealing which user or device │
│ │
│ 14. Submit proof ────►│
│ {proof, public_inputs, linkability_tag, k=14} │
│ │ • Check device not revoked
│ │ • Verify timestamp (±10min)
│ │ • Rate limit check (5/hour)
│ │ • Check nullifier (replay?)
│ │ • Verify ZK proof (~115s)
│ │ • Mark nullifier as used
│ │
│ ◄────│ {session_token, expires_at}
│ │
│ 15. Verify session (every request) ────►│
│ {session_token, linkability_tag} │
│ │ • Lookup in Redis
│ │ • Verify linkability_tag
│ │ (prevents session theft)
│ │ • Check not spent
│ ◄────│ {valid: true}
│ │
🔍 अधिक विवरण चाहते हैं? इसके लिए देखें ARCHITECTURE_FLOW.md:
┌─────────────────────────────────────────────────────────────────────────┐ │ SESSION SECURITY MECHANISMS │ ├─────────────────────────────────────────────────────────────────────────┤ │ │ │ 1. LINKABILITY TAG (Zero-Knowledge Device Binding) │ │ ═══════════════════════════════════════════════════════ │ │ │ │ linkability_tag = Blake3(device_pubkey || nullifier) │ │ │ │ • Computed client-side using hardware-bound device key │ │ • Sent with every session validation request │ │ • Server verifies: stored_tag == provided_tag │ │ │ │ ✅ PREVENTS: Session token theft/replay on different device │ │ ✅ ENSURES: Same user + same device for entire session │ │ ✅ MAINTAINS: Zero-knowledge (server doesn't learn identity) │ │ │ │ ───────────────────────────────────────────────────────────────── │ │ │ │ 2. SESSION TOKEN (Cryptographic Binding) │ │ ═══════════════════════════════════════════════════════ │ │ │ │ session_token = Poseidon(nullifier || timestamp || linkability_tag) │ │ │ │ • Generated server-side after proof verification │ │ • Stored in Redis with linkability_tag as value │ │ • Cannot be forged without knowing nullifier │ │ │ │ ✅ PREVENTS: Token forgery │ │ ✅ ENSURES: Cryptographic binding to proof │ │ │ │ ───────────────────────────────────────────────────────────────── │ │ │ │ 3. NULLIFIER (Replay Protection) │ │ ═══════════════════════════════════════════════════════ │ │ │ │ nullifier = Poseidon(credential_hash || challenge) │ │ │ │ • Unique per authentication attempt │ │ • Tracked in RocksDB (permanent) and Redis (cache) │ │ • Server rejects if nullifier seen before │ │ │ │ ✅ PREVENTS: Proof replay attacks │ │ ✅ ENSURES: One-time use per challenge │ │ │ │ ───────────────────────────────────────────────────────────────── │ │ │ │ 4. TIMESTAMP VALIDATION (Time-Bound Security) │ │ ═══════════════════════════════════════════════════════ │ │ │ │ • Proof includes timestamp (Unix epoch) │ │ • Server validates: |proof_time - server_time| < 5 minutes │ │ • Session TTL: 1 hour (sliding window) │ │ │ │ ✅ PREVENTS: Old proof replay │ │ ✅ ENSURES: Fresh authentication │ │ │ │ ───────────────────────────────────────────────────────────────── │ │ │ │ 5. CHALLENGE-RESPONSE (Freshness Guarantee) │ │ ═══════════════════════════════════════════════════════ │ │ │ │ • Server generates random 32-byte challenge │ │ • Stored in Redis with 5-minute TTL │ │ • Client must include in proof │ │ • Server verifies challenge matches and deletes │ │ │ │ ✅ PREVENTS: Pre-computed proof attacks │ │ ✅ ENSURES: Proof generated for this specific session │ │ │ └─────────────────────────────────────────────────────────────────────────┘
## 🔐 शून्य-ज्ञान गुणधर्म
### सर्वर क्या जानता है
- ✅ अनामिका सेट में किसी ने प्रमाणीकरण किया
- ✅ प्रमाण क्रिप्टोग्राफिक रूप से मान्य है
- ✅ लिंकेबिलिटी टैग के माध्यम से एक ही उपयोगकर्ता+डिवाइस
- ✅ रेट लिमिट स्थिति (शेष प्रयास)
- ✅ डिवाइस निरस्तीकरण स्थिति
- ✅ पंजीकृत उपयोगकर्ताओं की कुल संख्या
- ✅ Merkle ट्री रूट (सार्वजनिक)
### सर्वर क्या नहीं जान सकता
- ❌ कौन सा विशिष्ट उपयोगकर्ता (1 of 1M)
- ❌ कौन सा विशिष्ट डिवाइस (1 of 1K प्रति उपयोगकर्ता)
- ❌ रिकवरी वाक्यांश (BIP-39 सीड)
- ❌ account_id (वाक्यांश से व्युत्पन्न)
- ❌ डिवाइस निजी कुंजी (TPM/Secure Enclave में)
- ❌ कौन सी ट्री लीफ किस उपयोगकर्ता की है
- ❌ उपयोगकर्ता Merkle पथ (क्लाइंट-साइड गणना)
- ❌ उपयोगकर्ता की tree_index स्थिति
## 📦 परिनियोजन
विस्तृत उत्पादन परिनियोजन मार्गदर्शिका के लिए [DEPLOYMENT.md](https://github.com/deadends/legion/blob/HEAD/docs/DEPLOYMENT.md) देखें।
### Docker के साथ त्वरित परिनियोजन```bash
# Production build
docker-compose -f deployment/docker-compose.yml up -d
# Check logs
docker-compose -f deployment/docker-compose.yml logs -f legion-server
# Check health
curl http://localhost/health
RUST_LOG=info LEGION_DATA_PATH=/var/lib/legion/data REDIS_URL=redis://127.0.0.1:6379
## 🧪 परीक्षण```bash
# Run all tests
cargo test --workspace
# Run with Redis features
cargo test --workspace --features redis
# Benchmark
cargo bench
योगदान का स्वागत है! कृपया पहले CONTRIBUTING.md पढ़ें।
git checkout -b feature/amazing)git commit -m 'Add amazing feature')git push origin feature/amazing)सुरक्षा समस्या मिली? जिम्मेदार प्रकटीकरण के लिए SECURITY.md देखें।
कमजोरियों के लिए सार्वजनिक issues न खोलें।
MIT लाइसेंस - विवरण के लिए LICENSE फ़ाइल देखें।
प्रमुख परिवर्तन:
वास्तुकला:
प्रमुख परिवर्तन:
जोड़े गए:
सुरक्षा सुधार:
गोपनीयता और सुरक्षा के लिए ❤️ से निर्मित
| Property | Guarantee |
|---|
| प्रमाणीकरण | पासवर्डरहित (BIP-39 + फिंगरप्रिंट) |
| उपयोगकर्ता गुमनामी | 1 of 2^20 (1,048,576) |
| डिवाइस गुमनामी | 1 of 2^10 (1,024) प्रति उपयोगकर्ता |
| साउंडनेस त्रुटि | 2^-128 |
| प्रमाण प्रणाली | Halo2 PLONK (पारदर्शी सेटअप) |
| क्रेडेंशियल व्युत्पत्ति | Blake3 (BIP-39 सीड) |
| हार्डवेयर बाइंडिंग | WebAuthn Level 2 (TPM/Secure Enclave) |
| मल्टी-डिवाइस | प्रति खाता अधिकतम 2 डिवाइस |
| रेट लिमिटिंग | 5 प्रयास/घंटा |
| डिवाइस रद्दीकरण | तत्काल ब्लैकलिस्ट |
| सुरक्षा स्तर | k | प्रमाण समय | प्रमाण आकार | उपयोग केस |
|---|
| विकास | 12 | ~30s | 3.2 KB | परीक्षण |
| उत्पादन | 14 | ~2min | 3.4 KB | अनुशंसित |
| मीट्रिक | मान | नोट्स |
|---|
| प्रमाण आकार | 3,264 बाइट्स | 3.19 KB संपीड़ित |
| सार्वजनिक इनपुट | 10 | User tree root, device tree root, nullifier, आदि |
| पैराम्स जनरेशन | 7.03s | प्रति k मान एक बार का सेटअप |
| सर्किट निर्माण | 2.3µs | नगण्य ओवरहेड |
| सत्यापन कुंजी जनरेशन | 1.29s | एक बार का keygen |
| प्रमाण सत्यापन | 107.7ms | वास्तविक ZK प्रमाण जाँच |
| कुल सत्यापन | 8.43s | एंड-टू-एंड (कैशिंग के बिना) |
| मीट्रिक | मान | नोट्स |
|---|
| प्रमाण आकार | 3,392 बाइट्स | 3.31 KB संपीड़ित |
| सार्वजनिक इनपुट | 10 | User tree root, device tree root, nullifier, आदि |
| पैराम्स जनरेशन | 100.78s | प्रति k मान एक बार का सेटअप |
| सर्किट निर्माण | 5µs | नगण्य ओवरहेड |
| सत्यापन कुंजी जनरेशन | 12.89s | एक बार का keygen |
| प्रमाण सत्यापन | 967.2ms | वास्तविक ZK प्रमाण जाँच |
| कुल सत्यापन | 114.65s | एंड-टू-एंड (कैशिंग के बिना) |