Skip to main content

qualia_core_db/net/qdnf/link/
discovery.rs

1//! QLink discovery beacons. Private beacons carry no stable person identifier.
2
3use 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    /// Encodes into the caller buffer.
31    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    /// Decodes; fails closed on malformed input.
45    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    /// `true` when expired.
72    pub fn is_expired(&self, now_unix: u64) -> bool {
73        now_unix >= self.expiry_unix
74    }
75
76    /// Reject expired beacons before any neighbor insert.
77    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
86/// Rotating private rendezvous tag from a relationship secret.
87pub 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}