1use std::sync::Arc;
32
33use axum::{
34 extract::{Path, State},
35 http::{header, StatusCode},
36 response::{IntoResponse, Response},
37 Json,
38};
39use base64::{engine::general_purpose::URL_SAFE_NO_PAD, Engine};
40use ed25519_dalek::VerifyingKey;
41use serde_json::{json, Value};
42
43use super::state::{atproto_service_did_for_origin, OAuthState};
44
45#[derive(Clone, Debug)]
51pub(crate) struct RenderedAt9pIdentity {
52 pub did: String,
53 pub cid512: String,
54 pub capsule: Arc<[u8]>,
55}
56
57fn ed25519_to_multibase(vk: &VerifyingKey) -> String {
63 let mut payload = Vec::with_capacity(34);
65 payload.push(0xed);
66 payload.push(0x01);
67 payload.extend_from_slice(vk.as_bytes());
68 format!("z{}", bs58::encode(payload).into_string())
69}
70
71fn issuer_origin(issuer_url: &str) -> Option<String> {
76 let (scheme, rest) = issuer_url.split_once("://")?;
77 let authority = rest.split('/').next().unwrap_or(rest);
78 if authority.is_empty() {
79 None
80 } else {
81 Some(format!("{scheme}://{authority}"))
82 }
83}
84
85pub(crate) fn render_at9p_identity(
88 issuer_url: &str,
89 ed_sk: &ed25519_dalek::SigningKey,
90 pq_sk: &hyprstream_rpc::crypto::pq::MlDsaSigningKey,
91) -> anyhow::Result<RenderedAt9pIdentity> {
92 use hyprstream_pds::at9p::{
93 CapsuleBody, HybridKeyPair, ServiceEndpoint, ServiceEntry, ServiceType, Transport,
94 };
95 use hyprstream_pds::at9p_sign::sign_capsule;
96
97 let did = atproto_service_did_for_origin(issuer_url)
98 .ok_or_else(|| anyhow::anyhow!("OAuth issuer URL has no supported service DID"))?;
99 let origin = issuer_origin(issuer_url)
100 .ok_or_else(|| anyhow::anyhow!("OAuth issuer URL has no origin"))?;
101 anyhow::ensure!(
102 origin.starts_with("https://"),
103 "at9p identity publication requires an HTTPS OAuth issuer"
104 );
105
106 let subject_key = HybridKeyPair::new(
107 ed_sk.verifying_key().to_bytes(),
108 hyprstream_rpc::crypto::pq::ml_dsa_sk_to_vk_bytes(pq_sk),
109 )?;
110 let endpoint = ServiceEndpoint::new(Transport::Https, origin)?;
111 let service = ServiceEntry::new("#pds", ServiceType::AtprotoPds, endpoint)?;
112 let mut body = CapsuleBody::new(vec![subject_key], vec![service])?;
113 body.also_known_as = Some(vec![did]);
114
115 let capsule = sign_capsule(body, ed_sk, pq_sk)?;
116 let capsule_bytes = capsule.to_dag_cbor()?;
117 let cid512 = capsule.cid512()?;
118 Ok(RenderedAt9pIdentity {
119 did: format!("did:at9p:{cid512}"),
120 cid512,
121 capsule: Arc::from(capsule_bytes),
122 })
123}
124
125fn normalize_atproto_handle(handle: &str) -> Option<String> {
126 let handle = handle.trim_end_matches('.').to_ascii_lowercase();
127 if handle.len() > 253 || handle.split('.').count() < 2 {
128 return None;
129 }
130 let valid = handle.split('.').all(|label| {
131 !label.is_empty()
132 && label.len() <= 63
133 && !label.starts_with('-')
134 && !label.ends_with('-')
135 && label
136 .bytes()
137 .all(|byte| byte.is_ascii_alphanumeric() || byte == b'-')
138 });
139 valid.then_some(handle)
140}
141
142fn configured_handle_host(issuer_url: &str) -> Option<String> {
143 let url = url::Url::parse(issuer_url).ok()?;
144 match url.host()? {
145 url::Host::Domain(host) => normalize_atproto_handle(host),
146 url::Host::Ipv4(_) | url::Host::Ipv6(_) => None,
147 }
148}
149
150#[cfg(test)]
151fn account_handle(username: &str, issuer_url: &str) -> Option<String> {
152 let host = configured_handle_host(issuer_url)?;
153 normalize_atproto_handle(&format!("{username}.{host}"))
154}
155
156fn p256_to_multibase(vk: &p256::ecdsa::VerifyingKey) -> String {
163 let point = vk.to_encoded_point(true); let compressed = point.as_bytes();
165 let mut payload = Vec::with_capacity(2 + compressed.len());
166 payload.push(0x80);
167 payload.push(0x24);
168 payload.extend_from_slice(compressed);
169 format!("z{}", bs58::encode(payload).into_string())
170}
171
172const MULTICODEC_ML_DSA_65_PUB: [u8; 2] = [0x91, 0x24];
179
180fn mldsa65_to_multibase(vk_bytes: &[u8]) -> String {
190 let mut payload = Vec::with_capacity(MULTICODEC_ML_DSA_65_PUB.len() + vk_bytes.len());
191 payload.extend_from_slice(&MULTICODEC_ML_DSA_65_PUB);
192 payload.extend_from_slice(vk_bytes);
193 format!("z{}", bs58::encode(payload).into_string())
194}
195
196pub struct AtprotoIdentity<'a> {
201 pub p256_vk: &'a p256::ecdsa::VerifyingKey,
202 pub handle: &'a str,
203 pub drain: Option<AtprotoOverlapKey<'a>>,
204 pub lead: Option<AtprotoOverlapKey<'a>>,
205}
206
207pub struct AtprotoOverlapKey<'a> {
209 pub vk: &'a p256::ecdsa::VerifyingKey,
210 pub nbf: i64,
211 pub exp: i64,
212}
213
214pub struct TransportEndpoint {
218 pub fragment: String,
220 pub vm_type: String,
222 pub endpoint: Value,
224}
225
226pub(crate) fn atproto_verification_method(did: &str, vk: &p256::ecdsa::VerifyingKey) -> Value {
228 json!({
229 "id": format!("{did}#atproto"),
230 "type": "Multikey",
231 "controller": did,
232 "publicKeyMultibase": p256_to_multibase(vk),
233 })
234}
235
236fn atproto_overlap_verification_method(
237 did: &str,
238 fragment: &str,
239 key: &AtprotoOverlapKey<'_>,
240) -> Value {
241 json!({
242 "id": format!("{did}#{fragment}"),
243 "type": "Multikey",
244 "controller": did,
245 "publicKeyMultibase": p256_to_multibase(key.vk),
246 "nbf": key.nbf,
247 "exp": key.exp,
248 })
249}
250
251pub fn atproto_verification_methods(
255 did: &str,
256 active: &p256::ecdsa::VerifyingKey,
257 drain: Option<AtprotoOverlapKey<'_>>,
258 lead: Option<AtprotoOverlapKey<'_>>,
259) -> Vec<Value> {
260 let mut methods = vec![atproto_verification_method(did, active)];
261 if let Some(drain) = drain {
262 methods.push(atproto_overlap_verification_method(
263 did,
264 "atproto_drain",
265 &drain,
266 ));
267 }
268 if let Some(lead) = lead {
269 methods.push(atproto_overlap_verification_method(
270 did,
271 "atproto_lead",
272 &lead,
273 ));
274 }
275 methods
276}
277
278fn ed25519_verification_method(did: &str, key_id: &str, vk: &VerifyingKey) -> Value {
287 json!({
288 "id": format!("{did}#{key_id}"),
289 "type": "Multikey",
290 "controller": did,
291 "publicKeyMultibase": ed25519_to_multibase(vk),
292 })
293}
294
295fn mldsa65_verification_method(did: &str, key_id: &str, vk_bytes: &[u8]) -> Value {
303 json!({
304 "id": format!("{did}#{key_id}"),
305 "type": "Multikey",
306 "controller": did,
307 "publicKeyMultibase": mldsa65_to_multibase(vk_bytes),
308 })
309}
310
311const MULTICODEC_X25519_PUB: [u8; 2] = [0xec, 0x01];
317
318const MULTICODEC_ML_KEM_768_PUB: [u8; 2] = [0x8c, 0x24];
327
328fn x25519_to_multibase(ek_bytes: &[u8]) -> String {
331 let mut payload = Vec::with_capacity(MULTICODEC_X25519_PUB.len() + ek_bytes.len());
332 payload.extend_from_slice(&MULTICODEC_X25519_PUB);
333 payload.extend_from_slice(ek_bytes);
334 format!("z{}", bs58::encode(payload).into_string())
335}
336
337fn mlkem768_to_multibase(ek_bytes: &[u8]) -> String {
340 let mut payload = Vec::with_capacity(MULTICODEC_ML_KEM_768_PUB.len() + ek_bytes.len());
341 payload.extend_from_slice(&MULTICODEC_ML_KEM_768_PUB);
342 payload.extend_from_slice(ek_bytes);
343 format!("z{}", bs58::encode(payload).into_string())
344}
345
346fn mesh_kem_key_agreement_methods(did: &str, x25519_ek: &[u8], mlkem768_ek: &[u8]) -> Vec<Value> {
358 vec![
359 json!({
360 "id": format!("{did}#mesh-kem-x25519"),
361 "type": "Multikey",
362 "controller": did,
363 "publicKeyMultibase": x25519_to_multibase(x25519_ek),
364 }),
365 json!({
366 "id": format!("{did}#mesh-kem-mlkem768"),
367 "type": "Multikey",
368 "controller": did,
369 "publicKeyMultibase": mlkem768_to_multibase(mlkem768_ek),
370 }),
371 ]
372}
373
374fn mesh_kem_key_agreement(
386 did: &str,
387 recipient_public: Option<&hyprstream_rpc::crypto::hybrid_kem::RecipientPublic>,
388) -> Vec<Value> {
389 use hyprstream_rpc::crypto::hybrid_kem::SuiteId;
390 let Some(pub_material) = recipient_public else {
391 return Vec::new();
392 };
393 if pub_material.suite_id != SuiteId::HyKemX25519MlKem768 {
397 return Vec::new();
398 }
399 let [x25519_ek, mlkem768_ek] = &pub_material.eks[..] else {
400 return Vec::new();
401 };
402 mesh_kem_key_agreement_methods(did, x25519_ek, mlkem768_ek)
403}
404
405#[cfg(test)]
406#[allow(clippy::unwrap_used, clippy::expect_used)]
407mod mesh_kem_did_tests {
408 use super::*;
409
410 #[test]
411 fn mesh_kem_methods_shape_and_multicodec() {
412 let did = "did:web:example.com";
413 let x_ek = [0x11u8; 32];
414 let m_ek = [0x22u8; 1184];
415 let vms = mesh_kem_key_agreement_methods(did, &x_ek, &m_ek);
416 assert_eq!(vms.len(), 2);
417 assert_eq!(vms[0]["id"], format!("{did}#mesh-kem-x25519"));
418 assert_eq!(vms[0]["type"], "Multikey");
419 assert_eq!(vms[1]["id"], format!("{did}#mesh-kem-mlkem768"));
420 assert_eq!(vms[1]["type"], "Multikey");
421
422 let mb = vms[0]["publicKeyMultibase"].as_str().unwrap();
424 assert!(mb.starts_with('z'));
425 let decoded = bs58::decode(&mb[1..]).into_vec().unwrap();
426 assert_eq!(&decoded[..2], &MULTICODEC_X25519_PUB);
427 assert_eq!(decoded.len(), 2 + 32);
428
429 let mb2 = vms[1]["publicKeyMultibase"].as_str().unwrap();
430 let decoded2 = bs58::decode(&mb2[1..]).into_vec().unwrap();
431 assert_eq!(&decoded2[..2], &MULTICODEC_ML_KEM_768_PUB);
432 assert_eq!(decoded2.len(), 2 + 1184);
433 }
434}
435
436fn ed25519_verification_method_jwk(did: &str, key_id: &str, vk: &VerifyingKey) -> Value {
439 json!({
440 "id": format!("{did}#{key_id}-jwk"),
441 "type": "JsonWebKey2020",
442 "controller": did,
443 "publicKeyJwk": {
444 "kty": "OKP",
445 "crv": "Ed25519",
446 "x": URL_SAFE_NO_PAD.encode(vk.as_bytes()),
447 },
448 })
449}
450
451pub(crate) fn build_did_document(
467 did: &str,
468 issuer_url: &str,
469 keys: &[(String, VerifyingKey)],
470 atproto: Option<&AtprotoIdentity<'_>>,
471 transports: &[TransportEndpoint],
472 mesh_pq_vk: Option<&[u8]>,
473 mesh_kem_public: Option<&hyprstream_rpc::crypto::hybrid_kem::RecipientPublic>,
474) -> Value {
475 let mut verification_methods = Vec::with_capacity(keys.len() * 2 + 4);
476 let mut authentication_refs = Vec::with_capacity(keys.len() * 2 + 2);
477 let mut assertion_refs = Vec::with_capacity(keys.len() * 2 + 2);
478
479 if let Some(at) = atproto {
482 verification_methods.extend(atproto_verification_methods(
483 did,
484 at.p256_vk,
485 at.drain.as_ref().map(|key| AtprotoOverlapKey {
486 vk: key.vk,
487 nbf: key.nbf,
488 exp: key.exp,
489 }),
490 at.lead.as_ref().map(|key| AtprotoOverlapKey {
491 vk: key.vk,
492 nbf: key.nbf,
493 exp: key.exp,
494 }),
495 ));
496 let atproto_vm_id = format!("{did}#atproto");
497 authentication_refs.push(Value::String(atproto_vm_id.clone()));
498 assertion_refs.push(Value::String(atproto_vm_id));
499 }
500
501 for (key_id, vk) in keys {
503 let vm_id = format!("{did}#{key_id}");
504 let vm_id_jwk = format!("{did}#{key_id}-jwk");
505 verification_methods.push(ed25519_verification_method(did, key_id, vk));
506 verification_methods.push(ed25519_verification_method_jwk(did, key_id, vk));
507 authentication_refs.push(Value::String(vm_id.clone()));
508 authentication_refs.push(Value::String(vm_id_jwk.clone()));
509 assertion_refs.push(Value::String(vm_id));
510 assertion_refs.push(Value::String(vm_id_jwk));
511 }
512
513 if let Some(vk_bytes) = mesh_pq_vk {
517 verification_methods.push(mldsa65_verification_method(did, "mesh-pq", vk_bytes));
518 let vm_id = format!("{did}#mesh-pq");
519 authentication_refs.push(Value::String(vm_id.clone()));
520 assertion_refs.push(Value::String(vm_id));
521 }
522
523 let mut services = Vec::with_capacity(2 + transports.len());
526 if atproto.is_some() {
527 if let Some(origin) = issuer_origin(issuer_url) {
528 services.push(json!({
529 "id": format!("{did}#atproto_pds"),
530 "type": "AtprotoPersonalDataServer",
531 "serviceEndpoint": origin,
532 }));
533 }
534 }
535 services.push(json!({
536 "id": format!("{did}#hyprstream"),
537 "type": "HyprstreamService",
538 "serviceEndpoint": issuer_url,
539 }));
540 for t in transports {
541 services.push(json!({
542 "id": format!("{did}#{}", t.fragment),
543 "type": t.vm_type,
544 "serviceEndpoint": t.endpoint,
545 }));
546 }
547
548 let key_agreement = mesh_kem_key_agreement(did, mesh_kem_public);
553
554 let mut doc = json!({
555 "@context": [
556 "https://www.w3.org/ns/did/v1",
557 "https://w3id.org/security/multikey/v1",
558 "https://w3id.org/security/suites/jws-2020/v1",
559 ],
560 "id": did,
561 "verificationMethod": verification_methods,
562 "authentication": authentication_refs,
563 "assertionMethod": assertion_refs,
564 "keyAgreement": key_agreement,
565 "service": services,
566 });
567
568 if let Some(at) = atproto {
569 doc["alsoKnownAs"] = json!([format!("at://{}", at.handle)]);
570 }
571
572 doc
573}
574
575#[derive(Clone)]
576struct RootIdentityMethod {
577 fragment: String,
578 vk: VerifyingKey,
579 pq_vk: Vec<u8>,
580 nbf: Option<i64>,
581 exp: Option<i64>,
582}
583
584fn root_identity_methods(
585 legacy_key: &ed25519_dalek::SigningKey,
586 legacy_pq: &[u8],
587 slots: Option<&crate::auth::key_rotation::KeySlots>,
588 now: i64,
589) -> Vec<RootIdentityMethod> {
590 let Some(slots) = slots else {
591 return vec![RootIdentityMethod {
592 fragment: "key-1".to_owned(),
593 vk: legacy_key.verifying_key(),
594 pq_vk: legacy_pq.to_vec(),
595 nbf: None,
596 exp: None,
597 }];
598 };
599
600 let legacy_bytes = legacy_key.verifying_key().to_bytes();
601 let legacy_slot = [&slots.active, &slots.drain, &slots.lead]
602 .into_iter()
603 .flatten()
604 .find(|slot| slot.verifying_key_bytes() == legacy_bytes && now < slot.exp);
605
606 let mut methods = Vec::new();
607 if let Some(slot) = legacy_slot {
611 methods.push(RootIdentityMethod {
612 fragment: "key-1".to_owned(),
613 vk: legacy_key.verifying_key(),
614 pq_vk: legacy_pq.to_vec(),
615 nbf: Some(slot.nbf),
616 exp: Some(slot.exp),
617 });
618 }
619
620 for slot in [&slots.active, &slots.drain, &slots.lead]
623 .into_iter()
624 .flatten()
625 {
626 let pq = hyprstream_rpc::node_identity::derive_mesh_mldsa_key(&slot.key);
627 methods.push(RootIdentityMethod {
628 fragment: format!("mesh-{}", slot.kid()),
629 vk: slot.key.verifying_key(),
630 pq_vk: hyprstream_rpc::crypto::pq::ml_dsa_sk_to_vk_bytes(&pq),
631 nbf: Some(slot.nbf),
632 exp: Some(slot.exp),
633 });
634 }
635 methods
636}
637
638fn append_root_identity_methods(doc: &mut Value, did: &str, methods: &[RootIdentityMethod]) {
639 let Some(verification_methods) = doc
640 .get_mut("verificationMethod")
641 .and_then(Value::as_array_mut)
642 else {
643 return;
644 };
645 let mut relationship_ids = Vec::new();
646
647 for method in methods {
648 let mut ed = ed25519_verification_method(did, &method.fragment, &method.vk);
649 let mut ed_jwk = ed25519_verification_method_jwk(did, &method.fragment, &method.vk);
650 let pq_fragment = format!("{}-pq", method.fragment);
651 let mut pq = mldsa65_verification_method(did, &pq_fragment, &method.pq_vk);
652 for vm in [&mut ed, &mut ed_jwk, &mut pq] {
653 if let Some(nbf) = method.nbf {
654 vm["nbf"] = nbf.into();
655 }
656 if let Some(exp) = method.exp {
657 vm["exp"] = exp.into();
658 }
659 }
660 relationship_ids.extend([ed["id"].clone(), ed_jwk["id"].clone(), pq["id"].clone()]);
661 verification_methods.extend([ed, ed_jwk, pq]);
662 }
663
664 if let Some(first) = methods.first() {
668 let mut legacy_pq = mldsa65_verification_method(did, "mesh-pq", &first.pq_vk);
669 if let Some(nbf) = first.nbf {
670 legacy_pq["nbf"] = nbf.into();
671 }
672 if let Some(exp) = first.exp {
673 legacy_pq["exp"] = exp.into();
674 }
675 relationship_ids.push(legacy_pq["id"].clone());
676 verification_methods.push(legacy_pq);
677 }
678
679 for relationship in ["authentication", "assertionMethod"] {
680 if let Some(values) = doc.get_mut(relationship).and_then(Value::as_array_mut) {
681 values.extend(relationship_ids.iter().cloned());
682 }
683 }
684}
685
686pub async fn root_did_document(State(state): State<Arc<OAuthState>>) -> Response {
693 let did = match state.atproto_service_did() {
694 Some(a) => a,
695 None => {
696 return (
697 StatusCode::INTERNAL_SERVER_ERROR,
698 "issuer URL has no supported service DID",
699 )
700 .into_response()
701 }
702 };
703
704 let Some(ref sk) = state.signing_key else {
706 return (
707 StatusCode::SERVICE_UNAVAILABLE,
708 "OAuth signing key not configured",
709 )
710 .into_response();
711 };
712 let root_slots = if let Some(store) = &state.root_identity_key_store {
713 Some(store.slots_snapshot().await)
714 } else {
715 None
716 };
717 let now = chrono::Utc::now().timestamp();
718 let root_methods = root_identity_methods(
719 sk,
720 state.mesh_pq_verifying_key.as_deref().unwrap_or_default(),
721 root_slots.as_ref(),
722 now,
723 );
724
725 let slots = state
728 .es256_key_store
729 .as_ref()
730 .map(|store| store.slots_snapshot())
731 .unwrap_or_default();
732 let (active_slot, drain_slot, lead_slot) = (slots.active, slots.drain, slots.lead);
733 let handle = configured_handle_host(&state.issuer_url);
734 let atproto = active_slot
735 .as_ref()
736 .zip(handle.as_deref())
737 .map(|(active, handle)| AtprotoIdentity {
738 p256_vk: active.key.verifying_key(),
739 handle,
740 drain: drain_slot.as_ref().map(|slot| AtprotoOverlapKey {
741 vk: slot.key.verifying_key(),
742 nbf: slot.nbf,
743 exp: slot.exp,
744 }),
745 lead: lead_slot.as_ref().map(|slot| AtprotoOverlapKey {
746 vk: slot.key.verifying_key(),
747 nbf: slot.nbf,
748 exp: slot.exp,
749 }),
750 });
751
752 let mut transports: Vec<TransportEndpoint> = Vec::new();
757 if !state.quic_cert_hashes.is_empty() {
758 if let Some(ref quic_uri) = state.quic_public_uri {
759 let auth = match hyprstream_rpc::transport::QuicServerAuth::pinned(
760 state.quic_cert_hashes.clone(),
761 ) {
762 Ok(auth) => auth,
763 Err(_) => hyprstream_rpc::transport::QuicServerAuth::web_pki(),
764 };
765 transports.push(TransportEndpoint {
766 fragment: "quic".to_owned(),
767 vm_type: "QuicTransport".to_owned(),
768 endpoint: hyprstream_rpc::service_entry::encode_quic(
769 quic_uri,
770 &auth,
771 &["hyprstream-rpc/1"],
772 ),
773 });
774 }
775 }
776
777 if let Some(node_id) = state.iroh_node_id {
781 transports.push(TransportEndpoint {
782 fragment: "iroh".to_owned(),
783 vm_type: "IrohTransport".to_owned(),
784 endpoint: hyprstream_rpc::service_entry::encode_iroh(
785 &node_id,
786 &state.iroh_relays,
787 &["hyprstream-rpc/1"],
788 ),
789 });
790 }
791
792 let mut doc = build_did_document(
793 &did,
794 &state.issuer_url,
795 &[],
796 atproto.as_ref(),
797 &transports,
798 None,
799 state.mesh_kem_public.as_ref(),
800 );
801 append_root_identity_methods(&mut doc, &did, &root_methods);
802 if let Some(identity) = state.at9p_identity.as_ref() {
803 let mut aliases = doc
804 .get("alsoKnownAs")
805 .and_then(Value::as_array)
806 .cloned()
807 .unwrap_or_default();
808 aliases.push(Value::String(identity.did.clone()));
809 doc["alsoKnownAs"] = Value::Array(aliases);
810 }
811 (
812 StatusCode::OK,
813 [(header::CONTENT_TYPE, "application/did+json")],
814 Json(doc),
815 )
816 .into_response()
817}
818
819pub async fn at9p_capsule(
823 State(state): State<Arc<OAuthState>>,
824 Path(cid): Path<String>,
825) -> Response {
826 let Some(cid) = cid.strip_suffix(".cbor") else {
827 return StatusCode::NOT_FOUND.into_response();
828 };
829 let Some(identity) = state.at9p_identity.as_ref() else {
830 return StatusCode::SERVICE_UNAVAILABLE.into_response();
831 };
832 if cid != identity.cid512 {
833 return StatusCode::NOT_FOUND.into_response();
834 }
835
836 (
837 StatusCode::OK,
838 [
839 (header::CONTENT_TYPE, "application/cbor"),
840 (header::CACHE_CONTROL, "no-store"),
841 ],
842 identity.capsule.to_vec(),
843 )
844 .into_response()
845}
846
847pub async fn atproto_did(State(state): State<Arc<OAuthState>>) -> Response {
860 let Some(did) = state.atproto_service_did() else {
861 return (
862 StatusCode::INTERNAL_SERVER_ERROR,
863 "issuer URL has no supported service DID",
864 )
865 .into_response();
866 };
867 (
868 StatusCode::OK,
869 [(header::CONTENT_TYPE, "text/plain; charset=utf-8")],
870 did,
871 )
872 .into_response()
873}
874
875pub async fn user_did_document(
882 State(_state): State<Arc<OAuthState>>,
883 Path(username): Path<String>,
884) -> Response {
885 tracing::debug!(%username, "deprecated path-form account DID route requested");
886 path_form_account_did_disabled_response()
887}
888
889fn path_form_account_did_disabled_response() -> Response {
890 (
891 StatusCode::GONE,
892 "did:web path-form account minting is disabled; host-form account minting is not available yet (#1159)",
893 )
894 .into_response()
895}
896
897pub async fn client_did_document(
903 State(state): State<Arc<OAuthState>>,
904 Path(client_id): Path<String>,
905) -> Response {
906 let did = match state.atproto_service_did() {
907 Some(a) => a,
908 None => {
909 return (
910 StatusCode::INTERNAL_SERVER_ERROR,
911 "issuer URL has no supported service DID",
912 )
913 .into_response()
914 }
915 };
916 if client_id.contains(['/', '#', '?', ':']) || client_id.is_empty() {
917 return (StatusCode::BAD_REQUEST, "invalid client_id").into_response();
918 }
919 let did = format!("{did}:clients:{client_id}");
920
921 let keys: Vec<(String, VerifyingKey)> = Vec::new();
930
931 let doc = build_did_document(&did, &state.issuer_url, &keys, None, &[], None, None);
932 (
933 StatusCode::OK,
934 [(header::CONTENT_TYPE, "application/did+json")],
935 Json(doc),
936 )
937 .into_response()
938}
939
940#[allow(dead_code)]
947fn extract_ed25519_keys_from_jwks(jwks: &Option<Value>) -> Vec<(String, VerifyingKey)> {
948 let Some(jwks) = jwks else { return Vec::new() };
949 let Some(keys) = jwks.get("keys").and_then(|k| k.as_array()) else {
950 return Vec::new();
951 };
952 let mut out = Vec::new();
953 for (idx, key) in keys.iter().enumerate() {
954 if key.get("kty").and_then(|v| v.as_str()) != Some("OKP")
955 || key.get("crv").and_then(|v| v.as_str()) != Some("Ed25519")
956 {
957 continue;
958 }
959 let Some(x) = key.get("x").and_then(|v| v.as_str()) else {
960 continue;
961 };
962 let Ok(raw) = URL_SAFE_NO_PAD.decode(x) else {
963 continue;
964 };
965 let bytes: [u8; 32] = match raw.try_into() {
966 Ok(b) => b,
967 Err(_) => continue,
968 };
969 let Ok(vk) = VerifyingKey::from_bytes(&bytes) else {
970 continue;
971 };
972 let kid = key
973 .get("kid")
974 .and_then(|v| v.as_str())
975 .map(str::to_owned)
976 .unwrap_or_else(|| format!("key-{idx}"));
977 out.push((kid, vk));
978 }
979 out
980}
981
982#[cfg(test)]
983#[allow(clippy::unwrap_used, clippy::expect_used)]
984mod tests {
985 use super::*;
986 use ed25519_dalek::SigningKey;
987 use hyprstream_rpc::crypto::CryptoPolicy;
988 use rand::rngs::OsRng;
989
990 #[test]
991 fn rendered_at9p_capsule_is_key_owned_and_mutually_aliased() {
992 let sk = SigningKey::from_bytes(&[0x31; 32]);
993 let pq_sk = hyprstream_rpc::node_identity::derive_mesh_mldsa_key(&sk);
994 let identity =
995 render_at9p_identity("https://discovery.hyprstream.com", &sk, &pq_sk).unwrap();
996
997 let verified =
998 hyprstream_pds::at9p_gate::verify_did_at9p(&identity.did, &identity.capsule).unwrap();
999 assert_eq!(verified.cid512(), identity.cid512);
1000 assert_eq!(
1001 verified.capsule().body.subject_keys[0].ed25519_pub,
1002 sk.verifying_key().to_bytes(),
1003 );
1004 assert_eq!(
1005 verified.capsule().body.subject_keys[0].mldsa65_pub,
1006 hyprstream_rpc::crypto::pq::ml_dsa_sk_to_vk_bytes(&pq_sk),
1007 );
1008 assert_eq!(
1009 verified.capsule().body.also_known_as.as_deref(),
1010 Some(&["did:web:discovery.hyprstream.com".to_owned()][..]),
1011 );
1012 }
1013
1014 #[test]
1015 fn rendered_at9p_capsule_uses_canonical_service_did_alias() {
1016 let sk = SigningKey::from_bytes(&[0x31; 32]);
1017 let pq_sk = hyprstream_rpc::node_identity::derive_mesh_mldsa_key(&sk);
1018 for (issuer, expected) in [
1019 (
1020 "https://pds.example:8443/oauth",
1021 "did:web:pds.example%3A8443",
1022 ),
1023 ("https://PDS.example:443/oauth", "did:web:pds.example"),
1024 ] {
1025 let identity = render_at9p_identity(issuer, &sk, &pq_sk).unwrap();
1026 let verified =
1027 hyprstream_pds::at9p_gate::verify_did_at9p(&identity.did, &identity.capsule)
1028 .unwrap();
1029 assert_eq!(
1030 verified.capsule().body.also_known_as.as_deref(),
1031 Some(&[expected.to_owned()][..])
1032 );
1033 }
1034 for issuer in [
1035 "https://user@pds.example",
1036 "https://[::1]:8443",
1037 "not-a-url",
1038 ] {
1039 assert!(render_at9p_identity(issuer, &sk, &pq_sk).is_err());
1040 }
1041 }
1042
1043 #[test]
1044 fn rendered_at9p_capsule_refuses_non_https_identity_origin() {
1045 let sk = SigningKey::from_bytes(&[0x32; 32]);
1046 let pq_sk = hyprstream_rpc::node_identity::derive_mesh_mldsa_key(&sk);
1047 let error = render_at9p_identity("http://discovery.example", &sk, &pq_sk).unwrap_err();
1048 assert!(error.to_string().contains("requires an HTTPS OAuth issuer"));
1049 }
1050
1051 #[tokio::test]
1052 async fn non_https_issuer_degrades_only_at9p_identity() {
1053 use axum::body::Body;
1054 use axum::http::Request;
1055 use tower::ServiceExt as _;
1056
1057 let state = Arc::new(state_with_issuer("http://discovery.example"));
1058 assert!(state.signing_key.is_some());
1059 assert!(state.mesh_pq_verifying_key.is_some());
1060 assert!(state.mesh_kem_public.is_some());
1061 assert!(state.at9p_identity.is_none());
1062
1063 let cors = crate::config::server::CorsConfig {
1064 enabled: false,
1065 ..Default::default()
1066 };
1067 let response = super::super::create_app(state, &cors)
1068 .oneshot(
1069 Request::get("/.well-known/at9p/unavailable.cbor")
1070 .body(Body::empty())
1071 .unwrap(),
1072 )
1073 .await
1074 .unwrap();
1075 assert_eq!(response.status(), StatusCode::SERVICE_UNAVAILABLE);
1076 }
1077
1078 fn state_with_issuer(issuer_url: &str) -> OAuthState {
1079 use hyprstream_rpc::rpc_client::RpcClientImpl;
1080 use hyprstream_rpc::signer::LocalSigner;
1081 use hyprstream_rpc::transport::lazy_uds::LazyUdsTransport;
1082
1083 let local = SigningKey::from_bytes(&[0x33; 32]);
1084 let remote = SigningKey::from_bytes(&[0x34; 32]).verifying_key();
1085 let make_client = || {
1086 Arc::new(
1087 RpcClientImpl::new(
1088 LocalSigner::new(local.clone()),
1089 LazyUdsTransport::new("/dev/null/oauth-at9p-test.sock".into()),
1090 Some(remote),
1091 )
1092 .with_response_verify_policy(CryptoPolicy::Classical),
1093 )
1094 };
1095 let mut config = crate::config::OAuthConfig::default();
1096 config.external_url = Some(issuer_url.to_owned());
1097 OAuthState::new(
1098 &config,
1099 hyprstream_rpc_std::policy_client::PolicyClient::new(make_client()),
1100 hyprstream_rpc_std::discovery_client::DiscoveryClient::new(make_client()),
1101 local.verifying_key().to_bytes(),
1102 )
1103 .with_signing_key(local, CryptoPolicy::Hybrid)
1104 .unwrap()
1105 }
1106
1107 fn state_with_live_identity() -> Arc<OAuthState> {
1108 Arc::new(state_with_issuer("https://discovery.hyprstream.com"))
1109 }
1110
1111 #[tokio::test]
1112 async fn public_router_serves_only_its_live_capsule_without_credentials() {
1113 use axum::body::{to_bytes, Body};
1114 use axum::http::Request;
1115 use tower::ServiceExt as _;
1116
1117 let state = state_with_live_identity();
1118 let identity = state.at9p_identity.as_ref().unwrap().clone();
1119 let cors = crate::config::server::CorsConfig {
1120 enabled: false,
1121 ..Default::default()
1122 };
1123 let app = super::super::create_app(Arc::clone(&state), &cors);
1124
1125 let response = app
1126 .clone()
1127 .oneshot(
1128 Request::get(format!("/.well-known/at9p/{}.cbor", identity.cid512))
1129 .header(header::AUTHORIZATION, "Bearer must-be-ignored")
1130 .header(header::COOKIE, "session=must-be-ignored")
1131 .body(Body::empty())
1132 .unwrap(),
1133 )
1134 .await
1135 .unwrap();
1136 assert_eq!(response.status(), StatusCode::OK);
1137 assert_eq!(
1138 response.headers().get(header::CONTENT_TYPE).unwrap(),
1139 "application/cbor",
1140 );
1141 assert_eq!(
1142 response.headers().get(header::CACHE_CONTROL).unwrap(),
1143 "no-store",
1144 );
1145 assert!(!response.headers().contains_key(header::SET_COOKIE));
1146 let bytes = to_bytes(response.into_body(), 4 * 1024 * 1024)
1147 .await
1148 .unwrap();
1149 assert_eq!(bytes.as_ref(), identity.capsule.as_ref());
1150 hyprstream_pds::at9p_gate::verify_did_at9p(&identity.did, &bytes).unwrap();
1151
1152 let wrong = app
1153 .clone()
1154 .oneshot(
1155 Request::get("/.well-known/at9p/not-this-node.cbor")
1156 .body(Body::empty())
1157 .unwrap(),
1158 )
1159 .await
1160 .unwrap();
1161 assert_eq!(wrong.status(), StatusCode::NOT_FOUND);
1162
1163 let did_response = app
1164 .oneshot(
1165 Request::get("/.well-known/did.json")
1166 .body(Body::empty())
1167 .unwrap(),
1168 )
1169 .await
1170 .unwrap();
1171 assert_eq!(did_response.status(), StatusCode::OK);
1172 let did_bytes = to_bytes(did_response.into_body(), 1024 * 1024)
1173 .await
1174 .unwrap();
1175 let document: Value = serde_json::from_slice(&did_bytes).unwrap();
1176 assert!(document["alsoKnownAs"]
1177 .as_array()
1178 .unwrap()
1179 .iter()
1180 .any(|alias| alias == &identity.did));
1181 }
1182
1183 #[tokio::test]
1196 async fn path_form_account_document_endpoint_is_a_hard_error() {
1197 use crate::auth::user_store::{
1198 PubkeyEntry, UserFilter, UserProfile, UserProfilePatch, UserStore,
1199 };
1200 use crate::config::server::CorsConfig;
1201 use crate::config::OAuthConfig;
1202 use crate::services::oauth::create_app;
1203 use async_trait::async_trait;
1204 use axum::body::Body;
1205 use axum::http::Request as HttpRequest;
1206 use hyprstream_rpc::rpc_client::RpcClientImpl;
1207 use hyprstream_rpc::signer::LocalSigner;
1208 use hyprstream_rpc::transport::lazy_uds::LazyUdsTransport;
1209 use hyprstream_rpc_std::discovery_client::DiscoveryClient;
1210 use hyprstream_rpc_std::policy_client::PolicyClient;
1211 use tower::ServiceExt; struct UntouchedUserStore;
1218 #[async_trait]
1219 impl UserStore for UntouchedUserStore {
1220 async fn get_profile(&self, _: &str) -> anyhow::Result<Option<UserProfile>> {
1221 unreachable!("frozen account-DID handler must not read profiles")
1222 }
1223 async fn register(&self, _: &str) -> anyhow::Result<String> {
1224 unreachable!()
1225 }
1226 async fn set_profile(&self, _: &str, _: UserProfilePatch) -> anyhow::Result<()> {
1227 unreachable!()
1228 }
1229 async fn remove(&self, _: &str) -> anyhow::Result<bool> {
1230 unreachable!()
1231 }
1232 async fn list_users(&self) -> anyhow::Result<Vec<String>> {
1233 unreachable!()
1234 }
1235 async fn search(&self, _: &UserFilter) -> anyhow::Result<Vec<(String, UserProfile)>> {
1236 unreachable!()
1237 }
1238 async fn set_active(&self, _: &str, _: bool) -> anyhow::Result<()> {
1239 unreachable!()
1240 }
1241 async fn list_pubkeys(&self, _: &str) -> anyhow::Result<Vec<PubkeyEntry>> {
1242 unreachable!("frozen account-DID handler must not call list_pubkeys (#1159)")
1246 }
1247 async fn add_pubkey(
1248 &self,
1249 _: &str,
1250 _: VerifyingKey,
1251 _: Option<String>,
1252 ) -> anyhow::Result<String> {
1253 unreachable!()
1254 }
1255 async fn add_pubkey_hybrid(
1256 &self,
1257 _: &str,
1258 _: VerifyingKey,
1259 _: Vec<u8>,
1260 _: Option<String>,
1261 ) -> anyhow::Result<String> {
1262 unreachable!()
1263 }
1264 async fn remove_pubkey(&self, _: &str, _: &str) -> anyhow::Result<bool> {
1265 unreachable!()
1266 }
1267 async fn get_pubkey_user(&self, _: &str) -> anyhow::Result<Option<String>> {
1268 unreachable!()
1269 }
1270 async fn touch_pubkey(&self, _: &str, _: &str) -> anyhow::Result<()> {
1271 unreachable!()
1272 }
1273 }
1274
1275 let key = SigningKey::from_bytes(&[0x76; 32]);
1279 let vk = SigningKey::from_bytes(&[0x73; 32]).verifying_key();
1280 let dummy = std::path::PathBuf::from("/dev/null/did-doc-test.sock");
1281 let mk_client = || {
1282 let rpc = RpcClientImpl::new(
1283 LocalSigner::new(key.clone()),
1284 LazyUdsTransport::new(dummy.clone()),
1285 Some(vk),
1286 )
1287 .with_response_verify_policy(hyprstream_rpc::crypto::CryptoPolicy::Classical);
1288 Arc::new(rpc)
1289 };
1290 let state = Arc::new(
1291 OAuthState::new(
1292 &OAuthConfig::default(),
1293 PolicyClient::new(mk_client()),
1294 DiscoveryClient::new(mk_client()),
1295 [0x76; 32],
1296 )
1297 .with_user_service(Arc::new(
1298 crate::services::oauth::user_service::UserService::new(
1299 crate::auth::ProductionUserStore::for_test(Arc::new(UntouchedUserStore)),
1300 ),
1301 )),
1302 );
1303
1304 let cors = CorsConfig {
1305 enabled: false,
1306 ..Default::default()
1307 };
1308 let app = create_app(state, &cors);
1309
1310 let response = app
1311 .oneshot(
1312 HttpRequest::builder()
1313 .uri("/users/alice/did.json")
1314 .body(Body::empty())
1315 .unwrap(),
1316 )
1317 .await
1318 .unwrap();
1319 assert_eq!(response.status(), StatusCode::GONE);
1320 let body = axum::body::to_bytes(response.into_body(), 4096)
1321 .await
1322 .unwrap();
1323 assert!(
1324 std::str::from_utf8(&body)
1325 .unwrap()
1326 .contains("path-form account minting is disabled"),
1327 "body was: {}",
1328 std::str::from_utf8(&body).unwrap(),
1329 );
1330 }
1331
1332 #[test]
1333 fn ipv6_issuer_does_not_synthesize_atproto_handle() {
1334 assert_eq!(configured_handle_host("https://[::1]:6791"), None);
1335 assert_eq!(account_handle("alice", "https://[::1]:6791"), None);
1336 }
1337
1338 #[test]
1339 fn invalid_username_label_does_not_synthesize_atproto_handle() {
1340 assert_eq!(account_handle("alice_bad", "https://pds.example.com"), None);
1341 assert_eq!(
1342 account_handle("Alice", "https://PDS.Example.COM").as_deref(),
1343 Some("alice.pds.example.com")
1344 );
1345 }
1346
1347 #[test]
1348 fn ed25519_multibase_format() {
1349 let sk = SigningKey::generate(&mut OsRng);
1350 let mb = ed25519_to_multibase(&sk.verifying_key());
1351 assert!(mb.starts_with('z'), "must use base58btc multibase prefix");
1352 let decoded = bs58::decode(&mb[1..]).into_vec().unwrap();
1354 assert_eq!(decoded[0], 0xed);
1355 assert_eq!(decoded[1], 0x01);
1356 assert_eq!(&decoded[2..], sk.verifying_key().as_bytes());
1357 }
1358
1359 #[test]
1360 fn build_did_doc_minimum_structure() {
1361 let sk = SigningKey::generate(&mut OsRng);
1362 let did = "did:web:alice.hyprstream.example.com";
1363 let doc = build_did_document(
1364 did,
1365 "https://hyprstream.example.com",
1366 &[("key-1".to_owned(), sk.verifying_key())],
1367 None,
1368 &[],
1369 None,
1370 None,
1371 );
1372 assert_eq!(doc["id"].as_str().unwrap(), did);
1373 assert!(doc["@context"].is_array());
1374 assert_eq!(doc["verificationMethod"].as_array().unwrap().len(), 2); let vm = &doc["verificationMethod"][0];
1377 assert_eq!(vm["type"].as_str().unwrap(), "Multikey");
1378 assert!(vm["publicKeyMultibase"].as_str().unwrap().starts_with('z'));
1379 assert_eq!(
1381 doc["verificationMethod"][1]["type"].as_str().unwrap(),
1382 "JsonWebKey2020"
1383 );
1384 assert_eq!(
1385 doc["service"][0]["type"].as_str().unwrap(),
1386 "HyprstreamService"
1387 );
1388 assert_eq!(
1389 doc["service"][0]["serviceEndpoint"].as_str().unwrap(),
1390 "https://hyprstream.example.com",
1391 );
1392 }
1393
1394 #[test]
1395 fn build_did_doc_empty_keys_is_valid() {
1396 let did = "did:web:alice.example.com";
1397 let doc = build_did_document(did, "https://example.com", &[], None, &[], None, None);
1398 assert_eq!(doc["id"].as_str().unwrap(), did);
1399 assert_eq!(doc["verificationMethod"].as_array().unwrap().len(), 0);
1400 assert_eq!(doc["authentication"].as_array().unwrap().len(), 0);
1401 }
1402
1403 #[test]
1404 fn p256_multibase_format() {
1405 let sk = p256::ecdsa::SigningKey::random(&mut OsRng);
1406 let mb = p256_to_multibase(sk.verifying_key());
1407 assert!(mb.starts_with('z'), "must use base58btc multibase prefix");
1408 let decoded = bs58::decode(&mb[1..]).into_vec().unwrap();
1409 assert_eq!(decoded[0], 0x80);
1411 assert_eq!(decoded[1], 0x24);
1412 assert_eq!(decoded.len(), 2 + 33);
1414 assert!(decoded[2] == 0x02 || decoded[2] == 0x03);
1415 }
1416
1417 #[test]
1418 fn build_did_doc_atproto_identity() {
1419 let ed = SigningKey::generate(&mut OsRng);
1420 let p256_sk = p256::ecdsa::SigningKey::random(&mut OsRng);
1421 let p256_vk = p256_sk.verifying_key();
1422 let did = "did:web:hyprstream.example.com";
1423 let atproto = AtprotoIdentity {
1424 p256_vk,
1425 handle: "hyprstream.example.com",
1426 drain: None,
1427 lead: None,
1428 };
1429 let transports = [TransportEndpoint {
1430 fragment: "iroh".to_owned(),
1431 vm_type: "IrohTransport".to_owned(),
1432 endpoint: json!({ "uri": "iroh:abc", "accept": ["hyprstream-rpc/1", "moql"] }),
1433 }];
1434 let doc = build_did_document(
1435 did,
1436 "https://hyprstream.example.com/oauth",
1438 &[("key-1".to_owned(), ed.verifying_key())],
1439 Some(&atproto),
1440 &transports,
1441 None,
1442 None,
1443 );
1444
1445 let vms = doc["verificationMethod"].as_array().unwrap();
1447 assert_eq!(vms[0]["id"].as_str().unwrap(), format!("{did}#atproto"));
1448 assert_eq!(vms[0]["type"].as_str().unwrap(), "Multikey");
1449 assert!(vms[0]["publicKeyMultibase"]
1450 .as_str()
1451 .unwrap()
1452 .starts_with('z'));
1453 assert_eq!(vms.len(), 1 + 2);
1455 assert_eq!(vms[1]["type"].as_str().unwrap(), "Multikey");
1458 assert!(vms[1]["publicKeyMultibase"]
1459 .as_str()
1460 .unwrap()
1461 .starts_with('z'));
1462 assert_eq!(vms[2]["type"].as_str().unwrap(), "JsonWebKey2020");
1463
1464 let svcs = doc["service"].as_array().unwrap();
1466 assert_eq!(
1467 svcs[0]["id"].as_str().unwrap(),
1468 format!("{did}#atproto_pds")
1469 );
1470 assert_eq!(
1471 svcs[0]["type"].as_str().unwrap(),
1472 "AtprotoPersonalDataServer"
1473 );
1474 assert_eq!(
1475 svcs[0]["serviceEndpoint"].as_str().unwrap(),
1476 "https://hyprstream.example.com"
1477 );
1478 let iroh = svcs.iter().find(|s| s["type"] == "IrohTransport").unwrap();
1480 assert_eq!(iroh["id"].as_str().unwrap(), format!("{did}#iroh"));
1481 assert!(iroh["serviceEndpoint"]["accept"].is_array());
1482
1483 assert_eq!(
1485 doc["alsoKnownAs"][0].as_str().unwrap(),
1486 "at://hyprstream.example.com"
1487 );
1488 }
1489
1490 #[test]
1497 fn per_user_atproto_doc_pds_service_points_at_issuer() {
1498 let p256_sk = p256::ecdsa::SigningKey::random(&mut OsRng);
1499 let p256_vk = p256_sk.verifying_key();
1500 let issuer = "https://pds.example.com";
1501 let did = "did:web:pds.example.com:users:alice";
1502 let handle = "alice.pds.example.com";
1503 let atproto = AtprotoIdentity {
1504 p256_vk,
1505 handle,
1506 drain: None,
1507 lead: None,
1508 };
1509 let doc = build_did_document(did, issuer, &[], Some(&atproto), &[], None, None);
1510
1511 let pds = doc["service"]
1513 .as_array()
1514 .unwrap()
1515 .iter()
1516 .find(|s| s["type"] == "AtprotoPersonalDataServer")
1517 .expect("AtprotoPersonalDataServer service required for the sub→PDS round-trip");
1518 assert_eq!(
1519 pds["serviceEndpoint"].as_str().unwrap(),
1520 issuer,
1521 "PDS serviceEndpoint MUST equal the AS issuer (PDS = its own AS)"
1522 );
1523 assert_eq!(
1525 doc["alsoKnownAs"][0].as_str().unwrap(),
1526 "at://alice.pds.example.com"
1527 );
1528 assert!(doc["verificationMethod"]
1530 .as_array()
1531 .unwrap()
1532 .iter()
1533 .any(|vm| vm["id"].as_str() == Some(&format!("{did}#atproto"))));
1534 }
1535
1536 #[test]
1539 fn build_did_doc_publishes_bounded_overlap_slots() {
1540 let active_sk = p256::ecdsa::SigningKey::random(&mut OsRng);
1541 let active_vk = active_sk.verifying_key();
1542 let drain_sk = p256::ecdsa::SigningKey::random(&mut OsRng);
1543 let drain_vk = drain_sk.verifying_key();
1544 let lead_sk = p256::ecdsa::SigningKey::random(&mut OsRng);
1545 let lead_vk = lead_sk.verifying_key();
1546 let did = "did:web:hyprstream.example.com";
1547 let atproto = AtprotoIdentity {
1548 p256_vk: active_vk,
1549 handle: "hyprstream.example.com",
1550 drain: Some(AtprotoOverlapKey {
1551 vk: drain_vk,
1552 nbf: 1_000,
1553 exp: 2_000,
1554 }),
1555 lead: Some(AtprotoOverlapKey {
1556 vk: lead_vk,
1557 nbf: 1_500,
1558 exp: 3_000,
1559 }),
1560 };
1561 let doc = build_did_document(
1562 did,
1563 "https://hyprstream.example.com",
1564 &[],
1565 Some(&atproto),
1566 &[],
1567 None,
1568 None,
1569 );
1570 let vms = doc["verificationMethod"].as_array().unwrap();
1571 assert_eq!(vms[0]["id"].as_str().unwrap(), format!("{did}#atproto"));
1572 assert_eq!(
1575 vms.iter()
1576 .filter(|v| v["id"]
1577 .as_str()
1578 .map(|s| s.ends_with("#atproto"))
1579 .unwrap_or(false))
1580 .count(),
1581 1,
1582 "exactly one active #atproto method"
1583 );
1584 let drain = vms
1585 .iter()
1586 .find(|v| v["id"] == format!("{did}#atproto_drain"))
1587 .unwrap();
1588 assert_eq!(drain["nbf"], 1_000);
1589 assert_eq!(drain["exp"], 2_000);
1590 let lead = vms
1591 .iter()
1592 .find(|v| v["id"] == format!("{did}#atproto_lead"))
1593 .unwrap();
1594 assert_eq!(lead["nbf"], 1_500);
1595 assert_eq!(lead["exp"], 3_000);
1596
1597 let published = hyprstream_pds::commit::PublishedAtprotoKeys::from_did_document(&doc, did)
1598 .expect("published overlap document parses");
1599 assert_eq!(published.len(), 3);
1600 assert_eq!(published.live_keys(1_250).count(), 2, "active + drain");
1601 assert_eq!(published.live_keys(2_500).count(), 2, "active + lead");
1602 }
1603
1604 #[test]
1605 fn root_identity_publisher_and_consumer_enforce_bounded_overlap() {
1606 use hyprstream_rpc::admission::AdmittedIdentity;
1607 use hyprstream_rpc::auth::mac::Assurance;
1608 use hyprstream_rpc::auth::AtprotoPerimeterGateway;
1609 use hyprstream_rpc::identity_resolver::{DidDocumentProvider, MethodDispatchResolver};
1610
1611 #[derive(Clone)]
1612 struct Docs(Value);
1613 impl DidDocumentProvider for Docs {
1614 fn document(&self, _did: &str) -> anyhow::Result<Value> {
1615 Ok(self.0.clone())
1616 }
1617 }
1618
1619 let old = SigningKey::generate(&mut OsRng);
1620 let new = SigningKey::generate(&mut OsRng);
1621 let lead = SigningKey::generate(&mut OsRng);
1622 let old_pq = hyprstream_rpc::node_identity::derive_mesh_mldsa_key(&old);
1623 let old_pq = hyprstream_rpc::crypto::pq::ml_dsa_sk_to_vk_bytes(&old_pq);
1624 let slots = crate::auth::key_rotation::KeySlots {
1625 drain: Some(crate::auth::key_rotation::KeySlot::new(
1626 old.clone(),
1627 100,
1628 200,
1629 )),
1630 active: Some(crate::auth::key_rotation::KeySlot::new(
1631 new.clone(),
1632 150,
1633 400,
1634 )),
1635 lead: Some(crate::auth::key_rotation::KeySlot::new(
1636 lead.clone(),
1637 350,
1638 550,
1639 )),
1640 };
1641 let methods = root_identity_methods(&old, &old_pq, Some(&slots), 175);
1642 let did = "did:web:peer.example";
1643 let mut doc = build_did_document(did, "https://peer.example", &[], None, &[], None, None);
1644 append_root_identity_methods(&mut doc, did, &methods);
1645
1646 let ids: Vec<_> = doc["verificationMethod"]
1647 .as_array()
1648 .unwrap()
1649 .iter()
1650 .filter_map(|vm| vm["id"].as_str())
1651 .collect();
1652 assert!(ids.contains(&format!("{did}#key-1").as_str()));
1653 assert!(ids.contains(&format!("{did}#key-1-pq").as_str()));
1654 assert!(ids.contains(&format!("{did}#mesh-pq").as_str()));
1655 assert!(
1656 ids.iter().any(|id| id.contains("#mesh-")),
1657 "named rotation slots must be published"
1658 );
1659 let vms = doc["verificationMethod"].as_array().unwrap();
1663 let first_ed = vms
1664 .iter()
1665 .filter_map(|vm| vm["publicKeyMultibase"].as_str())
1666 .find_map(|multibase| hyprstream_rpc::did_web::decode_ed25519_multikey(multibase).ok())
1667 .unwrap();
1668 let first_pq = vms
1669 .iter()
1670 .filter_map(|vm| vm["publicKeyMultibase"].as_str())
1671 .find_map(|multibase| {
1672 hyprstream_rpc::did_web::decode_multikey(
1673 multibase,
1674 &hyprstream_rpc::did_web::MULTICODEC_ML_DSA_65_PUB,
1675 )
1676 .ok()
1677 })
1678 .unwrap();
1679 assert_eq!(first_ed, old.verifying_key().to_bytes());
1680 assert_eq!(first_pq, old_pq);
1681
1682 let now = Arc::new(std::sync::atomic::AtomicI64::new(175));
1683 let clock = Arc::clone(&now);
1684 let resolver = MethodDispatchResolver::new(Docs(doc))
1685 .with_clock(move || clock.load(std::sync::atomic::Ordering::SeqCst));
1686 let gateway = AtprotoPerimeterGateway::new(resolver);
1687 let admitted = |key: &SigningKey| AdmittedIdentity {
1688 origin: "https://peer.example".to_owned(),
1689 did: Some(did.to_owned()),
1690 key: key.verifying_key().to_bytes(),
1691 };
1692
1693 let old_peer = gateway
1694 .enroll(&admitted(&old))
1695 .expect("drain signer accepted during overlap");
1696 let new_peer = gateway
1697 .enroll(&admitted(&new))
1698 .expect("active signer accepted during overlap");
1699 assert_eq!(old_peer.assurance, Assurance::PqHybrid);
1700 assert_eq!(new_peer.assurance, Assurance::PqHybrid);
1701 assert!(
1702 gateway.enroll(&admitted(&lead)).is_err(),
1703 "lead is published before use but not accepted before nbf"
1704 );
1705
1706 now.store(200, std::sync::atomic::Ordering::SeqCst);
1707 assert!(
1708 gateway.enroll(&admitted(&old)).is_err(),
1709 "retired signer must fail exactly when its bound closes"
1710 );
1711 assert!(gateway.enroll(&admitted(&new)).is_ok());
1712 }
1713
1714 #[test]
1715 fn extract_jwks_filters_non_ed25519() {
1716 let jwks = json!({
1717 "keys": [
1718 {"kty": "OKP", "crv": "Ed25519", "x": URL_SAFE_NO_PAD.encode([1u8; 32]), "kid": "good"},
1719 {"kty": "EC", "crv": "P-256", "kid": "p256-not-ed25519"},
1720 {"kty": "OKP", "crv": "X25519", "kid": "wrong-curve"},
1721 ]
1722 });
1723 let keys = extract_ed25519_keys_from_jwks(&Some(jwks));
1724 assert_eq!(keys.len(), 1);
1725 assert_eq!(keys[0].0, "good");
1726 }
1727
1728 #[test]
1729 fn mesh_ed25519_vm_is_multikey() {
1730 let sk = SigningKey::generate(&mut OsRng);
1733 let did = "did:web:hyprstream.example.com";
1734 let vm = ed25519_verification_method(did, "mesh", &sk.verifying_key());
1735 assert_eq!(vm["id"].as_str().unwrap(), format!("{did}#mesh"));
1736 assert_eq!(vm["type"].as_str().unwrap(), "Multikey");
1737 assert_eq!(vm["controller"].as_str().unwrap(), did);
1738 let mb = vm["publicKeyMultibase"].as_str().unwrap();
1739 assert!(
1740 mb.starts_with('z'),
1741 "Multikey publicKeyMultibase must be base58btc multibase"
1742 );
1743 let decoded = bs58::decode(&mb[1..]).into_vec().unwrap();
1745 assert_eq!(&decoded[..2], &[0xed, 0x01]);
1746 assert_eq!(&decoded[2..], sk.verifying_key().as_bytes());
1747 }
1748
1749 #[test]
1750 fn mldsa65_multibase_multicodec_round_trip() {
1751 let vk_bytes = vec![0xABu8; 1952];
1754 let mb = mldsa65_to_multibase(&vk_bytes);
1755 assert!(mb.starts_with('z'), "must use base58btc multibase prefix");
1756 let decoded = bs58::decode(&mb[1..]).into_vec().unwrap();
1757 assert_eq!(&decoded[..2], &[0x91, 0x24]);
1759 assert_eq!(&decoded[2..], vk_bytes.as_slice());
1761 assert_eq!(decoded.len(), 2 + 1952);
1762 }
1763
1764 #[test]
1765 fn build_did_doc_publishes_mesh_pq_vm() {
1766 let sk = SigningKey::generate(&mut OsRng);
1770 let did = "did:web:hyprstream.example.com";
1771 let vk_bytes = vec![0x42u8; 1952];
1772 let doc = build_did_document(
1773 did,
1774 "https://hyprstream.example.com",
1775 &[("key-1".to_owned(), sk.verifying_key())],
1776 None,
1777 &[],
1778 Some(&vk_bytes),
1779 None,
1780 );
1781 let vms = doc["verificationMethod"].as_array().unwrap();
1782 assert_eq!(vms.len(), 3);
1784 let pq = vms
1785 .iter()
1786 .find(|v| v["id"] == format!("{did}#mesh-pq"))
1787 .unwrap();
1788 assert_eq!(pq["type"].as_str().unwrap(), "Multikey");
1789 let mb = pq["publicKeyMultibase"].as_str().unwrap();
1790 let decoded = bs58::decode(&mb[1..]).into_vec().unwrap();
1791 assert_eq!(&decoded[..2], &[0x91, 0x24]); assert_eq!(&decoded[2..], vk_bytes.as_slice());
1793 let mesh_pq_id = format!("{did}#mesh-pq");
1795 assert!(doc["authentication"]
1796 .as_array()
1797 .unwrap()
1798 .iter()
1799 .any(|v| *v == mesh_pq_id));
1800 assert!(doc["assertionMethod"]
1801 .as_array()
1802 .unwrap()
1803 .iter()
1804 .any(|v| *v == mesh_pq_id));
1805 }
1806
1807 #[test]
1808 fn mesh_pq_vm_matches_derived_signing_key() {
1809 let sk = SigningKey::generate(&mut OsRng);
1813 let pq_sk = hyprstream_rpc::node_identity::derive_mesh_mldsa_key(&sk);
1814 let pq_vk_bytes = hyprstream_rpc::crypto::pq::ml_dsa_sk_to_vk_bytes(&pq_sk);
1815
1816 let did = "did:web:hyprstream.example.com";
1817 let doc = build_did_document(
1818 did,
1819 "https://hyprstream.example.com",
1820 &[("key-1".to_owned(), sk.verifying_key())],
1821 None,
1822 &[],
1823 Some(&pq_vk_bytes),
1824 None,
1825 );
1826 let vms = doc["verificationMethod"].as_array().unwrap();
1827 let pq = vms
1828 .iter()
1829 .find(|v| v["id"] == format!("{did}#mesh-pq"))
1830 .unwrap();
1831 let mb = pq["publicKeyMultibase"].as_str().unwrap();
1832 let decoded = bs58::decode(&mb[1..]).into_vec().unwrap();
1833 assert_eq!(
1834 &decoded[2..],
1835 pq_vk_bytes.as_slice(),
1836 "published #mesh-pq key must equal the derived mesh signing key's public key"
1837 );
1838 }
1839
1840 #[test]
1841 fn root_doc_advertises_iroh_only_as_transport_when_bound() {
1842 let oauth_sk = SigningKey::generate(&mut OsRng);
1845 let node_sk = SigningKey::generate(&mut OsRng);
1846 let node_id = node_sk.verifying_key().to_bytes();
1847 let did = "did:web:hyprstream.example.com";
1848
1849 let keys = vec![("key-1".to_owned(), oauth_sk.verifying_key())];
1850 let transports = [TransportEndpoint {
1851 fragment: "iroh".to_owned(),
1852 vm_type: "IrohTransport".to_owned(),
1853 endpoint: hyprstream_rpc::service_entry::encode_iroh(
1854 &node_id,
1855 &[],
1856 &["hyprstream-rpc/1"],
1857 ),
1858 }];
1859 let doc = build_did_document(
1860 did,
1861 "https://hyprstream.example.com",
1862 &keys,
1863 None,
1864 &transports,
1865 None,
1866 None,
1867 );
1868
1869 let vms = doc["verificationMethod"].as_array().unwrap();
1871 assert!(vms.iter().all(|v| v["id"] != format!("{did}#iroh")));
1872
1873 let svcs = doc["service"].as_array().unwrap();
1875 let iroh_svc = svcs
1876 .iter()
1877 .find(|s| s["type"] == "IrohTransport")
1878 .expect("IrohTransport service entry must be advertised");
1879 assert_eq!(iroh_svc["id"].as_str().unwrap(), format!("{did}#iroh"));
1880 let accept = iroh_svc["serviceEndpoint"]["accept"].as_array().unwrap();
1881 let accept: Vec<&str> = accept.iter().filter_map(|v| v.as_str()).collect();
1882 assert_eq!(accept, vec!["hyprstream-rpc/1"]);
1883 }
1884
1885 #[test]
1886 fn root_doc_omits_iroh_when_not_bound() {
1887 let sk = SigningKey::generate(&mut OsRng);
1889 let did = "did:web:hyprstream.example.com";
1890 let doc = build_did_document(
1891 did,
1892 "https://hyprstream.example.com",
1893 &[("key-1".to_owned(), sk.verifying_key())],
1894 None,
1895 &[],
1896 None,
1897 None,
1898 );
1899 let vms = doc["verificationMethod"].as_array().unwrap();
1900 assert!(
1901 !vms.iter().any(|v| v["id"] == format!("{did}#iroh")),
1902 "carrier NodeId is never a DID verification method"
1903 );
1904 let svcs = doc["service"].as_array().unwrap();
1905 assert!(
1906 !svcs.iter().any(|s| s["type"] == "IrohTransport"),
1907 "no IrohTransport entry when iroh is not bound"
1908 );
1909 }
1910
1911 #[test]
1912 fn build_did_doc_omits_key_agreement_when_mesh_kem_absent() {
1913 let sk = SigningKey::generate(&mut OsRng);
1918 let did = "did:web:hyprstream.example.com";
1919 let doc = build_did_document(
1920 did,
1921 "https://hyprstream.example.com",
1922 &[("key-1".to_owned(), sk.verifying_key())],
1923 None,
1924 &[],
1925 None,
1926 None,
1927 );
1928 assert_eq!(doc["keyAgreement"].as_array().unwrap().len(), 0);
1929 }
1930
1931 #[test]
1932 fn build_did_doc_publishes_mesh_kem_key_agreement() {
1933 let node_sk = SigningKey::generate(&mut OsRng);
1939 let kem_kp = hyprstream_rpc::node_identity::derive_mesh_kem_recipient(&node_sk)
1940 .expect("derive #mesh-kem recipient");
1941 let kem_pub = kem_kp.public();
1942
1943 let did = "did:web:hyprstream.example.com";
1944 let doc = build_did_document(
1945 did,
1946 "https://hyprstream.example.com",
1947 &[("key-1".to_owned(), node_sk.verifying_key())],
1948 None,
1949 &[],
1950 None,
1951 Some(&kem_pub),
1952 );
1953
1954 let kas = doc["keyAgreement"].as_array().unwrap();
1957 assert_eq!(kas.len(), 2);
1958 assert_eq!(
1959 kas[0]["id"].as_str().unwrap(),
1960 format!("{did}#mesh-kem-x25519")
1961 );
1962 assert_eq!(kas[0]["type"].as_str().unwrap(), "Multikey");
1963 assert_eq!(
1964 kas[1]["id"].as_str().unwrap(),
1965 format!("{did}#mesh-kem-mlkem768")
1966 );
1967 assert_eq!(kas[1]["type"].as_str().unwrap(), "Multikey");
1968
1969 let vms = doc["verificationMethod"].as_array().unwrap();
1970 assert!(!vms
1971 .iter()
1972 .any(|v| v["id"] == format!("{did}#mesh-kem-x25519")));
1973 assert!(!vms
1974 .iter()
1975 .any(|v| v["id"] == format!("{did}#mesh-kem-mlkem768")));
1976 assert!(!doc["authentication"]
1977 .as_array()
1978 .unwrap()
1979 .iter()
1980 .any(|v| v.as_str().map(|s| s.contains("mesh-kem")).unwrap_or(false)));
1981
1982 let mb = kas[0]["publicKeyMultibase"].as_str().unwrap();
1985 let decoded = bs58::decode(&mb[1..]).into_vec().unwrap();
1986 assert_eq!(&decoded[..2], &MULTICODEC_X25519_PUB);
1987 assert_eq!(&decoded[2..], kem_pub.eks[0].as_slice());
1988
1989 let mb2 = kas[1]["publicKeyMultibase"].as_str().unwrap();
1990 let decoded2 = bs58::decode(&mb2[1..]).into_vec().unwrap();
1991 assert_eq!(&decoded2[..2], &MULTICODEC_ML_KEM_768_PUB);
1992 assert_eq!(&decoded2[2..], kem_pub.eks[1].as_slice());
1993 }
1994
1995 #[test]
1996 fn mldsa65_verification_method_is_multikey() {
1997 let did = "did:web:hyprstream.example.com";
1998 let vk_bytes = vec![0x07u8; 1952];
1999 let vm = mldsa65_verification_method(did, "mesh-pq", &vk_bytes);
2000 assert_eq!(vm["id"].as_str().unwrap(), format!("{did}#mesh-pq"));
2001 assert_eq!(vm["type"].as_str().unwrap(), "Multikey");
2002 assert_eq!(vm["controller"].as_str().unwrap(), did);
2003 let mb = vm["publicKeyMultibase"].as_str().unwrap();
2004 let decoded = bs58::decode(&mb[1..]).into_vec().unwrap();
2005 assert_eq!(&decoded[..2], &[0x91, 0x24]); assert_eq!(&decoded[2..], vk_bytes.as_slice());
2007 }
2008}