Skip to main content

qualia_core_db/p2p/connectivity/
cscp_wss.rs

1//! CSCP control on local TLS WSS, then QSession. Not a public relay.
2
3#![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
43/// Two loopback TLS WSS peers exchange CSCP ConnectRequest/Accept, then QSession.
44pub 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}