Code shared from the Rust Playground

playground.rs

//// src/main.rs

use std::collections::HashMap;

// --- PLACEHOLDER TYPES (Replacing ECC Types) ---
// In a real implementation, these would be Elliptic Curve Points or Scalars.
type MintPrivateKey = u64;    // k
type MintPublicKey = u64;     // K = k * G
type UserSecret = u64;        // x
type RandomPoint = u64;       // Y = hash_to_curve(x)
type BlindingFactor = u64;    // r
type BlindedPoint = u64;      // B' = Y + r * G
type BlindedSignature = u64;  // C' = k * B'
type UnblindedSignature = u64; // C = k * Y

// The Generator Point G is implicitly 1 for simple arithmetic.
const GENERATOR_POINT: u64 = 1;
// A large prime P would be used for modular arithmetic, but we'll omit it for simplicity.

// --- 1. PLACEHOLDER CRYPTOGRAPHIC FUNCTIONS ---
// These functions use simple addition/multiplication instead of complex ECC/Field operations.

/// Placeholder for the hash_to_curve(x) function.
/// In ECC: Y = hash_to_curve(x)
fn hash_to_curve(x: UserSecret) -> RandomPoint {
    // Insecure placeholder: just a simple fixed hash function
    x.wrapping_add(42) 
}

/// Placeholder for scalar multiplication (k * P).
/// In ECC: ProjectivePoint = Scalar * ProjectivePoint
fn scalar_mul(scalar: u64, point: u64) -> u64 {
    // Insecure placeholder: simple multiplication
    scalar.wrapping_mul(point)
}

/// Placeholder for point addition (P1 + P2).
/// In ECC: ProjectivePoint = ProjectivePoint + ProjectivePoint
fn point_add(p1: u64, p2: u64) -> u64 {
    // Insecure placeholder: simple addition
    p1.wrapping_add(p2)
}

/// Placeholder for point subtraction (P1 - P2).
/// In ECC: ProjectivePoint = ProjectivePoint - ProjectivePoint
fn point_sub(p1: u64, p2: u64) -> u64 {
    // Insecure placeholder: simple subtraction
    p1.wrapping_sub(p2)
}

// --- 2. Mint (Bob) Functions ---

/// 1. Mint Bob publishes public key K = kG.
fn mint_key_gen() -> (MintPrivateKey, MintPublicKey) {
    // In a real app, 'k' would be a secure random scalar, here we use a fixed value.
    let k: u64 = 7; 
    let k_pub: u64 = scalar_mul(k, GENERATOR_POINT); // K = k * G
    (k, k_pub)
}

/// 4. Bob sends back to Alice blind signature C' = k * B'.
fn mint_sign(k: MintPrivateKey, blinded_point: BlindedPoint) -> BlindedSignature {
    scalar_mul(k, blinded_point) // C' = k * B'
}

// --- 3. User (Alice) Functions ---

/// 2. User Alice picks secret x and computes Y = hash_to_curve(x).
fn alice_prepare_token() -> (UserSecret, RandomPoint, BlindingFactor) {
    // x is the secret key used for the ecash token
    let x: u64 = 101; 
    let y = hash_to_curve(x); // Y = hash_to_curve(x)
    
    // r is the random blinding factor
    let r: u64 = 5;
    (x, y, r)
}

/// 3. Alice sends to Bob B' = Y + rG with r being a random blinding factor.
fn alice_blind(y: RandomPoint, r: BlindingFactor) -> BlindedPoint {
    let r_g = scalar_mul(r, GENERATOR_POINT); // r * G
    point_add(y, r_g) // B' = Y + r * G
}

/// 5. Alice can calculate the unblinded signature as C' - rK = kY = C.
fn alice_unblind(
    k_pub: MintPublicKey,
    r: BlindingFactor,
    blinded_signature: BlindedSignature,
) -> UnblindedSignature {
    let r_k = scalar_mul(r, k_pub); // r * K
    point_sub(blinded_signature, r_k) // C = C' - r * K
}

// --- 4. Spender (Carol) & Mint (Bob) Verification Functions ---

/// 7. Carol sends (x, C) to Bob who then checks that k * hash_to_curve(x) = C.
fn mint_verify(k: MintPrivateKey, x: UserSecret, c: UnblindedSignature) -> bool {
    let y = hash_to_curve(x);       // Y = hash_to_curve(x)
    let c_expected = scalar_mul(k, y); // C_expected = k * Y
    c == c_expected
}

// --- 5. Main Execution Flow ---

fn main() {
    println!("--- Blind Diffie-Hellman Key Exchange (BDHKE) Protocol Simulation (Insecure, stdlib-only) ---");

    // MINT (BOB) SETUP
    let (k, k_pub) = mint_key_gen();
    println!("\n1. Bob (Mint) Setup:");
    println!("   Mint Private Key (k): {}", k);
    println!("   Mint Public Key (K = k * G): {}", k_pub);
    
    // ALICE PREPARES MINTING REQUEST
    let (x, y, r) = alice_prepare_token();
    println!("\n2. Alice Preparation:");
    println!("   User Secret (x): {}", x);
    println!("   Hashed Point (Y = hash_to_curve(x)): {}", y);
    println!("   Blinding Factor (r): {}", r);

    // ALICE BLINDS AND SENDS
    let b_prime = alice_blind(y, r);
    println!("\n3. Alice Blinds and Sends:");
    println!("   Blinded Point (B' = Y + r*G): {}", b_prime);
    
    // BOB SIGNS BLINDED POINT
    let c_prime = mint_sign(k, b_prime);
    println!("\n4. Bob Signs (Blind Signature):");
    println!("   Blinded Signature (C' = k * B'): {}", c_prime);
    
    // ALICE UNBLINDS
    let c = alice_unblind(k_pub, r, c_prime);
    println!("\n5. Alice Unblinds:");
    println!("   Unblinded Signature (C = C' - r*K): {}", c);
    
    // Final ecash token: (x, C)
    
    // CAROL SPENDS / BOB VERIFIES
    let is_valid = mint_verify(k, x, c);
    
    println!("\n6. Carol Spends / Bob Verifies (Token: ({}, {})):", x, c);
    if is_valid {
        println!("   ✅ Verification successful: k * hash_to_curve(x) == C");
    } else {
        println!("   ❌ Verification failed.");
    }
}