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