Skip to main content

qualia_core_db/poet_host/invoke/
qdnf_bridge.rs

1//! QDNF & Native SDN DNS Bridge for POET OS-Shell.
2//!
3//! Integrates QDNF Nym bearer, post-quantum IPC exchange, QDP front-door SDN DNS,
4//! protected contact state transitions, and identifier fabric plane separation.
5//! Adheres to AGENTS.md ยง0-B (< 320 lines).
6
7use crate::q_hash;
8use crate::NQuin;
9use crate::PermissiveRoutingLane;
10use crate::net::dns::quin_records::{encode_mx_record, encode_ns_record, OP_DNS_QDP_FRONT_DOOR};
11use crate::net::dns::sdn::{parse_front_door_txt, parse_ns_encoded_did};
12use crate::net::qdnf::authority::{Plane, TemporalGrant};
13use crate::net::qdnf::bearer::nym::{decapsulate_nym, encapsulate_nym, NYM_MAGIC, NYM_SPHINX_MTU};
14use crate::net::qdnf::contracts::identity::{
15    consume_as_person, consume_authority, infer_natural_person_from_handle,
16    inverse_functional_transfers_authority, same_as_transfers_authority, ReferentKind,
17};
18use crate::net::qdnf::fabric::{attempt_join, JoinAttempt, JoinKey};
19use crate::net::qdnf::registries::BearerProfile;
20use crate::net::qdnf::session::contact::{
21    admit_contact, admit_help, group_membership_is_private_consent, payment_bypasses_block,
22    revoke_mandate, ContactTable,
23};
24use crate::net::qdnf::types::{ObservedLocator, ProfileId, StrongDigest};
25use crate::net::qdnf::vertical::two_peer_ipc_exchange;
26use vibe::Value;
27
28/// Evaluates the QDNF Nym mixnet transition bearer and post-quantum vertical slice.
29pub fn evaluate_qdnf_nym_bearer(network: &str, peer_id: &str) -> Vec<(&'static str, Value)> {
30    let peer_bytes = peer_id.as_bytes();
31    let trunc_len = peer_bytes.len().min(32);
32    let locator = ObservedLocator::from_slice(&peer_bytes[..trunc_len])
33        .unwrap_or(ObservedLocator::EMPTY);
34
35    let mut env_buf = [0u8; 1024];
36    let enc_len = encapsulate_nym(&locator, b"QNYM-PROBE", &mut env_buf).unwrap_or(0);
37
38    let mut out_sender = ObservedLocator::EMPTY;
39    let mut dec_buf = [0u8; 1024];
40    let _ = decapsulate_nym(&env_buf[..enc_len], &mut out_sender, &mut dec_buf);
41
42    let pq_bytes = two_peer_ipc_exchange(b"qdnf-pq-check").unwrap_or(0);
43    let magic_str = std::str::from_utf8(&NYM_MAGIC).unwrap_or("QNYM");
44
45    vec![
46        ("qdnf_profile", Value::String("NymMixnetTransitionV1".into())),
47        ("qdnf_profile_code", Value::U64(BearerProfile::NymMixnetTransitionV1 as u64)),
48        ("nym_magic", Value::String(magic_str.into())),
49        ("nym_sphinx_mtu", Value::U64(NYM_SPHINX_MTU as u64)),
50        ("nym_envelope_bytes", Value::U64(enc_len as u64)),
51        ("qpr_suite", Value::String("qpr-pq-1 (ML-KEM-768 + X25519 + ChaCha20Poly1305)".into())),
52        ("qpr_vertical_slice_bytes", Value::U64(pq_bytes as u64)),
53        ("nym_network", Value::String(network.into())),
54    ]
55}
56
57/// Evaluates QDP Front-Door SDN DNS, bare-registrar NS records, and Super-Quin encoding.
58pub fn evaluate_qdnf_dns_front_door(
59    domain: &str,
60    front_door_did: &str,
61    agent_type: &str,
62    nym_locator: &str,
63) -> (Vec<(&'static str, Value)>, Option<NQuin>) {
64    let canonical_agent = match agent_type.to_ascii_lowercase().as_str() {
65        "naturalperson" | "person" => "person",
66        "organization" | "org" => "organization",
67        "device" | "agent" => "agent",
68        _ => "person",
69    };
70
71    let qdp_txt_clauses = format!(
72        "qdp:signer <{front_door_did}> ; qdp:agentType \"{canonical_agent}\" ; qdp:wireguard \"a1b2c3d4e5f60718\" ; qdp:overlay \"10.42.0.1\" ; qdp:nym \"{nym_locator}\" ; qdp:profile <https://{domain}/.well-known/QDP>"
73    );
74
75    let view = parse_front_door_txt(domain, &qdp_txt_clauses).unwrap_or_else(|_| {
76        let mut v = crate::net::dns::sdn::SdnFrontDoorView::empty(domain);
77        v.front_door_did = front_door_did;
78        v
79    });
80
81    let quin_opt = view.to_quin(3600, true);
82    let quin_parity_ok = quin_opt.as_ref().map(|q| q.verify_ecc_parity()).unwrap_or(false);
83
84    let did_suffix = front_door_did.strip_prefix("did:q42:").unwrap_or(front_door_did);
85    let ns_host = format!("ns1.{did_suffix}.webizen.network.");
86    let ns2_host = format!("ns2.{did_suffix}.webizen.network.");
87
88    let ns_ptr = parse_ns_encoded_did(&ns_host)
89        .and_then(|(_, ptr)| ptr)
90        .unwrap_or(0);
91
92    let _ns_quin = encode_ns_record(domain, &ns_host, 3600, PermissiveRoutingLane::PassthroughStandard);
93    let _mx_quin = encode_mx_record(domain, 10, &format!("mail.{domain}"), 3600, PermissiveRoutingLane::PassthroughStandard);
94
95    let pairs = vec![
96        ("dns_qdp_txt", Value::String(format!("_qdp.{domain}. 3600 IN TXT \"{qdp_txt_clauses}\""))),
97        ("qdp_txt_clauses", Value::String(qdp_txt_clauses)),
98        ("dns_ns1_record", Value::String(format!("{domain}. 3600 IN NS {ns_host}"))),
99        ("dns_ns2_record", Value::String(format!("{domain}. 3600 IN NS {ns2_host}"))),
100        ("ns_topological_pointer", Value::U64(ns_ptr)),
101        ("front_door_quin_opcode", Value::U64(OP_DNS_QDP_FRONT_DOOR as u64)),
102        ("front_door_parity_valid", Value::Bool(quin_parity_ok)),
103    ];
104
105    (pairs, quin_opt)
106}
107
108/// Evaluates QDNF contact gating, consent lifecycle, and reserved help slots.
109pub fn evaluate_qdnf_contact_gate(
110    peer_did: &str,
111    purpose_rel: &str,
112    action: &str,
113) -> Vec<(&'static str, Value)> {
114    let mut peer_d = StrongDigest::ZERO;
115    let ph = q_hash(peer_did);
116    peer_d.0[0..8].copy_from_slice(&ph.to_be_bytes());
117    peer_d.0[8] = 0x42;
118
119    let mut purpose_d = StrongDigest::ZERO;
120    let puh = q_hash(purpose_rel);
121    purpose_d.0[0..8].copy_from_slice(&puh.to_be_bytes());
122    purpose_d.0[8] = 0x42;
123
124    let mut table = ContactTable::new();
125    let grant = TemporalGrant {
126        purpose_digest: purpose_d,
127        audience_digest: StrongDigest::ZERO,
128        authority_generation: 1,
129        not_before_unix: 0,
130        expires_unix: u64::MAX,
131        profile: ProfileId::QDNF_CRYPTO_1,
132    };
133
134    let (state_str, admitted) = match action {
135        "send_request" | "request" => {
136            let _ = table.insert_request(peer_d, purpose_d, false, 1);
137            ("Request", false)
138        }
139        "consent" => {
140            let _ = table.insert_request(peer_d, purpose_d, false, 1);
141            let _ = table.consent(peer_d);
142            ("Consent", false)
143        }
144        "accept_connect" | "activate" => {
145            let _ = table.insert_request(peer_d, purpose_d, false, 1);
146            let _ = table.consent(peer_d);
147            let _ = table.activate(peer_d);
148            let ok = admit_contact(&table, peer_d, purpose_d, false, 100, &grant).is_ok();
149            ("Active", ok)
150        }
151        "suspend" => {
152            let _ = table.insert_request(peer_d, purpose_d, false, 1);
153            let _ = table.consent(peer_d);
154            let _ = table.activate(peer_d);
155            let _ = table.suspend(peer_d);
156            ("Suspended", false)
157        }
158        "block" => {
159            let _ = table.insert_request(peer_d, purpose_d, false, 1);
160            let _ = table.block(peer_d);
161            ("Blocked", false)
162        }
163        "revoke_mandate" => {
164            let _ = table.insert_request(peer_d, purpose_d, false, 1);
165            let _ = revoke_mandate(&mut table, peer_d, 1);
166            ("Blocked", false)
167        }
168        "admit_help" => {
169            let ok = admit_help(&mut table, peer_d).is_ok();
170            ("HelpAdmitted", ok)
171        }
172        _ => {
173            let _ = table.insert_request(peer_d, purpose_d, false, 1);
174            ("Request", false)
175        }
176    };
177
178    vec![
179        ("qdnf_contact_state", Value::String(state_str.into())),
180        ("qdnf_contact_admitted", Value::Bool(admitted)),
181        ("qdnf_contact_slots_max", Value::U64(16)),
182        ("qdnf_help_slots_reserved", Value::U64(2)),
183        ("payment_bypasses_block", Value::Bool(payment_bypasses_block())),
184        ("group_membership_is_private_consent", Value::Bool(group_membership_is_private_consent())),
185    ]
186}
187
188/// Evaluates identifier fabric planes and verifies strict personhood separation.
189pub fn evaluate_qdnf_identifier_fabric(_identifier_did: &str) -> Vec<(&'static str, Value)> {
190    let auth_handle = consume_authority(ReferentKind::Handle).is_err();
191    let auth_inst = consume_authority(ReferentKind::Instrument).is_err();
192    let person_handle = consume_as_person(ReferentKind::Handle).is_err();
193    let person_inst = consume_as_person(ReferentKind::Instrument).is_err();
194
195    let join_did = attempt_join(JoinAttempt {
196        left: Plane::Entity,
197        right: Plane::Instrument,
198        key: JoinKey::Did,
199    }).is_err();
200
201    let join_wallet = attempt_join(JoinAttempt {
202        left: Plane::Entity,
203        right: Plane::Instrument,
204        key: JoinKey::Wallet,
205    }).is_err();
206
207    let did_wallet_refused = join_did && join_wallet;
208    let handle_not_person = person_handle && person_inst && auth_handle && auth_inst;
209
210    vec![
211        ("fabric_plane_separation", Value::String("FND-02.01: Entity | Claim | Handle | Instrument | NaturalPerson".into())),
212        ("handle_is_person", Value::Bool(!handle_not_person)),
213        ("same_as_transfers_authority", Value::Bool(same_as_transfers_authority())),
214        ("infer_natural_person_from_handle", Value::Bool(infer_natural_person_from_handle())),
215        ("inverse_functional_transfers_authority", Value::Bool(inverse_functional_transfers_authority())),
216        ("did_wallet_join_refused", Value::Bool(did_wallet_refused)),
217    ]
218}
219
220#[cfg(test)]
221mod tests {
222    use super::*;
223
224    #[test]
225    fn test_qdnf_nym_bearer() {
226        let pairs = evaluate_qdnf_nym_bearer("sandbox", "peer_node_42");
227        assert!(pairs.iter().any(|(k, v)| *k == "nym_magic" && v == &Value::String("QNYM".into())));
228        assert!(pairs.iter().any(|(k, v)| *k == "nym_sphinx_mtu" && v == &Value::U64(1024)));
229    }
230
231    #[test]
232    fn test_qdnf_dns_front_door() {
233        let (pairs, quin) = evaluate_qdnf_dns_front_door(
234            "personal.webizen.example",
235            "did:q42:testfront",
236            "NaturalPerson",
237            "nym:sandbox:1234@gw",
238        );
239        assert!(quin.is_some());
240        assert!(pairs.iter().any(|(k, v)| *k == "front_door_parity_valid" && v == &Value::Bool(true)));
241        assert!(pairs.iter().any(|(k, _)| *k == "dns_ns1_record"));
242    }
243
244    #[test]
245    fn test_qdnf_contact_gate() {
246        let pairs = evaluate_qdnf_contact_gate("did:q42:peer_bob", "spc:Collaboration", "accept_connect");
247        assert!(pairs.iter().any(|(k, v)| *k == "qdnf_contact_state" && v == &Value::String("Active".into())));
248        assert!(pairs.iter().any(|(k, v)| *k == "qdnf_contact_admitted" && v == &Value::Bool(true)));
249    }
250
251    #[test]
252    fn test_qdnf_identifier_fabric() {
253        let pairs = evaluate_qdnf_identifier_fabric("did:q42:alice");
254        assert!(pairs.iter().any(|(k, v)| *k == "handle_is_person" && v == &Value::Bool(false)));
255        assert!(pairs.iter().any(|(k, v)| *k == "did_wallet_join_refused" && v == &Value::Bool(true)));
256    }
257}