1use std::collections::BTreeMap;
10use std::sync::Arc;
11
12use anyhow::{bail, ensure, Result};
13use async_trait::async_trait;
14use hyprstream_rpc::admission::DidDocResolve;
15use hyprstream_rpc::auth::mac::{SecurityContext, SecurityLabel};
16use hyprstream_rpc::auth::Claims;
17use hyprstream_rpc::identity::UNAUTHENTICATED_DID_SENTINEL;
18use parking_lot::RwLock;
19use serde::{Deserialize, Serialize};
20use serde_json::Value;
21use thiserror::Error;
22
23#[derive(Clone, Copy, Debug, Error, PartialEq, Eq)]
29pub enum IdentityDirectoryReadError {
30 #[error("identity not found")]
32 NotFound,
33}
34
35pub struct FederatedDidResolver {
41 plc: Arc<dyn DidDocResolve>,
42 web: Arc<dyn DidDocResolve>,
43}
44
45impl FederatedDidResolver {
46 pub fn new(plc: Arc<dyn DidDocResolve>, web: Arc<dyn DidDocResolve>) -> Self {
48 Self { plc, web }
49 }
50}
51
52#[async_trait]
54pub trait FederatedDidDocumentResolver: Send + Sync {
55 async fn resolve_federated_document(&self, did: &str) -> Result<Value>;
57}
58
59#[async_trait]
60impl FederatedDidDocumentResolver for FederatedDidResolver {
61 async fn resolve_federated_document(&self, did: &str) -> Result<Value> {
62 ensure_real_identity_did(did)?;
63 let resolver = if hyprstream_rpc::did_plc::is_did_plc(did) {
64 &self.plc
65 } else if did.starts_with("did:web:") {
66 &self.web
67 } else {
68 bail!("unsupported federated DID method: {did}");
69 };
70 let document = resolver.resolve_doc(did).await?;
71 ensure!(
72 document.get("id").and_then(Value::as_str) == Some(did),
73 "resolved DID document id does not match requested DID {did}"
74 );
75 Ok(document)
76 }
77}
78
79#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize)]
81#[serde(rename_all = "lowercase")]
82pub enum InventoryKind {
83 Local,
85 Federated,
87 Unauthenticated,
89}
90
91#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
97#[serde(rename_all = "camelCase")]
98pub struct InventoryEntry {
99 did: String,
100 handle: Option<String>,
101 kind: InventoryKind,
102 tenant: Option<String>,
103 pds_endpoint: Option<String>,
104}
105
106impl InventoryEntry {
107 fn federated(did: String, document: &Value) -> Result<Self> {
108 Self::indexed_federated(
109 did,
110 extract_handle(document)?,
111 extract_pds_endpoint(document)?,
112 )
113 }
114
115 pub fn local(
120 did: impl Into<String>,
121 handle: Option<String>,
122 tenant: impl Into<String>,
123 pds_endpoint: Option<String>,
124 ) -> Result<Self> {
125 let entry = Self {
126 did: did.into(),
127 handle,
128 kind: InventoryKind::Local,
129 tenant: Some(tenant.into()),
130 pds_endpoint,
131 };
132 entry.validate()?;
133 Ok(entry)
134 }
135
136 pub fn indexed_federated(
138 did: impl Into<String>,
139 handle: Option<String>,
140 pds_endpoint: Option<String>,
141 ) -> Result<Self> {
142 let entry = Self {
143 did: did.into(),
144 handle,
145 kind: InventoryKind::Federated,
146 tenant: None,
147 pds_endpoint,
148 };
149 entry.validate()?;
150 Ok(entry)
151 }
152
153 pub fn validate(&self) -> Result<()> {
155 ensure_real_identity_did(&self.did)?;
156 ensure!(!self.did.is_empty(), "inventory DID must not be empty");
157 ensure!(
158 self.handle.as_deref().is_none_or(|value| !value.is_empty()),
159 "inventory handle must not be empty"
160 );
161 ensure!(
162 self.pds_endpoint
163 .as_deref()
164 .is_none_or(|value| !value.is_empty()),
165 "inventory PDS endpoint must not be empty"
166 );
167 match self.kind {
168 InventoryKind::Local => ensure!(
169 self.tenant
170 .as_deref()
171 .is_some_and(|value| !value.is_empty()),
172 "local inventory entry requires an authority-resolved tenant"
173 ),
174 InventoryKind::Federated => ensure!(
175 self.tenant.is_none(),
176 "only a local inventory entry may carry a tenant"
177 ),
178 InventoryKind::Unauthenticated => {
179 bail!("the unauthenticated floor is not a listable inventory host")
180 }
181 }
182 Ok(())
183 }
184
185 pub fn did(&self) -> &str {
187 &self.did
188 }
189
190 pub fn handle(&self) -> Option<&str> {
192 self.handle.as_deref()
193 }
194
195 pub fn kind(&self) -> InventoryKind {
197 self.kind
198 }
199
200 pub fn tenant(&self) -> Option<&str> {
202 self.tenant.as_deref()
203 }
204
205 pub fn pds_endpoint(&self) -> Option<&str> {
207 self.pds_endpoint.as_deref()
208 }
209}
210
211#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
216#[serde(rename_all = "camelCase")]
217pub struct ResolvedDiscovery {
218 quic_url: Option<String>,
219 cert_hash: Option<String>,
220}
221
222impl ResolvedDiscovery {
223 fn from_document(document: &Value) -> Result<Self> {
224 let Some(services) = document.get("service").and_then(Value::as_array) else {
225 return Ok(Self {
226 quic_url: None,
227 cert_hash: None,
228 });
229 };
230 let mut quic_entries = services
231 .iter()
232 .filter(|entry| entry.get("type").and_then(Value::as_str) == Some("QuicTransport"));
233 let Some(entry) = quic_entries.next() else {
234 return Ok(Self {
235 quic_url: None,
236 cert_hash: None,
237 });
238 };
239 ensure!(
240 quic_entries.next().is_none(),
241 "DID document contains ambiguous QuicTransport discovery entries"
242 );
243 hyprstream_rpc::service_entry::decode_service_entry(entry)?;
244 let endpoint = entry
245 .get("serviceEndpoint")
246 .and_then(Value::as_object)
247 .ok_or_else(|| anyhow::anyhow!("QuicTransport serviceEndpoint is not an object"))?;
248 let quic_url = endpoint
249 .get("uri")
250 .and_then(Value::as_str)
251 .map(str::to_owned);
252 let cert_hashes = endpoint
253 .get("certHashes")
254 .and_then(Value::as_array)
255 .map(|hashes| {
256 hashes
257 .iter()
258 .map(|hash| {
259 hash.as_str()
260 .map(str::to_owned)
261 .ok_or_else(|| anyhow::anyhow!("QUIC cert hash is not a string"))
262 })
263 .collect::<Result<Vec<_>>>()
264 })
265 .transpose()?
266 .unwrap_or_default();
267 ensure!(
268 cert_hashes.len() <= 1,
269 "DID document contains ambiguous QUIC certificate hashes"
270 );
271 Ok(Self {
272 quic_url,
273 cert_hash: cert_hashes.into_iter().next(),
274 })
275 }
276
277 pub fn quic_url(&self) -> Option<&str> {
279 self.quic_url.as_deref()
280 }
281
282 pub fn cert_hash(&self) -> Option<&str> {
284 self.cert_hash.as_deref()
285 }
286}
287
288#[derive(Clone)]
289struct StoredInventoryEntry {
290 entry: InventoryEntry,
291 label: SecurityLabel,
292}
293
294#[async_trait]
299pub trait IdentityInventoryReadModel: Send + Sync {
300 async fn upsert_derived(&self, identity: InventoryEntry, label: SecurityLabel) -> Result<()>;
306
307 async fn query(
314 &self,
315 viewer: &SecurityContext,
316 filter: Option<&str>,
317 ) -> Result<Vec<InventoryEntry>> {
318 self.query_page(viewer, filter, None, 200).await
319 }
320
321 async fn query_page(
327 &self,
328 viewer: &SecurityContext,
329 filter: Option<&str>,
330 after: Option<&str>,
331 limit: usize,
332 ) -> Result<Vec<InventoryEntry>>;
333
334 async fn list(&self, viewer: &SecurityContext) -> Result<Vec<InventoryEntry>> {
336 self.query(viewer, None).await
337 }
338
339 async fn get(
344 &self,
345 viewer: Option<&SecurityContext>,
346 did: &str,
347 ) -> Result<Option<InventoryEntry>>;
348}
349
350#[derive(Default)]
352pub struct InMemoryIdentityInventory {
353 identities: RwLock<BTreeMap<String, StoredInventoryEntry>>,
354}
355
356#[async_trait]
357impl IdentityInventoryReadModel for InMemoryIdentityInventory {
358 async fn upsert_derived(&self, identity: InventoryEntry, label: SecurityLabel) -> Result<()> {
359 identity.validate()?;
360 let mut identities = self.identities.write();
361 if let Some(existing) = identities.get(identity.did()) {
362 ensure_safe_refresh(existing, &identity, &label)?;
363 }
364 identities.insert(
365 identity.did.clone(),
366 StoredInventoryEntry {
367 entry: identity,
368 label,
369 },
370 );
371 Ok(())
372 }
373
374 async fn query_page(
375 &self,
376 viewer: &SecurityContext,
377 filter: Option<&str>,
378 after: Option<&str>,
379 limit: usize,
380 ) -> Result<Vec<InventoryEntry>> {
381 ensure!(limit > 0, "inventory page limit must be positive");
382 let identities = self.identities.read();
383 Ok(identities
384 .values()
385 .filter(|stored| {
386 stored.entry.did() != UNAUTHENTICATED_DID_SENTINEL
387 && viewer.can_access(&stored.label)
388 && filter.is_none_or(|filter| matches_filter(&stored.entry, filter))
389 && after.is_none_or(|after| stored.entry.did() > after)
390 })
391 .map(|stored| stored.entry.clone())
392 .take(limit)
393 .collect())
394 }
395
396 async fn get(
397 &self,
398 viewer: Option<&SecurityContext>,
399 did: &str,
400 ) -> Result<Option<InventoryEntry>> {
401 if did == UNAUTHENTICATED_DID_SENTINEL {
402 return Ok(None);
403 }
404 let identities = self.identities.read();
405 Ok(identities
406 .get(did)
407 .filter(|stored| viewer.is_some_and(|clearance| clearance.can_access(&stored.label)))
408 .map(|stored| stored.entry.clone()))
409 }
410}
411
412fn ensure_safe_refresh(
413 existing: &StoredInventoryEntry,
414 incoming: &InventoryEntry,
415 incoming_label: &SecurityLabel,
416) -> Result<()> {
417 ensure!(
418 existing.entry.kind == incoming.kind,
419 "inventory refresh cannot change authority kind for {}",
420 incoming.did()
421 );
422 ensure!(
423 existing.entry.tenant == incoming.tenant,
424 "inventory refresh cannot change authority-resolved tenant for {}",
425 incoming.did()
426 );
427 ensure!(
428 incoming_label.can_access(&existing.label),
429 "inventory refresh cannot lower the security label for {}",
430 incoming.did()
431 );
432 Ok(())
433}
434
435pub struct FederationIntake {
437 resolver: Arc<dyn FederatedDidDocumentResolver>,
438 inventory: Arc<dyn IdentityInventoryReadModel>,
439 local_issuers: Vec<String>,
440}
441
442impl FederationIntake {
443 pub fn new(
445 resolver: Arc<dyn FederatedDidDocumentResolver>,
446 inventory: Arc<dyn IdentityInventoryReadModel>,
447 local_issuers: Vec<String>,
448 ) -> Self {
449 Self {
450 resolver,
451 inventory,
452 local_issuers,
453 }
454 }
455
456 pub async fn intake(&self, did: &str) -> Result<InventoryEntry> {
458 self.intake_inner(did).await
459 }
460
461 pub async fn intake_with_verified_claims(
469 &self,
470 did: &str,
471 mut claims: Claims,
472 ) -> Result<InventoryEntry> {
473 let local_issuers: Vec<&str> = self.local_issuers.iter().map(String::as_str).collect();
474 ensure!(
475 !claims.is_local_to(&local_issuers),
476 "federation intake requires claims from a foreign issuer"
477 );
478 claims.strip_federated_tenant(&local_issuers);
479 ensure!(
480 claims.tenant.is_none(),
481 "federated identity retained a local tenant after sanitization"
482 );
483 self.intake_inner(did).await
484 }
485
486 pub async fn resolve(
491 &self,
492 did: &str,
493 viewer: Option<&SecurityContext>,
494 ) -> Result<ResolvedDiscovery> {
495 if self.inventory.get(viewer, did).await?.is_none() {
496 return Err(IdentityDirectoryReadError::NotFound.into());
497 }
498 let document = self.resolver.resolve_federated_document(did).await?;
499 ResolvedDiscovery::from_document(&document)
500 }
501
502 async fn intake_inner(&self, did: &str) -> Result<InventoryEntry> {
503 ensure_real_identity_did(did)?;
504 let document = self.resolver.resolve_federated_document(did).await?;
505 let identity = InventoryEntry::federated(did.to_owned(), &document)?;
506 self.inventory
507 .upsert_derived(identity.clone(), SecurityLabel::bottom())
508 .await?;
509 Ok(identity)
510 }
511}
512
513fn matches_filter(entry: &InventoryEntry, filter: &str) -> bool {
514 let filter = filter.trim().to_lowercase();
515 filter.is_empty()
516 || entry.did.to_lowercase().contains(&filter)
517 || entry
518 .handle
519 .as_deref()
520 .is_some_and(|value| value.to_lowercase().contains(&filter))
521 || entry
522 .tenant
523 .as_deref()
524 .is_some_and(|value| value.to_lowercase().contains(&filter))
525 || entry
526 .pds_endpoint
527 .as_deref()
528 .is_some_and(|value| value.to_lowercase().contains(&filter))
529 || match entry.kind {
530 InventoryKind::Local => "local",
531 InventoryKind::Federated => "federated",
532 InventoryKind::Unauthenticated => "unauthenticated",
533 }
534 .contains(&filter)
535}
536
537fn extract_handle(document: &Value) -> Result<Option<String>> {
538 let Some(aliases) = document.get("alsoKnownAs").and_then(Value::as_array) else {
539 return Ok(None);
540 };
541 let handles = aliases
542 .iter()
543 .filter_map(Value::as_str)
544 .filter_map(|alias| alias.strip_prefix("at://"))
545 .filter(|handle| !handle.is_empty() && !handle.contains('/'))
546 .map(str::to_owned)
547 .collect::<Vec<_>>();
548 ensure!(
549 handles.len() <= 1,
550 "DID document contains ambiguous ATProto handles"
551 );
552 Ok(handles.into_iter().next())
553}
554
555fn extract_pds_endpoint(document: &Value) -> Result<Option<String>> {
556 let Some(services) = document.get("service").and_then(Value::as_array) else {
557 return Ok(None);
558 };
559 let endpoints = services
560 .iter()
561 .filter(|entry| {
562 entry.get("type").and_then(Value::as_str) == Some("AtprotoPersonalDataServer")
563 })
564 .map(|entry| {
565 entry
566 .get("serviceEndpoint")
567 .and_then(Value::as_str)
568 .map(str::to_owned)
569 .ok_or_else(|| anyhow::anyhow!("ATProto PDS serviceEndpoint is not a string"))
570 })
571 .collect::<Result<Vec<_>>>()?;
572 ensure!(
573 endpoints.len() <= 1,
574 "DID document contains ambiguous ATProto PDS endpoints"
575 );
576 Ok(endpoints.into_iter().next())
577}
578
579fn ensure_real_identity_did(did: &str) -> Result<()> {
580 ensure!(
581 did != UNAUTHENTICATED_DID_SENTINEL,
582 "{UNAUTHENTICATED_DID_SENTINEL} is reserved for the unauthenticated floor and is not a federated identity"
583 );
584 Ok(())
585}
586
587#[cfg(test)]
588mod tests {
589 #![allow(clippy::expect_used, clippy::unwrap_used)]
590
591 use super::*;
592 use hyprstream_rpc::auth::mac::{
593 CompartmentSet, Level, MacDecision, SecurityContext, VerifiedKeyMaterial,
594 };
595 use hyprstream_rpc::Subject;
596 use hyprstream_vfs::{SyntheticMount, SyntheticNode};
597
598 use crate::{AccountRecordReadAuthorizer, AccountRecordStore, OAUTH_ACCOUNT_RESOLVER_SUBJECT};
599
600 const FEDERATED_DID: &str = "did:plc:ewvi7nxzyoun6zhxrhs64oiz";
601 const FEDERATED_WEB_DID: &str = "did:web:alice.example";
602
603 struct FixtureResolver {
604 expected_did: &'static str,
605 document: Value,
606 }
607
608 #[async_trait]
609 impl DidDocResolve for FixtureResolver {
610 async fn resolve_doc(&self, did: &str) -> Result<Value> {
611 ensure!(did == self.expected_did, "unexpected DID {did}");
612 Ok(self.document.clone())
613 }
614 }
615
616 struct NeverResolver;
617
618 #[async_trait]
619 impl DidDocResolve for NeverResolver {
620 async fn resolve_doc(&self, did: &str) -> Result<Value> {
621 bail!("wrong resolver arm selected for {did}")
622 }
623 }
624
625 struct PermitAccountReads;
626
627 impl AccountRecordReadAuthorizer for PermitAccountReads {
628 fn check_read(
629 &self,
630 _subject: &Subject,
631 _verified_tenant: Option<&str>,
632 _security_context: Option<&SecurityContext>,
633 _object_id: &str,
634 ) -> MacDecision {
635 MacDecision::Permit
636 }
637 }
638
639 fn unauthenticated_viewer() -> SecurityContext {
640 SecurityContext::new(
641 Level::Public,
642 CompartmentSet::EMPTY,
643 VerifiedKeyMaterial::Unverified,
644 )
645 }
646
647 #[tokio::test]
648 async fn federated_did_resolves_lists_and_has_no_hosted_tenant() {
649 let resolver = Arc::new(FederatedDidResolver::new(
650 Arc::new(FixtureResolver {
651 expected_did: FEDERATED_DID,
652 document: serde_json::json!({
653 "id": FEDERATED_DID,
654 "alsoKnownAs": ["at://alice.example"],
655 "service": [{
656 "id": format!("{FEDERATED_DID}#atproto_pds"),
657 "type": "AtprotoPersonalDataServer",
658 "serviceEndpoint": "https://pds.alice.example"
659 }]
660 }),
661 }),
662 Arc::new(NeverResolver),
663 ));
664 let inventory = Arc::new(InMemoryIdentityInventory::default());
665 let intake = FederationIntake::new(
666 resolver,
667 inventory.clone(),
668 vec!["https://local.example".to_owned()],
669 );
670 let foreign_claims = Claims::new(FEDERATED_DID.to_owned(), 1, 2)
671 .with_issuer("https://foreign.example".to_owned())
672 .with_tenant("acme".to_owned());
673
674 let resolved = intake
675 .intake_with_verified_claims(FEDERATED_DID, foreign_claims)
676 .await
677 .unwrap();
678 assert_eq!(resolved.did(), FEDERATED_DID);
679 assert_eq!(resolved.handle(), Some("alice.example"));
680 assert_eq!(resolved.kind(), InventoryKind::Federated);
681 assert_eq!(resolved.tenant(), None);
682 assert_eq!(resolved.pds_endpoint(), Some("https://pds.alice.example"));
683
684 let listed = inventory.list(&unauthenticated_viewer()).await.unwrap();
685 assert_eq!(listed.len(), 1);
686 assert_eq!(listed[0].did(), FEDERATED_DID);
687 assert_eq!(listed[0].tenant(), None);
688 let projected = serde_json::to_value(&listed[0]).unwrap();
689 assert!(projected.get("quicUrl").is_none());
690 assert!(projected.get("certHash").is_none());
691 assert!(projected.get("certHashes").is_none());
692 assert!(projected.get("document").is_none());
693
694 let account_store = AccountRecordStore::new(
695 Arc::new(SyntheticMount::new(SyntheticNode::dir())),
696 Arc::new(PermitAccountReads),
697 );
698 let tenant = account_store
699 .resolve_tenant_for_hosted_did(
700 &Subject::new(OAUTH_ACCOUNT_RESOLVER_SUBJECT),
701 FEDERATED_DID,
702 )
703 .await
704 .unwrap();
705 assert_eq!(tenant, None);
706 }
707
708 #[tokio::test]
709 async fn method_dispatch_rejects_document_subject_mismatch() {
710 let resolver = FederatedDidResolver::new(
711 Arc::new(FixtureResolver {
712 expected_did: FEDERATED_DID,
713 document: serde_json::json!({ "id": "did:plc:z23456723456723456723456" }),
714 }),
715 Arc::new(NeverResolver),
716 );
717
718 let error = resolver
719 .resolve_federated_document(FEDERATED_DID)
720 .await
721 .unwrap_err();
722 assert!(error.to_string().contains("does not match"));
723 }
724
725 #[tokio::test]
726 async fn did_web_arm_resolves_and_lists_without_a_tenant() {
727 let resolver = Arc::new(FederatedDidResolver::new(
728 Arc::new(NeverResolver),
729 Arc::new(FixtureResolver {
730 expected_did: FEDERATED_WEB_DID,
731 document: serde_json::json!({
732 "id": FEDERATED_WEB_DID,
733 "service": [{
734 "id": format!("{FEDERATED_WEB_DID}#quic"),
735 "type": "QuicTransport",
736 "serviceEndpoint": {
737 "uri": "https://alice.example:443",
738 "webpki": true,
739 "certHashes": []
740 }
741 }]
742 }),
743 }),
744 ));
745 let inventory = Arc::new(InMemoryIdentityInventory::default());
746 let intake = FederationIntake::new(resolver, inventory.clone(), Vec::new());
747
748 let resolved = intake.intake(FEDERATED_WEB_DID).await.unwrap();
749 assert_eq!(resolved.did(), FEDERATED_WEB_DID);
750 assert_eq!(resolved.tenant(), None);
751 assert_eq!(
752 inventory.list(&unauthenticated_viewer()).await.unwrap(),
753 vec![resolved]
754 );
755 let viewer = unauthenticated_viewer();
756 let discovery = intake
757 .resolve(FEDERATED_WEB_DID, Some(&viewer))
758 .await
759 .unwrap();
760 assert_eq!(discovery.quic_url(), Some("https://alice.example:443"));
761 assert_eq!(discovery.cert_hash(), None);
762 let projected = serde_json::to_value(discovery).unwrap();
763 assert!(projected.get("quicUrl").is_some());
764 assert!(projected.get("certHash").is_some());
765 assert!(projected.get("certHashes").is_none());
766 }
767
768 #[tokio::test]
769 async fn inventory_listing_prefilters_above_clearance_without_a_hidden_count() {
770 let inventory = InMemoryIdentityInventory::default();
771 let public =
772 InventoryEntry::indexed_federated("did:web:public.example", None, None).unwrap();
773 inventory
774 .upsert_derived(public.clone(), SecurityLabel::bottom())
775 .await
776 .unwrap();
777 inventory
778 .upsert_derived(
779 InventoryEntry::indexed_federated("did:web:hidden.example", None, None).unwrap(),
780 SecurityLabel::new(
781 Level::Secret,
782 hyprstream_rpc::auth::mac::Assurance::Unverified,
783 CompartmentSet::EMPTY,
784 ),
785 )
786 .await
787 .unwrap();
788
789 let visible = inventory.list(&unauthenticated_viewer()).await.unwrap();
790 assert_eq!(visible, vec![public]);
791 assert_eq!(visible.len(), 1, "only the post-filter count is observable");
792 }
793
794 #[tokio::test]
795 async fn above_floor_direct_access_is_not_found_not_forbidden() {
796 const HIDDEN_DID: &str = "did:web:hidden.example";
797 const MISSING_DID: &str = "did:web:missing.example";
798
799 let inventory = Arc::new(InMemoryIdentityInventory::default());
800 inventory.identities.write().insert(
801 HIDDEN_DID.to_owned(),
802 StoredInventoryEntry {
803 entry: InventoryEntry {
804 did: HIDDEN_DID.to_owned(),
805 handle: None,
806 kind: InventoryKind::Federated,
807 tenant: None,
808 pds_endpoint: None,
809 },
810 label: SecurityLabel::new(
811 Level::Secret,
812 hyprstream_rpc::auth::mac::Assurance::Unverified,
813 CompartmentSet::EMPTY,
814 ),
815 },
816 );
817 let intake = FederationIntake::new(
818 Arc::new(FederatedDidResolver::new(
819 Arc::new(NeverResolver),
820 Arc::new(NeverResolver),
821 )),
822 inventory.clone(),
823 Vec::new(),
824 );
825 let viewer = unauthenticated_viewer();
826
827 assert_eq!(
828 inventory.get(Some(&viewer), HIDDEN_DID).await.unwrap(),
829 None
830 );
831 assert_eq!(
832 inventory.get(Some(&viewer), MISSING_DID).await.unwrap(),
833 None
834 );
835 assert_eq!(inventory.get(None, HIDDEN_DID).await.unwrap(), None);
836
837 for did in [HIDDEN_DID, MISSING_DID] {
838 let error = intake.resolve(did, Some(&viewer)).await.unwrap_err();
839 assert_eq!(
840 error.downcast_ref::<IdentityDirectoryReadError>(),
841 Some(&IdentityDirectoryReadError::NotFound),
842 "direct access to {did} must be 404-style, never forbidden: {error:#}"
843 );
844 }
845 }
846
847 #[tokio::test]
848 async fn federated_intake_cannot_demote_or_declassify_a_local_projection() {
849 let inventory = Arc::new(InMemoryIdentityInventory::default());
850 let local = InventoryEntry::local(
851 FEDERATED_WEB_DID,
852 Some("local.example".to_owned()),
853 "tenant-authority",
854 Some("https://local-pds.example".to_owned()),
855 )
856 .unwrap();
857 inventory
858 .upsert_derived(
859 local.clone(),
860 SecurityLabel::new(
861 Level::Secret,
862 hyprstream_rpc::auth::mac::Assurance::PqHybrid,
863 CompartmentSet::single(3),
864 ),
865 )
866 .await
867 .unwrap();
868 let intake = FederationIntake::new(
869 Arc::new(FederatedDidResolver::new(
870 Arc::new(NeverResolver),
871 Arc::new(FixtureResolver {
872 expected_did: FEDERATED_WEB_DID,
873 document: serde_json::json!({
874 "id": FEDERATED_WEB_DID,
875 "alsoKnownAs": ["at://foreign.example"],
876 }),
877 }),
878 )),
879 inventory.clone(),
880 Vec::new(),
881 );
882
883 let error = intake.intake(FEDERATED_WEB_DID).await.unwrap_err();
884 assert!(error.to_string().contains("cannot change authority kind"));
885 assert!(
886 inventory
887 .list(&unauthenticated_viewer())
888 .await
889 .unwrap()
890 .is_empty(),
891 "rejected federation refresh must not declassify the local row"
892 );
893 let privileged = SecurityContext::new(
894 Level::Secret,
895 CompartmentSet::single(3),
896 VerifiedKeyMaterial::PqHybrid,
897 );
898 assert_eq!(
899 inventory
900 .get(Some(&privileged), FEDERATED_WEB_DID)
901 .await
902 .unwrap(),
903 Some(local)
904 );
905 }
906
907 #[tokio::test]
908 async fn unauthenticated_sentinel_is_never_resolved_or_listed() {
909 let resolver = Arc::new(FederatedDidResolver::new(
910 Arc::new(NeverResolver),
911 Arc::new(NeverResolver),
912 ));
913 let inventory = Arc::new(InMemoryIdentityInventory::default());
914 let intake = FederationIntake::new(resolver, inventory.clone(), Vec::new());
915
916 let error = intake
917 .intake(UNAUTHENTICATED_DID_SENTINEL)
918 .await
919 .unwrap_err();
920 assert!(
921 error.to_string().contains("unauthenticated floor"),
922 "{error:#}"
923 );
924 assert!(inventory
925 .list(&unauthenticated_viewer())
926 .await
927 .unwrap()
928 .is_empty());
929 let error = intake
930 .resolve(
931 UNAUTHENTICATED_DID_SENTINEL,
932 Some(&unauthenticated_viewer()),
933 )
934 .await
935 .unwrap_err();
936 assert_eq!(
937 error.downcast_ref::<IdentityDirectoryReadError>(),
938 Some(&IdentityDirectoryReadError::NotFound)
939 );
940
941 inventory.identities.write().insert(
942 UNAUTHENTICATED_DID_SENTINEL.to_owned(),
943 StoredInventoryEntry {
944 entry: InventoryEntry {
945 did: UNAUTHENTICATED_DID_SENTINEL.to_owned(),
946 handle: None,
947 kind: InventoryKind::Unauthenticated,
948 tenant: None,
949 pds_endpoint: None,
950 },
951 label: SecurityLabel::bottom(),
952 },
953 );
954 assert!(
955 inventory
956 .list(&unauthenticated_viewer())
957 .await
958 .unwrap()
959 .is_empty(),
960 "legacy/corrupt sentinel rows must be filtered from inventory listing"
961 );
962 }
963
964 #[tokio::test]
965 async fn local_identity_claims_cannot_enter_federation_intake() {
966 let resolver = Arc::new(FederatedDidResolver::new(
967 Arc::new(NeverResolver),
968 Arc::new(NeverResolver),
969 ));
970 let inventory = Arc::new(InMemoryIdentityInventory::default());
971 let intake = FederationIntake::new(
972 resolver,
973 inventory.clone(),
974 vec!["https://local.example".to_owned()],
975 );
976 let local_claims = Claims::new("alice".to_owned(), 1, 2)
977 .with_issuer("https://local.example".to_owned())
978 .with_tenant("acme".to_owned());
979
980 let error = intake
981 .intake_with_verified_claims(FEDERATED_DID, local_claims)
982 .await
983 .unwrap_err();
984 assert!(error.to_string().contains("foreign issuer"));
985 assert!(inventory
986 .list(&unauthenticated_viewer())
987 .await
988 .unwrap()
989 .is_empty());
990 }
991}