1use 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
28pub 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
57pub 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
108pub 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
188pub 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}