1use anyhow::{anyhow, bail, Result};
29use async_trait::async_trait;
30use serde::de::{self, Deserialize, Deserializer, MapAccess, SeqAccess, Visitor};
31use serde_json::Value;
32
33use crate::did_url::percent_decode;
34use crate::registry::SocketKind;
35use crate::resolver::Resolver;
36use crate::service_entry::{decode_service_entry, DecodedEntry};
37use crate::transport::{EndpointType, TransportConfig};
38
39pub(crate) fn parse_did_document_no_duplicates(body: &[u8], url: &str) -> Result<Value> {
44 serde_json::from_slice::<NoDuplicateJson>(body)
45 .map(|document| document.0)
46 .map_err(|e| anyhow!("DID document at {url} is invalid or ambiguous JSON: {e}"))
47}
48
49struct NoDuplicateJson(Value);
50
51impl<'de> Deserialize<'de> for NoDuplicateJson {
52 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
53 where
54 D: Deserializer<'de>,
55 {
56 struct NoDuplicateVisitor;
57
58 impl<'de> Visitor<'de> for NoDuplicateVisitor {
59 type Value = Value;
60
61 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
62 formatter.write_str("valid JSON without duplicate object keys")
63 }
64
65 fn visit_bool<E: de::Error>(self, value: bool) -> std::result::Result<Value, E> {
66 Ok(Value::Bool(value))
67 }
68
69 fn visit_i64<E: de::Error>(self, value: i64) -> std::result::Result<Value, E> {
70 Ok(Value::Number(value.into()))
71 }
72
73 fn visit_u64<E: de::Error>(self, value: u64) -> std::result::Result<Value, E> {
74 Ok(Value::Number(value.into()))
75 }
76
77 fn visit_f64<E: de::Error>(self, value: f64) -> std::result::Result<Value, E> {
78 serde_json::Number::from_f64(value)
79 .map(Value::Number)
80 .ok_or_else(|| E::custom("JSON number is not finite"))
81 }
82
83 fn visit_str<E: de::Error>(self, value: &str) -> std::result::Result<Value, E> {
84 Ok(Value::String(value.to_owned()))
85 }
86
87 fn visit_string<E: de::Error>(self, value: String) -> std::result::Result<Value, E> {
88 Ok(Value::String(value))
89 }
90
91 fn visit_none<E: de::Error>(self) -> std::result::Result<Value, E> {
92 Ok(Value::Null)
93 }
94
95 fn visit_unit<E: de::Error>(self) -> std::result::Result<Value, E> {
96 Ok(Value::Null)
97 }
98
99 fn visit_seq<A: SeqAccess<'de>>(
100 self,
101 mut seq: A,
102 ) -> std::result::Result<Value, A::Error> {
103 let mut values = Vec::new();
104 while let Some(value) = seq.next_element::<NoDuplicateJson>()? {
105 values.push(value.0);
106 }
107 Ok(Value::Array(values))
108 }
109
110 fn visit_map<A: MapAccess<'de>>(
111 self,
112 mut map: A,
113 ) -> std::result::Result<Value, A::Error> {
114 let mut keys = std::collections::HashSet::new();
115 let mut values = serde_json::Map::new();
116 while let Some(key) = map.next_key::<String>()? {
117 if !keys.insert(key.clone()) {
118 return Err(de::Error::custom(format!(
119 "duplicate JSON object key `{key}`"
120 )));
121 }
122 let value = map.next_value::<NoDuplicateJson>()?;
123 values.insert(key, value.0);
124 }
125 Ok(Value::Object(values))
126 }
127 }
128
129 deserializer.deserialize_any(NoDuplicateVisitor).map(Self)
130 }
131}
132
133pub fn did_web_to_url(did: &str) -> Result<String> {
150 let did = did.split(['#', '?']).next().unwrap_or(did);
152 let msi = did
153 .strip_prefix("did:web:")
154 .ok_or_else(|| anyhow!("not a did:web identifier: {did}"))?;
155 if msi.is_empty() {
156 bail!("did:web has empty method-specific identifier: {did}");
157 }
158
159 let mut segments = msi.split(':');
161 let host_raw = segments.next().unwrap_or_default();
162 let host = percent_decode(host_raw)?;
163 if host.is_empty() {
164 bail!("did:web has empty host: {did}");
165 }
166 validate_host_segment(&host, did)?;
171
172 let mut path_segments: Vec<String> = Vec::new();
179 for raw in segments.filter(|s| !s.is_empty()) {
180 let seg = percent_decode(raw)?;
181 validate_path_segment(&seg, did)?;
182 path_segments.push(seg);
183 }
184
185 if path_segments.is_empty() {
186 Ok(format!("https://{host}/.well-known/did.json"))
188 } else {
189 Ok(format!(
191 "https://{host}/{}/did.json",
192 path_segments.join("/")
193 ))
194 }
195}
196
197fn validate_host_segment(host: &str, did: &str) -> Result<()> {
203 if host.contains(['/', '\\', '\0']) {
204 bail!("did:web host contains an illegal character (`/`, `\\`, or NUL): {did}");
205 }
206 Ok(())
207}
208
209fn validate_path_segment(seg: &str, did: &str) -> Result<()> {
216 if seg.is_empty() || seg == "." || seg == ".." {
217 bail!("did:web path segment is empty, `.`, or `..` (traversal): {did}");
218 }
219 if seg.contains(['/', '\\', '\0']) {
220 bail!("did:web path segment contains an illegal character (`/`, `\\`, or NUL): {did}");
221 }
222 Ok(())
223}
224
225pub fn transport_entries(doc: &Value) -> Vec<DecodedEntry> {
241 let Some(services) = doc.get("service").and_then(Value::as_array) else {
242 return Vec::new();
243 };
244
245 let mut ranked: Vec<(u8, usize, DecodedEntry)> = Vec::new();
247 for (idx, entry) in services.iter().enumerate() {
248 let ty = entry
249 .get("type")
250 .and_then(Value::as_str)
251 .unwrap_or_default();
252 let rank = match ty {
253 "IrohTransport" => 0,
254 "QuicTransport" => 1,
255 "OnionTransport" => {
256 tracing::debug!(
264 service_type = %ty,
265 "skipping OnionTransport DID-doc reach: onion is not yet dialable (no EndpointType::Onion)"
266 );
267 continue;
268 }
269 _ => continue,
271 };
272 match decode_service_entry(entry) {
276 Ok(decoded) => ranked.push((rank, idx, decoded)),
277 Err(e) => {
278 tracing::debug!(error = %e, service_type = %ty, "skipping undecodable transport service entry");
279 }
280 }
281 }
282
283 ranked.sort_by_key(|(rank, idx, _)| (*rank, *idx));
285 ranked.into_iter().map(|(_, _, d)| d).collect()
286}
287
288pub fn preferred_transport(doc: &Value, kind: Option<SocketKind>) -> Option<TransportConfig> {
296 let entries = transport_entries(doc);
297 entries
298 .into_iter()
299 .find(|d| match kind {
300 Some(SocketKind::Quic) => matches!(d.config.endpoint, EndpointType::Quic { .. }),
301 Some(_) => false,
304 None => true,
305 })
306 .map(|d| d.config)
307}
308
309pub use crate::did_key::{
319 decode_ed25519_multikey, decode_multikey, did_key_to_ed25519, ed25519_to_did_key,
320 MULTICODEC_ML_DSA_65_PUB,
321};
322#[cfg(test)]
324use crate::did_key::MULTICODEC_ED25519_PUB;
325
326pub fn is_did_key(did: &str) -> bool {
332 did.starts_with("did:key:")
333}
334
335pub fn verification_method_ed25519_keys(doc: &Value) -> Vec<[u8; 32]> {
346 let Some(vms) = doc.get("verificationMethod").and_then(Value::as_array) else {
347 return Vec::new();
348 };
349 let mut keys = Vec::new();
350 for vm in vms {
351 let Some(mb) = vm.get("publicKeyMultibase").and_then(Value::as_str) else {
352 continue;
353 };
354 match decode_ed25519_multikey(mb) {
355 Ok(k) => keys.push(k),
356 Err(e) => {
357 tracing::debug!(error = %e, "skipping undecodable verificationMethod Multikey");
358 }
359 }
360 }
361 keys
362}
363
364const MULTICODEC_X25519_PUB: [u8; 2] = [0xec, 0x01];
367const MULTICODEC_ML_KEM_768_PUB: [u8; 2] = [0x8c, 0x24];
369
370pub fn mesh_kem_recipient(doc: &Value) -> Option<crate::crypto::hybrid_kem::RecipientPublic> {
380 let kas = doc.get("keyAgreement")?.as_array()?;
381 let mut x25519: Option<Vec<u8>> = None;
382 let mut mlkem768: Option<Vec<u8>> = None;
383 for vm in kas {
384 let mb = vm.get("publicKeyMultibase").and_then(Value::as_str)?;
385 let payload = bs58::decode(mb.strip_prefix('z')?).into_vec().ok()?;
386 let (codec, key) = payload.split_at_checked(2)?;
387 match codec {
388 c if c == MULTICODEC_X25519_PUB => {
389 if x25519.replace(key.to_vec()).is_some() {
390 return None; }
392 }
393 c if c == MULTICODEC_ML_KEM_768_PUB => {
394 if mlkem768.replace(key.to_vec()).is_some() {
395 return None;
396 }
397 }
398 _ => return None, }
400 }
401 let recipient = crate::crypto::hybrid_kem::RecipientPublic {
402 suite_id: crate::crypto::hybrid_kem::SuiteId::HyKemX25519MlKem768,
403 eks: vec![x25519?, mlkem768?],
404 };
405 recipient.validate().ok()?;
406 Some(recipient)
407}
408
409pub fn verification_method_ml_dsa_65_keys(
426 doc: &Value,
427) -> Vec<crate::crypto::pq::MlDsaVerifyingKey> {
428 let Some(vms) = doc.get("verificationMethod").and_then(Value::as_array) else {
429 return Vec::new();
430 };
431 let mut keys = Vec::new();
432 for vm in vms {
433 let Some(mb) = vm.get("publicKeyMultibase").and_then(Value::as_str) else {
434 continue;
435 };
436 let raw = match decode_multikey(mb, &MULTICODEC_ML_DSA_65_PUB) {
439 Ok(raw) => raw,
440 Err(_) => continue,
441 };
442 match crate::crypto::pq::ml_dsa_vk_from_bytes(&raw) {
443 Ok(vk) => keys.push(vk),
444 Err(e) => {
445 tracing::debug!(error = %e, "skipping ml-dsa-65 verificationMethod: not a valid ML-DSA-65 key");
446 }
447 }
448 }
449 keys
450}
451
452pub fn jwks_ed25519_keys(jwks: &Value) -> Vec<[u8; 32]> {
466 use base64::{engine::general_purpose::URL_SAFE_NO_PAD, Engine};
467 let Some(keys) = jwks.get("keys").and_then(Value::as_array) else {
468 return Vec::new();
469 };
470 let mut out = Vec::new();
471 for key in keys {
472 if key.get("kty").and_then(Value::as_str) != Some("OKP") {
473 continue;
474 }
475 if key.get("crv").and_then(Value::as_str) != Some("Ed25519") {
476 continue;
477 }
478 let Some(x) = key.get("x").and_then(Value::as_str) else {
479 continue;
480 };
481 match URL_SAFE_NO_PAD
482 .decode(x)
483 .ok()
484 .and_then(|raw| <[u8; 32]>::try_from(raw).ok())
485 {
486 Some(k) => out.push(k),
487 None => {
488 tracing::debug!("skipping JWKS OKP/Ed25519 key with malformed/wrong-length 'x'");
489 }
490 }
491 }
492 out
493}
494
495#[async_trait]
503pub trait DidDocFetcher: Send + Sync {
504 async fn fetch(&self, url: &str) -> Result<Value>;
506}
507
508pub struct DidWebResolver<F: DidDocFetcher> {
519 fetcher: F,
520}
521
522impl<F: DidDocFetcher> DidWebResolver<F> {
523 pub fn new(fetcher: F) -> Self {
525 Self { fetcher }
526 }
527
528 pub async fn resolve_all(&self, did: &str) -> Result<Vec<DecodedEntry>> {
532 let url = did_web_to_url(did)?;
533 let doc = self.fetcher.fetch(&url).await?;
534 Ok(transport_entries(&doc))
535 }
536
537 pub async fn resolve_document(&self, did: &str) -> Result<Value> {
544 let url = did_web_to_url(did)?;
545 self.fetcher.fetch(&url).await
546 }
547}
548
549#[async_trait]
550impl<F: DidDocFetcher> Resolver for DidWebResolver<F> {
551 async fn resolve(&self, name: &str, kind: SocketKind) -> Result<TransportConfig> {
552 let url = did_web_to_url(name)?;
553 let doc = self.fetcher.fetch(&url).await?;
554 preferred_transport(&doc, Some(kind)).ok_or_else(|| {
555 anyhow!("did:web {name}: no dialable {kind:?} transport reach in DID document")
556 })
557 }
558}
559
560pub struct ChainedResolver {
569 primary: std::sync::Arc<dyn Resolver>,
570 fallback: std::sync::Arc<dyn Resolver>,
571}
572
573impl ChainedResolver {
574 pub fn new(
576 primary: std::sync::Arc<dyn Resolver>,
577 fallback: std::sync::Arc<dyn Resolver>,
578 ) -> Self {
579 Self { primary, fallback }
580 }
581}
582
583#[async_trait]
584impl Resolver for ChainedResolver {
585 async fn resolve(&self, name: &str, kind: SocketKind) -> Result<TransportConfig> {
586 match self.primary.resolve(name, kind).await {
587 Ok(cfg) => Ok(cfg),
588 Err(primary_err) => self.fallback.resolve(name, kind).await.map_err(|fb_err| {
589 anyhow!(
590 "resolve {name}: primary failed ({primary_err}); fallback failed ({fb_err})"
591 )
592 }),
593 }
594 }
595}
596
597pub fn install_chained<F: DidDocFetcher + 'static>(did_web: DidWebResolver<F>) {
605 let did_web: std::sync::Arc<dyn Resolver> = std::sync::Arc::new(did_web);
606 match crate::resolver::try_global() {
607 Some(existing) => {
608 crate::resolver::set_global(std::sync::Arc::new(ChainedResolver::new(
609 did_web, existing,
610 )));
611 }
612 None => crate::resolver::set_global(did_web),
613 }
614}
615
616const MAX_DID_DOC_BYTES: usize = 1024 * 1024;
622
623const MAX_CACHE_ENTRIES: usize = 256;
628
629pub struct HttpDidDocFetcher {
653 http: reqwest::Client,
654 cache: parking_lot::Mutex<std::collections::HashMap<String, CachedDoc>>,
655 ttl: std::time::Duration,
656}
657
658struct CachedDoc {
659 doc: Value,
660 fetched_at: std::time::Instant,
661}
662
663impl HttpDidDocFetcher {
664 pub fn new(ttl: std::time::Duration) -> Result<Self> {
671 Self::build(ttl, None)
672 }
673
674 pub fn with_extra_root(ttl: std::time::Duration, extra_root_pem: &[u8]) -> Result<Self> {
681 Self::build(ttl, Some(extra_root_pem))
682 }
683
684 fn build(ttl: std::time::Duration, extra_root_pem: Option<&[u8]>) -> Result<Self> {
685 let mut builder = reqwest::Client::builder()
686 .redirect(reqwest::redirect::Policy::none())
689 .connect_timeout(std::time::Duration::from_secs(10))
691 .timeout(std::time::Duration::from_secs(10));
692 if let Some(pem) = extra_root_pem {
693 let cert = reqwest::Certificate::from_pem(pem).map_err(|e| {
694 anyhow!("extra did:web TLS root is not a valid PEM certificate: {e}")
695 })?;
696 builder = builder.add_root_certificate(cert);
697 }
698 let http = builder
699 .build()
700 .map_err(|e| anyhow!("failed to build did:web HTTPS client: {e}"))?;
701 Ok(Self {
702 http,
703 cache: parking_lot::Mutex::new(std::collections::HashMap::new()),
704 ttl,
705 })
706 }
707}
708
709impl Default for HttpDidDocFetcher {
710 #[allow(clippy::expect_used)]
714 fn default() -> Self {
715 Self::new(std::time::Duration::from_secs(3600))
717 .expect("did:web HTTPS client must build with the default configuration")
718 }
719}
720
721#[async_trait]
722impl DidDocFetcher for HttpDidDocFetcher {
723 async fn fetch(&self, url: &str) -> Result<Value> {
724 if !url.starts_with("https://") {
726 bail!("did:web document URL must use https:// (got {url})");
727 }
728
729 {
731 let cache = self.cache.lock();
732 if let Some(entry) = cache.get(url) {
733 if entry.fetched_at.elapsed() < self.ttl {
734 return Ok(entry.doc.clone());
735 }
736 }
737 }
738
739 let resp = self.http.get(url).send().await?.error_for_status()?;
741 let body = read_capped(resp, MAX_DID_DOC_BYTES).await?;
742 let doc = parse_did_document_no_duplicates(&body, url)?;
743
744 {
745 let mut cache = self.cache.lock();
746 evict_for_insert(&mut cache, self.ttl);
747 cache.insert(
748 url.to_owned(),
749 CachedDoc {
750 doc: doc.clone(),
751 fetched_at: std::time::Instant::now(),
752 },
753 );
754 }
755 Ok(doc)
756 }
757}
758
759async fn read_capped(resp: reqwest::Response, max: usize) -> Result<Vec<u8>> {
763 use futures::StreamExt;
764
765 if let Some(len) = resp.content_length() {
767 if len > max as u64 {
768 bail!("did:web document exceeds {max}-byte cap (Content-Length {len})");
769 }
770 }
771
772 let mut buf: Vec<u8> = Vec::new();
773 let mut stream = resp.bytes_stream();
774 while let Some(chunk) = stream.next().await {
775 let chunk = chunk?;
776 push_capped(&mut buf, &chunk, max)?;
777 }
778 Ok(buf)
779}
780
781fn push_capped(buf: &mut Vec<u8>, chunk: &[u8], max: usize) -> Result<()> {
785 if buf.len() + chunk.len() > max {
787 bail!("did:web document exceeds {max}-byte cap");
788 }
789 buf.extend_from_slice(chunk);
790 Ok(())
791}
792
793fn evict_for_insert(
797 cache: &mut std::collections::HashMap<String, CachedDoc>,
798 ttl: std::time::Duration,
799) {
800 cache.retain(|_, entry| entry.fetched_at.elapsed() < ttl);
802
803 while cache.len() >= MAX_CACHE_ENTRIES {
805 let Some(oldest) = cache
806 .iter()
807 .min_by_key(|(_, entry)| entry.fetched_at)
808 .map(|(k, _)| k.clone())
809 else {
810 break;
811 };
812 cache.remove(&oldest);
813 }
814}
815
816#[cfg(test)]
817#[allow(clippy::unwrap_used, clippy::expect_used)]
818mod tests {
819 use super::*;
820 use crate::service_entry::{encode_iroh, encode_quic};
821 use crate::transport::QuicServerAuth;
822 use serde_json::json;
823
824 #[test]
825 fn parser_rejects_ambiguous_duplicate_keys() {
826 assert!(parse_did_document_no_duplicates(
827 br#"{"id":"did:web:example.com","id":"did:web:attacker.example"}"#,
828 "https://example.com/.well-known/did.json",
829 )
830 .is_err());
831 }
832
833 #[test]
836 fn url_bare_host() {
837 assert_eq!(
838 did_web_to_url("did:web:example.com").unwrap(),
839 "https://example.com/.well-known/did.json"
840 );
841 }
842
843 #[test]
844 fn url_bare_host_with_encoded_port() {
845 assert_eq!(
847 did_web_to_url("did:web:localhost%3A8443").unwrap(),
848 "https://localhost:8443/.well-known/did.json"
849 );
850 }
851
852 #[test]
853 fn url_path_form() {
854 assert_eq!(
855 did_web_to_url("did:web:example.com:users:alice").unwrap(),
856 "https://example.com/users/alice/did.json"
857 );
858 }
859
860 #[test]
861 fn url_path_form_with_encoded_port() {
862 assert_eq!(
863 did_web_to_url("did:web:127.0.0.1%3A6791:users:12345").unwrap(),
864 "https://127.0.0.1:6791/users/12345/did.json"
865 );
866 }
867
868 #[test]
869 fn url_strips_fragment_and_query() {
870 assert_eq!(
871 did_web_to_url("did:web:example.com#mesh").unwrap(),
872 "https://example.com/.well-known/did.json"
873 );
874 assert_eq!(
875 did_web_to_url("did:web:example.com:users:alice?versionId=1").unwrap(),
876 "https://example.com/users/alice/did.json"
877 );
878 }
879
880 #[test]
881 fn url_rejects_non_did_web() {
882 assert!(did_web_to_url("did:key:z6Mk...").is_err());
883 assert!(did_web_to_url("https://example.com").is_err());
884 assert!(did_web_to_url("did:web:").is_err());
885 }
886
887 #[test]
888 fn url_rejects_invalid_utf8_percent_encoding() {
889 assert!(did_web_to_url("did:web:example%FF.com").is_err());
890 assert!(did_web_to_url("did:web:example.com:path%FE").is_err());
891 }
892
893 #[test]
894 fn url_rejects_path_traversal() {
895 assert!(did_web_to_url("did:web:victim.com:..%2F..%2Fsecret").is_err());
897 assert!(did_web_to_url("did:web:victim.com:%2E%2E").is_err());
899 assert!(did_web_to_url("did:web:victim.com:..").is_err());
900 assert!(did_web_to_url("did:web:victim.com:a%2Fb").is_err());
902 assert!(did_web_to_url("did:web:victim.com:%2E").is_err());
904 assert!(did_web_to_url("did:web:victim.com:a%5Cb").is_err());
906 assert!(did_web_to_url("did:web:victim.com:a%00b").is_err());
907 assert!(did_web_to_url("did:web:victim.com%2Fevil").is_err());
909 assert_eq!(
911 did_web_to_url("did:web:127.0.0.1%3A6791:users:12345").unwrap(),
912 "https://127.0.0.1:6791/users/12345/did.json"
913 );
914 }
915
916 fn doc_with_services(services: Vec<Value>) -> Value {
921 json!({
922 "@context": ["https://www.w3.org/ns/did/v1"],
923 "id": "did:web:example.com",
924 "verificationMethod": [],
925 "service": services,
926 })
927 }
928
929 fn iroh_service(node_id: [u8; 32]) -> Value {
930 json!({
931 "id": "did:web:example.com#iroh",
932 "type": "IrohTransport",
933 "serviceEndpoint": encode_iroh(&node_id, &["https://relay.example".to_owned()], &["hyprstream-rpc/1", "moql"]),
934 })
935 }
936
937 fn quic_service(uri: &str, hash: [u8; 32]) -> Value {
938 let auth = QuicServerAuth::pinned(vec![hash]).unwrap();
939 json!({
940 "id": "did:web:example.com#quic",
941 "type": "QuicTransport",
942 "serviceEndpoint": encode_quic(uri, &auth, &["hyprstream-rpc/1", "moql"]),
943 })
944 }
945
946 #[test]
947 fn extract_orders_iroh_before_quic() {
948 let doc = doc_with_services(vec![
950 quic_service("https://10.0.0.1:4433", [1u8; 32]),
951 iroh_service([7u8; 32]),
952 ]);
953 let entries = transport_entries(&doc);
954 assert_eq!(entries.len(), 2);
955 assert!(
956 matches!(entries[0].config.endpoint, EndpointType::Iroh { .. }),
957 "iroh must be preferred first"
958 );
959 assert!(matches!(
960 entries[1].config.endpoint,
961 EndpointType::Quic { .. }
962 ));
963 }
965
966 #[test]
967 fn extract_preserves_doc_order_within_class() {
968 let doc = doc_with_services(vec![
969 quic_service("https://10.0.0.1:4433", [1u8; 32]),
970 quic_service("https://10.0.0.2:4433", [2u8; 32]),
971 ]);
972 let entries = transport_entries(&doc);
973 assert_eq!(entries.len(), 2);
974 match (&entries[0].config.endpoint, &entries[1].config.endpoint) {
975 (EndpointType::Quic { addr: a, .. }, EndpointType::Quic { addr: b, .. }) => {
976 assert_eq!(a.to_string(), "10.0.0.1:4433");
977 assert_eq!(b.to_string(), "10.0.0.2:4433");
978 }
979 other => panic!("expected two Quic entries, got {other:?}"),
980 }
981 }
982
983 #[test]
984 fn extract_skips_non_transport_services() {
985 let doc = doc_with_services(vec![
986 json!({
987 "id": "did:web:example.com#hyprstream",
988 "type": "HyprstreamService",
989 "serviceEndpoint": "https://example.com",
990 }),
991 json!({
992 "id": "did:web:example.com#atproto_pds",
993 "type": "AtprotoPersonalDataServer",
994 "serviceEndpoint": "https://example.com",
995 }),
996 quic_service("https://10.0.0.1:4433", [1u8; 32]),
997 ]);
998 let entries = transport_entries(&doc);
999 assert_eq!(entries.len(), 1);
1000 assert!(matches!(
1001 entries[0].config.endpoint,
1002 EndpointType::Quic { .. }
1003 ));
1004 }
1005
1006 #[test]
1007 fn extract_no_transport_entries_is_empty() {
1008 let doc = doc_with_services(vec![json!({
1010 "id": "did:web:example.com#hyprstream",
1011 "type": "HyprstreamService",
1012 "serviceEndpoint": "https://example.com",
1013 })]);
1014 assert!(transport_entries(&doc).is_empty());
1015
1016 let doc = json!({ "id": "did:web:example.com", "verificationMethod": [] });
1018 assert!(transport_entries(&doc).is_empty());
1019 }
1020
1021 #[test]
1022 fn extract_skips_undecodable_entry_gracefully() {
1023 let doc = doc_with_services(vec![
1026 json!({
1027 "id": "did:web:example.com#quic",
1028 "type": "QuicTransport",
1029 "serviceEndpoint": { "uri": "https://10.0.0.1:4433", "webpki": false },
1030 }),
1031 iroh_service([7u8; 32]),
1032 ]);
1033 let entries = transport_entries(&doc);
1034 assert_eq!(entries.len(), 1);
1035 assert!(matches!(
1036 entries[0].config.endpoint,
1037 EndpointType::Iroh { .. }
1038 ));
1039 }
1040
1041 #[test]
1042 fn extract_skips_onion_transport() {
1043 let doc = doc_with_services(vec![
1046 json!({
1047 "id": "did:web:example.com#onion",
1048 "type": "OnionTransport",
1049 "serviceEndpoint": { "uri": "abcdef.onion:443" },
1050 }),
1051 quic_service("https://10.0.0.1:4433", [1u8; 32]),
1052 ]);
1053 let entries = transport_entries(&doc);
1054 assert_eq!(entries.len(), 1);
1055 assert!(matches!(
1056 entries[0].config.endpoint,
1057 EndpointType::Quic { .. }
1058 ));
1059 }
1060
1061 #[test]
1062 fn preferred_transport_filters_by_kind() {
1063 let doc = doc_with_services(vec![
1064 iroh_service([7u8; 32]),
1065 quic_service("https://10.0.0.1:4433", [1u8; 32]),
1066 ]);
1067 assert!(matches!(
1069 preferred_transport(&doc, None).unwrap().endpoint,
1070 EndpointType::Iroh { .. }
1071 ));
1072 assert!(matches!(
1074 preferred_transport(&doc, Some(SocketKind::Quic))
1075 .unwrap()
1076 .endpoint,
1077 EndpointType::Quic { .. }
1078 ));
1079 assert!(preferred_transport(&doc, Some(SocketKind::Rep)).is_none());
1081 }
1082
1083 struct FixtureFetcher {
1086 doc: Value,
1087 }
1088
1089 #[async_trait]
1090 impl DidDocFetcher for FixtureFetcher {
1091 async fn fetch(&self, url: &str) -> Result<Value> {
1092 assert_eq!(url, "https://example.com/.well-known/did.json");
1093 Ok(self.doc.clone())
1094 }
1095 }
1096
1097 #[tokio::test]
1098 async fn resolver_resolves_quic_from_fixture_doc() {
1099 let doc = doc_with_services(vec![
1100 iroh_service([7u8; 32]),
1101 quic_service("https://10.0.0.1:4433", [1u8; 32]),
1102 ]);
1103 let resolver = DidWebResolver::new(FixtureFetcher { doc });
1104 let cfg = resolver
1105 .resolve("did:web:example.com", SocketKind::Quic)
1106 .await
1107 .unwrap();
1108 match cfg.endpoint {
1109 EndpointType::Quic { addr, .. } => assert_eq!(addr.to_string(), "10.0.0.1:4433"),
1110 other => panic!("expected Quic, got {other:?}"),
1111 }
1112 }
1113
1114 #[tokio::test]
1115 async fn resolver_resolve_all_returns_preference_order() {
1116 let doc = doc_with_services(vec![
1117 quic_service("https://10.0.0.1:4433", [1u8; 32]),
1118 iroh_service([7u8; 32]),
1119 ]);
1120 let resolver = DidWebResolver::new(FixtureFetcher { doc });
1121 let all = resolver.resolve_all("did:web:example.com").await.unwrap();
1122 assert_eq!(all.len(), 2);
1123 assert!(matches!(all[0].config.endpoint, EndpointType::Iroh { .. }));
1124 assert!(matches!(all[1].config.endpoint, EndpointType::Quic { .. }));
1125 }
1126
1127 #[tokio::test]
1128 async fn resolver_empty_doc_errors_for_kind() {
1129 let doc = doc_with_services(vec![]);
1130 let resolver = DidWebResolver::new(FixtureFetcher { doc });
1131 let res = resolver
1132 .resolve("did:web:example.com", SocketKind::Quic)
1133 .await;
1134 assert!(
1135 res.is_err(),
1136 "no reach → resolve() errors (resolve_all would be empty)"
1137 );
1138 }
1139
1140 struct AlwaysOk(TransportConfig);
1143 #[async_trait]
1144 impl Resolver for AlwaysOk {
1145 async fn resolve(&self, _name: &str, _kind: SocketKind) -> Result<TransportConfig> {
1146 Ok(self.0.clone())
1147 }
1148 }
1149 struct AlwaysErr;
1150 #[async_trait]
1151 impl Resolver for AlwaysErr {
1152 async fn resolve(&self, _name: &str, _kind: SocketKind) -> Result<TransportConfig> {
1153 bail!("nope")
1154 }
1155 }
1156
1157 #[tokio::test]
1158 async fn chained_falls_back_on_primary_error() {
1159 let fallback = TransportConfig::inproc("hyprstream/local");
1160 let chained = ChainedResolver::new(
1161 std::sync::Arc::new(AlwaysErr),
1162 std::sync::Arc::new(AlwaysOk(fallback.clone())),
1163 );
1164 let cfg = chained.resolve("anything", SocketKind::Rep).await.unwrap();
1165 assert_eq!(cfg.endpoint_string(), fallback.endpoint_string());
1166 }
1167
1168 #[tokio::test]
1169 async fn chained_prefers_primary() {
1170 let primary = TransportConfig::inproc("hyprstream/primary");
1171 let fallback = TransportConfig::inproc("hyprstream/fallback");
1172 let chained = ChainedResolver::new(
1173 std::sync::Arc::new(AlwaysOk(primary.clone())),
1174 std::sync::Arc::new(AlwaysOk(fallback)),
1175 );
1176 let cfg = chained.resolve("anything", SocketKind::Rep).await.unwrap();
1177 assert_eq!(cfg.endpoint_string(), primary.endpoint_string());
1178 }
1179
1180 #[test]
1183 fn fetcher_constructs_with_hardened_client() {
1184 let f = HttpDidDocFetcher::new(std::time::Duration::from_secs(1));
1188 assert!(f.is_ok(), "hardened client must build");
1189 let _ = HttpDidDocFetcher::default();
1191 }
1192
1193 #[tokio::test]
1194 async fn fetcher_rejects_non_https() {
1195 let f = HttpDidDocFetcher::new(std::time::Duration::from_secs(1)).unwrap();
1196 let err = f
1197 .fetch("http://example.com/.well-known/did.json")
1198 .await
1199 .unwrap_err();
1200 assert!(
1201 err.to_string().contains("https"),
1202 "must reject non-https: {err}"
1203 );
1204 }
1205
1206 #[test]
1207 fn push_capped_rejects_oversized_body() {
1208 let mut buf = Vec::new();
1211 assert!(push_capped(&mut buf, &vec![b'x'; MAX_DID_DOC_BYTES], MAX_DID_DOC_BYTES).is_ok());
1213 assert_eq!(buf.len(), MAX_DID_DOC_BYTES);
1214 let err = push_capped(&mut buf, b"!", MAX_DID_DOC_BYTES).unwrap_err();
1216 assert!(err.to_string().contains("cap"), "{err}");
1217 assert_eq!(buf.len(), MAX_DID_DOC_BYTES);
1219 }
1220
1221 #[test]
1222 fn push_capped_accepts_under_cap() {
1223 let mut buf = Vec::new();
1224 push_capped(&mut buf, b"{\"ok\":", 16).unwrap();
1225 push_capped(&mut buf, b"true}", 16).unwrap();
1226 assert_eq!(buf, b"{\"ok\":true}");
1227 }
1228
1229 #[test]
1230 fn cache_is_bounded() {
1231 let mut cache: std::collections::HashMap<String, CachedDoc> =
1232 std::collections::HashMap::new();
1233 let ttl = std::time::Duration::from_secs(3600);
1234 for i in 0..(MAX_CACHE_ENTRIES * 3) {
1236 evict_for_insert(&mut cache, ttl);
1237 cache.insert(
1238 format!("https://h{i}.example/.well-known/did.json"),
1239 CachedDoc {
1240 doc: json!({ "i": i }),
1241 fetched_at: std::time::Instant::now(),
1242 },
1243 );
1244 assert!(
1245 cache.len() <= MAX_CACHE_ENTRIES,
1246 "cache exceeded cap at i={i}: len={}",
1247 cache.len()
1248 );
1249 }
1250 assert!(cache.len() <= MAX_CACHE_ENTRIES);
1251 }
1252
1253 fn ed25519_multikey(raw: &[u8; 32]) -> String {
1259 let mut payload = Vec::with_capacity(2 + 32);
1260 payload.extend_from_slice(&MULTICODEC_ED25519_PUB);
1261 payload.extend_from_slice(raw);
1262 format!("z{}", bs58::encode(payload).into_string())
1263 }
1264
1265 fn rand_ed25519() -> [u8; 32] {
1266 use ed25519_dalek::SigningKey;
1267 use rand::rngs::OsRng;
1268 SigningKey::generate(&mut OsRng).verifying_key().to_bytes()
1269 }
1270
1271 #[test]
1272 fn did_key_decodes_known_fixture() {
1273 let did = ed25519_to_did_key(&[0u8; 32]);
1278 assert!(
1279 did.starts_with("did:key:z6Mk"),
1280 "ed25519 did:key must start with z6Mk: {did}"
1281 );
1282 assert_eq!(did_key_to_ed25519(&did).unwrap(), [0u8; 32]);
1283 }
1284
1285 #[test]
1286 fn did_key_roundtrips_random_key() {
1287 for _ in 0..16 {
1288 let raw = rand_ed25519();
1289 assert_eq!(did_key_to_ed25519(&ed25519_to_did_key(&raw)).unwrap(), raw);
1290 }
1291 }
1292
1293 #[test]
1294 fn did_key_strips_fragment() {
1295 let raw = [3u8; 32];
1297 let base = ed25519_to_did_key(&raw);
1298 let mb = base.strip_prefix("did:key:").unwrap();
1299 let with_fragment = format!("{base}#{mb}");
1300 assert_eq!(did_key_to_ed25519(&with_fragment).unwrap(), raw);
1301 }
1302
1303 #[test]
1304 fn did_key_rejects_non_did_key() {
1305 assert!(did_key_to_ed25519("did:web:example.com").is_err());
1306 assert!(did_key_to_ed25519("https://example.com").is_err());
1307 assert!(did_key_to_ed25519("did:key:").is_err());
1308 assert!(!is_did_key("did:web:example.com"));
1309 assert!(is_did_key("did:key:z6MkfooBar"));
1310 }
1311
1312 #[test]
1313 fn did_key_rejects_wrong_multicodec() {
1314 let mut payload = vec![0x80u8, 0x24];
1317 payload.extend_from_slice(&[0u8; 33]); let did = format!("did:key:z{}", bs58::encode(payload).into_string());
1319 assert!(did_key_to_ed25519(&did).is_err());
1320 }
1321
1322 #[test]
1323 fn did_key_rejects_bad_length() {
1324 let mut payload = vec![0xedu8, 0x01];
1326 payload.extend_from_slice(&[0u8; 31]);
1327 let did = format!("did:key:z{}", bs58::encode(payload).into_string());
1328 assert!(did_key_to_ed25519(&did).is_err());
1329 }
1330
1331 #[test]
1332 fn did_key_rejects_non_base58btc_multibase() {
1333 assert!(did_key_to_ed25519("did:key:bMkfoo").is_err());
1335 }
1336
1337 #[test]
1338 fn did_key_equivalent_to_vm_multikey() {
1339 let raw = rand_ed25519();
1343 let vm_multibase = ed25519_multikey(&raw); let did_key = ed25519_to_did_key(&raw);
1345 assert_eq!(did_key, format!("did:key:{vm_multibase}"));
1346 assert_eq!(decode_ed25519_multikey(&vm_multibase).unwrap(), raw);
1348 assert_eq!(did_key_to_ed25519(&did_key).unwrap(), raw);
1349 }
1350
1351 #[test]
1352 fn did_key_identity_is_independent_of_iroh_reach_equality() {
1353 let identity = rand_ed25519();
1354 let unrelated_reach = rand_ed25519();
1355 let did = ed25519_to_did_key(&identity);
1356 for node_id in [identity, unrelated_reach] {
1357 let doc = json!({
1358 "id": did,
1359 "verificationMethod": [{
1360 "id": format!("{did}#key-1"), "type": "Multikey",
1361 "controller": did, "publicKeyMultibase": ed25519_multikey(&identity),
1362 }],
1363 "service": [{
1364 "id": format!("{did}#iroh"), "type": "IrohTransport",
1365 "serviceEndpoint": encode_iroh(&node_id, &[], &["hyprstream-rpc/1"]),
1366 }],
1367 });
1368 assert_eq!(verification_method_ed25519_keys(&doc), vec![identity]);
1369 let reach = transport_entries(&doc);
1370 assert!(matches!(&reach[0].config.endpoint,
1371 crate::transport::EndpointType::Iroh { node_id: got, .. } if *got == node_id));
1372 }
1373 }
1374}