shadow_core/

peer.rs

use serde::{Deserialize, Serialize};
use std::fmt;
use std::hash::{Hash, Hasher};

/// Unique identifier for a peer in the network
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)]
pub struct PeerId([u8; 32]);

impl PeerId {
    /// Create a new random PeerId
    pub fn random() -> Self {
        use bytes::Bytes;
        let mut id = [0u8; 32];
        // In production, use a cryptographically secure RNG
        for byte in &mut id {
            *byte = rand::random();
        }
        Self(id)
    }

    /// Create PeerId from bytes
    pub fn from_bytes(bytes: [u8; 32]) -> Self {
        Self(bytes)
    }

    /// Get the underlying bytes
    pub fn as_bytes(&self) -> &[u8; 32] {
        &self.0
    }

    /// Calculate XOR distance to another PeerId (for Kademlia)
    pub fn xor_distance(&self, other: &PeerId) -> [u8; 32] {
        let mut result = [0u8; 32];
        for i in 0..32 {
            result[i] = self.0[i] ^ other.0[i];
        }
        result
    }

    /// Count leading zeros in the XOR distance (for Kademlia bucket calculation)
    pub fn leading_zeros_to(&self, other: &PeerId) -> usize {
        let distance = self.xor_distance(other);
        let mut zeros = 0;
        for byte in distance.iter() {
            if *byte == 0 {
                zeros += 8;
            } else {
                zeros += byte.leading_zeros() as usize;
                break;
            }
        }
        zeros
    }
}

impl Hash for PeerId {
    fn hash<H: Hasher>(&self, state: &mut H) {
        self.0.hash(state);
    }
}

impl fmt::Debug for PeerId {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(f, "PeerId({}...)", hex::encode(&self.0[..4]))
    }
}

impl fmt::Display for PeerId {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(f, "{}", hex::encode(&self.0))
    }
}

/// Information about a peer in the network
#[derive(Clone, Debug, Serialize, Deserialize)]
pub struct PeerInfo {
    /// Unique identifier for this peer
    pub id: PeerId,
    
    /// Network addresses where this peer can be reached
    pub addresses: Vec<String>,
    
    /// Public key for encryption (X25519)
    pub public_key: [u8; 32],
    
    /// Signature verification key (Ed25519)
    pub verify_key: [u8; 32],
    
    /// Last seen timestamp (Unix epoch)
    pub last_seen: u64,
    
    /// Reputation score (for Sybil resistance)
    pub reputation: f64,
    
    /// Geographic location hint (for routing optimization)
    pub location: Option<GeoLocation>,
    
    /// Supported cover protocols
    pub supported_protocols: Vec<String>,
}

impl PeerInfo {
    /// Create new peer info
    pub fn new(
        id: PeerId,
        addresses: Vec<String>,
        public_key: [u8; 32],
        verify_key: [u8; 32],
    ) -> Self {
        Self {
            id,
            addresses,
            public_key,
            verify_key,
            last_seen: current_timestamp(),
            reputation: 0.5, // Neutral starting reputation
            location: None,
            supported_protocols: vec![],
        }
    }

    /// Update last seen timestamp
    pub fn touch(&mut self) {
        self.last_seen = current_timestamp();
    }

    /// Check if peer info is stale
    pub fn is_stale(&self, max_age_secs: u64) -> bool {
        let now = current_timestamp();
        now - self.last_seen > max_age_secs
    }
}

/// Geographic location for routing optimization
#[derive(Clone, Debug, Serialize, Deserialize)]
pub struct GeoLocation {
    pub latitude: f64,
    pub longitude: f64,
    pub city: Option<String>,
    pub country: Option<String>,
}

impl GeoLocation {
    /// Calculate approximate distance to another location (in kilometers)
    pub fn distance_to(&self, other: &GeoLocation) -> f64 {
        // Haversine formula
        const EARTH_RADIUS_KM: f64 = 6371.0;
        
        let lat1 = self.latitude.to_radians();
        let lat2 = other.latitude.to_radians();
        let delta_lat = (other.latitude - self.latitude).to_radians();
        let delta_lon = (other.longitude - self.longitude).to_radians();
        
        let a = (delta_lat / 2.0).sin().powi(2)
            + lat1.cos() * lat2.cos() * (delta_lon / 2.0).sin().powi(2);
        let c = 2.0 * a.sqrt().atan2((1.0 - a).sqrt());
        
        EARTH_RADIUS_KM * c
    }
}

/// Get current Unix timestamp
fn current_timestamp() -> u64 {
    use std::time::{SystemTime, UNIX_EPOCH};
    SystemTime::now()
        .duration_since(UNIX_EPOCH)
        .unwrap()
        .as_secs()
}

// We need the hex crate for display
mod hex {
    pub fn encode(data: &[u8]) -> String {
        data.iter().map(|b| format!("{:02x}", b)).collect()
    }
}

// Mock rand for now
mod rand {
    pub fn random<T>() -> T
    where
        Standard: Distribution<T>,
    {
        Standard.sample(&mut thread_rng())
    }
    
    use std::sync::Mutex;
    use std::collections::hash_map::RandomState;
    use std::hash::{BuildHasher, Hash, Hasher};
    
    static RNG_STATE: Mutex<u64> = Mutex::new(12345);
    
    fn thread_rng() -> impl Iterator<Item = u8> {
        std::iter::repeat_with(|| {
            let mut state = RNG_STATE.lock().unwrap();
            *state = state.wrapping_mul(6364136223846793005).wrapping_add(1);
            (*state >> 32) as u8
        })
    }
    
    pub struct Standard;
    
    pub trait Distribution<T> {
        fn sample<R>(&self, rng: &mut R) -> T
        where
            R: Iterator<Item = u8>;
    }
    
    impl Distribution<u8> for Standard {
        fn sample<R>(&self, rng: &mut R) -> u8
        where
            R: Iterator<Item = u8>,
        {
            rng.next().unwrap()
        }
    }
}