qualia_core_db/p2p/connectivity/
cscp_wss.rs1#![cfg(not(target_arch = "wasm32"))]
4
5use crate::crypto::network::digest::sha384;
6use crate::did_qi::{format_did, DidQi};
7use crate::net::peer::fabric::carrier::PathClass;
8use crate::net::peer::fabric::connect::{connect, Fabric};
9use crate::net::peer::fabric::evidence::{PathEvidence, TransportWitness};
10use crate::net::peer::fabric::intent::ConnectionIntent;
11use crate::net::peer::fabric::intent::{ProtectionPolicy, Purpose};
12use crate::net::peer::fabric::kernel::KernelEvent;
13use crate::net::peer::fabric::outcome::encode_outcome;
14use crate::net::peer::fabric::wire::{
15 connect_from_wire, decode_accept, encode_connect_request, CscpError,
16};
17use crate::net::peer::runtime::ResourceBudget;
18use crate::net::qdnf::authority::{
19 binding_for_controllers, AuthorityOwner, ContactState, InstalledSessionKeys,
20};
21use crate::net::qdnf::bearer::contract::Bearer;
22use crate::net::qdnf::registries::BearerProfile;
23use crate::net::qdnf::session::handshake::handshake_over_fragments;
24use crate::net::qdnf::session::{SessionBinding, SessionState};
25use crate::net::qdnf::types::{Generation, ObservedLocator, ScopeEpoch};
26use crate::p2p::connectivity::wss::{recv_datagram, send_datagram};
27use crate::p2p::connectivity::wss_bearer::WssBearer;
28use crate::p2p::connectivity::wss_tls::{loopback_tls_wss, mint_ca};
29
30fn loc(b: u8) -> ObservedLocator {
31 ObservedLocator::from_slice(&[b]).unwrap()
32}
33
34fn qi_controller_pair() -> ([u8; 64], usize, [u8; 64], usize) {
35 let a_src = b"did:qi:zDgtiZgtgfbh7upfLB47yVTWLdSN4CcoaPHok9sew2BVu";
36 let mut a = [0u8; 64];
37 a[..a_src.len()].copy_from_slice(a_src);
38 let mut b = [0u8; 64];
39 let nb = format_did(&DidQi([0x22; 32]), &mut b).expect("did:qi b");
40 (a, a_src.len(), b, nb)
41}
42
43pub fn cscp_then_qsession_over_local_tls_wss() -> Result<SessionBinding, String> {
45 let ca = mint_ca().map_err(|e| format!("ca: {e}"))?;
46 let (mut client, mut server) = loopback_tls_wss(&ca).map_err(|e| format!("tls: {e}"))?;
47 let peer = [0xC5u8; 32];
48 let intent = ConnectionIntent::new(
49 peer,
50 Purpose::ordinary(),
51 ProtectionPolicy::RELAY_ONLY,
52 ResourceBudget {
53 bytes: 4096,
54 work: 4,
55 io: 4,
56 },
57 10,
58 9_000,
59 );
60 let mut req = [0u8; 512];
61 let n = encode_connect_request(&intent, &mut req).map_err(|e| format!("enc: {e:?}"))?;
62 send_datagram(&mut client, 1, 1, &req[..n], true).map_err(|e| format!("send: {e}"))?;
63 let (_, _, payload) = recv_datagram(&mut server).map_err(|e| format!("recv: {e}"))?;
64 let mut fb = Fabric::new();
65 connect_from_wire(&mut fb, &payload, 20).map_err(|e| format!("admit: {e:?}"))?;
66 if intent.protection.public_dht {
67 return Err("relay-only must not enable public DHT".into());
68 }
69 fb.kernel.step(
70 KernelEvent::Descriptor {
71 stale: false,
72 expired: false,
73 direct_locator: false,
74 },
75 20,
76 );
77 fb.kernel.step(KernelEvent::LeaseLive, 20);
78 fb.kernel.step(
79 KernelEvent::PathValidated {
80 class: PathClass::Relayed,
81 },
82 20,
83 );
84 let path = PathEvidence::from_witness(TransportWitness::from_local(
85 PathClass::Relayed,
86 fb.kernel.generation,
87 256,
88 8,
89 20,
90 ));
91 let mut acc = [0u8; 128];
92 let an = encode_outcome(&fb.kernel, path, &mut acc).map_err(|e| format!("outcome: {e:?}"))?;
93 send_datagram(&mut server, 1, 1, &acc[..an], false).map_err(|e| format!("acc: {e}"))?;
94 let (_, _, ap) = recv_datagram(&mut client).map_err(|e| format!("accrecv: {e}"))?;
95 let (class, _) = decode_accept(&ap).map_err(|e| format!("decode accept: {e:?}"))?;
96 if class != PathClass::Relayed {
97 return Err("expected relayed accept".into());
98 }
99 if matches!(decode_accept(&payload), Ok(_)) {
100 return Err("connect request is not accept".into());
101 }
102 let _ = CscpError::Policy;
103
104 let scope = ScopeEpoch { scope: 1, epoch: 1 };
105 let dest_b = loc(0x02);
106 let dest_a = loc(0x01);
107 let mut a = WssBearer::new(client, dest_a, dest_b, scope, true);
108 let mut b = WssBearer::new(server, dest_b, dest_a, scope, false);
109 if a.profile() != BearerProfile::TlsWssTransitionV1
110 || b.profile() != BearerProfile::TlsWssTransitionV1
111 {
112 return Err("wss bearer must be TlsWssTransitionV1".into());
113 }
114 let (did_a, na, did_b, nb) = qi_controller_pair();
115 let id_a = sha384(&did_a[..na]);
116 let id_b = sha384(&did_b[..nb]);
117 let hs = handshake_over_fragments(&mut a, &mut b, &dest_b, &dest_a, &id_a, &id_b)
118 .map_err(|e| format!("qsession: {e:?}"))?;
119 let now = 1_700_000_000u64;
120 let mut owner = AuthorityOwner::new();
121 let binding = binding_for_controllers(&did_a[..na], &did_b[..nb], b"q42:QSync/1", b"op-c")
122 .map_err(|e| format!("bind: {e:?}"))?;
123 let (_cred, _contact, handle) = owner
124 .install_grant(binding, now, now.saturating_add(3600), ContactState::Active)
125 .map_err(|e| format!("grant: {e:?}"))?;
126 let permit = owner
127 .issue_permit(handle, binding, now, 4096)
128 .map_err(|e| format!("permit: {e:?}"))?;
129 let keys = InstalledSessionKeys::new(
130 Generation(1),
131 hs.keys.initiator_to_responder,
132 hs.keys.responder_to_initiator,
133 true,
134 )
135 .map_err(|e| format!("keys: {e:?}"))?;
136 let session =
137 SessionBinding::from_permit(&permit, &keys, now).map_err(|e| format!("session: {e:?}"))?;
138 session
139 .admit_application()
140 .map_err(|e| format!("admit: {e:?}"))?;
141 if session.state() != SessionState::Active {
142 return Err("not Active".into());
143 }
144 let _ = connect(
145 &mut Fabric::new(),
146 peer,
147 Purpose::ordinary(),
148 ProtectionPolicy::RELAY_ONLY,
149 intent.budget,
150 10,
151 9_000,
152 );
153 Ok(session)
154}
155
156#[cfg(test)]
157mod tests {
158 use super::*;
159 use crate::net::peer::connectivity::evidence::{
160 masque_bound_udp_internet_executed, public_relay_dialed,
161 };
162
163 #[test]
164 fn cscp_control_then_qsession_on_local_tls_wss() {
165 let session = cscp_then_qsession_over_local_tls_wss().unwrap();
166 assert_eq!(session.state(), SessionState::Active);
167 assert!(!public_relay_dialed());
168 assert!(!masque_bound_udp_internet_executed());
169 }
170}