Skip to main content

clm_rust_core/
discovery_engine.rs

1use std::collections::HashMap;
2use std::net::UdpSocket;
3use std::path::Path;
4use std::fs;
5use std::time::{Duration, Instant};
6use mdns_sd::{ServiceDaemon, ServiceEvent, ServiceInfo};
7use serde::{Serialize, Deserialize};
8use ed25519_dalek::{VerifyingKey, SigningKey, Verifier, Signature, Signer};
9use ed25519_dalek::pkcs8::{DecodePrivateKey, DecodePublicKey};
10
11
12// Structure matching JavaScript peer export
13#[derive(Serialize, Deserialize, Clone, Debug)]
14pub struct PeerInfo {
15    pub name: String,
16    pub ip: String,
17    pub port: u16,
18    pub did: String,
19    pub capabilities: Vec<String>,
20    pub protocol: String,
21    #[serde(rename = "discoveredAt")]
22    pub discovered_at: String,
23    /// WireGuard public key (hex-encoded X25519 public key).
24    /// Present when the peer announces WireGuard support via mDNS.
25    /// `None` for peers that don't support WireGuard (backward compatible).
26    #[serde(default, skip_serializing_if = "Option::is_none")]
27    pub wg_public_key: Option<String>,
28}
29
30pub struct DiscoveryEngine {
31    pub service_type: String,
32}
33
34impl DiscoveryEngine {
35    pub fn new() -> Self {
36        Self {
37            service_type: "_pkc._tcp.local.".to_string(),
38        }
39    }
40
41    pub fn get_local_ip() -> String {
42        if let Ok(socket) = UdpSocket::bind("0.0.0.0:0") {
43            if socket.connect("8.8.8.8:80").is_ok() {
44                if let Ok(addr) = socket.local_addr() {
45                    return addr.ip().to_string();
46                }
47            }
48        }
49        "127.0.0.1".to_string()
50    }
51
52    pub fn announce(&self, service_name: &str, did: &str, port: u16) -> Result<(), String> {
53        self.announce_with_wireguard(service_name, did, port, None)
54    }
55
56    /// Announce the PKC service with a WireGuard public key.
57    ///
58    /// In addition to the standard mDNS properties (did, version, capabilities, protocol),
59    /// this includes `wg_public_key` so peers can establish WireGuard-encrypted tunnels.
60    pub fn announce_with_wireguard(
61        &self,
62        service_name: &str,
63        did: &str,
64        port: u16,
65        wg_public_key: Option<&str>,
66    ) -> Result<(), String> {
67        let mdns = ServiceDaemon::new().map_err(|e| format!("Failed to create mDNS daemon: {}", e))?;
68        let local_ip = Self::get_local_ip();
69
70        let host_name = format!("{}.local.", service_name);
71        let mut properties = HashMap::new();
72        properties.insert("did".to_string(), did.to_string());
73        properties.insert("version".to_string(), "1.0".to_string());
74        properties.insert("capabilities".to_string(), "s3_access,ipfs_access,webrtc_relay".to_string());
75        properties.insert("protocol".to_string(), "challenge-response".to_string());
76        if let Some(wg_key) = wg_public_key {
77            properties.insert("wg_public_key".to_string(), wg_key.to_string());
78        }
79
80        let service_info = ServiceInfo::new(
81            &self.service_type,
82            service_name,
83            &host_name,
84            &local_ip,
85            port,
86            properties,
87        )
88        .map_err(|e| format!("Failed to create ServiceInfo: {}", e))?
89        .enable_addr_auto();
90
91        mdns.register(service_info).map_err(|e| format!("Failed to register service: {}", e))?;
92
93        println!("[mDNS PKC] ✅ Announced service: {} on port {}", service_name, port);
94        println!("[mDNS PKC]    IPs: {}", local_ip);
95        println!("[mDNS PKC]    DID: {}", did);
96
97        // Keep running to maintain registration
98        loop {
99            std::thread::sleep(Duration::from_secs(10));
100        }
101    }
102
103    pub fn discover(&self, timeout: Duration) -> Result<Vec<PeerInfo>, String> {
104        let mdns = ServiceDaemon::new().map_err(|e| format!("Failed to create mDNS daemon: {}", e))?;
105        let receiver = mdns.browse(&self.service_type).map_err(|e| format!("Failed to browse: {}", e))?;
106
107        println!("[mDNS PKC] 🔍 Discovering PKC peers on network...");
108
109        let start_time = Instant::now();
110        let mut discovered_peers: HashMap<String, PeerInfo> = HashMap::new();
111
112        while start_time.elapsed() < timeout {
113            let remaining = timeout.saturating_sub(start_time.elapsed());
114            if remaining.is_zero() {
115                break;
116            }
117
118            if let Ok(event) = receiver.recv_timeout(remaining) {
119                match event {
120                    ServiceEvent::ServiceResolved(info) => {
121                        let name = info.get_fullname().to_string();
122                        let port = info.get_port();
123                        
124                        let props = info.get_properties();
125                        let did = props.get_property_val_str("did").unwrap_or("unknown").to_string();
126                        let capabilities = props.get_property_val_str("capabilities")
127                            .map(|s| s.split(',').map(|x| x.to_string()).collect())
128                            .unwrap_or_else(Vec::new);
129                        let protocol = props.get_property_val_str("protocol").unwrap_or("unknown").to_string();
130
131
132                        let wg_public_key = props.get_property_val_str("wg_public_key").map(|s| s.to_string());
133
134                        for ip_addr in info.get_addresses() {
135                            let ip = ip_addr.to_string();
136                            let peer_id = format!("{}:{}", ip, port);
137                            
138                            // Check skip self if we knew ours, but we just list all non-self or all discovered
139                            discovered_peers.insert(peer_id, PeerInfo {
140                                name: name.clone(),
141                                ip,
142                                port,
143                                did: did.clone(),
144                                capabilities: capabilities.clone(),
145                                protocol: protocol.clone(),
146                                discovered_at: chrono::Utc::now().to_rfc3339_opts(chrono::SecondsFormat::Millis, true),
147                                wg_public_key: wg_public_key.clone(),
148                            });
149                        }
150                    }
151                    _ => {}
152                }
153            }
154        }
155
156        let peers: Vec<PeerInfo> = discovered_peers.into_values().collect();
157        Ok(peers)
158    }
159
160    /// Announce the PKC service asynchronously with structured cancellation.
161    pub async fn announce_with_cancellation(
162        &self,
163        service_name: &str,
164        did: &str,
165        port: u16,
166        wg_public_key: Option<&str>,
167        token: tokio_util::sync::CancellationToken,
168    ) -> Result<(), String> {
169        let mdns = ServiceDaemon::new().map_err(|e| format!("Failed to create mDNS daemon: {}", e))?;
170        let local_ip = Self::get_local_ip();
171
172        let host_name = format!("{}.local.", service_name);
173        let mut properties = HashMap::new();
174        properties.insert("did".to_string(), did.to_string());
175        properties.insert("version".to_string(), "1.0".to_string());
176        properties.insert("capabilities".to_string(), "s3_access,ipfs_access,webrtc_relay".to_string());
177        properties.insert("protocol".to_string(), "challenge-response".to_string());
178        if let Some(wg_key) = wg_public_key {
179            properties.insert("wg_public_key".to_string(), wg_key.to_string());
180        }
181
182        let service_info = ServiceInfo::new(
183            &self.service_type,
184            service_name,
185            &host_name,
186            &local_ip,
187            port,
188            properties,
189        )
190        .map_err(|e| format!("Failed to create ServiceInfo: {}", e))?
191        .enable_addr_auto();
192
193        mdns.register(service_info).map_err(|e| format!("Failed to register service: {}", e))?;
194
195        // Gracefully wait until token cancellation
196        tokio::select! {
197            _ = token.cancelled() => {
198                let _ = mdns.shutdown();
199                Ok(())
200            }
201        }
202    }
203
204    /// Discover PKC peers asynchronously with structured cancellation.
205    pub async fn discover_with_cancellation(
206        &self,
207        timeout: Duration,
208        token: tokio_util::sync::CancellationToken,
209    ) -> Result<Vec<PeerInfo>, String> {
210        let mdns = ServiceDaemon::new().map_err(|e| format!("Failed to create mDNS daemon: {}", e))?;
211        let receiver = mdns.browse(&self.service_type).map_err(|e| format!("Failed to browse: {}", e))?;
212
213        let start_time = Instant::now();
214        let mut discovered_peers: HashMap<String, PeerInfo> = HashMap::new();
215
216        while start_time.elapsed() < timeout && !token.is_cancelled() {
217            let remaining = timeout.saturating_sub(start_time.elapsed());
218            if remaining.is_zero() {
219                break;
220            }
221
222            let step = remaining.min(Duration::from_millis(50));
223            tokio::select! {
224                _ = token.cancelled() => break,
225                res = tokio::task::spawn_blocking({
226                    let receiver = receiver.clone();
227                    move || receiver.recv_timeout(step)
228                }) => {
229                    if let Ok(Ok(event)) = res {
230                        match event {
231                            ServiceEvent::ServiceResolved(info) => {
232                                let name = info.get_fullname().to_string();
233                                let port = info.get_port();
234                                let props = info.get_properties();
235                                let did = props.get_property_val_str("did").unwrap_or("unknown").to_string();
236                                let capabilities = props.get_property_val_str("capabilities")
237                                    .map(|s| s.split(',').map(|x| x.to_string()).collect())
238                                    .unwrap_or_else(Vec::new);
239                                let protocol = props.get_property_val_str("protocol").unwrap_or("unknown").to_string();
240                                let wg_public_key = props.get_property_val_str("wg_public_key").map(|s| s.to_string());
241
242                                for ip_addr in info.get_addresses() {
243                                    let ip = ip_addr.to_string();
244                                    let peer_id = format!("{}:{}", ip, port);
245                                    discovered_peers.insert(peer_id, PeerInfo {
246                                        name: name.clone(),
247                                        ip,
248                                        port,
249                                        did: did.clone(),
250                                        capabilities: capabilities.clone(),
251                                        protocol: protocol.clone(),
252                                        discovered_at: chrono::Utc::now().to_rfc3339_opts(chrono::SecondsFormat::Millis, true),
253                                        wg_public_key: wg_public_key.clone(),
254                                    });
255                                }
256                            }
257                            _ => {}
258                        }
259                    }
260                }
261            }
262        }
263
264        let _ = mdns.shutdown();
265        let peers: Vec<PeerInfo> = discovered_peers.into_values().collect();
266        Ok(peers)
267    }
268}
269
270// Helpers for Hex Encoding/Decoding
271pub fn decode_hex(s: &str) -> Result<Vec<u8>, String> {
272    if s.len() % 2 != 0 {
273        return Err("Hex string must have an even length".to_string());
274    }
275    (0..s.len())
276        .step_by(2)
277        .map(|i| {
278            u8::from_str_radix(&s[i..i + 2], 16)
279                .map_err(|e| format!("Invalid hex digit: {}", e))
280        })
281        .collect()
282}
283
284pub fn encode_hex(bytes: &[u8]) -> String {
285    bytes.iter().map(|b| format!("{:02x}", b)).collect()
286}
287
288// SQLite / Agent Card parser structs
289#[derive(Deserialize, Debug)]
290pub struct AgentCard {
291    pub public_key: String,
292    #[serde(default)]
293    pub capabilities: Vec<String>,
294}
295
296pub fn get_agent_card_from_db_pub(db_path: &str, did: &str) -> Result<Option<AgentCard>, String> {
297    get_agent_card_from_db(db_path, did)
298}
299
300fn get_agent_card_from_db(db_path: &str, did: &str) -> Result<Option<AgentCard>, String> {
301    if !Path::new(db_path).exists() {
302        return Err(format!("Database file not found at: {}", db_path));
303    }
304    let conn = rusqlite::Connection::open(db_path)
305        .map_err(|e| format!("Failed to open agent identity DB: {}", e))?;
306    
307    let mut stmt = conn.prepare("SELECT content FROM card WHERE hash = ?")
308        .map_err(|e| format!("Prepare query failed: {}", e))?;
309    
310    let content_opt: Option<String> = stmt.query_row(rusqlite::params![did], |row| row.get(0))
311        .ok();
312
313    if let Some(content) = content_opt {
314        let card: AgentCard = serde_yaml::from_str(&content)
315            .map_err(|e| format!("Failed to parse YAML agent card: {}", e))?;
316        Ok(Some(card))
317    } else {
318        Ok(None)
319    }
320}
321
322// --- QUIC Challenge Response EOA Server ---
323#[derive(Serialize)]
324struct ChallengeMessage<'a> {
325    #[serde(rename = "type")]
326    msg_type: &'static str,
327    nonce: &'a str,
328}
329
330#[derive(Deserialize)]
331struct ResponseMessage {
332    #[serde(rename = "type")]
333    msg_type: String,
334    did: String,
335    signature: String,
336}
337
338#[derive(Serialize)]
339struct RejectedResponse<'a> {
340    status: &'static str,
341    reason: &'a str,
342}
343
344#[derive(Serialize)]
345struct CapabilityDetail {
346    endpoint: String,
347    bucket: String,
348    access: String,
349}
350
351#[derive(Serialize)]
352struct IpfsDetail {
353    gateway: String,
354    folder_cid: String,
355}
356
357#[derive(Serialize)]
358struct WebrtcDetail {
359    relay: String,
360}
361
362#[derive(Serialize)]
363struct CapabilitiesInfo {
364    s3: CapabilityDetail,
365    ipfs: IpfsDetail,
366    webrtc: WebrtcDetail,
367}
368
369pub fn generate_random_bytes_pub(len: usize) -> Vec<u8> {
370    generate_random_bytes(len)
371}
372
373fn generate_random_bytes(len: usize) -> Vec<u8> {
374    use std::time::SystemTime;
375    let seed = format!("{:?}", SystemTime::now());
376    let ptr_bytes = (&seed as *const _ as usize).to_ne_bytes();
377    let mut combined = seed.as_bytes().to_vec();
378    combined.extend_from_slice(&ptr_bytes);
379    let result = crate::hash::raw_hash_bytes_32(&combined);
380    result[..len.min(32)].to_vec()
381}
382
383#[derive(Serialize)]
384struct AuthorizedResponse {
385    status: &'static str,
386    capabilities: CapabilitiesInfo,
387}
388
389async fn handle_node_connection(
390    mut send_stream: quinn::SendStream,
391    mut recv_stream: quinn::RecvStream,
392    db_path: &str,
393) -> Result<Option<String>, String> {
394
395    // Generate 16-byte random challenge nonce
396    let nonce = encode_hex(&generate_random_bytes(16));
397
398    // Send challenge nonce
399    let challenge = ChallengeMessage {
400        msg_type: "challenge",
401        nonce: &nonce,
402    };
403
404    let challenge_json = serde_json::to_string(&challenge)
405        .map_err(|e| format!("Failed to serialize challenge: {}", e))?;
406
407    send_stream.write_all(challenge_json.as_bytes())
408        .await
409        .map_err(|e| format!("Failed to write challenge: {}", e))?;
410    send_stream.finish()
411        .map_err(|e| format!("Failed to finish challenge stream: {}", e))?;
412
413    // Read response
414    let response_buf = recv_stream.read_to_end(1024 * 1024)
415        .await
416        .map_err(|e| format!("Failed to read response: {}", e))?;
417
418    if response_buf.is_empty() {
419        return Ok(None);
420    }
421
422    let response_str = String::from_utf8_lossy(&response_buf);
423    let response: ResponseMessage = match serde_json::from_str(&response_str) {
424        Ok(msg) => msg,
425        Err(_) => {
426            return Ok(None);
427        }
428    };
429
430    if response.msg_type != "response" {
431        return Ok(None);
432    }
433
434    println!("[P2P NODE] Verifying EOA credentials for {}...", response.did);
435
436    // Retrieve DID card
437    let agent_card = match get_agent_card_from_db(db_path, &response.did)? {
438        Some(card) => card,
439        None => {
440            println!("[P2P NODE] Unauthorized: DID {} not registered in identity registry.", response.did);
441            return Ok(None);
442        }
443    };
444
445    // Parse VerifyingKey from PEM
446    let public_key = match VerifyingKey::from_public_key_pem(&agent_card.public_key) {
447        Ok(key) => key,
448        Err(e) => {
449            println!("[P2P NODE] Unauthorized: Public key parse failed for {}: {}", response.did, e);
450            return Ok(None);
451        }
452    };
453
454    // Verify signature
455    let signature_bytes = match decode_hex(&response.signature) {
456        Ok(bytes) => bytes,
457        Err(_) => {
458            return Ok(None);
459        }
460    };
461
462    let signature = match Signature::from_slice(&signature_bytes) {
463        Ok(sig) => sig,
464        Err(_) => {
465            return Ok(None);
466        }
467    };
468
469    if public_key.verify(nonce.as_bytes(), &signature).is_err() {
470        println!("[P2P NODE] Cryptographic validation failed for {}.", response.did);
471        return Ok(None);
472    }
473
474    // Success! Check capabilities
475    let has_s3 = agent_card.capabilities.iter().any(|c| c == "s3_access");
476    let has_ipfs = agent_card.capabilities.iter().any(|c| c == "ipfs_access");
477
478    if has_s3 || has_ipfs {
479        println!("[P2P NODE] Authentication succeeded for {}. Capability access granted.", response.did);
480        let cap_res = AuthorizedResponse {
481            status: "authorized",
482            capabilities: CapabilitiesInfo {
483                s3: CapabilityDetail {
484                    endpoint: "http://127.0.0.1:9000".to_string(),
485                    bucket: "sprint42-bucket".to_string(),
486                    access: "read-write".to_string(),
487                },
488                ipfs: IpfsDetail {
489                    gateway: "http://127.0.0.1:5001".to_string(),
490                    folder_cid: "QmULx3x6FCZiYksGkuK1FQ1t59uAwRtYpuqHAvGqc7s9Ba".to_string(),
491                },
492                webrtc: WebrtcDetail {
493                    relay: "http://127.0.0.1:9090".to_string(),
494                },
495            },
496        };
497        let cap_json = serde_json::to_string(&cap_res)
498            .map_err(|e| format!("Failed to serialize auth response: {}", e))?;
499        return Ok(Some(cap_json));
500    } else {
501        println!("[P2P NODE] DID {} authenticated but lacks authorized storage capabilities.", response.did);
502    }
503
504    Ok(None)
505}
506
507pub fn run_discovery_node(port: u16, db_path: &str) -> Result<(), String> {
508    use crate::quic_transport::{QuicEndpoint, generate_self_signed_cert};
509
510    let cert = generate_self_signed_cert("pkc-discovery-node")
511        .map_err(|e| format!("Failed to generate TLS cert: {}", e))?;
512
513    let endpoint = QuicEndpoint::new_server(port, &cert)
514        .map_err(|e| format!("Failed to bind QUIC endpoint to port {}: {}", port, e))?;
515
516    println!("[P2P NODE] Starting discovery node on port {} (QUIC)...", port);
517    println!("[P2P NODE] Using identity database: {}", db_path);
518    println!("[P2P NODE] Node is listening on port {} (QUIC/UDP)", port);
519
520    let rt = tokio::runtime::Runtime::new()
521        .map_err(|e| format!("Failed to create tokio runtime: {}", e))?;
522
523    rt.block_on(async {
524        loop {
525            match endpoint.accept().await {
526                Ok(conn) => {
527                    let db = db_path.to_string();
528                    tokio::spawn(async move {
529                        // Accept a bidirectional stream for the handshake
530                        match conn.conn.accept_bi().await {
531                            Ok((send_stream, recv_stream)) => {
532                                match handle_node_connection(send_stream, recv_stream, &db).await {
533                                    Ok(Some(auth_json)) => {
534                                        // Send auth response via uni-stream
535                                        match conn.conn.open_uni().await {
536                                            Ok(mut auth_stream) => {
537                                                let _ = auth_stream.write_all(auth_json.as_bytes()).await;
538                                                let _ = auth_stream.finish();
539                                            }
540                                            Err(e) => {
541                                                eprintln!("[P2P NODE] Failed to open auth stream: {}", e);
542                                            }
543                                        }
544                                    }
545                                    Ok(None) => {
546                                        // No auth response (rejected or empty)
547                                        let rej = RejectedResponse { status: "rejected", reason: "unauthorized" };
548                                        match conn.conn.open_uni().await {
549                                            Ok(mut auth_stream) => {
550                                                let rej_json = serde_json::to_string(&rej).unwrap_or_default();
551                                                let _ = auth_stream.write_all(rej_json.as_bytes()).await;
552                                                let _ = auth_stream.finish();
553                                            }
554                                            Err(e) => {
555                                                eprintln!("[P2P NODE] Failed to open reject stream: {}", e);
556                                            }
557                                        }
558                                    }
559                                    Err(e) => {
560                                        eprintln!("[P2P NODE] Connection handler error: {}", e);
561                                    }
562                                }
563                            }
564                            Err(e) => {
565                                eprintln!("[P2P NODE] Failed to accept bi-stream: {}", e);
566                            }
567                        }
568                        // Keep connection alive until closed
569                        let _ = conn.conn.closed().await;
570                    });
571                }
572                Err(e) => {
573                    eprintln!("[P2P NODE] Connection accept failed: {}", e);
574                }
575            }
576        }
577    })
578}
579
580// --- QUIC Handshake Client ---
581pub fn perform_handshake(
582    ip: &str,
583    port: u16,
584    did: &str,
585    private_key_path: &str,
586) -> Result<serde_json::Value, String> {
587    use crate::quic_transport::QuicEndpoint;
588
589    if !Path::new(private_key_path).exists() {
590        return Err(format!("Private key file not found at: {}", private_key_path));
591    }
592
593    let private_key_pem = fs::read_to_string(private_key_path)
594        .map_err(|e| format!("Failed to read private key PEM: {}", e))?;
595
596    let signing_key = SigningKey::from_pkcs8_pem(&private_key_pem)
597        .map_err(|e| format!("Failed to parse private key: {}", e))?;
598
599    let rt = tokio::runtime::Runtime::new()
600        .map_err(|e| format!("Failed to create tokio runtime: {}", e))?;
601
602    rt.block_on(async {
603        let client = QuicEndpoint::new_client()
604            .map_err(|e| format!("Failed to create QUIC client: {}", e))?;
605
606        let server_addr = format!("{}:{}", ip, port);
607        let conn = client.connect(&server_addr, "pkc-discovery-node")
608            .await
609            .map_err(|e| format!("Failed to connect to {}: {}", server_addr, e))?;
610
611
612        // Open a bi-stream for the handshake
613        let (mut send_stream, mut recv_stream) = conn.conn
614            .open_bi()
615            .await
616            .map_err(|e| format!("Failed to open handshake stream: {}", e))?;
617
618        // Read challenge from server
619        let challenge_buf = recv_stream.read_to_end(1024 * 1024)
620            .await
621            .map_err(|e| format!("Failed to read challenge from server: {}", e))?;
622
623        let challenge_str = String::from_utf8_lossy(&challenge_buf);
624        let challenge_msg: serde_json::Value = serde_json::from_str(&challenge_str)
625            .map_err(|e| format!("Failed to parse challenge JSON: {}", e))?;
626
627        if challenge_msg["type"] != "challenge" {
628            return Err("Protocol mismatch: expected challenge message".to_string());
629        }
630
631        let nonce = challenge_msg["nonce"].as_str()
632            .ok_or_else(|| "Missing nonce in challenge message".to_string())?;
633
634        // Sign the challenge nonce
635        let signature = signing_key.sign(nonce.as_bytes());
636        let signature_hex = encode_hex(&signature.to_bytes());
637
638        // Send Response
639        let response = serde_json::json!({
640            "type": "response",
641            "did": did,
642            "signature": signature_hex,
643        });
644
645        let response_bytes = serde_json::to_vec(&response)
646            .map_err(|e| format!("Failed to serialize response: {}", e))?;
647
648        send_stream.write_all(&response_bytes)
649            .await
650            .map_err(|e| format!("Failed to write response: {}", e))?;
651        send_stream.finish()
652            .map_err(|e| format!("Failed to finish send stream: {}", e))?;
653
654        // Read final authorization from a new stream (server opens uni-stream)
655        let mut auth_stream = conn.conn.accept_uni()
656            .await
657            .map_err(|e| format!("Failed to accept auth stream: {}", e))?;
658
659        let auth_buf = auth_stream.read_to_end(1024 * 1024)
660            .await
661            .map_err(|e| format!("Failed to read final response from server: {}", e))?;
662
663        let auth_str = String::from_utf8_lossy(&auth_buf);
664        let final_res: serde_json::Value = serde_json::from_str(&auth_str)
665            .map_err(|e| format!("Failed to parse final response JSON: {}", e))?;
666
667        client.close();
668        Ok(final_res)
669    })
670}
671
672#[cfg(test)]
673mod tests {
674    use super::*;
675
676    #[test]
677    fn test_peer_info_wg_public_key_default_none() {
678        let json = r#"{"name":"test","ip":"127.0.0.1","port":9095,"did":"did:pkc:test","capabilities":[],"protocol":"challenge-response","discoveredAt":"2026-01-01T00:00:00Z"}"#;
679        let peer: PeerInfo = serde_json::from_str(json).unwrap();
680        assert!(peer.wg_public_key.is_none());
681    }
682
683    #[test]
684    fn test_peer_info_wg_public_key_present() {
685        let json = r#"{"name":"test","ip":"127.0.0.1","port":9095,"did":"did:pkc:test","capabilities":[],"protocol":"challenge-response","discoveredAt":"2026-01-01T00:00:00Z","wg_public_key":"abcdef0123456789"}"#;
686        let peer: PeerInfo = serde_json::from_str(json).unwrap();
687        assert_eq!(peer.wg_public_key.as_deref(), Some("abcdef0123456789"));
688    }
689
690    #[test]
691    fn test_peer_info_wg_public_key_not_serialized_when_none() {
692        let peer = PeerInfo {
693            name: "test".to_string(),
694            ip: "127.0.0.1".to_string(),
695            port: 9095,
696            did: "did:pkc:test".to_string(),
697            capabilities: vec![],
698            protocol: "challenge-response".to_string(),
699            discovered_at: "2026-01-01T00:00:00Z".to_string(),
700            wg_public_key: None,
701        };
702        let json = serde_json::to_string(&peer).unwrap();
703        assert!(!json.contains("wg_public_key"));
704    }
705
706    #[test]
707    fn test_peer_info_wg_public_key_serialized_when_some() {
708        let peer = PeerInfo {
709            name: "test".to_string(),
710            ip: "127.0.0.1".to_string(),
711            port: 9095,
712            did: "did:pkc:test".to_string(),
713            capabilities: vec![],
714            protocol: "challenge-response".to_string(),
715            discovered_at: "2026-01-01T00:00:00Z".to_string(),
716            wg_public_key: Some("abcdef".to_string()),
717        };
718        let json = serde_json::to_string(&peer).unwrap();
719        assert!(json.contains("wg_public_key"));
720        assert!(json.contains("abcdef"));
721    }
722
723    #[test]
724    fn test_no_tcp_imports_in_discovery_engine() {
725        let source = include_str!("discovery_engine.rs");
726        // Check for TCP usage in production code only (before test module)
727        let prod_code = source.split("#[cfg(test)]").next().unwrap_or("");
728        assert!(!prod_code.contains("TcpListener"), "TcpListener found in production code");
729        assert!(!prod_code.contains("TcpStream"), "TcpStream found in production code");
730    }
731
732    #[tokio::test]
733    async fn test_tcp_connection_to_quic_port_refused() {
734        use std::net::TcpStream;
735        use std::time::Duration;
736
737        // A QUIC server listens on UDP, not TCP. A TCP connection to the same
738        // port should be refused.
739        let cert = crate::quic_transport::generate_self_signed_cert("tcp-refused-test").unwrap();
740        let server = crate::quic_transport::QuicEndpoint::new_server(0, &cert).unwrap();
741        let port = server.local_addr().unwrap().port();
742
743        // Try TCP connect — should fail
744        let result = TcpStream::connect_timeout(
745            &format!("127.0.0.1:{}", port).parse().unwrap(),
746            Duration::from_millis(500),
747        );
748        assert!(result.is_err(), "TCP connection to QUIC port should be refused");
749    }
750
751    #[tokio::test]
752    async fn test_quic_discovery_handshake_round_trip() {
753        use crate::quic_transport::{QuicEndpoint, generate_self_signed_cert};
754        use ed25519_dalek::{SigningKey, VerifyingKey, Signer, Verifier};
755        use ed25519_dalek::pkcs8::{EncodePublicKey, EncodePrivateKey};
756        use pkcs8::LineEnding;
757
758        // Generate keypair for client
759        let signing_key = SigningKey::generate(&mut rand::rngs::OsRng);
760        let verifying_key = VerifyingKey::from(&signing_key);
761        let _public_key_pem = verifying_key.to_public_key_pem(LineEnding::LF).unwrap();
762        let _private_key_pem = signing_key
763            .to_pkcs8_pem(LineEnding::LF)
764            .unwrap()
765            .to_string();
766
767        let did = "did:pkc:test:quic-discovery";
768
769        // Set up QUIC server
770        let cert = generate_self_signed_cert("discovery-server").unwrap();
771        let server = QuicEndpoint::new_server(0, &cert).unwrap();
772        let server_addr = server.local_addr().unwrap();
773
774        // Server task: accept connection, perform challenge-response
775        let did_clone = did.to_string();
776        let verifying_key_clone = verifying_key;
777        let server_handle = tokio::spawn(async move {
778            let conn = server.accept().await.unwrap();
779
780            // Server opens bi-stream for handshake (server-initiated)
781            let (mut send_stream, _recv_stream) = conn.conn.open_bi().await.unwrap();
782
783            // Send challenge
784            let nonce = encode_hex(&generate_random_bytes(16));
785            let challenge = serde_json::json!({
786                "type": "challenge",
787                "nonce": nonce,
788            });
789            let challenge_bytes = serde_json::to_vec(&challenge).unwrap();
790            send_stream.write_all(&challenge_bytes).await.unwrap();
791            send_stream.finish().unwrap();
792
793            // Accept a new bi-stream for the client's response
794            let (_, mut response_recv) = conn.conn.accept_bi().await.unwrap();
795            let response_buf = response_recv.read_to_end(1024 * 1024).await.unwrap();
796            let response: serde_json::Value = serde_json::from_slice(&response_buf).unwrap();
797            assert_eq!(response["type"], "response");
798            assert_eq!(response["did"], did_clone);
799
800            // Verify signature
801            let sig_hex = response["signature"].as_str().unwrap();
802            let sig_bytes = decode_hex(sig_hex).unwrap();
803            let signature = ed25519_dalek::Signature::from_slice(&sig_bytes).unwrap();
804            assert!(verifying_key_clone.verify(nonce.as_bytes(), &signature).is_ok());
805
806            // Send authorized response via uni-stream
807            let mut auth_stream = conn.conn.open_uni().await.unwrap();
808            let auth = serde_json::json!({"status": "authorized", "did": did_clone});
809            let auth_bytes = serde_json::to_vec(&auth).unwrap();
810            auth_stream.write_all(&auth_bytes).await.unwrap();
811            auth_stream.finish().unwrap();
812
813            let _ = conn.conn.closed().await;
814        });
815
816        // Client connects and performs handshake
817        tokio::time::sleep(std::time::Duration::from_millis(100)).await;
818        let client = QuicEndpoint::new_client().unwrap();
819        let conn = client.connect(&server_addr.to_string(), "discovery-server").await.unwrap();
820
821        // Accept bi-stream (server-initiated) for handshake
822        let (_, mut recv_stream) = conn.conn.accept_bi().await.unwrap();
823
824        // Read challenge
825        let challenge_buf = recv_stream.read_to_end(1024 * 1024).await.unwrap();
826        let challenge: serde_json::Value = serde_json::from_slice(&challenge_buf).unwrap();
827        assert_eq!(challenge["type"], "challenge");
828        let nonce = challenge["nonce"].as_str().unwrap().to_string();
829
830        // Sign nonce
831        let signature = signing_key.sign(nonce.as_bytes());
832        let sig_hex = encode_hex(&signature.to_bytes());
833
834        // Open a new bi-stream to send the response
835        let (mut send_stream, _) = conn.conn.open_bi().await.unwrap();
836
837        // Send response
838        let response = serde_json::json!({
839            "type": "response",
840            "did": did,
841            "signature": sig_hex,
842        });
843        let response_bytes = serde_json::to_vec(&response).unwrap();
844        send_stream.write_all(&response_bytes).await.unwrap();
845        send_stream.finish().unwrap();
846
847        // Read authorization from uni-stream
848        let mut auth_stream = conn.conn.accept_uni().await.unwrap();
849        let auth_buf = auth_stream.read_to_end(1024 * 1024).await.unwrap();
850        let auth: serde_json::Value = serde_json::from_slice(&auth_buf).unwrap();
851        assert_eq!(auth["status"], "authorized");
852        assert_eq!(auth["did"], did);
853
854        server_handle.await.unwrap();
855        client.close();
856    }
857}