Skip to main content

qualia_core_db/p2p/connectivity/
establish.rs

1//! Local production path: TLS WSS + ICE/TURN checks + QSession admission.
2
3#![cfg(not(target_arch = "wasm32"))]
4
5use crate::crypto::network::digest::sha384;
6use crate::net::peer::connectivity::candidates::CandidateKind;
7use crate::net::peer::connectivity::policy::PathPolicy;
8use crate::net::peer::connectivity::state::{ConnSlot, ConnState};
9use crate::net::qdnf::authority::{
10    binding_for_controllers, AuthorityOwner, ContactState, InstalledSessionKeys,
11};
12use crate::net::qdnf::session::handshake::handshake_over_fragments;
13use crate::net::qdnf::session::{SessionBinding, SessionState};
14use crate::net::qdnf::types::{Generation, ObservedLocator, ScopeEpoch};
15use crate::p2p::connectivity::ice::{IceAgent, IceRole};
16use crate::p2p::connectivity::ice_udp::local_binding_check;
17use crate::p2p::connectivity::turn_local::local_allocate_and_forward;
18use crate::p2p::connectivity::wss_bearer::WssBearer;
19use crate::p2p::connectivity::wss_tls::{loopback_tls_wss, mint_ca};
20
21fn loc(b: u8) -> ObservedLocator {
22    ObservedLocator::from_slice(&[b]).unwrap()
23}
24
25/// CarrierReady is not SessionReady. SessionReady requires an Active binding.
26pub fn session_ready_without_qsession() -> Result<ConnState, String> {
27    Err("SessionReady requires QSession authentication".into())
28}
29
30/// TLS WSS + real ICE Binding + local TURN + QSession handshake + permit.
31pub fn session_ready_over_local_production_path() -> Result<SessionBinding, String> {
32    let mapped = local_binding_check().map_err(|e| format!("ice: {e}"))?;
33    if !mapped.ip().is_loopback() {
34        return Err("ice mapped not loopback".into());
35    }
36    let mut ice = IceAgent::new(IceRole::Controlling, PathPolicy::ORDINARY, true, true);
37    if !ice.mark_checked(CandidateKind::Host) || !ice.nominate(CandidateKind::Host, 0) {
38        return Err("ice nominate after check".into());
39    }
40    let forwarded = local_allocate_and_forward(b"turn-ok").map_err(|e| format!("turn: {e}"))?;
41    if forwarded != b"turn-ok" {
42        return Err("turn payload".into());
43    }
44
45    let ca = mint_ca().map_err(|e| format!("ca: {e}"))?;
46    let (client, server) = loopback_tls_wss(&ca).map_err(|e| format!("tls: {e}"))?;
47    let scope = ScopeEpoch { scope: 1, epoch: 1 };
48    let dest_b = loc(0x02);
49    let dest_a = loc(0x01);
50    let mut a = WssBearer::new(client, dest_a, dest_b, scope, true);
51    let mut b = WssBearer::new(server, dest_b, dest_a, scope, false);
52    let id_a = sha384(b"did:q42:a");
53    let id_b = sha384(b"did:q42:b");
54    let hs = handshake_over_fragments(&mut a, &mut b, &dest_b, &dest_a, &id_a, &id_b)
55        .map_err(|e| format!("qsession: {e:?}"))?;
56    if hs.client_fragments < 2 || hs.server_fragments < 2 {
57        return Err("handshake not fragmented".into());
58    }
59    if hs.keys.transcript_digest.is_zero() {
60        return Err("empty transcript".into());
61    }
62
63    let now = 1_700_000_000u64;
64    let mut owner = AuthorityOwner::new();
65    let binding = binding_for_controllers(b"did:q42:a", b"did:q42:b", b"q42:QSync/1", b"op-a")
66        .map_err(|e| format!("bind: {e:?}"))?;
67    let (_cred, _contact, handle) = owner
68        .install_grant(binding, now, now.saturating_add(3600), ContactState::Active)
69        .map_err(|e| format!("grant: {e:?}"))?;
70    let permit = owner
71        .issue_permit(handle, binding, now, 4096)
72        .map_err(|e| format!("permit: {e:?}"))?;
73    let keys = InstalledSessionKeys::new(
74        Generation(1),
75        hs.keys.initiator_to_responder,
76        hs.keys.responder_to_initiator,
77        true,
78    )
79    .map_err(|e| format!("keys: {e:?}"))?;
80    let session =
81        SessionBinding::from_permit(&permit, &keys, now).map_err(|e| format!("session: {e:?}"))?;
82    session
83        .admit_application()
84        .map_err(|e| format!("admit: {e:?}"))?;
85    if session.state() != SessionState::Active {
86        return Err("not Active".into());
87    }
88
89    let mut slot = ConnSlot::new(7);
90    slot.transition(1, ConnState::Establishing)
91        .map_err(|e| format!("{e:?}"))?;
92    slot.transition(1, ConnState::CarrierReady)
93        .map_err(|e| format!("{e:?}"))?;
94    slot.transition(1, ConnState::SessionReady)
95        .map_err(|e| format!("{e:?}"))?;
96    if slot.state != ConnState::SessionReady {
97        return Err("slot".into());
98    }
99    Ok(session)
100}
101
102#[cfg(test)]
103mod tests {
104    use super::*;
105
106    #[test]
107    fn carrier_ready_is_not_session_ready() {
108        assert!(session_ready_without_qsession().is_err());
109    }
110
111    #[test]
112    fn local_production_path_requires_qsession() {
113        let session = session_ready_over_local_production_path().unwrap();
114        assert_eq!(session.state(), SessionState::Active);
115        assert!(session.admit_application().is_ok());
116    }
117}