use std::collections::HashMap;
use std::net::UdpSocket;
use std::path::Path;
use std::fs;
use std::time::{Duration, Instant};
use mdns_sd::{ServiceDaemon, ServiceEvent, ServiceInfo};
use serde::{Serialize, Deserialize};
use ed25519_dalek::{VerifyingKey, SigningKey, Verifier, Signature, Signer};
use ed25519_dalek::pkcs8::{DecodePrivateKey, DecodePublicKey};
#[derive(Serialize, Deserialize, Clone, Debug)]
pub struct PeerInfo {
pub name: String,
pub ip: String,
pub port: u16,
pub did: String,
pub capabilities: Vec<String>,
pub protocol: String,
#[serde(rename = "discoveredAt")]
pub discovered_at: String,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub wg_public_key: Option<String>,
}
pub struct DiscoveryEngine {
pub service_type: String,
}
impl Default for DiscoveryEngine {
fn default() -> Self {
Self::new()
}
}
impl DiscoveryEngine {
pub fn new() -> Self {
Self {
service_type: "_pkc._tcp.local.".to_string(),
}
}
pub fn get_local_ip() -> String {
if let Ok(socket) = UdpSocket::bind("0.0.0.0:0")
&& socket.connect("8.8.8.8:80").is_ok()
&& let Ok(addr) = socket.local_addr() {
return addr.ip().to_string();
}
"127.0.0.1".to_string()
}
pub fn announce(&self, service_name: &str, did: &str, port: u16) -> Result<(), String> {
self.announce_with_wireguard(service_name, did, port, None)
}
pub fn announce_with_wireguard(
&self,
service_name: &str,
did: &str,
port: u16,
wg_public_key: Option<&str>,
) -> Result<(), String> {
let mdns = ServiceDaemon::new().map_err(|e| format!("Failed to create mDNS daemon: {}", e))?;
let local_ip = Self::get_local_ip();
let host_name = format!("{}.local.", service_name);
let mut properties = HashMap::new();
properties.insert("did".to_string(), did.to_string());
properties.insert("version".to_string(), "1.0".to_string());
properties.insert("capabilities".to_string(), "s3_access,ipfs_access,webrtc_relay".to_string());
properties.insert("protocol".to_string(), "challenge-response".to_string());
if let Some(wg_key) = wg_public_key {
properties.insert("wg_public_key".to_string(), wg_key.to_string());
}
let service_info = ServiceInfo::new(
&self.service_type,
service_name,
&host_name,
&local_ip,
port,
properties,
)
.map_err(|e| format!("Failed to create ServiceInfo: {}", e))?
.enable_addr_auto();
mdns.register(service_info).map_err(|e| format!("Failed to register service: {}", e))?;
println!("[mDNS PKC] ✅ Announced service: {} on port {}", service_name, port);
println!("[mDNS PKC] IPs: {}", local_ip);
println!("[mDNS PKC] DID: {}", did);
loop {
std::thread::sleep(Duration::from_secs(10));
}
}
pub fn discover(&self, timeout: Duration) -> Result<Vec<PeerInfo>, String> {
let mdns = ServiceDaemon::new().map_err(|e| format!("Failed to create mDNS daemon: {}", e))?;
let receiver = mdns.browse(&self.service_type).map_err(|e| format!("Failed to browse: {}", e))?;
println!("[mDNS PKC] 🔍 Discovering PKC peers on network...");
let start_time = Instant::now();
let mut discovered_peers: HashMap<String, PeerInfo> = HashMap::new();
while start_time.elapsed() < timeout {
let remaining = timeout.saturating_sub(start_time.elapsed());
if remaining.is_zero() {
break;
}
if let Ok(event) = receiver.recv_timeout(remaining)
&& let ServiceEvent::ServiceResolved(info) = event {
let name = info.get_fullname().to_string();
let port = info.get_port();
let props = info.get_properties();
let did = props.get_property_val_str("did").unwrap_or("unknown").to_string();
let capabilities = props.get_property_val_str("capabilities")
.map(|s| s.split(',').map(|x| x.to_string()).collect())
.unwrap_or_else(Vec::new);
let protocol = props.get_property_val_str("protocol").unwrap_or("unknown").to_string();
let wg_public_key = props.get_property_val_str("wg_public_key").map(|s| s.to_string());
for ip_addr in info.get_addresses() {
let ip = ip_addr.to_string();
let peer_id = format!("{}:{}", ip, port);
discovered_peers.insert(peer_id, PeerInfo {
name: name.clone(),
ip,
port,
did: did.clone(),
capabilities: capabilities.clone(),
protocol: protocol.clone(),
discovered_at: chrono::Utc::now().to_rfc3339_opts(chrono::SecondsFormat::Millis, true),
wg_public_key: wg_public_key.clone(),
});
}
}
}
let peers: Vec<PeerInfo> = discovered_peers.into_values().collect();
Ok(peers)
}
pub async fn announce_with_cancellation(
&self,
service_name: &str,
did: &str,
port: u16,
wg_public_key: Option<&str>,
token: tokio_util::sync::CancellationToken,
) -> Result<(), String> {
let mdns = ServiceDaemon::new().map_err(|e| format!("Failed to create mDNS daemon: {}", e))?;
let local_ip = Self::get_local_ip();
let host_name = format!("{}.local.", service_name);
let mut properties = HashMap::new();
properties.insert("did".to_string(), did.to_string());
properties.insert("version".to_string(), "1.0".to_string());
properties.insert("capabilities".to_string(), "s3_access,ipfs_access,webrtc_relay".to_string());
properties.insert("protocol".to_string(), "challenge-response".to_string());
if let Some(wg_key) = wg_public_key {
properties.insert("wg_public_key".to_string(), wg_key.to_string());
}
let service_info = ServiceInfo::new(
&self.service_type,
service_name,
&host_name,
&local_ip,
port,
properties,
)
.map_err(|e| format!("Failed to create ServiceInfo: {}", e))?
.enable_addr_auto();
mdns.register(service_info).map_err(|e| format!("Failed to register service: {}", e))?;
tokio::select! {
_ = token.cancelled() => {
let _ = mdns.shutdown();
Ok(())
}
}
}
pub async fn discover_with_cancellation(
&self,
timeout: Duration,
token: tokio_util::sync::CancellationToken,
) -> Result<Vec<PeerInfo>, String> {
let mdns = ServiceDaemon::new().map_err(|e| format!("Failed to create mDNS daemon: {}", e))?;
let receiver = mdns.browse(&self.service_type).map_err(|e| format!("Failed to browse: {}", e))?;
let start_time = Instant::now();
let mut discovered_peers: HashMap<String, PeerInfo> = HashMap::new();
while start_time.elapsed() < timeout && !token.is_cancelled() {
let remaining = timeout.saturating_sub(start_time.elapsed());
if remaining.is_zero() {
break;
}
let step = remaining.min(Duration::from_millis(50));
tokio::select! {
_ = token.cancelled() => break,
res = tokio::task::spawn_blocking({
let receiver = receiver.clone();
move || receiver.recv_timeout(step)
}) => {
if let Ok(Ok(event)) = res
&& let ServiceEvent::ServiceResolved(info) = event {
let name = info.get_fullname().to_string();
let port = info.get_port();
let props = info.get_properties();
let did = props.get_property_val_str("did").unwrap_or("unknown").to_string();
let capabilities = props.get_property_val_str("capabilities")
.map(|s| s.split(',').map(|x| x.to_string()).collect())
.unwrap_or_else(Vec::new);
let protocol = props.get_property_val_str("protocol").unwrap_or("unknown").to_string();
let wg_public_key = props.get_property_val_str("wg_public_key").map(|s| s.to_string());
for ip_addr in info.get_addresses() {
let ip = ip_addr.to_string();
let peer_id = format!("{}:{}", ip, port);
discovered_peers.insert(peer_id, PeerInfo {
name: name.clone(),
ip,
port,
did: did.clone(),
capabilities: capabilities.clone(),
protocol: protocol.clone(),
discovered_at: chrono::Utc::now().to_rfc3339_opts(chrono::SecondsFormat::Millis, true),
wg_public_key: wg_public_key.clone(),
});
}
}
}
}
}
let _ = mdns.shutdown();
let peers: Vec<PeerInfo> = discovered_peers.into_values().collect();
Ok(peers)
}
}
pub fn decode_hex(s: &str) -> Result<Vec<u8>, String> {
if !s.len().is_multiple_of(2) {
return Err("Hex string must have an even length".to_string());
}
(0..s.len())
.step_by(2)
.map(|i| {
u8::from_str_radix(&s[i..i + 2], 16)
.map_err(|e| format!("Invalid hex digit: {}", e))
})
.collect()
}
pub fn encode_hex(bytes: &[u8]) -> String {
bytes.iter().map(|b| format!("{:02x}", b)).collect()
}
#[derive(Deserialize, Debug)]
pub struct AgentCard {
pub public_key: String,
#[serde(default)]
pub capabilities: Vec<String>,
}
pub fn get_agent_card_from_db_pub(db_path: &str, did: &str) -> Result<Option<AgentCard>, String> {
get_agent_card_from_db(db_path, did)
}
fn get_agent_card_from_db(db_path: &str, did: &str) -> Result<Option<AgentCard>, String> {
if !Path::new(db_path).exists() {
return Err(format!("Database file not found at: {}", db_path));
}
let conn = rusqlite::Connection::open(db_path)
.map_err(|e| format!("Failed to open agent identity DB: {}", e))?;
let mut stmt = conn.prepare("SELECT content FROM card WHERE hash = ?")
.map_err(|e| format!("Prepare query failed: {}", e))?;
let content_opt: Option<String> = stmt.query_row(rusqlite::params![did], |row| row.get(0))
.ok();
if let Some(content) = content_opt {
let card: AgentCard = serde_yaml::from_str(&content)
.map_err(|e| format!("Failed to parse YAML agent card: {}", e))?;
Ok(Some(card))
} else {
Ok(None)
}
}
#[derive(Serialize)]
struct ChallengeMessage<'a> {
#[serde(rename = "type")]
msg_type: &'static str,
nonce: &'a str,
}
#[derive(Deserialize)]
struct ResponseMessage {
#[serde(rename = "type")]
msg_type: String,
did: String,
signature: String,
}
#[derive(Serialize)]
struct RejectedResponse<'a> {
status: &'static str,
reason: &'a str,
}
#[derive(Serialize)]
struct CapabilityDetail {
endpoint: String,
bucket: String,
access: String,
}
#[derive(Serialize)]
struct IpfsDetail {
gateway: String,
folder_cid: String,
}
#[derive(Serialize)]
struct WebrtcDetail {
relay: String,
}
#[derive(Serialize)]
struct CapabilitiesInfo {
s3: CapabilityDetail,
ipfs: IpfsDetail,
webrtc: WebrtcDetail,
}
pub fn generate_random_bytes_pub(len: usize) -> Vec<u8> {
generate_random_bytes(len)
}
fn generate_random_bytes(len: usize) -> Vec<u8> {
use std::time::SystemTime;
let seed = format!("{:?}", SystemTime::now());
let ptr_bytes = (&seed as *const _ as usize).to_ne_bytes();
let mut combined = seed.as_bytes().to_vec();
combined.extend_from_slice(&ptr_bytes);
let result = crate::hash::raw_hash_bytes_32(&combined);
result[..len.min(32)].to_vec()
}
#[derive(Serialize)]
struct AuthorizedResponse {
status: &'static str,
capabilities: CapabilitiesInfo,
}
async fn handle_node_connection(
mut send_stream: quinn::SendStream,
mut recv_stream: quinn::RecvStream,
db_path: &str,
) -> Result<Option<String>, String> {
let nonce = encode_hex(&generate_random_bytes(16));
let challenge = ChallengeMessage {
msg_type: "challenge",
nonce: &nonce,
};
let challenge_json = serde_json::to_string(&challenge)
.map_err(|e| format!("Failed to serialize challenge: {}", e))?;
send_stream.write_all(challenge_json.as_bytes())
.await
.map_err(|e| format!("Failed to write challenge: {}", e))?;
send_stream.finish()
.map_err(|e| format!("Failed to finish challenge stream: {}", e))?;
let response_buf = recv_stream.read_to_end(1024 * 1024)
.await
.map_err(|e| format!("Failed to read response: {}", e))?;
if response_buf.is_empty() {
return Ok(None);
}
let response_str = String::from_utf8_lossy(&response_buf);
let response: ResponseMessage = match serde_json::from_str(&response_str) {
Ok(msg) => msg,
Err(_) => {
return Ok(None);
}
};
if response.msg_type != "response" {
return Ok(None);
}
println!("[P2P NODE] Verifying EOA credentials for {}...", response.did);
let agent_card = match get_agent_card_from_db(db_path, &response.did)? {
Some(card) => card,
None => {
println!("[P2P NODE] Unauthorized: DID {} not registered in identity registry.", response.did);
return Ok(None);
}
};
let public_key = match VerifyingKey::from_public_key_pem(&agent_card.public_key) {
Ok(key) => key,
Err(e) => {
println!("[P2P NODE] Unauthorized: Public key parse failed for {}: {}", response.did, e);
return Ok(None);
}
};
let signature_bytes = match decode_hex(&response.signature) {
Ok(bytes) => bytes,
Err(_) => {
return Ok(None);
}
};
let signature = match Signature::from_slice(&signature_bytes) {
Ok(sig) => sig,
Err(_) => {
return Ok(None);
}
};
if public_key.verify(nonce.as_bytes(), &signature).is_err() {
println!("[P2P NODE] Cryptographic validation failed for {}.", response.did);
return Ok(None);
}
let has_s3 = agent_card.capabilities.iter().any(|c| c == "s3_access");
let has_ipfs = agent_card.capabilities.iter().any(|c| c == "ipfs_access");
if has_s3 || has_ipfs {
println!("[P2P NODE] Authentication succeeded for {}. Capability access granted.", response.did);
let cap_res = AuthorizedResponse {
status: "authorized",
capabilities: CapabilitiesInfo {
s3: CapabilityDetail {
endpoint: "http://127.0.0.1:9000".to_string(),
bucket: "sprint42-bucket".to_string(),
access: "read-write".to_string(),
},
ipfs: IpfsDetail {
gateway: "http://127.0.0.1:5001".to_string(),
folder_cid: "QmULx3x6FCZiYksGkuK1FQ1t59uAwRtYpuqHAvGqc7s9Ba".to_string(),
},
webrtc: WebrtcDetail {
relay: "http://127.0.0.1:9090".to_string(),
},
},
};
let cap_json = serde_json::to_string(&cap_res)
.map_err(|e| format!("Failed to serialize auth response: {}", e))?;
return Ok(Some(cap_json));
} else {
println!("[P2P NODE] DID {} authenticated but lacks authorized storage capabilities.", response.did);
}
Ok(None)
}
pub fn run_discovery_node(port: u16, db_path: &str) -> Result<(), String> {
use crate::quic_transport::{QuicEndpoint, generate_self_signed_cert};
let cert = generate_self_signed_cert("pkc-discovery-node")
.map_err(|e| format!("Failed to generate TLS cert: {}", e))?;
let endpoint = QuicEndpoint::new_server(port, &cert)
.map_err(|e| format!("Failed to bind QUIC endpoint to port {}: {}", port, e))?;
println!("[P2P NODE] Starting discovery node on port {} (QUIC)...", port);
println!("[P2P NODE] Using identity database: {}", db_path);
println!("[P2P NODE] Node is listening on port {} (QUIC/UDP)", port);
let rt = tokio::runtime::Runtime::new()
.map_err(|e| format!("Failed to create tokio runtime: {}", e))?;
rt.block_on(async {
loop {
match endpoint.accept().await {
Ok(conn) => {
let db = db_path.to_string();
tokio::spawn(async move {
match conn.conn.accept_bi().await {
Ok((send_stream, recv_stream)) => {
match handle_node_connection(send_stream, recv_stream, &db).await {
Ok(Some(auth_json)) => {
match conn.conn.open_uni().await {
Ok(mut auth_stream) => {
let _ = auth_stream.write_all(auth_json.as_bytes()).await;
let _ = auth_stream.finish();
}
Err(e) => {
eprintln!("[P2P NODE] Failed to open auth stream: {}", e);
}
}
}
Ok(None) => {
let rej = RejectedResponse { status: "rejected", reason: "unauthorized" };
match conn.conn.open_uni().await {
Ok(mut auth_stream) => {
let rej_json = serde_json::to_string(&rej).unwrap_or_default();
let _ = auth_stream.write_all(rej_json.as_bytes()).await;
let _ = auth_stream.finish();
}
Err(e) => {
eprintln!("[P2P NODE] Failed to open reject stream: {}", e);
}
}
}
Err(e) => {
eprintln!("[P2P NODE] Connection handler error: {}", e);
}
}
}
Err(e) => {
eprintln!("[P2P NODE] Failed to accept bi-stream: {}", e);
}
}
let _ = conn.conn.closed().await;
});
}
Err(e) => {
eprintln!("[P2P NODE] Connection accept failed: {}", e);
}
}
}
})
}
pub fn perform_handshake(
ip: &str,
port: u16,
did: &str,
private_key_path: &str,
) -> Result<serde_json::Value, String> {
use crate::quic_transport::QuicEndpoint;
if !Path::new(private_key_path).exists() {
return Err(format!("Private key file not found at: {}", private_key_path));
}
let private_key_pem = fs::read_to_string(private_key_path)
.map_err(|e| format!("Failed to read private key PEM: {}", e))?;
let signing_key = SigningKey::from_pkcs8_pem(&private_key_pem)
.map_err(|e| format!("Failed to parse private key: {}", e))?;
let rt = tokio::runtime::Runtime::new()
.map_err(|e| format!("Failed to create tokio runtime: {}", e))?;
rt.block_on(async {
let client = QuicEndpoint::new_client()
.map_err(|e| format!("Failed to create QUIC client: {}", e))?;
let server_addr = format!("{}:{}", ip, port);
let conn = client.connect(&server_addr, "pkc-discovery-node")
.await
.map_err(|e| format!("Failed to connect to {}: {}", server_addr, e))?;
let (mut send_stream, mut recv_stream) = conn.conn
.open_bi()
.await
.map_err(|e| format!("Failed to open handshake stream: {}", e))?;
let challenge_buf = recv_stream.read_to_end(1024 * 1024)
.await
.map_err(|e| format!("Failed to read challenge from server: {}", e))?;
let challenge_str = String::from_utf8_lossy(&challenge_buf);
let challenge_msg: serde_json::Value = serde_json::from_str(&challenge_str)
.map_err(|e| format!("Failed to parse challenge JSON: {}", e))?;
if challenge_msg["type"] != "challenge" {
return Err("Protocol mismatch: expected challenge message".to_string());
}
let nonce = challenge_msg["nonce"].as_str()
.ok_or_else(|| "Missing nonce in challenge message".to_string())?;
let signature = signing_key.sign(nonce.as_bytes());
let signature_hex = encode_hex(&signature.to_bytes());
let response = serde_json::json!({
"type": "response",
"did": did,
"signature": signature_hex,
});
let response_bytes = serde_json::to_vec(&response)
.map_err(|e| format!("Failed to serialize response: {}", e))?;
send_stream.write_all(&response_bytes)
.await
.map_err(|e| format!("Failed to write response: {}", e))?;
send_stream.finish()
.map_err(|e| format!("Failed to finish send stream: {}", e))?;
let mut auth_stream = conn.conn.accept_uni()
.await
.map_err(|e| format!("Failed to accept auth stream: {}", e))?;
let auth_buf = auth_stream.read_to_end(1024 * 1024)
.await
.map_err(|e| format!("Failed to read final response from server: {}", e))?;
let auth_str = String::from_utf8_lossy(&auth_buf);
let final_res: serde_json::Value = serde_json::from_str(&auth_str)
.map_err(|e| format!("Failed to parse final response JSON: {}", e))?;
client.close();
Ok(final_res)
})
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test_peer_info_wg_public_key_default_none() {
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"}"#;
let peer: PeerInfo = serde_json::from_str(json).unwrap();
assert!(peer.wg_public_key.is_none());
}
#[test]
fn test_peer_info_wg_public_key_present() {
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"}"#;
let peer: PeerInfo = serde_json::from_str(json).unwrap();
assert_eq!(peer.wg_public_key.as_deref(), Some("abcdef0123456789"));
}
#[test]
fn test_peer_info_wg_public_key_not_serialized_when_none() {
let peer = PeerInfo {
name: "test".to_string(),
ip: "127.0.0.1".to_string(),
port: 9095,
did: "did:pkc:test".to_string(),
capabilities: vec![],
protocol: "challenge-response".to_string(),
discovered_at: "2026-01-01T00:00:00Z".to_string(),
wg_public_key: None,
};
let json = serde_json::to_string(&peer).unwrap();
assert!(!json.contains("wg_public_key"));
}
#[test]
fn test_peer_info_wg_public_key_serialized_when_some() {
let peer = PeerInfo {
name: "test".to_string(),
ip: "127.0.0.1".to_string(),
port: 9095,
did: "did:pkc:test".to_string(),
capabilities: vec![],
protocol: "challenge-response".to_string(),
discovered_at: "2026-01-01T00:00:00Z".to_string(),
wg_public_key: Some("abcdef".to_string()),
};
let json = serde_json::to_string(&peer).unwrap();
assert!(json.contains("wg_public_key"));
assert!(json.contains("abcdef"));
}
#[test]
fn test_no_tcp_imports_in_discovery_engine() {
let source = include_str!("discovery_engine.rs");
let prod_code = source.split("#[cfg(test)]").next().unwrap_or("");
assert!(!prod_code.contains("TcpListener"), "TcpListener found in production code");
assert!(!prod_code.contains("TcpStream"), "TcpStream found in production code");
}
#[tokio::test]
async fn test_tcp_connection_to_quic_port_refused() {
use std::net::TcpStream;
use std::time::Duration;
let cert = crate::quic_transport::generate_self_signed_cert("tcp-refused-test").unwrap();
let server = crate::quic_transport::QuicEndpoint::new_server(0, &cert).unwrap();
let port = server.local_addr().unwrap().port();
let result = TcpStream::connect_timeout(
&format!("127.0.0.1:{}", port).parse().unwrap(),
Duration::from_millis(500),
);
assert!(result.is_err(), "TCP connection to QUIC port should be refused");
}
#[tokio::test]
async fn test_quic_discovery_handshake_round_trip() {
use crate::quic_transport::{QuicEndpoint, generate_self_signed_cert};
use ed25519_dalek::{SigningKey, VerifyingKey, Signer, Verifier};
use ed25519_dalek::pkcs8::{EncodePublicKey, EncodePrivateKey};
use pkcs8::LineEnding;
let signing_key = SigningKey::generate(&mut rand::rngs::OsRng);
let verifying_key = VerifyingKey::from(&signing_key);
let _public_key_pem = verifying_key.to_public_key_pem(LineEnding::LF).unwrap();
let _private_key_pem = signing_key
.to_pkcs8_pem(LineEnding::LF)
.unwrap()
.to_string();
let did = "did:pkc:test:quic-discovery";
let cert = generate_self_signed_cert("discovery-server").unwrap();
let server = QuicEndpoint::new_server(0, &cert).unwrap();
let server_addr = server.local_addr().unwrap();
let did_clone = did.to_string();
let verifying_key_clone = verifying_key;
let server_handle = tokio::spawn(async move {
let conn = server.accept().await.unwrap();
let (mut send_stream, _recv_stream) = conn.conn.open_bi().await.unwrap();
let nonce = encode_hex(&generate_random_bytes(16));
let challenge = serde_json::json!({
"type": "challenge",
"nonce": nonce,
});
let challenge_bytes = serde_json::to_vec(&challenge).unwrap();
send_stream.write_all(&challenge_bytes).await.unwrap();
send_stream.finish().unwrap();
let (_, mut response_recv) = conn.conn.accept_bi().await.unwrap();
let response_buf = response_recv.read_to_end(1024 * 1024).await.unwrap();
let response: serde_json::Value = serde_json::from_slice(&response_buf).unwrap();
assert_eq!(response["type"], "response");
assert_eq!(response["did"], did_clone);
let sig_hex = response["signature"].as_str().unwrap();
let sig_bytes = decode_hex(sig_hex).unwrap();
let signature = ed25519_dalek::Signature::from_slice(&sig_bytes).unwrap();
assert!(verifying_key_clone.verify(nonce.as_bytes(), &signature).is_ok());
let mut auth_stream = conn.conn.open_uni().await.unwrap();
let auth = serde_json::json!({"status": "authorized", "did": did_clone});
let auth_bytes = serde_json::to_vec(&auth).unwrap();
auth_stream.write_all(&auth_bytes).await.unwrap();
auth_stream.finish().unwrap();
let _ = conn.conn.closed().await;
});
tokio::time::sleep(std::time::Duration::from_millis(100)).await;
let client = QuicEndpoint::new_client().unwrap();
let conn = client.connect(&server_addr.to_string(), "discovery-server").await.unwrap();
let (_, mut recv_stream) = conn.conn.accept_bi().await.unwrap();
let challenge_buf = recv_stream.read_to_end(1024 * 1024).await.unwrap();
let challenge: serde_json::Value = serde_json::from_slice(&challenge_buf).unwrap();
assert_eq!(challenge["type"], "challenge");
let nonce = challenge["nonce"].as_str().unwrap().to_string();
let signature = signing_key.sign(nonce.as_bytes());
let sig_hex = encode_hex(&signature.to_bytes());
let (mut send_stream, _) = conn.conn.open_bi().await.unwrap();
let response = serde_json::json!({
"type": "response",
"did": did,
"signature": sig_hex,
});
let response_bytes = serde_json::to_vec(&response).unwrap();
send_stream.write_all(&response_bytes).await.unwrap();
send_stream.finish().unwrap();
let mut auth_stream = conn.conn.accept_uni().await.unwrap();
let auth_buf = auth_stream.read_to_end(1024 * 1024).await.unwrap();
let auth: serde_json::Value = serde_json::from_slice(&auth_buf).unwrap();
assert_eq!(auth["status"], "authorized");
assert_eq!(auth["did"], did);
server_handle.await.unwrap();
client.close();
}
}