Skip to main content

qualia_core_db/net/peer/host/
discovery.rs

1//! QLink announce/accept with pre-auth budget and reachability challenges (E05.3).
2
3use super::NativePeer;
4use crate::net::qdnf::bearer::contract::Bearer;
5use crate::net::qdnf::errors::QdnfError;
6use crate::net::qdnf::frame::{copy_payload, decode_frame, encode_frame, FrameHeader};
7use crate::net::qdnf::link::{
8    accept_beacon, insert_after_challenge, rotating_tag, Adjacency, AdjacencyState, Beacon,
9    DiscoveryMode,
10};
11use crate::net::qdnf::registries::{FrameType, NextProtocol};
12use crate::net::qdnf::types::{LinkId, ObservedLocator};
13
14impl NativePeer {
15    /// QLink beacon announce. Replaces mDNS. Tag is HMAC-bound, not a DID.
16    pub fn announce(&mut self, dest: &ObservedLocator, now_unix: u64) -> Result<(), QdnfError> {
17        let mut tag = [0u8; 16];
18        rotating_tag(self.identity.digest().as_bytes(), 1, &mut tag)?;
19        let beacon = Beacon {
20            mode: DiscoveryMode::PrivatePairwise,
21            tag,
22            link_id: self.local_link,
23            epoch: 1,
24            expiry_unix: now_unix.saturating_add(60),
25            mtu: self.bearer.mtu(),
26        };
27        let mut payload = [0u8; Beacon::WIRE_LEN];
28        let pn = beacon.encode(&mut payload)?;
29        let mut header = FrameHeader::new(FrameType::DiscoveryBeacon, NextProtocol::QLink);
30        header.source_link_id = self.local_link;
31        header.payload_len = pn as u16;
32        let mut wire = [0u8; 256];
33        let n = encode_frame(&header, &payload[..pn], &mut wire)?;
34        self.bearer.send(dest, &wire[..n])?;
35        Ok(())
36    }
37
38    /// Accept using `now_unix = 1`. Callers with a clock use [`Self::accept_announce_at`].
39    pub fn accept_announce(&mut self) -> Result<LinkId, QdnfError> {
40        self.accept_announce_at(1)
41    }
42
43    /// Charge the pre-auth budget, reject expired beacons, then insert only after
44    /// a locator-bound challenge. Link possession is not DID authority.
45    pub fn accept_announce_at(&mut self, now_unix: u64) -> Result<LinkId, QdnfError> {
46        let mut out = [0u8; 256];
47        let (got, meta) = self.bearer.recv(&mut out)?;
48        let (decoded, off, len) = decode_frame(&out[..got])?;
49        if decoded.frame_type != FrameType::DiscoveryBeacon {
50            return Err(QdnfError::Malformed);
51        }
52        let mut payload = [0u8; 64];
53        let copied = copy_payload(&out[..got], off, len, &mut payload)?;
54        let beacon = Beacon::decode(&payload[..copied])?;
55        accept_beacon(&beacon, now_unix, &mut self.preauth)?;
56        let mut secret = [0u8; 32];
57        secret.copy_from_slice(&self.identity.digest().as_bytes()[..32]);
58        let challenge = self.challenges.issue(
59            self.bearer.scope(),
60            beacon.link_id,
61            meta.observed_source,
62            now_unix,
63            60,
64            &secret,
65        )?;
66        insert_after_challenge(
67            &mut self.neighbors,
68            Adjacency {
69                local: self.local_link,
70                remote: beacon.link_id,
71                observed_peer: meta.observed_source,
72                state: AdjacencyState::Adjacent,
73                generation: 1,
74                mtu: beacon.mtu,
75            },
76            &challenge,
77            self.bearer.scope(),
78            now_unix,
79        )?;
80        Ok(beacon.link_id)
81    }
82}
83
84#[cfg(test)]
85mod tests {
86    use super::super::NativePeer;
87    use crate::net::qdnf::errors::QdnfError;
88    use crate::net::qdnf::types::ScopeEpoch;
89
90    #[test]
91    fn expired_beacon_is_not_installed() {
92        let scope = ScopeEpoch { scope: 1, epoch: 1 };
93        let (mut a, mut b) = NativePeer::pair_ipc(b"did:q42:a", b"did:q42:b", scope, 1280).unwrap();
94        let now = 1_700_000_000u64;
95        a.announce(&b.locator(), now).unwrap();
96        assert_eq!(
97            b.accept_announce_at(now.saturating_add(120)).unwrap_err(),
98            QdnfError::Expired
99        );
100        assert_eq!(b.neighbor_count(), 0);
101    }
102}