1use serde::{Deserialize, Serialize};
2use std::fmt;
3
4#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, Eq)]
10pub enum GossipMessage {
11 GenerationAnnouncement {
12 producer_id: String,
13 issuer_key_hash: Vec<u8>,
14 epoch: u64,
15 manifest_digest: [u8; 32],
16 bundle_url: Option<String>,
17 #[serde(default)]
23 origin_node: String,
24 },
25 UrgentRevocation {
26 producer_id: String,
27 issuer_key_hash: Vec<u8>,
28 epoch: u64,
29 #[serde(default)]
31 origin_node: String,
32 },
33}
34
35impl GossipMessage {
36 pub(crate) fn valid_bounds(&self) -> bool {
37 let (producer, hash) = self.scope_key();
38 !producer.is_empty()
39 && producer.len() <= 256
40 && self.origin_node().len() <= 256
41 && matches!(hash.len(), 20 | 32)
42 && match self {
43 Self::GenerationAnnouncement {
44 bundle_url: Some(url),
45 ..
46 } => url.len() <= 1024,
47 _ => true,
48 }
49 }
50
51 pub fn scope_key(&self) -> (&str, &[u8]) {
52 match self {
53 GossipMessage::GenerationAnnouncement {
54 producer_id,
55 issuer_key_hash,
56 ..
57 } => (producer_id, issuer_key_hash),
58 GossipMessage::UrgentRevocation {
59 producer_id,
60 issuer_key_hash,
61 ..
62 } => (producer_id, issuer_key_hash),
63 }
64 }
65
66 pub fn epoch(&self) -> u64 {
67 match self {
68 GossipMessage::GenerationAnnouncement { epoch, .. } => *epoch,
69 GossipMessage::UrgentRevocation { epoch, .. } => *epoch,
70 }
71 }
72
73 pub fn origin_node(&self) -> &str {
76 match self {
77 GossipMessage::GenerationAnnouncement { origin_node, .. } => origin_node,
78 GossipMessage::UrgentRevocation { origin_node, .. } => origin_node,
79 }
80 }
81}
82
83impl fmt::Display for GossipMessage {
84 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
85 match self {
86 GossipMessage::GenerationAnnouncement {
87 producer_id,
88 issuer_key_hash,
89 epoch,
90 ..
91 } => write!(
92 f,
93 "GenerationAnnouncement(producer={}, ikh={}, epoch={})",
94 producer_id,
95 hex::encode(&issuer_key_hash[..8.min(issuer_key_hash.len())]),
96 epoch
97 ),
98 GossipMessage::UrgentRevocation {
99 producer_id,
100 issuer_key_hash,
101 epoch,
102 ..
103 } => write!(
104 f,
105 "UrgentRevocation(producer={}, ikh={}, epoch={})",
106 producer_id,
107 hex::encode(&issuer_key_hash[..8.min(issuer_key_hash.len())]),
108 epoch
109 ),
110 }
111 }
112}
113
114#[derive(Clone, Debug, PartialEq, Eq)]
118pub struct BroadcastKey {
119 pub producer_id: String,
120 pub issuer_key_hash: Vec<u8>,
121 pub epoch: u64,
122}
123
124impl foca::Invalidates for BroadcastKey {
125 fn invalidates(&self, other: &Self) -> bool {
126 self.producer_id == other.producer_id
127 && self.issuer_key_hash == other.issuer_key_hash
128 && self.epoch > other.epoch
129 }
130}
131
132pub struct HoikeBroadcastHandler {
134 tx: tokio::sync::mpsc::Sender<GossipMessage>,
135 verifier: crate::crypto::GossipVerifier,
140 admitted: std::collections::HashMap<(String, Vec<u8>), std::time::Instant>,
141}
142
143impl HoikeBroadcastHandler {
144 pub fn new(
145 tx: tokio::sync::mpsc::Sender<GossipMessage>,
146 verifier: crate::crypto::GossipVerifier,
147 ) -> Self {
148 Self {
149 tx,
150 verifier,
151 admitted: Default::default(),
152 }
153 }
154}
155
156#[derive(Debug)]
157pub struct BroadcastError(String);
158
159impl fmt::Display for BroadcastError {
160 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
161 write!(f, "broadcast error: {}", self.0)
162 }
163}
164
165impl std::error::Error for BroadcastError {}
166
167impl<T> foca::BroadcastHandler<T> for HoikeBroadcastHandler {
168 type Key = BroadcastKey;
169 type Error = BroadcastError;
170
171 fn receive_item(
172 &mut self,
173 data: &[u8],
174 _sender: Option<&T>,
175 ) -> Result<Option<Self::Key>, Self::Error> {
176 if data.len() > 2048 {
177 return Ok(None);
178 }
179 let payload: &[u8] = match self.verifier.check(data) {
184 crate::crypto::VerifyOutcome::Accept(p) => p,
185 crate::crypto::VerifyOutcome::Reject(reason) => {
186 tracing::warn!(reason, "gossip message rejected (authentication)");
187 return Ok(None);
188 }
189 };
190
191 let msg: GossipMessage =
192 serde_json::from_slice(payload).map_err(|e| BroadcastError(format!("decode: {e}")))?;
193
194 if !msg.valid_bounds() {
195 return Ok(None);
196 }
197 self.admitted
198 .retain(|_, seen| seen.elapsed() < std::time::Duration::from_secs(3600));
199 let scope = (msg.scope_key().0.to_string(), msg.scope_key().1.to_vec());
200 if !self.admitted.contains_key(&scope) && self.admitted.len() >= 4096 {
201 return Ok(None);
202 }
203 self.admitted.insert(scope, std::time::Instant::now());
204 let key = BroadcastKey {
205 producer_id: msg.scope_key().0.to_string(),
206 issuer_key_hash: msg.scope_key().1.to_vec(),
207 epoch: msg.epoch(),
208 };
209
210 if let Err(e) = self.tx.try_send(msg) {
211 tracing::warn!(error = %e, "gossip message channel full — announcement may be lost");
212 }
213
214 Ok(Some(key))
215 }
216}
217
218#[cfg(test)]
219mod tests {
220 use super::*;
221
222 #[test]
223 fn handler_bounds_new_scopes_and_payloads() {
224 use crate::config::AuthMode;
225 use crate::crypto::GossipVerifier;
226 use foca::BroadcastHandler;
227 let (tx, _rx) = tokio::sync::mpsc::channel(8192);
228 let mut handler = HoikeBroadcastHandler::new(
231 tx,
232 GossipVerifier::for_identities(vec![], AuthMode::Permissive),
233 );
234 for n in 0..4100 {
235 let msg = GossipMessage::UrgentRevocation {
236 producer_id: format!("p{n}"),
237 issuer_key_hash: vec![1; 32],
238 epoch: 1,
239 origin_node: "peer".into(),
240 };
241 let accepted = handler
242 .receive_item(&serde_json::to_vec(&msg).unwrap(), None::<&()>)
243 .unwrap()
244 .is_some();
245 assert_eq!(accepted, n < 4096);
246 }
247 assert!(
248 handler
249 .receive_item(&vec![0; 2049], None::<&()>)
250 .unwrap()
251 .is_none()
252 );
253 assert_eq!(handler.admitted.len(), 4096);
254 }
255
256 #[test]
257 fn gossip_message_serialization_round_trip() {
258 let msg = GossipMessage::GenerationAnnouncement {
259 producer_id: "signer-a".into(),
260 issuer_key_hash: vec![0xAA; 32],
261 epoch: 42,
262 manifest_digest: [0xBB; 32],
263 bundle_url: Some("https://signer-a.example/ahu/latest.ahu".into()),
264 origin_node: "edge-1".into(),
265 };
266
267 let json = serde_json::to_vec(&msg).unwrap();
268 let decoded: GossipMessage = serde_json::from_slice(&json).unwrap();
269 assert_eq!(msg, decoded);
270 assert_eq!(decoded.origin_node(), "edge-1");
271
272 let msg2 = GossipMessage::UrgentRevocation {
273 producer_id: "signer-b".into(),
274 issuer_key_hash: vec![0xCC; 32],
275 epoch: 100,
276 origin_node: "signer-b".into(),
277 };
278 let json2 = serde_json::to_vec(&msg2).unwrap();
279 let decoded2: GossipMessage = serde_json::from_slice(&json2).unwrap();
280 assert_eq!(msg2, decoded2);
281 }
282
283 #[test]
288 fn legacy_announcement_without_origin_node_decodes() {
289 let legacy = serde_json::json!({
290 "GenerationAnnouncement": {
291 "producer_id": "signer-a",
292 "issuer_key_hash": [1, 2, 3],
293 "epoch": 7,
294 "manifest_digest": vec![0u8; 32],
295 "bundle_url": null
296 }
297 });
298 let decoded: GossipMessage = serde_json::from_value(legacy).unwrap();
299 assert_eq!(decoded.epoch(), 7);
300 assert_eq!(decoded.origin_node(), "", "missing origin decodes to empty");
301 }
302
303 #[test]
307 fn handler_drops_forged_and_admits_signed() {
308 use crate::config::AuthMode;
309 use crate::crypto::{GossipSigner, GossipVerifier};
310 use ed25519_dalek::SigningKey;
311 use foca::BroadcastHandler;
312
313 let trusted_key = SigningKey::from_bytes(&[1u8; 32]);
314 let signer = GossipSigner::new(trusted_key.clone());
315 let verifier = GossipVerifier::new(vec![trusted_key.verifying_key()], AuthMode::Required);
316
317 let (tx, mut rx) = tokio::sync::mpsc::channel::<GossipMessage>(4);
318 let mut handler = HoikeBroadcastHandler::new(tx, verifier);
319
320 let msg = GossipMessage::GenerationAnnouncement {
321 producer_id: "signer-a".into(),
322 issuer_key_hash: vec![0xAA; 32],
323 epoch: 9,
324 manifest_digest: [0u8; 32],
325 bundle_url: None,
326 origin_node: "node-a".into(),
327 };
328 let payload = serde_json::to_vec(&msg).unwrap();
329
330 let good = signer.frame(&payload);
332 let key = handler
333 .receive_item(&good, None::<&()>)
334 .expect("no decode error");
335 assert!(key.is_some(), "valid signed message must be accepted");
336 assert_eq!(rx.try_recv().unwrap().epoch(), 9);
337
338 let attacker = GossipSigner::new(SigningKey::from_bytes(&[9u8; 32]));
340 let forged = attacker.frame(&payload);
341 let key = handler
342 .receive_item(&forged, None::<&()>)
343 .expect("drop is not a decode error");
344 assert!(key.is_none(), "forged message must be dropped");
345 assert!(
346 rx.try_recv().is_err(),
347 "nothing forwarded for forged message"
348 );
349
350 let key = handler
352 .receive_item(&payload, None::<&()>)
353 .expect("drop is not a decode error");
354 assert!(
355 key.is_none(),
356 "unsigned message dropped under Required policy"
357 );
358 assert!(rx.try_recv().is_err());
359 }
360
361 #[test]
367 fn permissive_handler_decodes_signed_and_unsigned_from_provisioned_peer() {
368 use crate::config::AuthMode;
369 use crate::crypto::{GossipSigner, GossipVerifier};
370 use ed25519_dalek::SigningKey;
371 use foca::BroadcastHandler;
372
373 let peer_key = SigningKey::from_bytes(&[7u8; 32]);
374 let signer = GossipSigner::new(peer_key.clone());
375 let verifier = GossipVerifier::for_identities(
376 vec![("node-a".into(), peer_key.verifying_key())],
377 AuthMode::Permissive,
378 );
379
380 let (tx, mut rx) = tokio::sync::mpsc::channel::<GossipMessage>(4);
381 let mut handler = HoikeBroadcastHandler::new(tx, verifier);
382
383 let msg = GossipMessage::GenerationAnnouncement {
384 producer_id: "signer-a".into(),
385 issuer_key_hash: vec![0xAA; 32],
386 epoch: 11,
387 manifest_digest: [0u8; 32],
388 bundle_url: None,
389 origin_node: "node-a".into(),
390 };
391 let payload = serde_json::to_vec(&msg).unwrap();
392
393 let framed = signer.frame(&payload);
395 let key = handler
396 .receive_item(&framed, None::<&()>)
397 .expect("permissive node must decode a provisioned peer's frame");
398 assert!(key.is_some());
399 assert_eq!(rx.try_recv().unwrap().epoch(), 11);
400
401 let key = handler
403 .receive_item(&payload, None::<&()>)
404 .expect("permissive node decodes unsigned too");
405 assert!(key.is_some());
406 assert_eq!(rx.try_recv().unwrap().epoch(), 11);
407
408 let unprovisioned = GossipSigner::new(SigningKey::from_bytes(&[9u8; 32]));
411 let forged = unprovisioned.frame(&payload);
412 let key = handler
413 .receive_item(&forged, None::<&()>)
414 .expect("drop is not a decode error");
415 assert!(key.is_none());
416 assert!(rx.try_recv().is_err());
417 }
418
419 #[test]
420 fn broadcast_key_invalidation() {
421 let old = BroadcastKey {
422 producer_id: "prod-1".into(),
423 issuer_key_hash: vec![0x01; 32],
424 epoch: 5,
425 };
426 let new = BroadcastKey {
427 producer_id: "prod-1".into(),
428 issuer_key_hash: vec![0x01; 32],
429 epoch: 10,
430 };
431 let other_producer = BroadcastKey {
432 producer_id: "prod-2".into(),
433 issuer_key_hash: vec![0x01; 32],
434 epoch: 10,
435 };
436
437 use foca::Invalidates;
438 assert!(new.invalidates(&old));
439 assert!(!old.invalidates(&new));
440 assert!(!new.invalidates(&other_producer));
441 assert!(!old.invalidates(&old)); }
443}