1use 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
24pub 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}