Skip to main content

qualia_core_db/net/qdnf/
vertical.rs

1//! Example 64-byte two-peer vertical slice over `local-ipc-v1`.
2//!
3//! This module is **not** the application API. Applications use
4//! `qualia_peer::PeerHost::{pair, exchange_protected}` (public QPR). This file
5//! keeps a bounded 64-byte demo of QFrame, QLink adjacency, QRoute SPF, QSession
6//! policy gate and QSync payload. libp2p is not imported.
7
8use crate::crypto::network::kem::MlKem768Secret;
9use crate::crypto::network::transcript::Transcript;
10use crate::net::peer::runtime::{ReservationLedger, ResourceBudget};
11use crate::net::qdnf::bearer::contract::Bearer;
12use crate::net::qdnf::bearer::ipc_pair;
13use crate::net::qdnf::crypto::handshake::{
14    derive_handshake_keys, initiator_complete, initiator_share, responder_complete,
15};
16use crate::net::qdnf::errors::QdnfError;
17use crate::net::qdnf::frame::{copy_payload, decode_frame, encode_frame, FrameHeader};
18use crate::net::qdnf::link::{Adjacency, AdjacencyState, NeighborTable};
19use crate::net::qdnf::registries::{FrameType, NextProtocol};
20use crate::net::qdnf::route::{compute_spf, ForwardingGeneration, LinkMetric};
21use crate::net::qdnf::session::packet_protection::PacketProtection;
22use crate::net::qdnf::types::{Generation, LinkId, ScopeEpoch};
23
24/// Run A↔B native exchange and return payload bytes copied at B.
25///
26/// Demo ceiling remains 64 bytes. The authorised application path is
27/// `authorised_ipc_stream_exchange` / `PeerHost::exchange_protected` (4096).
28pub fn two_peer_ipc_exchange(payload: &[u8]) -> Result<usize, QdnfError> {
29    if payload.len() > 64 {
30        return Err(QdnfError::Capacity);
31    }
32    let mut ledger = ReservationLedger::new(
33        ResourceBudget {
34            bytes: 4096,
35            work: 64,
36            io: 16,
37        },
38        ResourceBudget {
39            bytes: 4096,
40            work: 64,
41            io: 16,
42        },
43        ResourceBudget {
44            bytes: 4096,
45            work: 64,
46            io: 16,
47        },
48        ResourceBudget {
49            bytes: 4096,
50            work: 64,
51            io: 16,
52        },
53        ResourceBudget {
54            bytes: 4096,
55            work: 64,
56            io: 16,
57        },
58    );
59    let charge = ledger.reserve(
60        ResourceBudget {
61            bytes: (80 + payload.len()) as u64,
62            work: 1,
63            io: 1,
64        },
65        true,
66    )?;
67
68    let (sk, pk) = MlKem768Secret::generate()?;
69    let i_x = [21u8; 32];
70    let r_x = [22u8; 32];
71    let ishare = initiator_share(&i_x, &pk)?;
72    let (rshare, r_kem, r_dh) = responder_complete(&ishare, &r_x)?;
73    let (i_kem, i_dh) = initiator_complete(&sk, &i_x, &rshare)?;
74    let mut t = Transcript::new();
75    t.append(b"suite", b"qpr-pq-1")?;
76    let keys = derive_handshake_keys(&i_kem, &i_dh, &t)?;
77    use crate::net::qdnf::crypto::finished::{finished_mac, verify_finished};
78    let tag = finished_mac(&keys.initiator_to_responder, &keys.transcript_digest, true)?;
79    verify_finished(
80        &keys.initiator_to_responder,
81        &keys.transcript_digest,
82        true,
83        &tag,
84    )?;
85    assert_eq!(i_kem, r_kem);
86    assert_eq!(i_dh, r_dh);
87
88    let mut neighbors = NeighborTable::new();
89    let mut remote = LinkId::ZERO;
90    remote.0[0] = 2;
91    neighbors.insert(Adjacency {
92        local: LinkId::ZERO,
93        remote,
94        observed_peer: crate::net::qdnf::types::ObservedLocator::from_slice(&[0x02])?,
95        state: AdjacencyState::Adjacent,
96        generation: 1,
97        mtu: 1280,
98    })?;
99
100    let links = [LinkMetric {
101        from: 0,
102        to: 1,
103        cost: 1,
104        bidirectional: true,
105    }];
106    let mut table = crate::net::qdnf::route::SpfTable::EMPTY;
107    compute_spf(0, &links, &mut table)?;
108    let mut gen = ForwardingGeneration::empty(1);
109    gen.publish(table)?;
110    let _ = gen.lookup_next(1)?;
111
112    let mut send_p = PacketProtection::from_keys(
113        keys.initiator_to_responder,
114        keys.responder_to_initiator,
115        Generation(1),
116    )?;
117    let mut recv_p = PacketProtection::from_keys(
118        keys.responder_to_initiator,
119        keys.initiator_to_responder,
120        Generation(1),
121    )?;
122
123    let scope = ScopeEpoch { scope: 1, epoch: 1 };
124    let (mut a, mut b) = ipc_pair(scope, 1280)?;
125    let mut pt = [0u8; 64];
126    pt[..payload.len()].copy_from_slice(payload);
127    let mut sealed = [0u8; 96];
128    let sn = send_p.seal(b"qsession/stream", &mut pt[..payload.len()], &mut sealed)?;
129    let mut header = FrameHeader::new(FrameType::SessionStream, NextProtocol::QSession);
130    header.hop_limit = 16;
131    header.payload_len = sn as u16;
132    header.destination_link_id = remote;
133    let mut wire = [0u8; 256];
134    let n = encode_frame(&header, &sealed[..sn], &mut wire)?;
135    a.send(&b.locator(), &wire[..n])?;
136    let mut out = [0u8; 256];
137    let (got, meta) = b.recv(&mut out)?;
138    if meta.observed_source.as_slice() != &[0x01] {
139        return Err(QdnfError::Unauthorized);
140    }
141    let (decoded, off, len) = decode_frame(&out[..got])?;
142    if decoded.frame_type != FrameType::SessionStream {
143        return Err(QdnfError::Malformed);
144    }
145    let mut sealed_in = [0u8; 96];
146    let copied_sealed = copy_payload(&out[..got], off, len, &mut sealed_in)?;
147    let mut payload_out = [0u8; 64];
148    let copied = recv_p.open(
149        b"qsession/stream",
150        &sealed_in[..copied_sealed],
151        &mut payload_out,
152    )?;
153    if &payload_out[..copied] != payload {
154        return Err(QdnfError::Malformed);
155    }
156    ledger.release(charge)?;
157    Ok(copied)
158}
159
160#[cfg(test)]
161mod tests {
162    use super::*;
163    use crate::net::qdnf::authority::PolicyOutcome;
164    use crate::net::qdnf::session::{SessionBinding, SessionState};
165    use crate::net::qdnf::types::{OperationId, StrongDigest};
166
167    #[test]
168    fn two_peer_native_stream_without_libp2p() {
169        let n = two_peer_ipc_exchange(b"qsync-hello").unwrap();
170        assert_eq!(n, 11);
171    }
172
173    #[test]
174    fn demo_keeps_64_byte_ceiling() {
175        assert_eq!(
176            two_peer_ipc_exchange(&[0u8; 65]).unwrap_err(),
177            QdnfError::Capacity
178        );
179        assert_eq!(two_peer_ipc_exchange(&[1u8; 64]).unwrap(), 64);
180    }
181
182    #[test]
183    fn deny_policy_blocks_payload() {
184        let session = SessionBinding::test_fixture(
185            OperationId([1u8; 16]),
186            StrongDigest([2u8; 48]),
187            StrongDigest([3u8; 48]),
188            StrongDigest([4u8; 48]),
189            PolicyOutcome::Deny,
190            SessionState::Active,
191        );
192        assert_eq!(session.admit_application(), Err(QdnfError::Denied));
193    }
194}