1use crate::crdt::CrdtLog;
9use crate::sheaf::Marking;
10use serde::{Deserialize, Serialize};
11use std::cell::RefCell;
12use std::collections::HashMap;
13
14#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
15pub struct Peer {
16 pub did: String,
17 pub verifying_key: String,
18 pub endpoint: String,
19}
20
21#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
22pub enum FederationMessage {
23 Hello { did: String, verifying_key: String },
24 Ping,
25 Pong,
26 CrdtSync { log: CrdtLog },
27 PCardDispatch {
28 pcard_hash: String,
29 sender_did: String,
30 co_signatures: Vec<String>,
31 },
32}
33
34#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
40pub struct CrossPkcDispatchRequest {
41 pub pcard_hash: String,
42 pub input_marking: Marking,
43 pub source_pkc_did: String,
44 pub target_pkc_did: String,
45}
46
47#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
50pub struct CrossPkcDispatchResponse {
51 pub vcard_hash: String,
52 pub vcard_yaml: String,
53 pub target_signature: String,
54 pub exit_code: i64,
55 pub exec_output: String,
56}
57
58#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
60pub struct CoSignedVCard {
61 pub vcard_hash: String,
62 pub vcard_yaml: String,
63 pub signatures: Vec<String>,
64}
65
66#[derive(Debug, Clone, Default)]
67pub struct FederationRouter {
68 pub peers: HashMap<String, Peer>,
69 pub inbox: Vec<(String, FederationMessage)>,
70}
71
72impl FederationRouter {
73 pub fn new() -> Self {
74 Self::default()
75 }
76
77 pub fn register_peer(&mut self, peer: Peer) {
78 self.peers.insert(peer.did.clone(), peer);
79 }
80
81 pub fn route(&mut self, sender_did: &str, message: FederationMessage) -> Result<(), String> {
82 if !self.peers.contains_key(sender_did) && !matches!(message, FederationMessage::Hello { .. }) {
83 return Err(format!("unknown sender: {}", sender_did));
84 }
85 self.inbox.push((sender_did.to_string(), message));
86 Ok(())
87 }
88
89 pub fn dispatch_pcard(
90 &mut self,
91 pcard_hash: &str,
92 sender_did: &str,
93 ) -> Result<FederationMessage, String> {
94 if !self.peers.contains_key(sender_did) {
95 return Err(format!("unknown sender: {}", sender_did));
96 }
97 let co_signatures = vec![format!("co-sig:{}", sender_did)];
98 let msg = FederationMessage::PCardDispatch {
99 pcard_hash: pcard_hash.to_string(),
100 sender_did: sender_did.to_string(),
101 co_signatures,
102 };
103 self.inbox.push((sender_did.to_string(), msg.clone()));
104 Ok(msg)
105 }
106
107 #[cfg(feature = "native")]
109 pub async fn send_message(
110 &self,
111 peer_did: &str,
112 msg: &FederationMessage,
113 conn: &crate::quic_transport::QuicConnection,
114 ) -> Result<(), String> {
115 if !self.peers.contains_key(peer_did) {
116 return Err(format!("unknown peer: {}", peer_did));
117 }
118 let json = serde_json::to_vec(msg)
119 .map_err(|e| format!("Failed to serialize federation message: {}", e))?;
120 conn.send_one_way(&json).await?;
121 Ok(())
122 }
123
124 #[cfg(feature = "native")]
126 pub async fn recv_message(
127 &mut self,
128 conn: &crate::quic_transport::QuicConnection,
129 ) -> Result<FederationMessage, String> {
130 let (data, _, _) = conn.recv_bi().await?;
131 let msg: FederationMessage = serde_json::from_slice(&data)
132 .map_err(|e| format!("Failed to deserialize federation message: {}", e))?;
133 Ok(msg)
134 }
135}
136
137#[cfg(feature = "native")]
146pub async fn dispatch_cross_pkc(
147 request: &CrossPkcDispatchRequest,
148 conn: &crate::quic_transport::QuicConnection,
149) -> Result<CrossPkcDispatchResponse, String> {
150 let json = serde_json::to_vec(request)
151 .map_err(|e| format!("Failed to serialize dispatch request: {}", e))?;
152 let response_bytes = conn.send(&json).await?;
153 let response: CrossPkcDispatchResponse = serde_json::from_slice(&response_bytes)
154 .map_err(|e| format!("Failed to deserialize dispatch response: {}", e))?;
155 Ok(response)
156}
157
158#[cfg(feature = "native")]
163pub async fn receive_cross_pkc_dispatch(
164 conn: &crate::quic_transport::QuicConnection,
165) -> Result<(CrossPkcDispatchRequest, quinn::SendStream), String> {
166 let (data, send_stream, _recv_stream) = conn.recv_bi().await?;
167 let request: CrossPkcDispatchRequest = serde_json::from_slice(&data)
168 .map_err(|e| format!("Failed to deserialize dispatch request: {}", e))?;
169 Ok((request, send_stream))
170}
171
172pub fn co_sign_vcard(
177 response: &CrossPkcDispatchResponse,
178 source_pkc_did: &str,
179 target_pkc_did: &str,
180) -> CoSignedVCard {
181 let signatures = vec![
182 format!("sig:{}", target_pkc_did),
183 format!("sig:{}", source_pkc_did),
184 ];
185 CoSignedVCard {
186 vcard_hash: response.vcard_hash.clone(),
187 vcard_yaml: response.vcard_yaml.clone(),
188 signatures,
189 }
190}
191
192thread_local! {
193 static ROUTER: RefCell<FederationRouter> = RefCell::new(FederationRouter::new());
194}
195
196pub fn init_federation() {
197 ROUTER.with(|r| *r.borrow_mut() = FederationRouter::new());
198}
199
200pub fn register_peer(peer: Peer) {
201 ROUTER.with(|r| r.borrow_mut().register_peer(peer));
202}
203
204pub fn dispatch_pcard(pcard_hash: &str, sender_did: &str) -> Result<FederationMessage, String> {
205 ROUTER.with(|r| r.borrow_mut().dispatch_pcard(pcard_hash, sender_did))
206}
207
208pub fn take_inbox() -> Vec<(String, FederationMessage)> {
209 ROUTER.with(|r| std::mem::take(&mut r.borrow_mut().inbox))
210}
211
212#[cfg(test)]
213mod tests {
214 use super::*;
215
216 #[cfg_attr(not(target_arch = "wasm32"), test)]
217 #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test::wasm_bindgen_test)]
218 fn test_peer_registration() {
219 init_federation();
220 let peer = Peer {
221 did: "did:key:alice".to_string(),
222 verifying_key: "vk-alice".to_string(),
223 endpoint: "localhost:9000".to_string(),
224 };
225 register_peer(peer.clone());
226 ROUTER.with(|r| {
227 assert_eq!(r.borrow().peers.get("did:key:alice"), Some(&peer));
228 });
229 }
230
231 #[cfg_attr(not(target_arch = "wasm32"), test)]
232 #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test::wasm_bindgen_test)]
233 fn test_dispatch_pcard_creates_co_signed_message() {
234 init_federation();
235 let peer = Peer {
236 did: "did:key:bob".to_string(),
237 verifying_key: "vk-bob".to_string(),
238 endpoint: "localhost:9001".to_string(),
239 };
240 register_peer(peer);
241 let msg = dispatch_pcard("sha256:pcard1", "did:key:bob").unwrap();
242 match msg {
243 FederationMessage::PCardDispatch { pcard_hash, sender_did, co_signatures } => {
244 assert_eq!(pcard_hash, "sha256:pcard1");
245 assert_eq!(sender_did, "did:key:bob");
246 assert_eq!(co_signatures, vec!["co-sig:did:key:bob"]);
247 }
248 _ => panic!("expected PCardDispatch"),
249 }
250 }
251
252 #[cfg_attr(not(target_arch = "wasm32"), test)]
253 #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test::wasm_bindgen_test)]
254 fn test_unknown_sender_rejected() {
255 init_federation();
256 assert!(dispatch_pcard("sha256:pcard1", "did:key:unknown").is_err());
257 }
258
259 #[cfg(feature = "native")]
260 #[tokio::test]
261 async fn test_federation_message_quic_round_trip() {
262 use crate::quic_transport::{QuicEndpoint, generate_self_signed_cert};
263
264 let cert = generate_self_signed_cert("federation-test").unwrap();
265 let server = QuicEndpoint::new_server(0, &cert).unwrap();
266 let server_addr = server.local_addr().unwrap();
267
268 let server_handle = tokio::spawn(async move {
269 let conn = server.accept().await.unwrap();
270 let (data, send_stream, _) = conn.recv_bi().await.unwrap();
271
272 conn.respond(send_stream, &data).await.unwrap();
274 let _ = conn.conn.closed().await;
275 });
276
277 tokio::time::sleep(std::time::Duration::from_millis(100)).await;
278 let client = QuicEndpoint::new_client().unwrap();
279 let conn = client.connect(&server_addr.to_string(), "federation-test").await.unwrap();
280
281 let mut router = FederationRouter::new();
282 router.register_peer(Peer {
283 did: "did:key:alice".to_string(),
284 verifying_key: "vk-alice".to_string(),
285 endpoint: server_addr.to_string(),
286 });
287
288 let msg = FederationMessage::Ping;
290 let json = serde_json::to_vec(&msg).unwrap();
291 let _response = conn.send(&json).await.unwrap();
292
293 server_handle.await.unwrap();
294 client.close();
295 }
296
297 #[cfg(feature = "native")]
298 #[tokio::test]
299 async fn test_cross_pkc_dispatch_round_trip() {
300 use crate::quic_transport::{QuicEndpoint, generate_self_signed_cert};
301 use std::time::Instant;
302
303 let cert = generate_self_signed_cert("cross-pkc-test").unwrap();
304 let server = QuicEndpoint::new_server(0, &cert).unwrap();
305 let server_addr = server.local_addr().unwrap();
306
307 let server_handle = tokio::spawn(async move {
308 let conn = server.accept().await.unwrap();
309
310 let (request, send_stream) = receive_cross_pkc_dispatch(&conn).await.unwrap();
312 assert_eq!(request.pcard_hash, "sha256:test-pcard");
313 assert_eq!(request.source_pkc_did, "did:pkc:source");
314 assert_eq!(request.target_pkc_did, "did:pkc:target");
315
316 let vcard_yaml = format!(
318 "vcard_token:\n gate_type: \"dispatch\"\n result: \"pass\"\n pcard_hash: \"{}\"\n timestamp: \"{}\"",
319 request.pcard_hash,
320 chrono::Utc::now().to_rfc3339()
321 );
322 let vcard_hash = crate::fs_utils::compute_sha256_hex(vcard_yaml.as_bytes());
323
324 let response = CrossPkcDispatchResponse {
325 vcard_hash: crate::hash::prefixed(&vcard_hash),
326 vcard_yaml,
327 target_signature: "sig:did:pkc:target".to_string(),
328 exit_code: 0,
329 exec_output: "OK".to_string(),
330 };
331
332 let response_json = serde_json::to_vec(&response).unwrap();
334 conn.respond(send_stream, &response_json).await.unwrap();
335 let _ = conn.conn.closed().await;
336 });
337
338 tokio::time::sleep(std::time::Duration::from_millis(100)).await;
339 let client = QuicEndpoint::new_client().unwrap();
340 let conn = client.connect(&server_addr.to_string(), "cross-pkc-test").await.unwrap();
341
342 let request = CrossPkcDispatchRequest {
343 pcard_hash: "sha256:test-pcard".to_string(),
344 input_marking: Marking::new(),
345 source_pkc_did: "did:pkc:source".to_string(),
346 target_pkc_did: "did:pkc:target".to_string(),
347 };
348
349 let start = Instant::now();
350 let response = dispatch_cross_pkc(&request, &conn).await.unwrap();
351 let elapsed = start.elapsed();
352
353 assert_eq!(response.exit_code, 0);
354 assert_eq!(response.exec_output, "OK");
355 assert!(response.vcard_hash.starts_with("blake3:") || response.vcard_hash.starts_with("sha256:"));
356 assert!(response.target_signature.contains("did:pkc:target"));
357
358 assert!(elapsed.as_millis() < 5000, "latency {}ms exceeds 5000ms budget", elapsed.as_millis());
360
361 server_handle.await.unwrap();
362 client.close();
363 }
364
365 #[cfg_attr(not(target_arch = "wasm32"), test)]
366 #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test::wasm_bindgen_test)]
367 fn test_vcard_co_signing_contains_both_dids() {
368 let response = CrossPkcDispatchResponse {
369 vcard_hash: "sha256:vcard-1".to_string(),
370 vcard_yaml: "vcard_token: ...".to_string(),
371 target_signature: "sig:did:pkc:target".to_string(),
372 exit_code: 0,
373 exec_output: "OK".to_string(),
374 };
375
376 let co_signed = co_sign_vcard(&response, "did:pkc:source", "did:pkc:target");
377 assert_eq!(co_signed.signatures.len(), 2);
378 assert!(co_signed.signatures.contains(&"sig:did:pkc:target".to_string()));
379 assert!(co_signed.signatures.contains(&"sig:did:pkc:source".to_string()));
380 }
381
382 #[cfg(feature = "native")]
383 #[tokio::test]
384 async fn test_cross_pkc_dispatch_timeout_on_unreachable_target() {
385 use crate::quic_transport::{QuicEndpoint, generate_self_signed_cert};
386
387 let cert = generate_self_signed_cert("timeout-test").unwrap();
388 let server = QuicEndpoint::new_server(0, &cert).unwrap();
390 let server_addr = server.local_addr().unwrap();
391 drop(server);
392
393 let client = QuicEndpoint::new_client().unwrap();
394 let result = tokio::time::timeout(
396 std::time::Duration::from_secs(5),
397 client.connect(&server_addr.to_string(), "timeout-test"),
398 ).await;
399
400 assert!(result.is_err() || result.unwrap().is_err(), "expected timeout or connection error");
401 client.close();
402 }
403}