qualia_core_db/net/qdnf/link/
discovery.rs1use crate::crypto::network::kdf::hmac_sha384;
4use crate::net::qdnf::errors::QdnfError;
5use crate::net::qdnf::types::LinkId;
6
7#[repr(u8)]
8#[derive(Clone, Copy, Debug, PartialEq, Eq)]
9pub enum DiscoveryMode {
10 PrivatePairwise = 1,
11 ClosedGroup = 2,
12 PublicService = 3,
13 Manual = 4,
14}
15
16#[repr(C)]
17#[derive(Clone, Copy, Debug, PartialEq, Eq)]
18pub struct Beacon {
19 pub mode: DiscoveryMode,
20 pub tag: [u8; 16],
21 pub link_id: LinkId,
22 pub epoch: u64,
23 pub expiry_unix: u64,
24 pub mtu: u16,
25}
26
27impl Beacon {
28 pub const WIRE_LEN: usize = 1 + 16 + 16 + 8 + 8 + 2;
29
30 pub fn encode(&self, out: &mut [u8]) -> Result<usize, QdnfError> {
32 if out.len() < Self::WIRE_LEN {
33 return Err(QdnfError::Capacity);
34 }
35 out[0] = self.mode as u8;
36 out[1..17].copy_from_slice(&self.tag);
37 out[17..33].copy_from_slice(&self.link_id.0);
38 out[33..41].copy_from_slice(&self.epoch.to_be_bytes());
39 out[41..49].copy_from_slice(&self.expiry_unix.to_be_bytes());
40 out[49..51].copy_from_slice(&self.mtu.to_be_bytes());
41 Ok(Self::WIRE_LEN)
42 }
43
44 pub fn decode(src: &[u8]) -> Result<Self, QdnfError> {
46 if src.len() < Self::WIRE_LEN {
47 return Err(QdnfError::Truncated);
48 }
49 let mode = match src[0] {
50 1 => DiscoveryMode::PrivatePairwise,
51 2 => DiscoveryMode::ClosedGroup,
52 3 => DiscoveryMode::PublicService,
53 4 => DiscoveryMode::Manual,
54 _ => return Err(QdnfError::Unsupported),
55 };
56 let mut tag = [0u8; 16];
57 tag.copy_from_slice(&src[1..17]);
58 let mut link = LinkId::ZERO;
59 link.0.copy_from_slice(&src[17..33]);
60 Ok(Self {
61 mode,
62 tag,
63 link_id: link,
64 epoch: u64::from_be_bytes(src[33..41].try_into().unwrap()),
65 expiry_unix: u64::from_be_bytes(src[41..49].try_into().unwrap()),
66 mtu: u16::from_be_bytes([src[49], src[50]]),
67 })
68 }
69
70 #[inline]
71 pub fn is_expired(&self, now_unix: u64) -> bool {
73 now_unix >= self.expiry_unix
74 }
75
76 pub fn accept(&self, now_unix: u64) -> Result<(), QdnfError> {
78 if self.is_expired(now_unix) {
79 Err(QdnfError::Expired)
80 } else {
81 Ok(())
82 }
83 }
84}
85
86pub fn rotating_tag(secret: &[u8], epoch: u64, out: &mut [u8; 16]) -> Result<(), QdnfError> {
88 let mut mac = [0u8; 48];
89 let mut info = [0u8; 16];
90 info[..8].copy_from_slice(b"qdnf-tag");
91 info[8..].copy_from_slice(&epoch.to_be_bytes());
92 hmac_sha384(secret, &info, &mut mac)?;
93 out.copy_from_slice(&mac[..16]);
94 Ok(())
95}
96
97#[cfg(test)]
98mod tests {
99 use super::*;
100
101 #[test]
102 fn private_beacon_has_no_did_field() {
103 let beacon = Beacon {
104 mode: DiscoveryMode::PrivatePairwise,
105 tag: [1u8; 16],
106 link_id: LinkId([2u8; 16]),
107 epoch: 3,
108 expiry_unix: 10,
109 mtu: 1280,
110 };
111 let mut buf = [0u8; 64];
112 let n = beacon.encode(&mut buf).unwrap();
113 let decoded = Beacon::decode(&buf[..n]).unwrap();
114 assert_eq!(decoded.mode, DiscoveryMode::PrivatePairwise);
115 assert_eq!(decoded.mtu, 1280);
116 }
117
118 #[test]
119 fn expired_beacon_is_expired() {
120 let beacon = Beacon {
121 mode: DiscoveryMode::PrivatePairwise,
122 tag: [1u8; 16],
123 link_id: LinkId([2u8; 16]),
124 epoch: 3,
125 expiry_unix: 10,
126 mtu: 1280,
127 };
128 assert_eq!(beacon.accept(9), Ok(()));
129 assert_eq!(beacon.accept(10), Err(QdnfError::Expired));
130 assert_eq!(beacon.accept(11), Err(QdnfError::Expired));
131 assert!(beacon.is_expired(10));
132 }
133}