qualia_core_db/p2p/connectivity/
establish.rs1#![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
25pub fn session_ready_without_qsession() -> Result<ConnState, String> {
27 Err("SessionReady requires QSession authentication".into())
28}
29
30pub 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}