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#[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 #[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 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 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 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 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 tokio::select! {
197 _ = token.cancelled() => {
198 let _ = mdns.shutdown();
199 Ok(())
200 }
201 }
202 }
203
204 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
270pub 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#[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#[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 let nonce = encode_hex(&generate_random_bytes(16));
397
398 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 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 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 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 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 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 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 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 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 let _ = conn.conn.closed().await;
570 });
571 }
572 Err(e) => {
573 eprintln!("[P2P NODE] Connection accept failed: {}", e);
574 }
575 }
576 }
577 })
578}
579
580pub 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 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 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 let signature = signing_key.sign(nonce.as_bytes());
636 let signature_hex = encode_hex(&signature.to_bytes());
637
638 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 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 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 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 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 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 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 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 let (mut send_stream, _recv_stream) = conn.conn.open_bi().await.unwrap();
782
783 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 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 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 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 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 let (_, mut recv_stream) = conn.conn.accept_bi().await.unwrap();
823
824 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 let signature = signing_key.sign(nonce.as_bytes());
832 let sig_hex = encode_hex(&signature.to_bytes());
833
834 let (mut send_stream, _) = conn.conn.open_bi().await.unwrap();
836
837 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 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}