qzkp 0.1.0__tar.gz

qzkp-0.1.0/PKG-INFO

@@ -0,0 +1,72 @@
+Metadata-Version: 2.4
+Name: qzkp
+Version: 0.1.0
+Classifier: Programming Language :: Rust
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Security :: Cryptography
+Classifier: License :: OSI Approved :: MIT License
+Summary: Quantum Zero-Knowledge Proof protocol with BB84 simulation and Aadhaar integration (Rust-powered)
+Keywords: quantum,zero-knowledge-proof,bb84,aadhaar,cryptography
+License: MIT
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown; charset=UTF-8; variant=GFM
+Project-URL: Documentation, https://github.com/vrag99/QZKP-simulation#readme
+Project-URL: Repository, https://github.com/vrag99/QZKP-simulation
+
+# qzkp
+
+Quantum Zero-Knowledge Proof protocol with BB84 simulation and Aadhaar identity verification -- powered by Rust.
+
+## Install
+
+```bash
+pip install qzkp
+```
+
+## Quick start
+
+```python
+from qzkp import QZKPProtocol, QAadhaarProtocol, ServiceProvider, BB84QKD
+
+# QZKP proof: same secret => valid
+proto = QZKPProtocol("shared_secret", "shared_secret", 32, 0.025)
+result = proto.run_protocol()
+print(result["verification_status"])  # True
+print(result["qber"])                 # ~0.02-0.09
+
+# QZKP proof: different secrets => invalid
+proto2 = QZKPProtocol("secret_a", "secret_b", 32, 0.025)
+result2 = proto2.run_protocol()
+print(result2["verification_status"])  # False
+
+# Aadhaar authentication
+aadhaar = QAadhaarProtocol(
+    aadhaar_id="1234-5678-9012",
+    master_secret="my_secret",
+    attributes={"name": "Alice", "age": "25"},
+)
+challenge = aadhaar.request_authentication("Gov Portal", "identity_verification")
+proof, qzkp_result = aadhaar.generate_proof(challenge)
+
+verifier = ServiceProvider("Gov Portal")
+print(verifier.verify_proof(proof))  # True
+
+# BB84 key distribution
+bb84 = BB84QKD(100, 0.02)
+keys = bb84.generate_key()
+print(keys["error_rate"])  # < 0.11
+```
+
+## Reproducibility
+
+All methods accept an optional `seed` parameter for deterministic results:
+
+```python
+result = proto.run_protocol(seed=42)
+```
+
+## License
+
+MIT
+

qzkp-0.1.0/README.md

@@ -0,0 +1,55 @@
+# qzkp
+
+Quantum Zero-Knowledge Proof protocol with BB84 simulation and Aadhaar identity verification -- powered by Rust.
+
+## Install
+
+```bash
+pip install qzkp
+```
+
+## Quick start
+
+```python
+from qzkp import QZKPProtocol, QAadhaarProtocol, ServiceProvider, BB84QKD
+
+# QZKP proof: same secret => valid
+proto = QZKPProtocol("shared_secret", "shared_secret", 32, 0.025)
+result = proto.run_protocol()
+print(result["verification_status"])  # True
+print(result["qber"])                 # ~0.02-0.09
+
+# QZKP proof: different secrets => invalid
+proto2 = QZKPProtocol("secret_a", "secret_b", 32, 0.025)
+result2 = proto2.run_protocol()
+print(result2["verification_status"])  # False
+
+# Aadhaar authentication
+aadhaar = QAadhaarProtocol(
+    aadhaar_id="1234-5678-9012",
+    master_secret="my_secret",
+    attributes={"name": "Alice", "age": "25"},
+)
+challenge = aadhaar.request_authentication("Gov Portal", "identity_verification")
+proof, qzkp_result = aadhaar.generate_proof(challenge)
+
+verifier = ServiceProvider("Gov Portal")
+print(verifier.verify_proof(proof))  # True
+
+# BB84 key distribution
+bb84 = BB84QKD(100, 0.02)
+keys = bb84.generate_key()
+print(keys["error_rate"])  # < 0.11
+```
+
+## Reproducibility
+
+All methods accept an optional `seed` parameter for deterministic results:
+
+```python
+result = proto.run_protocol(seed=42)
+```
+
+## License
+
+MIT

qzkp-0.1.0/crates/qzkp/.gitignore

@@ -0,0 +1,18 @@
+# Rust
+/target/
+**/*.rs.bk
+*.pdb
+
+# Cargo
+Cargo.lock
+
+# IDE
+.vscode/
+.idea/
+*.swp
+*.swo
+*~
+
+# OS
+.DS_Store
+Thumbs.db

qzkp-0.1.0/crates/qzkp/Cargo.toml

@@ -0,0 +1,26 @@
+[package]
+name = "qzkp"
+version = "0.1.0"
+edition = "2021"
+description = "Quantum Zero-Knowledge Proof protocol with BB84 simulation and Aadhaar identity verification"
+license = "MIT"
+repository = "https://github.com/vrag99/QZKP-simulation"
+homepage = "https://github.com/vrag99/QZKP-simulation"
+documentation = "https://docs.rs/qzkp"
+readme = "README.md"
+keywords = ["quantum", "zero-knowledge-proof", "bb84", "aadhaar", "cryptography"]
+categories = ["cryptography", "simulation"]
+authors = ["Sahil Gill", "Garv Makkar"]
+
+[lib]
+name = "qzkp"
+path = "src/lib.rs"
+
+[[example]]
+name = "demo"
+path = "examples/demo.rs"
+
+[dependencies]
+rand = "0.8"
+sha2 = "0.10"
+num-complex = "0.4"

qzkp-0.1.0/crates/qzkp/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Sahil Gill, Garv Makkar
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

qzkp-0.1.0/crates/qzkp/README.md

@@ -0,0 +1,101 @@
+# qzkp
+
+[![Crates.io](https://img.shields.io/crates/v/qzkp.svg)](https://crates.io/crates/qzkp)
+[![docs.rs](https://docs.rs/qzkp/badge.svg)](https://docs.rs/qzkp)
+[![MIT licensed](https://img.shields.io/badge/license-MIT-blue.svg)](LICENSE)
+
+Quantum Zero-Knowledge Proof (QZKP) protocol implementation in Rust, featuring
+BB84 quantum key distribution simulation and Aadhaar identity verification.
+
+## Features
+
+- **Quantum simulation** -- single-qubit state-vector simulator with depolarizing
+  noise and amplitude damping channels
+- **BB84 QKD** -- full BB84 protocol: encode, transmit, measure, sift, estimate
+  error rate
+- **QZKP protocol** -- SHA-256 KDF, quantum state preparation, basis
+  reconciliation, QBER threshold verification
+- **Aadhaar integration** -- challenge-response identity verification with masked
+  IDs, Merkle root over attributes, and proof generation/verification
+
+## Quick start
+
+Add to your `Cargo.toml`:
+
+```toml
+[dependencies]
+qzkp = "0.1"
+```
+
+### QZKP proof verification
+
+```rust
+use qzkp::qzkp::QZKPProtocol;
+
+let protocol = QZKPProtocol::new(
+    "shared_secret".into(),
+    "shared_secret".into(),
+    32,
+    0.025,
+);
+let result = protocol.run_protocol(&mut rand::thread_rng());
+assert!(result.verification_status);
+assert!(result.qber < 0.11);
+```
+
+### Aadhaar authentication
+
+```rust
+use std::collections::BTreeMap;
+use qzkp::qaadhaar::{QAadhaarProtocol, ServiceProvider};
+
+let mut attrs = BTreeMap::new();
+attrs.insert("name".into(), "Alice".into());
+attrs.insert("age".into(), "25".into());
+
+let proto = QAadhaarProtocol::new(
+    "1234-5678-9012".into(),
+    "master_secret".into(),
+    attrs,
+);
+
+let mut rng = rand::thread_rng();
+let challenge = proto.request_authentication("Gov Portal", "id_verify", &mut rng);
+let (proof, result) = proto.generate_proof(&challenge, 0.025, &mut rng);
+
+let verifier = ServiceProvider::new("Gov Portal".into());
+assert!(verifier.verify_proof(&proof));
+```
+
+### BB84 key distribution
+
+```rust
+use qzkp::bb84::BB84QKD;
+
+let bb84 = BB84QKD::new(100, 0.02);
+let (key_alice, key_bob, error_rate) = bb84.generate_key(&mut rand::thread_rng());
+assert!(error_rate < 0.11);
+```
+
+## Modules
+
+| Module | Description |
+|--------|-------------|
+| `quantum` | `QuantumState`, `QuantumCircuit` -- gates, noise, measurement |
+| `bb84` | `BB84QKD` -- BB84 quantum key distribution |
+| `qzkp` | `QZKPProtocol`, `ProtocolResult` -- full QZKP protocol |
+| `qaadhaar` | `QAadhaarProtocol`, `AuthChallenge`, `AuthProof`, `ServiceProvider` |
+
+## Python bindings
+
+A Python package wrapping this crate is available:
+
+```bash
+pip install qzkp
+```
+
+See [PyPI](https://pypi.org/project/qzkp/) for details.
+
+## License
+
+MIT

qzkp-0.1.0/crates/qzkp/examples/demo.rs

@@ -0,0 +1,128 @@
+use qzkp::bb84::BB84QKD;
+use qzkp::qaadhaar::{QAadhaarProtocol, ServiceProvider};
+use qzkp::qzkp::QZKPProtocol;
+use rand::thread_rng;
+use std::collections::BTreeMap;
+use std::io::{self, Write};
+
+fn main() {
+    let mut rng = thread_rng();
+
+    println!("\n### SCENARIO 1: Both parties share the same secret ###\n");
+    let qzkp1 = QZKPProtocol::new(
+        "quantum_secret_123".to_string(),
+        "quantum_secret_123".to_string(),
+        32,
+        0.03,
+    );
+    let result1 = qzkp1.run_protocol(&mut rng);
+
+    println!("\n\n");
+    print!("Press Enter to continue to Scenario 2...");
+    io::stdout().flush().unwrap();
+    let mut input = String::new();
+    io::stdin().read_line(&mut input).unwrap();
+    println!("\n\n");
+
+    println!("\n### SCENARIO 2: Parties have different secrets ###\n");
+    let qzkp2 = QZKPProtocol::new(
+        "quantum_secret_123".to_string(),
+        "different_secret_456".to_string(),
+        32,
+        0.03,
+    );
+    let result2 = qzkp2.run_protocol(&mut rng);
+
+    println!("\n\n");
+
+    println!("SIMULATION SUMMARY");
+
+    println!(
+        "Scenario 1 (Same secrets):      QBER = {:.4}, Valid = {}",
+        result1.qber, result1.verification_status
+    );
+    println!(
+        "Scenario 2 (Different secrets): QBER = {:.4}, Valid = {}",
+        result2.qber, result2.verification_status
+    );
+    println!("{}", "=".repeat(70));
+
+    println!("\n");
+    print!("Would you like to see a standalone BB84 QKD demonstration? (y/n): ");
+    io::stdout().flush().unwrap();
+    let mut user_input = String::new();
+    io::stdin().read_line(&mut user_input).unwrap();
+
+    if user_input.trim().eq_ignore_ascii_case("y") {
+        println!("BB84 QUANTUM KEY DISTRIBUTION DEMONSTRATION");
+
+        let bb84 = BB84QKD::new(100, 0.05);
+        let (key_alice, key_bob, error_rate) = bb84.generate_key(&mut rng);
+
+        println!("\nBB84 Protocol Results:");
+        println!("  Initial qubits sent: 100");
+        println!(
+            "  Final key length: {} bits (after basis reconciliation)",
+            key_alice.len()
+        );
+
+        let alice_key_str: String = key_alice.iter().map(|&b| b.to_string()).collect();
+        let bob_key_str: String = key_bob.iter().map(|&b| b.to_string()).collect();
+
+        if key_alice.len() > 20 {
+            println!("  Alice's key: {}...", &alice_key_str[..20]);
+            println!("  Bob's key:   {}...", &bob_key_str[..20]);
+        } else {
+            println!("  Alice's key: {}", alice_key_str);
+            println!("  Bob's key:   {}", bob_key_str);
+        }
+
+        println!(
+            "  Error rate: {:.4} ({:.2}%)",
+            error_rate,
+            error_rate * 100.0
+        );
+        println!("  Keys match: {}", key_alice == key_bob);
+
+        if error_rate < 0.11 {
+            println!("  Error rate below threshold - communication is secure");
+        } else {
+            println!("  Error rate too high - possible eavesdropping!");
+        }
+        println!("{}", "=".repeat(70));
+    }
+
+    println!("QBER Verification");
+
+    let mut attributes = BTreeMap::new();
+    attributes.insert("name".to_string(), "Sahil Gill".to_string());
+    attributes.insert("state".to_string(), "Punjab".to_string());
+    attributes.insert("age".to_string(), "25".to_string());
+
+    let qaadhaar = QAadhaarProtocol::new(
+        "1234-5678-9012".to_string(),
+        "quantum_aadhaar_master_secret".to_string(),
+        attributes,
+    );
+
+    let challenge =
+        qaadhaar.request_authentication("Government Portal", "identity_verification", &mut rng);
+
+    let (proof, qzkp_result) = qaadhaar.generate_proof(&challenge, 0.025, &mut rng);
+
+    let verifier = ServiceProvider::new("Government Portal".to_string());
+    let access_granted = verifier.verify_proof(&proof);
+
+    println!("Challenge session: {}", challenge.session_id);
+    println!("Aadhaar (masked): {}", proof.aadhaar_id_partial);
+    println!("QBER: {:.4}", proof.qber);
+    println!(
+        "QZKP verification status: {}",
+        qzkp_result.verification_status
+    );
+    println!(
+        "QAadhaar authentication: {}",
+        if access_granted { "GRANTED" } else { "DENIED" }
+    );
+    println!("{}", "=".repeat(70));
+}

qzkp-0.1.0/crates/qzkp/src/bb84.rs

@@ -0,0 +1,159 @@
+//! BB84 quantum key distribution protocol simulation.
+//!
+//! Implements the core BB84 protocol: Alice encodes random bits in random bases,
+//! Bob measures in random bases, they sift to matching bases, and estimate the
+//! error rate on a sample to detect eavesdropping.
+
+use crate::quantum::QuantumCircuit;
+use rand::Rng;
+
+/// BB84 quantum key distribution simulator.
+///
+/// # Example
+///
+/// ```
+/// use qzkp::bb84::BB84QKD;
+///
+/// let bb84 = BB84QKD::new(100, 0.02);
+/// let (key_alice, key_bob, error_rate) = bb84.generate_key(&mut rand::thread_rng());
+/// assert!(error_rate < 0.11);
+/// ```
+pub struct BB84QKD {
+    /// Number of qubits transmitted.
+    pub n_bits: usize,
+    /// Channel noise level (depolarizing error probability per qubit).
+    pub noise_level: f64,
+}
+
+impl BB84QKD {
+    /// Create a new BB84 instance.
+    ///
+    /// * `n_bits` -- number of qubits to transmit
+    /// * `noise_level` -- depolarizing noise probability per qubit
+    pub fn new(n_bits: usize, noise_level: f64) -> Self {
+        BB84QKD {
+            n_bits,
+            noise_level,
+        }
+    }
+
+    fn encode_bit(&self, bit: u8, basis: u8) -> QuantumCircuit {
+        let mut qc = QuantumCircuit::new(1, self.noise_level);
+        if bit == 1 {
+            qc.x(0);
+        }
+        if basis == 1 {
+            qc.h(0);
+        }
+        qc
+    }
+
+    fn measure_bit(&self, qc: &mut QuantumCircuit, basis: u8, rng: &mut impl Rng) -> u8 {
+        if basis == 1 {
+            qc.h(0);
+        }
+        qc.measure(0, rng)
+    }
+
+    /// Run the BB84 protocol and return `(alice_key, bob_key, error_rate)`.
+    ///
+    /// The returned keys are the sifted keys (after basis reconciliation and
+    /// error sampling). The error rate is estimated on half the sifted bits.
+    pub fn generate_key(&self, rng: &mut impl Rng) -> (Vec<u8>, Vec<u8>, f64) {
+        let alice_bits: Vec<u8> = (0..self.n_bits).map(|_| rng.gen_range(0..2)).collect();
+        let alice_bases: Vec<u8> = (0..self.n_bits).map(|_| rng.gen_range(0..2)).collect();
+        let bob_bases: Vec<u8> = (0..self.n_bits).map(|_| rng.gen_range(0..2)).collect();
+
+        let mut bob_results = Vec::new();
+        for i in 0..self.n_bits {
+            let mut qc = self.encode_bit(alice_bits[i], alice_bases[i]);
+            qc.apply_noise(rng);
+            let result = self.measure_bit(&mut qc, bob_bases[i], rng);
+            bob_results.push(result);
+        }
+
+        let mut sifted_key_alice = Vec::new();
+        let mut sifted_key_bob = Vec::new();
+        for i in 0..self.n_bits {
+            if alice_bases[i] == bob_bases[i] {
+                sifted_key_alice.push(alice_bits[i]);
+                sifted_key_bob.push(bob_results[i]);
+            }
+        }
+
+        let sample_size = sifted_key_alice.len() / 2;
+        let error_count = (0..sample_size)
+            .filter(|&i| sifted_key_alice[i] != sifted_key_bob[i])
+            .count();
+
+        let error_rate = if sample_size > 0 {
+            error_count as f64 / sample_size as f64
+        } else {
+            0.0
+        };
+
+        let final_key_alice = sifted_key_alice[sample_size..].to_vec();
+        let final_key_bob = sifted_key_bob[sample_size..].to_vec();
+
+        (final_key_alice, final_key_bob, error_rate)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use rand::rngs::StdRng;
+    use rand::SeedableRng;
+
+    fn seeded_rng() -> StdRng {
+        StdRng::seed_from_u64(123)
+    }
+
+    #[test]
+    fn low_noise_yields_matching_keys() {
+        let bb84 = BB84QKD::new(200, 0.0);
+        let mut rng = seeded_rng();
+        let (key_a, key_b, error_rate) = bb84.generate_key(&mut rng);
+        assert_eq!(key_a, key_b, "zero-noise keys should match exactly");
+        assert!((error_rate - 0.0).abs() < 1e-10);
+    }
+
+    #[test]
+    fn keys_have_reasonable_length() {
+        let bb84 = BB84QKD::new(100, 0.02);
+        let mut rng = seeded_rng();
+        let (key_a, _key_b, _error_rate) = bb84.generate_key(&mut rng);
+        // ~50% basis match, then half used for sampling => ~25% of n_bits
+        assert!(key_a.len() >= 10, "sifted key too short: {}", key_a.len());
+        assert!(
+            key_a.len() <= 60,
+            "sifted key unexpectedly long: {}",
+            key_a.len()
+        );
+    }
+
+    #[test]
+    fn low_noise_error_rate_below_threshold() {
+        let bb84 = BB84QKD::new(200, 0.02);
+        let mut rng = seeded_rng();
+        let (_ka, _kb, error_rate) = bb84.generate_key(&mut rng);
+        assert!(
+            error_rate < 0.11,
+            "error rate {} too high for low noise",
+            error_rate
+        );
+    }
+
+    #[test]
+    fn high_noise_degrades_keys() {
+        let bb84 = BB84QKD::new(200, 0.3);
+        let mut rng = seeded_rng();
+        let (key_a, key_b, error_rate) = bb84.generate_key(&mut rng);
+        // With 30% noise, many bits should differ
+        let mismatches = key_a.iter().zip(&key_b).filter(|(a, b)| a != b).count();
+        assert!(
+            mismatches > 0 || error_rate > 0.05,
+            "high noise should cause errors"
+        );
+    }
+}

qzkp-0.1.0/crates/qzkp/src/lib.rs

@@ -0,0 +1,53 @@
+//! # qzkp -- Quantum Zero-Knowledge Proof Protocol
+//!
+//! A Rust implementation of the QZKP protocol: a BB84-inspired quantum channel
+//! simulation combined with QBER (Quantum Bit Error Rate) verification for
+//! zero-knowledge identity proofs, with built-in Aadhaar integration.
+//!
+//! ## Overview
+//!
+//! The library provides four layers, each building on the one below:
+//!
+//! | Module | Purpose |
+//! |--------|---------|
+//! | [`quantum`] | Single-qubit state-vector simulator with noise models |
+//! | [`bb84`] | BB84 quantum key distribution protocol |
+//! | [`qzkp`] | Full QZKP proof protocol (KDF, quantum stage, QBER) |
+//! | [`qaadhaar`] | Aadhaar identity verification on top of QZKP |
+//!
+//! ## Quick start
+//!
+//! ```rust
+//! use qzkp::qzkp::QZKPProtocol;
+//!
+//! let protocol = QZKPProtocol::new(
+//!     "shared_secret".into(),
+//!     "shared_secret".into(),
+//!     32,
+//!     0.025,
+//! );
+//! let result = protocol.run_protocol(&mut rand::thread_rng());
+//! assert!(result.verification_status);
+//! ```
+//!
+//! ## Aadhaar authentication
+//!
+//! ```rust
+//! use std::collections::BTreeMap;
+//! use qzkp::qaadhaar::{QAadhaarProtocol, ServiceProvider};
+//!
+//! let mut attrs = BTreeMap::new();
+//! attrs.insert("name".into(), "Alice".into());
+//!
+//! let proto = QAadhaarProtocol::new("1234-5678-9012".into(), "secret".into(), attrs);
+//! let challenge = proto.request_authentication("Portal", "id_verify", &mut rand::thread_rng());
+//! let (proof, result) = proto.generate_proof(&challenge, 0.025, &mut rand::thread_rng());
+//!
+//! let verifier = ServiceProvider::new("Portal".into());
+//! assert!(verifier.verify_proof(&proof));
+//! ```
+
+pub mod bb84;
+pub mod qaadhaar;
+pub mod quantum;
+pub mod qzkp;