Skip to main content

qualia_core_db/p2p/connectivity/
cscp_h2.rs

1//! CSCP control on local TLS HTTP/2 Extended CONNECT + RFC 9297 capsules, then QSession.
2//!
3//! Loopback only. Not a public relay, not UDP, not MASQUE Internet. Nested
4//! recovery over the reliable capsule stream is degraded (head-of-line blocking).
5
6#![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
95/// Two loopback TLS HTTP/2 peers exchange CSCP ConnectRequest/Accept as DATAGRAM
96/// capsules, then QSession. Not a public relay and not MASQUE Internet.
97pub 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}