qualia_core_db/p2p/connectivity/
cscp_h2.rs1#![cfg(not(target_arch = "wasm32"))]
7
8use crate::crypto::network::digest::sha384;
9use crate::did_qi::{format_did, DidQi};
10use crate::net::peer::fabric::carrier::PathClass;
11use crate::net::peer::fabric::connect::{connect, Fabric};
12use crate::net::peer::fabric::evidence::{PathEvidence, TransportWitness};
13use crate::net::peer::fabric::intent::{ConnectionIntent, ProtectionPolicy, Purpose};
14use crate::net::peer::fabric::kernel::KernelEvent;
15use crate::net::peer::fabric::outcome::encode_outcome;
16use crate::net::peer::fabric::wire::{
17 connect_from_wire, decode_accept, encode_connect_request, CscpError,
18};
19use crate::net::peer::runtime::ResourceBudget;
20use crate::net::qdnf::authority::{
21 binding_for_controllers, AuthorityOwner, ContactState, InstalledSessionKeys,
22};
23use crate::net::qdnf::bearer::contract::{check_frame_mtu, Bearer, RecvMeta};
24use crate::net::qdnf::bearer::mtu::MIN_QDNF_MTU;
25use crate::net::qdnf::errors::QdnfError;
26use crate::net::qdnf::registries::BearerProfile;
27use crate::net::qdnf::session::handshake::handshake_over_fragments;
28use crate::net::qdnf::session::{SessionBinding, SessionState};
29use crate::net::qdnf::types::{Generation, ObservedLocator, ScopeEpoch};
30use crate::p2p::connectivity::h2_capsule::{loopback_tls_h2_capsule, CapsuleEndpoint};
31use crate::p2p::connectivity::wss_tls::mint_ca;
32
33fn loc(b: u8) -> ObservedLocator {
34 ObservedLocator::from_slice(&[b]).unwrap()
35}
36
37fn qi_controller_pair() -> ([u8; 64], usize, [u8; 64], usize) {
38 let a_src = b"did:qi:zDgtiZgtgfbh7upfLB47yVTWLdSN4CcoaPHok9sew2BVu";
39 let mut a = [0u8; 64];
40 a[..a_src.len()].copy_from_slice(a_src);
41 let mut b = [0u8; 64];
42 let nb = format_did(&DidQi([0x22; 32]), &mut b).expect("did:qi b");
43 (a, a_src.len(), b, nb)
44}
45
46struct H2CapsuleBearer {
47 ep: CapsuleEndpoint,
48 remote: ObservedLocator,
49 scope: ScopeEpoch,
50}
51
52impl Bearer for H2CapsuleBearer {
53 fn profile(&self) -> BearerProfile {
54 BearerProfile::Http2CapsuleTransitionV1
55 }
56
57 fn mtu(&self) -> u16 {
58 MIN_QDNF_MTU
59 }
60
61 fn scope(&self) -> ScopeEpoch {
62 self.scope
63 }
64
65 fn send(&mut self, dest: &ObservedLocator, frame: &[u8]) -> Result<usize, QdnfError> {
66 check_frame_mtu(frame.len(), self.mtu())?;
67 if dest.as_slice() != self.remote.as_slice() {
68 return Err(QdnfError::Unauthorized);
69 }
70 self.ep.send_payload(frame).map_err(|_| QdnfError::Closed)?;
71 Ok(frame.len())
72 }
73
74 fn recv(&mut self, out: &mut [u8]) -> Result<(usize, RecvMeta), QdnfError> {
75 let p = self.ep.recv_payload().map_err(|_| QdnfError::Closed)?;
76 if p.len() > out.len() {
77 return Err(QdnfError::Capacity);
78 }
79 out[..p.len()].copy_from_slice(&p);
80 Ok((
81 p.len(),
82 RecvMeta {
83 observed_source: self.remote,
84 scope: self.scope,
85 mtu: self.mtu(),
86 },
87 ))
88 }
89
90 fn shutdown(&mut self) -> Result<(), QdnfError> {
91 Ok(())
92 }
93}
94
95pub fn cscp_then_qsession_over_local_tls_h2() -> Result<SessionBinding, String> {
98 let ca = mint_ca().map_err(|e| format!("ca: {e}"))?;
99 let (client, server) = loopback_tls_h2_capsule(&ca).map_err(|e| format!("tls-h2: {e}"))?;
100 let peer = [0xC5u8; 32];
101 let intent = ConnectionIntent::new(
102 peer,
103 Purpose::ordinary(),
104 ProtectionPolicy::RELAY_ONLY,
105 ResourceBudget {
106 bytes: 4096,
107 work: 4,
108 io: 4,
109 },
110 10,
111 9_000,
112 );
113 let mut req = [0u8; 512];
114 let n = encode_connect_request(&intent, &mut req).map_err(|e| format!("enc: {e:?}"))?;
115 client
116 .send_payload(&req[..n])
117 .map_err(|e| format!("send: {e}"))?;
118 let payload = server.recv_payload().map_err(|e| format!("recv: {e}"))?;
119 let mut fb = Fabric::new();
120 connect_from_wire(&mut fb, &payload, 20).map_err(|e| format!("admit: {e:?}"))?;
121 if intent.protection.public_dht {
122 return Err("relay-only must not enable public DHT".into());
123 }
124 fb.kernel.step(
125 KernelEvent::Descriptor {
126 stale: false,
127 expired: false,
128 direct_locator: false,
129 },
130 20,
131 );
132 fb.kernel.step(KernelEvent::LeaseLive, 20);
133 fb.kernel.step(
134 KernelEvent::PathValidated {
135 class: PathClass::Relayed,
136 },
137 20,
138 );
139 let path = PathEvidence::from_witness(TransportWitness::from_local(
140 PathClass::Relayed,
141 fb.kernel.generation,
142 256,
143 8,
144 20,
145 ));
146 let mut acc = [0u8; 128];
147 let an = encode_outcome(&fb.kernel, path, &mut acc).map_err(|e| format!("outcome: {e:?}"))?;
148 server
149 .send_payload(&acc[..an])
150 .map_err(|e| format!("acc: {e}"))?;
151 let ap = client.recv_payload().map_err(|e| format!("accrecv: {e}"))?;
152 let (class, _) = decode_accept(&ap).map_err(|e| format!("decode accept: {e:?}"))?;
153 if class != PathClass::Relayed {
154 return Err("expected relayed accept".into());
155 }
156 if matches!(decode_accept(&payload), Ok(_)) {
157 return Err("connect request is not accept".into());
158 }
159 let _ = CscpError::Policy;
160
161 let scope = ScopeEpoch { scope: 1, epoch: 1 };
162 let dest_b = loc(0x02);
163 let dest_a = loc(0x01);
164 let mut a = H2CapsuleBearer {
165 ep: client,
166 remote: dest_b,
167 scope,
168 };
169 let mut b = H2CapsuleBearer {
170 ep: server,
171 remote: dest_a,
172 scope,
173 };
174 if a.profile() != BearerProfile::Http2CapsuleTransitionV1
175 || b.profile() != BearerProfile::Http2CapsuleTransitionV1
176 {
177 return Err("h2 bearer must be Http2CapsuleTransitionV1".into());
178 }
179 let (did_a, na, did_b, nb) = qi_controller_pair();
180 let id_a = sha384(&did_a[..na]);
181 let id_b = sha384(&did_b[..nb]);
182 let hs = handshake_over_fragments(&mut a, &mut b, &dest_b, &dest_a, &id_a, &id_b)
183 .map_err(|e| format!("qsession: {e:?}"))?;
184 let now = 1_700_000_000u64;
185 let mut owner = AuthorityOwner::new();
186 let binding = binding_for_controllers(&did_a[..na], &did_b[..nb], b"q42:QSync/1", b"op-c")
187 .map_err(|e| format!("bind: {e:?}"))?;
188 let (_cred, _contact, handle) = owner
189 .install_grant(binding, now, now.saturating_add(3600), ContactState::Active)
190 .map_err(|e| format!("grant: {e:?}"))?;
191 let permit = owner
192 .issue_permit(handle, binding, now, 4096)
193 .map_err(|e| format!("permit: {e:?}"))?;
194 let keys = InstalledSessionKeys::new(
195 Generation(1),
196 hs.keys.initiator_to_responder,
197 hs.keys.responder_to_initiator,
198 true,
199 )
200 .map_err(|e| format!("keys: {e:?}"))?;
201 let session =
202 SessionBinding::from_permit(&permit, &keys, now).map_err(|e| format!("session: {e:?}"))?;
203 session
204 .admit_application()
205 .map_err(|e| format!("admit: {e:?}"))?;
206 if session.state() != SessionState::Active {
207 return Err("not Active".into());
208 }
209 let _ = connect(
210 &mut Fabric::new(),
211 peer,
212 Purpose::ordinary(),
213 ProtectionPolicy::RELAY_ONLY,
214 intent.budget,
215 10,
216 9_000,
217 );
218 Ok(session)
219}
220
221#[cfg(test)]
222mod tests {
223 use super::*;
224 use crate::net::peer::connectivity::evidence::{
225 masque_bound_udp_internet_executed, public_relay_dialed,
226 };
227 use crate::net::peer::fabric::capsule::encode_capsule;
228 use crate::p2p::connectivity::h2_capsule::loopback_tls_h2_connect;
229
230 #[test]
231 fn cscp_control_then_qsession_on_local_tls_h2() {
232 let session = cscp_then_qsession_over_local_tls_h2().unwrap();
233 assert_eq!(session.state(), SessionState::Active);
234 assert!(!public_relay_dialed());
235 assert!(!masque_bound_udp_internet_executed());
236 }
237
238 #[test]
239 fn wrong_connect_protocol_rejected() {
240 let ca = mint_ca().unwrap();
241 let err = match loopback_tls_h2_connect(&ca, "websocket") {
242 Ok(_) => panic!("wrong :protocol must be rejected"),
243 Err(e) => e,
244 };
245 assert!(
246 err.contains("capsule") || err.contains("CONNECT") || err.contains("rejected"),
247 "{err}"
248 );
249 }
250
251 #[test]
252 fn unknown_critical_capsule_rejected() {
253 let ca = mint_ca().unwrap();
254 let (c, s) = loopback_tls_h2_capsule(&ca).unwrap();
255 let mut frame = [0u8; 16];
256 let n = encode_capsule(0x40, b"y", &mut frame).unwrap();
257 c.send_raw_capsule(&frame[..n]).unwrap();
258 let err = s.recv_payload().unwrap_err();
259 assert!(err.contains("critical"), "{err}");
260 }
261
262 #[test]
263 fn honesty_flags_remain_false_for_local_h2() {
264 assert!(!public_relay_dialed());
265 assert!(!masque_bound_udp_internet_executed());
266 }
267}