1use qualia_core_db::identifier::parse_did_q42;
38use qualia_core_db::net::dns::sdn::parse_ns_encoded_did;
39#[cfg(not(target_arch = "wasm32"))]
40use qualia_core_db::net::dns::{QualiaDnsResolver, ResolverConfig};
41use reqwest::Client;
42use serde::Deserialize;
43
44#[derive(Debug)]
48pub struct ResolvedIdentity {
49 pub did: String,
51 pub q42_pointer: Option<u64>,
53 pub webid: Option<String>,
55 pub source: ResolutionSource,
57}
58
59#[derive(Debug, PartialEq)]
60pub enum ResolutionSource {
61 LocalQ42,
63 NsEncoding,
65 QdpHttp,
67 DnsTxt,
69}
70
71pub async fn resolve_qdp_did(domain_or_did: &str) -> Result<String, String> {
75 resolve_identity(domain_or_did).await.map(|r| r.did)
76}
77
78pub async fn resolve_identity(input: &str) -> Result<ResolvedIdentity, String> {
80 let input = input.trim();
81
82 if input.starts_with("did:q42:") {
84 let pointer =
85 parse_did_q42(input.as_bytes()).map_err(|e| format!("Invalid did:q42 URI: {:?}", e))?;
86 return Ok(ResolvedIdentity {
87 did: input.to_string(),
88 q42_pointer: Some(pointer),
89 webid: None,
90 source: ResolutionSource::LocalQ42,
91 });
92 }
93
94 if input.starts_with("did:") {
96 return Ok(ResolvedIdentity {
97 did: input.to_string(),
98 q42_pointer: None,
99 webid: None,
100 source: ResolutionSource::LocalQ42,
101 });
102 }
103
104 if let Ok(Some(identity)) = resolve_via_ns_encoding(input).await {
106 return Ok(identity);
107 }
108
109 if let Ok(profile) = fetch_qdp_profile(input).await {
111 let did = profile
112 .front_door_did
113 .or_else(|| profile.webid.clone())
114 .ok_or_else(|| format!("QDP profile at {} has no DID", input))?;
115
116 let q42_pointer = if did.starts_with("did:q42:") {
117 parse_did_q42(did.as_bytes()).ok()
118 } else {
119 None
120 };
121
122 return Ok(ResolvedIdentity {
123 webid: profile.webid,
124 q42_pointer,
125 did,
126 source: ResolutionSource::QdpHttp,
127 });
128 }
129
130 let did = verify_front_door_did_via_dns(input)
132 .await
133 .map_err(|e| format!("All resolution tiers failed for '{}'. Last: {}", input, e))?;
134
135 let q42_pointer = if did.starts_with("did:q42:") {
136 parse_did_q42(did.as_bytes()).ok()
137 } else {
138 None
139 };
140
141 Ok(ResolvedIdentity {
142 did,
143 q42_pointer,
144 webid: None,
145 source: ResolutionSource::DnsTxt,
146 })
147}
148
149async fn resolve_via_ns_encoding(domain: &str) -> Result<Option<ResolvedIdentity>, String> {
156 #[derive(Deserialize)]
157 struct DohResponse {
158 #[serde(rename = "Answer")]
159 answer: Option<Vec<DohRecord>>,
160 }
161 #[derive(Deserialize)]
162 struct DohRecord {
163 #[serde(rename = "type")]
164 record_type: u16,
165 data: String,
166 }
167
168 let url = format!(
169 "https://cloudflare-dns.com/dns-query?name={}&type=NS",
170 domain
171 );
172
173 let client = Client::builder()
174 .timeout(std::time::Duration::from_secs(5))
175 .build()
176 .map_err(|e| e.to_string())?;
177
178 let resp: DohResponse = client
179 .get(&url)
180 .header("Accept", "application/dns-json")
181 .send()
182 .await
183 .map_err(|e| format!("NS DoH request failed: {}", e))?
184 .json()
185 .await
186 .map_err(|e| format!("NS DoH parse failed: {}", e))?;
187
188 const NS_TYPE: u16 = 2;
189 for record in resp.answer.unwrap_or_default() {
190 if record.record_type != NS_TYPE {
191 continue;
192 }
193 let ns = record.data.trim_end_matches('.');
194 if let Some((payload, q42_pointer)) = parse_ns_encoded_did(ns) {
195 let did = if payload.starts_with("did:") {
196 payload.to_string()
197 } else {
198 format!("did:q42:{}", payload)
199 };
200
201 return Ok(Some(ResolvedIdentity {
202 did,
203 q42_pointer,
204 webid: None,
205 source: ResolutionSource::NsEncoding,
206 }));
207 }
208 }
209
210 Ok(None)
211}
212
213#[derive(Debug)]
217pub struct QdpProfile {
218 pub domain: String,
219 pub webid: Option<String>,
221 pub front_door_did: Option<String>,
223 pub raw: String,
224}
225
226pub async fn fetch_qdp_profile(domain: &str) -> Result<QdpProfile, String> {
228 let domain = domain
229 .trim_start_matches("https://")
230 .trim_start_matches("http://");
231
232 let client = Client::builder()
233 .timeout(std::time::Duration::from_secs(10))
234 .build()
235 .map_err(|e| format!("HTTP client error: {}", e))?;
236
237 let response = client
238 .get(format!("https://{}/.well-known/QDP", domain))
239 .header(
240 "Accept",
241 "application/ld+json, text/turtle;q=0.9, */*;q=0.5",
242 )
243 .send()
244 .await
245 .map_err(|e| format!("QDP fetch failed for {}: {}", domain, e))?;
246
247 if !response.status().is_success() {
248 return Err(format!("QDP {} for {}", response.status(), domain));
249 }
250
251 let body = response
252 .text()
253 .await
254 .map_err(|e| format!("QDP body read error: {}", e))?;
255
256 Ok(parse_qdp_body(domain, &body))
257}
258
259fn parse_qdp_body(domain: &str, body: &str) -> QdpProfile {
260 let mut webid: Option<String> = None;
261 let mut front_door_did: Option<String> = None;
262
263 for line in body.lines() {
264 let line = line.trim();
265
266 if line.contains("hasWebID") || line.contains("QDP:webid") || line.contains("foaf:openid") {
267 if let Some(uri) =
268 extract_angle_bracket_uri(line).or_else(|| extract_json_string_uri(line))
269 {
270 if webid.is_none() {
271 webid = Some(uri);
272 }
273 }
274 }
275
276 if line.contains("qdp:signer") || line.contains("QDP:frontDoorDid") {
277 if let Some(did) =
278 extract_angle_bracket_uri(line).or_else(|| extract_did_from_text(line))
279 {
280 front_door_did = Some(did);
281 }
282 }
283
284 if line.contains("did:") {
286 if let Some(did) = extract_did_from_text(line) {
287 if front_door_did.is_none() || did.starts_with("did:q42:") {
288 front_door_did = Some(did);
289 }
290 }
291 }
292 }
293
294 QdpProfile {
295 domain: domain.to_string(),
296 webid,
297 front_door_did,
298 raw: body.to_string(),
299 }
300}
301
302pub async fn verify_front_door_did_via_dns(domain: &str) -> Result<String, String> {
307 #[cfg(not(target_arch = "wasm32"))]
309 {
310 let resolver = QualiaDnsResolver::new(ResolverConfig::default());
311 let mut txt_storage = [0u8; 512];
312 if let Ok(view) = resolver.resolve_sdn_front_door(domain, &mut txt_storage) {
313 if !view.front_door_did.is_empty() {
314 return Ok(view.front_door_did.to_string());
315 }
316 }
317 }
318
319 #[derive(Deserialize)]
321 struct DohResponse {
322 #[serde(rename = "Answer")]
323 answer: Option<Vec<DohRecord>>,
324 }
325 #[derive(Deserialize)]
326 struct DohRecord {
327 #[serde(rename = "type")]
328 record_type: u16,
329 data: String,
330 }
331
332 let lookup = format!("_qdp.{}", domain.trim_start_matches("_qdp."));
333 let url = format!(
334 "https://cloudflare-dns.com/dns-query?name={}&type=TXT",
335 lookup
336 );
337
338 let client = Client::builder()
339 .timeout(std::time::Duration::from_secs(5))
340 .build()
341 .map_err(|e| e.to_string())?;
342
343 let resp: DohResponse = client
344 .get(&url)
345 .header("Accept", "application/dns-json")
346 .send()
347 .await
348 .map_err(|e| format!("DoH request failed: {}", e))?
349 .json()
350 .await
351 .map_err(|e| format!("DoH parse failed: {}", e))?;
352
353 const TXT: u16 = 16;
354 for record in resp.answer.unwrap_or_default() {
355 if record.record_type == TXT {
356 let txt = record.data.trim_matches('"');
357 if txt.contains("qdp:signer") || txt.contains("did:") {
358 if let Some(did) = extract_did_from_text(txt) {
359 return Ok(did);
360 }
361 }
362 }
363 }
364
365 Err(format!("No Front Door DID in _qdp TXT for {}", domain))
366}
367
368pub fn encode_did_for_ns(did: &str) -> Option<String> {
379 if did.starts_with("did:q42:") {
380 let payload = did.trim_start_matches("did:q42:");
381 let safe: String = payload
385 .chars()
386 .filter(|c| c.is_ascii_alphanumeric() || *c == '-')
387 .take(63)
388 .collect::<String>()
389 .to_lowercase();
390 if safe.is_empty() {
391 None
392 } else {
393 Some(safe)
394 }
395 } else {
396 None
397 }
398}
399
400pub const WEBIZEN_NS_SUFFIX: &str = ".webizen.network";
401
402pub fn ns_records_for_did(did: &str) -> Option<(String, String)> {
407 let payload = encode_did_for_ns(did)?;
408 Some((
409 format!("ns1.{payload}{WEBIZEN_NS_SUFFIX}"),
410 format!("ns2.{payload}{WEBIZEN_NS_SUFFIX}"),
411 ))
412}
413
414fn extract_angle_bracket_uri(text: &str) -> Option<String> {
417 let start = text.find('<')? + 1;
418 let end = text[start..].find('>')? + start;
419 let uri = text[start..end].trim().to_string();
420 if uri.starts_with("http") || uri.starts_with("did:") || uri.starts_with("urn:") {
421 Some(uri)
422 } else {
423 None
424 }
425}
426
427fn extract_json_string_uri(text: &str) -> Option<String> {
428 let colon = text.find(": \"")?;
429 let rest = &text[colon + 3..];
430 let end = rest.find('"')?;
431 let uri = rest[..end].to_string();
432 if uri.starts_with("http") || uri.starts_with("did:") {
433 Some(uri)
434 } else {
435 None
436 }
437}
438
439fn extract_did_from_text(text: &str) -> Option<String> {
440 let start = text.find("did:")?;
441 let rest = &text[start..];
442 let end = rest
443 .find(|c: char| c.is_whitespace() || c == '>' || c == '"' || c == ')')
444 .unwrap_or(rest.len());
445 let did = rest[..end].trim_end_matches(['.', ',', ';']).to_string();
446 if did.len() > 4 {
447 Some(did)
448 } else {
449 None
450 }
451}
452
453#[cfg(test)]
456mod tests {
457 use super::*;
458
459 #[test]
460 fn ns_encoding_roundtrip() {
461 let did = "did:q42:z6MkpTHR8VNs";
462 let (ns1, ns2) = ns_records_for_did(did).unwrap();
463 assert!(ns1.starts_with("ns1."));
464 assert!(ns1.ends_with(WEBIZEN_NS_SUFFIX));
465 assert!(ns2.starts_with("ns2."));
466
467 let without_suffix = &ns1[..ns1.len() - WEBIZEN_NS_SUFFIX.len()];
469 let payload = without_suffix.strip_prefix("ns1.").unwrap();
470 let reconstructed = format!("did:q42:{}", payload);
471 assert!(
473 reconstructed.starts_with("did:q42:z6mk"),
474 "got: {}",
475 reconstructed
476 );
477 }
478
479 #[test]
480 fn encode_did_strips_prefix() {
481 let encoded = encode_did_for_ns("did:q42:z6MkABC").unwrap();
482 assert_eq!(encoded, "z6mkabc");
483 }
484
485 #[test]
486 fn encode_non_q42_returns_none() {
487 assert!(encode_did_for_ns("did:web:example.com").is_none());
488 }
489
490 #[test]
491 fn did_q42_passthrough_is_local() {
492 let input = "did:q42:z6MkpTHR8VNs";
495 assert!(input.starts_with("did:q42:"));
496 }
497}