1#![forbid(unsafe_code)]
7#![allow(
8 clippy::doc_markdown,
9 clippy::missing_errors_doc,
10 clippy::module_name_repetitions,
11 reason = "HNS, DNSSEC, TLSA, DANE, ODoH, and HNSR are protocol names"
12)]
13
14use hns_browser_runtime::{AuthorityState, RUNTIME_SCHEMA_VERSION, RuntimeSnapshot};
15pub use hns_icann_dane::IcannDnssecStatus;
16pub use hns_namespace_resolution::{Namespace, OutcomeKind, RootFailureKind, SelectionReason};
17use hns_resolution_policy::{
18 ChainAnchor, HnsrPolicy, Network, PolicySnapshot, ProviderPolicy, ResolutionTransport,
19 ValidationEvidence, WireProfile,
20};
21use thiserror::Error;
22
23pub const STATUS_SCHEMA_VERSION: u16 = 2;
25pub const MAX_IDENTITY_BYTES: usize = 256;
27pub const MAX_UNSUPPORTED_EVIDENCE: usize = 64;
29
30#[must_use]
36pub const fn name_tree_interval(network: Network) -> u32 {
37 match network {
38 Network::Mainnet | Network::Testnet => 36,
39 Network::Regtest => 5,
40 Network::Simnet => 2,
41 }
42}
43
44#[must_use]
51pub const fn name_tree_authority_height(network: Network, chain_height: u32) -> u32 {
52 if chain_height == 0 {
53 return 0;
54 }
55 let interval = name_tree_interval(network);
56 ((chain_height - 1) / interval) * interval + 1
57}
58
59#[derive(Clone, Copy, Debug, Eq, PartialEq)]
67pub struct NameTreeCurrentness {
68 network: Network,
69 local_header_height: Option<u32>,
70 target_header_height: Option<u32>,
71 local_authority_height: Option<u32>,
72 target_authority_height: Option<u32>,
73 blocks_until_authority: Option<u32>,
74 ready: bool,
75}
76
77impl NameTreeCurrentness {
78 #[must_use]
81 pub const fn assess(
82 network: Network,
83 local_header_height: Option<u32>,
84 target_header_height: Option<u32>,
85 ) -> Self {
86 let local_authority_height = match local_header_height {
87 Some(height) if height > 0 => Some(name_tree_authority_height(network, height)),
88 _ => None,
89 };
90 let target_authority_height = match target_header_height {
91 Some(height) if height > 0 => Some(name_tree_authority_height(network, height)),
92 _ => None,
93 };
94 let ready = match (local_authority_height, target_authority_height) {
95 (Some(local), Some(target)) => local >= target,
96 _ => false,
97 };
98 let blocks_until_authority = match (ready, local_header_height, target_authority_height) {
99 (true, Some(_), Some(_)) => Some(0),
100 (false, Some(local), Some(target)) => Some(target.saturating_sub(local)),
101 _ => None,
102 };
103 Self {
104 network,
105 local_header_height,
106 target_header_height,
107 local_authority_height,
108 target_authority_height,
109 blocks_until_authority,
110 ready,
111 }
112 }
113
114 #[must_use]
116 pub const fn network(self) -> Network {
117 self.network
118 }
119
120 #[must_use]
122 pub const fn local_header_height(self) -> Option<u32> {
123 self.local_header_height
124 }
125
126 #[must_use]
128 pub const fn target_header_height(self) -> Option<u32> {
129 self.target_header_height
130 }
131
132 #[must_use]
134 pub const fn local_authority_height(self) -> Option<u32> {
135 self.local_authority_height
136 }
137
138 #[must_use]
140 pub const fn target_authority_height(self) -> Option<u32> {
141 self.target_authority_height
142 }
143
144 #[must_use]
146 pub const fn blocks_until_authority(self) -> Option<u32> {
147 self.blocks_until_authority
148 }
149
150 #[must_use]
152 pub const fn is_ready(self) -> bool {
153 self.ready
154 }
155}
156pub const RUNTIME_FEATURE_SCHEMA_VERSION: u16 = 1;
158
159#[derive(Clone, Copy, Debug, Eq, PartialEq)]
164pub struct RuntimeFeatureState {
165 compiled: bool,
166 configured: bool,
167 active: bool,
168 observed: Option<bool>,
169}
170
171impl RuntimeFeatureState {
172 pub fn try_new(
174 compiled: bool,
175 configured: bool,
176 active: bool,
177 observed: Option<bool>,
178 ) -> Result<Self, RuntimeFeatureStateError> {
179 if configured && !compiled {
180 return Err(RuntimeFeatureStateError::ConfiguredWithoutCapability);
181 }
182 if active && !configured {
183 return Err(RuntimeFeatureStateError::ActiveWithoutConfiguration);
184 }
185 if observed == Some(true) && !active {
186 return Err(RuntimeFeatureStateError::ObservedWithoutActivePath);
187 }
188 Ok(Self {
189 compiled,
190 configured,
191 active,
192 observed,
193 })
194 }
195
196 #[must_use]
198 pub const fn not_compiled() -> Self {
199 Self {
200 compiled: false,
201 configured: false,
202 active: false,
203 observed: None,
204 }
205 }
206
207 #[must_use]
209 pub const fn compiled_disabled() -> Self {
210 Self {
211 compiled: true,
212 configured: false,
213 active: false,
214 observed: None,
215 }
216 }
217
218 #[must_use]
220 pub const fn configured_inactive() -> Self {
221 Self {
222 compiled: true,
223 configured: true,
224 active: false,
225 observed: None,
226 }
227 }
228
229 #[must_use]
231 pub const fn active(observed: Option<bool>) -> Self {
232 Self {
233 compiled: true,
234 configured: true,
235 active: true,
236 observed,
237 }
238 }
239
240 #[must_use]
242 pub const fn is_compiled(self) -> bool {
243 self.compiled
244 }
245
246 #[must_use]
248 pub const fn is_configured(self) -> bool {
249 self.configured
250 }
251
252 #[must_use]
254 pub const fn is_active(self) -> bool {
255 self.active
256 }
257
258 #[must_use]
260 pub const fn observed(self) -> Option<bool> {
261 self.observed
262 }
263}
264
265#[derive(Clone, Copy, Debug, Error, Eq, PartialEq)]
267pub enum RuntimeFeatureStateError {
268 #[error("runtime feature cannot be configured when it is not compiled")]
270 ConfiguredWithoutCapability,
271 #[error("runtime feature cannot be active when it is not configured")]
273 ActiveWithoutConfiguration,
274 #[error("runtime feature cannot be observed on an inactive path")]
276 ObservedWithoutActivePath,
277}
278
279#[derive(Clone, Copy, Debug, Eq, PartialEq)]
281pub struct RuntimeFeatureDiagnostics {
282 pub resolver_cache: RuntimeFeatureState,
284 pub connection_pooling: RuntimeFeatureState,
286 pub tls_resumption: RuntimeFeatureState,
288 pub http3_promotion: RuntimeFeatureState,
290}
291
292#[repr(u8)]
294#[derive(Clone, Copy, Debug, Default, Eq, PartialEq)]
295pub enum ReadinessState {
296 #[default]
298 Disabled = 0,
299 Starting = 1,
301 Ready = 2,
303 RateLimited = 3,
305 Degraded = 4,
307 Revoked = 5,
309}
310
311#[derive(Clone, Copy, Debug, Default, Eq, PartialEq)]
313pub struct ProviderReadiness {
314 pub dns_relay: ReadinessState,
316 pub odoh_proxy: ReadinessState,
318 pub odoh_target: ReadinessState,
320 pub hnsr_endpoint: ReadinessState,
322 pub hnsr_relay: ReadinessState,
324 pub market_gossip: ReadinessState,
326}
327
328impl ProviderReadiness {
329 #[must_use]
336 pub const fn from_policy(policy: PolicySnapshot) -> Self {
337 let config = policy.config();
338 Self {
339 dns_relay: initial_readiness(config.providers.dns_relay),
340 odoh_proxy: initial_readiness(config.providers.odoh_proxy),
341 odoh_target: initial_readiness(config.providers.odoh_target),
342 hnsr_endpoint: initial_readiness(config.hnsr.endpoint_enabled()),
343 hnsr_relay: initial_readiness(config.hnsr.relay_enabled()),
344 market_gossip: initial_readiness(config.providers.market_gossip),
345 }
346 }
347}
348
349const fn initial_readiness(enabled: bool) -> ReadinessState {
350 if enabled {
351 ReadinessState::Starting
352 } else {
353 ReadinessState::Disabled
354 }
355}
356
357#[derive(Clone, Copy, Debug, Default, Eq, PartialEq)]
359pub struct RateLimitState {
360 pub in_flight: u32,
362 pub max_concurrency: u32,
364 pub window_requests: u64,
366 pub window_limit: u64,
368 pub rejected_total: u64,
370 pub limited: bool,
372}
373
374impl RateLimitState {
375 fn validate(self) -> Result<(), StatusError> {
376 if (self.max_concurrency == 0) != (self.window_limit == 0) {
377 return Err(StatusError::InvalidRateLimit);
378 }
379 if self.max_concurrency == 0 {
380 if self.in_flight != 0 || self.window_requests != 0 || self.limited {
381 return Err(StatusError::InvalidRateLimit);
382 }
383 return Ok(());
384 }
385 if self.in_flight > self.max_concurrency || self.window_requests > self.window_limit {
386 return Err(StatusError::InvalidRateLimit);
387 }
388 let saturated =
389 self.in_flight == self.max_concurrency || self.window_requests == self.window_limit;
390 if self.limited != saturated {
391 return Err(StatusError::InvalidRateLimit);
392 }
393 Ok(())
394 }
395}
396
397#[repr(u16)]
399#[derive(Clone, Copy, Debug, Eq, PartialEq)]
400pub enum DegradedReason {
401 HeadersStale = 1,
403 HeaderSyncUnavailable = 2,
405 ProofUnavailable = 3,
407 ResolutionTransportUnavailable = 4,
409 DnssecFailure = 5,
411 TlsaFailure = 6,
413 DaneFailure = 7,
415 BrowserBridgeUnavailable = 8,
417 ProviderUnavailable = 9,
419}
420
421#[repr(u16)]
423#[derive(Clone, Copy, Debug, Eq, PartialEq)]
424pub enum RevocationReason {
425 PolicyChanged = 1,
427 RuntimeChanged = 2,
429 NetworkChanged = 3,
431 RegistryChanged = 4,
433 ProviderDisabled = 5,
435 Stopped = 6,
437}
438
439#[repr(u8)]
441#[derive(Clone, Copy, Debug, Eq, PartialEq)]
442pub enum EvidenceKind {
443 HnsProof = 0,
445 ChainCurrency = 1,
447 Dnssec = 2,
449 Tlsa = 3,
451 Dane = 4,
453 OriginSni = 5,
455 TransportProtocol = 6,
457}
458
459#[derive(Clone, Copy, Debug, Eq, PartialEq)]
461pub struct UnsupportedEvidence {
462 pub kind: EvidenceKind,
464 pub code: u16,
466}
467
468#[derive(Clone, Debug, Default, Eq, PartialEq)]
470pub struct TransportIdentities {
471 pub peer: Option<String>,
473 pub proxy: Option<String>,
475 pub target: Option<String>,
477 pub direct_relay_fallback: bool,
479}
480
481#[repr(u8)]
483#[derive(Clone, Copy, Debug, Eq, PartialEq)]
484pub enum IcannTlsAction {
485 EnforceDane = 1,
487 WebPkiAuthenticatedAbsence = 2,
489 WebPkiInsecureDelegation = 3,
491 FailClosed = 4,
493}
494
495#[derive(Clone, Debug, Eq, PartialEq)]
497pub struct StatusInput {
498 pub runtime: RuntimeSnapshot,
500 pub network: Network,
502 pub policy: PolicySnapshot,
504 pub chain_anchor: Option<ChainAnchor>,
506 pub actual_transport: ResolutionTransport,
508 pub identities: TransportIdentities,
510 pub registry_profile: WireProfile,
512 pub registry_fingerprint: [u8; 32],
514 pub protocol_version: u16,
516 pub provider_readiness: ProviderReadiness,
518 pub rate_limits: RateLimitState,
520 pub evidence: ValidationEvidence,
522 pub namespace_outcome: Option<OutcomeKind>,
524 pub hns_root_failure: Option<RootFailureKind>,
526 pub icann_root_failure: Option<RootFailureKind>,
528 pub selected_namespace: Option<Namespace>,
530 pub selection_reason: Option<SelectionReason>,
532 pub decision_fingerprint: Option<[u8; 32]>,
534 pub icann_tls_action: Option<IcannTlsAction>,
539 pub icann_dnssec_status: Option<IcannDnssecStatus>,
541 pub degraded_reason: Option<DegradedReason>,
543 pub revocation_reason: Option<RevocationReason>,
545 pub unsupported_evidence: Vec<UnsupportedEvidence>,
547}
548
549#[derive(Clone, Debug, Eq, PartialEq)]
551pub struct BrowserStatus {
552 input: StatusInput,
553}
554
555impl BrowserStatus {
556 pub fn new(input: StatusInput) -> Result<Self, StatusError> {
558 if input.runtime.schema_version() != RUNTIME_SCHEMA_VERSION
559 || input.runtime.generation() == 0
560 || input.policy.generation() == 0
561 {
562 return Err(StatusError::InvalidGeneration);
563 }
564 validate_identities(input.actual_transport, &input.identities)?;
565 validate_provider_readiness(
566 input.policy.config().providers,
567 input.policy.config().hnsr,
568 input.provider_readiness,
569 )?;
570 input.rate_limits.validate()?;
571 if input.unsupported_evidence.len() > MAX_UNSUPPORTED_EVIDENCE {
572 return Err(StatusError::UnsupportedEvidenceLimit);
573 }
574 if matches!(
575 input.evidence.hns_proof,
576 hns_resolution_policy::EvidenceState::Verified
577 ) && input.chain_anchor.is_none()
578 {
579 return Err(StatusError::MissingChainAnchor);
580 }
581 if input.evidence.fully_verified()
582 && input.actual_transport == ResolutionTransport::Unavailable
583 {
584 return Err(StatusError::VerifiedWithoutTransport);
585 }
586 if is_experimental_p2p(input.actual_transport) {
587 if input.registry_fingerprint == [0; 32] || input.protocol_version == 0 {
588 return Err(StatusError::MissingProtocolIdentity);
589 }
590 } else if input.registry_fingerprint != [0; 32] || input.protocol_version != 0 {
591 return Err(StatusError::UnexpectedProtocolIdentity);
592 }
593 validate_failure_reasons(
594 input.runtime.authority_state(),
595 input.degraded_reason,
596 input.revocation_reason,
597 )?;
598 validate_namespace_context(&input)?;
599 validate_icann_tls_context(
600 input.selected_namespace == Some(Namespace::Icann),
601 input.icann_root_failure,
602 input.icann_tls_action,
603 input.icann_dnssec_status,
604 input.evidence,
605 )?;
606 Ok(Self { input })
607 }
608
609 #[must_use]
611 pub const fn schema_version(&self) -> u16 {
612 STATUS_SCHEMA_VERSION
613 }
614
615 #[must_use]
617 pub const fn runtime_session(&self) -> [u8; 16] {
618 self.input.runtime.session_bytes()
619 }
620
621 #[must_use]
623 pub const fn runtime_generation(&self) -> u64 {
624 self.input.runtime.generation()
625 }
626
627 #[must_use]
629 pub const fn policy_generation(&self) -> u64 {
630 self.input.policy.generation()
631 }
632
633 #[must_use]
635 pub const fn event_sequence(&self) -> u64 {
636 self.input.runtime.event_sequence()
637 }
638
639 #[must_use]
641 pub const fn runtime_snapshot(&self) -> RuntimeSnapshot {
642 self.input.runtime
643 }
644
645 #[must_use]
647 pub const fn authority_state(&self) -> AuthorityState {
648 self.input.runtime.authority_state()
649 }
650
651 #[must_use]
653 pub const fn network(&self) -> Network {
654 self.input.network
655 }
656
657 #[must_use]
659 pub const fn chain_anchor(&self) -> Option<ChainAnchor> {
660 self.input.chain_anchor
661 }
662
663 #[must_use]
665 pub const fn transport_policy(&self) -> PolicySnapshot {
666 self.input.policy
667 }
668
669 #[must_use]
671 pub const fn actual_transport(&self) -> ResolutionTransport {
672 self.input.actual_transport
673 }
674
675 #[must_use]
677 pub const fn identities(&self) -> &TransportIdentities {
678 &self.input.identities
679 }
680
681 #[must_use]
683 pub const fn registry_profile(&self) -> WireProfile {
684 self.input.registry_profile
685 }
686
687 #[must_use]
689 pub const fn registry_fingerprint(&self) -> [u8; 32] {
690 self.input.registry_fingerprint
691 }
692
693 #[must_use]
695 pub const fn protocol_version(&self) -> u16 {
696 self.input.protocol_version
697 }
698
699 #[must_use]
701 pub const fn hnsr_mode(&self) -> HnsrPolicy {
702 self.input.policy.config().hnsr
703 }
704
705 #[must_use]
707 pub const fn provider_roles(&self) -> ProviderPolicy {
708 self.input.policy.config().providers
709 }
710
711 #[must_use]
713 pub const fn provider_readiness(&self) -> ProviderReadiness {
714 self.input.provider_readiness
715 }
716
717 #[must_use]
719 pub const fn rate_limits(&self) -> RateLimitState {
720 self.input.rate_limits
721 }
722
723 #[must_use]
725 pub const fn evidence(&self) -> ValidationEvidence {
726 self.input.evidence
727 }
728
729 #[must_use]
731 pub const fn namespace_outcome(&self) -> Option<OutcomeKind> {
732 self.input.namespace_outcome
733 }
734
735 #[must_use]
737 pub const fn hns_root_failure(&self) -> Option<RootFailureKind> {
738 self.input.hns_root_failure
739 }
740
741 #[must_use]
743 pub const fn icann_root_failure(&self) -> Option<RootFailureKind> {
744 self.input.icann_root_failure
745 }
746
747 #[must_use]
749 pub const fn selected_namespace(&self) -> Option<Namespace> {
750 self.input.selected_namespace
751 }
752
753 #[must_use]
755 pub const fn selection_reason(&self) -> Option<SelectionReason> {
756 self.input.selection_reason
757 }
758
759 #[must_use]
761 pub const fn decision_fingerprint(&self) -> Option<[u8; 32]> {
762 self.input.decision_fingerprint
763 }
764
765 #[must_use]
767 pub const fn icann_tls_action(&self) -> Option<IcannTlsAction> {
768 self.input.icann_tls_action
769 }
770
771 #[must_use]
773 pub const fn icann_dnssec_status(&self) -> Option<IcannDnssecStatus> {
774 self.input.icann_dnssec_status
775 }
776
777 #[must_use]
779 pub const fn degraded_reason(&self) -> Option<DegradedReason> {
780 self.input.degraded_reason
781 }
782
783 #[must_use]
785 pub const fn revocation_reason(&self) -> Option<RevocationReason> {
786 self.input.revocation_reason
787 }
788
789 #[must_use]
791 pub fn unsupported_evidence(&self) -> &[UnsupportedEvidence] {
792 &self.input.unsupported_evidence
793 }
794}
795
796const fn is_experimental_p2p(transport: ResolutionTransport) -> bool {
797 matches!(
798 transport,
799 ResolutionTransport::HandshakeP2pOdoh | ResolutionTransport::HandshakeP2pDnsRelay
800 )
801}
802
803fn validate_failure_reasons(
804 authority: AuthorityState,
805 degraded: Option<DegradedReason>,
806 revoked: Option<RevocationReason>,
807) -> Result<(), StatusError> {
808 if degraded.is_some() && revoked.is_some() {
809 return Err(StatusError::ConflictingFailureReasons);
810 }
811 match authority {
812 AuthorityState::Degraded => {
813 if degraded.is_none() {
814 return Err(StatusError::MissingFailureReason);
815 }
816 }
817 AuthorityState::Revoked => {
818 if revoked.is_none() {
819 return Err(StatusError::MissingFailureReason);
820 }
821 if revoked == Some(RevocationReason::Stopped) {
822 return Err(StatusError::FailureReasonMismatch);
823 }
824 }
825 AuthorityState::Stopped => {
826 if revoked.is_none() {
827 return Err(StatusError::MissingFailureReason);
828 }
829 if revoked != Some(RevocationReason::Stopped) {
830 return Err(StatusError::FailureReasonMismatch);
831 }
832 }
833 AuthorityState::Uninitialized
834 | AuthorityState::LocalStateOpened
835 | AuthorityState::HeaderSyncing
836 | AuthorityState::HeaderCurrent
837 | AuthorityState::ProofReady
838 | AuthorityState::ResolutionTransportReady
839 | AuthorityState::DnssecVerified
840 | AuthorityState::DaneOriginVerified
841 | AuthorityState::BrowserBridgeReady
842 | AuthorityState::Active => {
843 if degraded.is_some() || revoked.is_some() {
844 return Err(StatusError::FailureReasonMismatch);
845 }
846 }
847 }
848 Ok(())
849}
850
851fn validate_namespace_context(input: &StatusInput) -> Result<(), StatusError> {
852 if input.decision_fingerprint == Some([0; 32]) {
853 return Err(StatusError::InvalidDecisionFingerprint);
854 }
855 if input.namespace_outcome.is_some()
856 && (input.hns_root_failure.is_some() || input.icann_root_failure.is_some())
857 {
858 return Err(StatusError::InvalidNamespaceContext);
859 }
860
861 match input.namespace_outcome {
862 None => {
863 if input.selected_namespace.is_some()
864 || input.selection_reason.is_some()
865 || input.decision_fingerprint.is_some()
866 {
867 return Err(StatusError::InvalidNamespaceContext);
868 }
869 }
870 Some(OutcomeKind::Neither) => {
871 if input.selected_namespace.is_some()
872 || input.selection_reason.is_some()
873 || input.decision_fingerprint.is_none()
874 || input.actual_transport != ResolutionTransport::Unavailable
875 {
876 return Err(StatusError::InvalidNamespaceContext);
877 }
878 }
879 Some(OutcomeKind::HnsOnly) => {
880 if input.selected_namespace != Some(Namespace::Hns)
881 || input.selection_reason.is_none()
882 || input.decision_fingerprint.is_none()
883 {
884 return Err(StatusError::InvalidNamespaceContext);
885 }
886 }
887 Some(OutcomeKind::IcannOnly) => {
888 if input.selected_namespace != Some(Namespace::Icann)
889 || input.selection_reason.is_none()
890 || input.decision_fingerprint.is_none()
891 {
892 return Err(StatusError::InvalidNamespaceContext);
893 }
894 }
895 Some(OutcomeKind::BothConvergent | OutcomeKind::BothDivergent) => {
896 if input.selected_namespace.is_none()
897 || input.selection_reason.is_none()
898 || input.decision_fingerprint.is_none()
899 {
900 return Err(StatusError::InvalidNamespaceContext);
901 }
902 }
903 }
904 if !valid_namespace_selection(
905 input.namespace_outcome,
906 input.selected_namespace,
907 input.selection_reason,
908 ) {
909 return Err(StatusError::InvalidNamespaceContext);
910 }
911
912 let selected_icann = input.selected_namespace == Some(Namespace::Icann);
913 let failed_icann = input.icann_root_failure.is_some();
914 let failed_hns_only = input.hns_root_failure.is_some() && !failed_icann;
915 let used_icann_doh = input.actual_transport == ResolutionTransport::ValidatingIcannDoh;
916 if selected_icann && !used_icann_doh {
917 return Err(StatusError::InvalidIcannTlsContext);
918 }
919 if failed_icann && !used_icann_doh {
920 return Err(StatusError::InvalidIcannTlsContext);
921 }
922 if failed_hns_only && input.actual_transport != ResolutionTransport::Unavailable {
923 return Err(StatusError::InvalidNamespaceContext);
924 }
925 if used_icann_doh && !selected_icann && !failed_icann {
926 return Err(StatusError::InvalidIcannTlsContext);
927 }
928 if !selected_icann
929 && !failed_icann
930 && (input.icann_tls_action.is_some() || input.icann_dnssec_status.is_some())
931 {
932 return Err(StatusError::InvalidIcannTlsContext);
933 }
934 if failed_icann && input.icann_tls_action != Some(IcannTlsAction::FailClosed) {
935 return Err(StatusError::InvalidIcannTlsContext);
936 }
937 Ok(())
938}
939
940fn validate_icann_tls_context(
941 selected_icann: bool,
942 root_failure: Option<RootFailureKind>,
943 action: Option<IcannTlsAction>,
944 dnssec_status: Option<IcannDnssecStatus>,
945 evidence: ValidationEvidence,
946) -> Result<(), StatusError> {
947 use hns_resolution_policy::EvidenceState::{NotAttempted, Unavailable, Verified};
948
949 let dane =
950 evidence.dnssec == Verified && evidence.tlsa == Verified && evidence.dane == Verified;
951 let webpki = evidence.dnssec == Verified
952 && evidence.tlsa == Unavailable
953 && matches!(evidence.dane, NotAttempted | Unavailable);
954
955 let valid = match action {
956 None if selected_icann => {
957 evidence.dnssec == Verified
958 && evidence.tlsa == NotAttempted
959 && evidence.dane == NotAttempted
960 && matches!(
961 dnssec_status,
962 Some(IcannDnssecStatus::Secure | IcannDnssecStatus::InsecureDelegation)
963 )
964 }
965 None => root_failure.is_none() && dnssec_status.is_none(),
966 Some(IcannTlsAction::EnforceDane) => {
967 selected_icann && dnssec_status == Some(IcannDnssecStatus::Secure) && dane
968 }
969 Some(IcannTlsAction::WebPkiAuthenticatedAbsence) => {
970 selected_icann && dnssec_status == Some(IcannDnssecStatus::Secure) && webpki
971 }
972 Some(IcannTlsAction::WebPkiInsecureDelegation) => {
973 selected_icann && dnssec_status == Some(IcannDnssecStatus::InsecureDelegation) && webpki
974 }
975 Some(IcannTlsAction::FailClosed) if root_failure.is_some() => {
976 validate_icann_failure_context(root_failure, dnssec_status, evidence)
977 && !dane
978 && !webpki
979 }
980 Some(IcannTlsAction::FailClosed) => {
981 selected_icann
982 && matches!(
983 dnssec_status,
984 Some(IcannDnssecStatus::Secure | IcannDnssecStatus::InsecureDelegation)
985 )
986 && evidence.dnssec == Verified
987 && !dane
988 && !webpki
989 }
990 };
991 if valid {
992 Ok(())
993 } else {
994 Err(StatusError::InvalidIcannTlsContext)
995 }
996}
997
998fn validate_icann_failure_context(
999 root_failure: Option<RootFailureKind>,
1000 dnssec_status: Option<IcannDnssecStatus>,
1001 evidence: ValidationEvidence,
1002) -> bool {
1003 use hns_resolution_policy::EvidenceState::{Failed, NotAttempted, Unavailable};
1004
1005 match root_failure {
1006 Some(RootFailureKind::BogusDnssec) => {
1007 dnssec_status == Some(IcannDnssecStatus::Bogus) && evidence.dnssec == Failed
1008 }
1009 Some(RootFailureKind::IndeterminateDnssec) => {
1010 dnssec_status == Some(IcannDnssecStatus::Indeterminate)
1011 && matches!(evidence.dnssec, NotAttempted | Unavailable)
1012 }
1013 Some(
1014 RootFailureKind::Timeout
1015 | RootFailureKind::Transport
1016 | RootFailureKind::UnauthenticatedResolver
1017 | RootFailureKind::MalformedResponse
1018 | RootFailureKind::Unsupported
1019 | RootFailureKind::Cancelled
1020 | RootFailureKind::Internal
1021 | RootFailureKind::StaleEvidence,
1022 ) => {
1023 dnssec_status.is_none()
1024 && evidence.dnssec != hns_resolution_policy::EvidenceState::Verified
1025 }
1026 Some(RootFailureKind::StaleHnsAnchor) | None => false,
1027 }
1028}
1029
1030const fn valid_namespace_selection(
1031 outcome: Option<OutcomeKind>,
1032 selected: Option<Namespace>,
1033 reason: Option<SelectionReason>,
1034) -> bool {
1035 matches!(
1036 (outcome, selected, reason),
1037 (None | Some(OutcomeKind::Neither), None, None)
1038 | (
1039 Some(OutcomeKind::HnsOnly),
1040 Some(Namespace::Hns),
1041 Some(
1042 SelectionReason::SingleRoot
1043 | SelectionReason::ExplicitPin
1044 | SelectionReason::StickyBinding,
1045 ),
1046 )
1047 | (
1048 Some(OutcomeKind::IcannOnly),
1049 Some(Namespace::Icann),
1050 Some(
1051 SelectionReason::SingleRoot
1052 | SelectionReason::ExplicitPin
1053 | SelectionReason::StickyBinding,
1054 ),
1055 )
1056 | (
1057 Some(OutcomeKind::BothConvergent | OutcomeKind::BothDivergent),
1058 Some(Namespace::Hns),
1059 Some(SelectionReason::ExplicitPin | SelectionReason::StickyBinding),
1060 )
1061 | (
1062 Some(OutcomeKind::BothConvergent | OutcomeKind::BothDivergent),
1063 Some(Namespace::Icann),
1064 Some(
1065 SelectionReason::ExplicitPin
1066 | SelectionReason::StickyBinding
1067 | SelectionReason::IcannDefault,
1068 ),
1069 )
1070 )
1071}
1072
1073fn validate_identities(
1074 transport: ResolutionTransport,
1075 identities: &TransportIdentities,
1076) -> Result<(), StatusError> {
1077 for identity in [
1078 identities.peer.as_deref(),
1079 identities.proxy.as_deref(),
1080 identities.target.as_deref(),
1081 ]
1082 .into_iter()
1083 .flatten()
1084 {
1085 if identity.is_empty() || identity.len() > MAX_IDENTITY_BYTES {
1086 return Err(StatusError::InvalidIdentity);
1087 }
1088 }
1089 match transport {
1090 ResolutionTransport::HandshakeP2pOdoh => {
1091 let proxy = identities
1092 .proxy
1093 .as_deref()
1094 .ok_or(StatusError::MissingIdentity)?;
1095 let target = identities
1096 .target
1097 .as_deref()
1098 .ok_or(StatusError::MissingIdentity)?;
1099 if proxy == target || identities.peer.is_some() || identities.direct_relay_fallback {
1100 return Err(StatusError::InvalidTransportContext);
1101 }
1102 }
1103 ResolutionTransport::HandshakeP2pDnsRelay => {
1104 if identities.peer.is_none()
1105 || identities.proxy.is_some()
1106 || identities.target.is_some()
1107 {
1108 return Err(StatusError::InvalidTransportContext);
1109 }
1110 }
1111 ResolutionTransport::DirectAuthoritativeUdp
1112 | ResolutionTransport::DirectAuthoritativeTcp
1113 | ResolutionTransport::AuthenticatedAuthoritativeDoh
1114 | ResolutionTransport::ValidatingIcannDoh
1115 | ResolutionTransport::UserConfiguredRecursiveHnsDoh
1116 | ResolutionTransport::LocalHnsProof => {
1117 if identities.peer.is_some()
1118 || identities.proxy.is_some()
1119 || identities.target.is_some()
1120 || identities.direct_relay_fallback
1121 {
1122 return Err(StatusError::InvalidTransportContext);
1123 }
1124 }
1125 ResolutionTransport::Unavailable => {
1126 if identities != &TransportIdentities::default() {
1127 return Err(StatusError::InvalidTransportContext);
1128 }
1129 }
1130 }
1131 Ok(())
1132}
1133
1134fn validate_provider_readiness(
1135 roles: ProviderPolicy,
1136 hnsr: HnsrPolicy,
1137 readiness: ProviderReadiness,
1138) -> Result<(), StatusError> {
1139 let endpoint_enabled = hnsr.endpoint_enabled();
1140 let relay_enabled = hnsr.relay_enabled();
1141 for (enabled, state) in [
1142 (roles.dns_relay, readiness.dns_relay),
1143 (roles.odoh_proxy, readiness.odoh_proxy),
1144 (roles.odoh_target, readiness.odoh_target),
1145 (endpoint_enabled, readiness.hnsr_endpoint),
1146 (relay_enabled, readiness.hnsr_relay),
1147 (roles.market_gossip, readiness.market_gossip),
1148 ] {
1149 if !enabled && !matches!(state, ReadinessState::Disabled | ReadinessState::Revoked) {
1150 return Err(StatusError::InvalidProviderReadiness);
1151 }
1152 if enabled && state == ReadinessState::Disabled {
1153 return Err(StatusError::InvalidProviderReadiness);
1154 }
1155 }
1156 Ok(())
1157}
1158
1159#[derive(Clone, Copy, Debug, Eq, Error, PartialEq)]
1161#[non_exhaustive]
1162pub enum StatusError {
1163 #[error("invalid status generation")]
1165 InvalidGeneration,
1166 #[error("invalid transport identity")]
1168 InvalidIdentity,
1169 #[error("missing transport identity")]
1171 MissingIdentity,
1172 #[error("invalid actual-transport context")]
1174 InvalidTransportContext,
1175 #[error("provider readiness conflicts with provider roles")]
1177 InvalidProviderReadiness,
1178 #[error("invalid rate-limit state")]
1180 InvalidRateLimit,
1181 #[error("unsupported-evidence detail bound exceeded")]
1183 UnsupportedEvidenceLimit,
1184 #[error("verified HNS evidence has no chain anchor")]
1186 MissingChainAnchor,
1187 #[error("verified result has no actual transport")]
1189 VerifiedWithoutTransport,
1190 #[error("experimental P2P transport has no protocol identity")]
1192 MissingProtocolIdentity,
1193 #[error("non-P2P transport carries experimental protocol identity")]
1195 UnexpectedProtocolIdentity,
1196 #[error("status is both degraded and revoked")]
1198 ConflictingFailureReasons,
1199 #[error("authority state requires a failure reason")]
1201 MissingFailureReason,
1202 #[error("failure reason conflicts with authority state")]
1204 FailureReasonMismatch,
1205 #[error("invalid name-free namespace decision context")]
1207 InvalidNamespaceContext,
1208 #[error("invalid namespace decision fingerprint")]
1210 InvalidDecisionFingerprint,
1211 #[error("ICANN TLS action conflicts with validation evidence")]
1213 InvalidIcannTlsContext,
1214}
1215
1216#[cfg(test)]
1217#[allow(
1218 clippy::unwrap_used,
1219 reason = "tests fail immediately when a locally constructed status fixture is invalid"
1220)]
1221mod tests {
1222 use hns_browser_runtime::{BrowserRuntime, RuntimeSessionId};
1223 use hns_resolution_policy::{
1224 DnsRelayRequesterPolicy, EvidenceState, HnsrPolicy, ObliviousDnsPolicy, PolicyConfig,
1225 ProviderPolicy, ValidationEvidence,
1226 };
1227
1228 use super::*;
1229
1230 fn policy() -> PolicySnapshot {
1231 PolicySnapshot::new(
1232 7,
1233 PolicyConfig {
1234 dns_relay_requester: DnsRelayRequesterPolicy::Auto,
1235 oblivious_dns: ObliviousDnsPolicy::Preferred,
1236 hnsr: HnsrPolicy::disabled().with_endpoint(true),
1237 authenticated_authoritative_doh: true,
1238 user_configured_recursive_hns_doh: false,
1239 providers: ProviderPolicy {
1240 dns_relay: true,
1241 odoh_proxy: false,
1242 odoh_target: false,
1243 market_gossip: false,
1244 },
1245 wire_profile: WireProfile::ShakescapeV1,
1246 allow_legacy_regtest_compatibility: false,
1247 },
1248 )
1249 .unwrap()
1250 }
1251
1252 fn active_runtime(session_byte: u8, dane_applies: bool) -> RuntimeSnapshot {
1253 let mut runtime = BrowserRuntime::new(RuntimeSessionId::new([session_byte; 16]).unwrap());
1254 for state in [
1255 AuthorityState::LocalStateOpened,
1256 AuthorityState::HeaderSyncing,
1257 AuthorityState::HeaderCurrent,
1258 AuthorityState::ProofReady,
1259 AuthorityState::ResolutionTransportReady,
1260 AuthorityState::DnssecVerified,
1261 ] {
1262 runtime.transition(state).unwrap();
1263 }
1264 if dane_applies {
1265 runtime
1266 .transition(AuthorityState::DaneOriginVerified)
1267 .unwrap();
1268 }
1269 runtime
1270 .transition(AuthorityState::BrowserBridgeReady)
1271 .unwrap();
1272 runtime.transition(AuthorityState::Active).unwrap();
1273 runtime.snapshot()
1274 }
1275
1276 fn input() -> StatusInput {
1277 let policy = policy();
1278 let mut provider_readiness = ProviderReadiness::from_policy(policy);
1279 provider_readiness.dns_relay = ReadinessState::Ready;
1280 StatusInput {
1281 runtime: active_runtime(7, true),
1282 network: Network::Mainnet,
1283 policy,
1284 chain_anchor: Some(ChainAnchor {
1285 height: 123,
1286 tree_root: [4; 32],
1287 }),
1288 actual_transport: ResolutionTransport::HandshakeP2pDnsRelay,
1289 identities: TransportIdentities {
1290 peer: Some("peer-a".to_owned()),
1291 ..TransportIdentities::default()
1292 },
1293 registry_profile: WireProfile::ShakescapeV1,
1294 registry_fingerprint: [8; 32],
1295 protocol_version: 1,
1296 provider_readiness,
1297 rate_limits: RateLimitState {
1298 in_flight: 2,
1299 max_concurrency: 8,
1300 window_requests: 5,
1301 window_limit: 10,
1302 rejected_total: 1,
1303 limited: false,
1304 },
1305 evidence: ValidationEvidence {
1306 hns_proof: EvidenceState::Verified,
1307 dnssec: EvidenceState::Verified,
1308 tlsa: EvidenceState::Verified,
1309 dane: EvidenceState::Verified,
1310 chain_current: EvidenceState::Verified,
1311 origin_sni: EvidenceState::Verified,
1312 },
1313 namespace_outcome: None,
1314 hns_root_failure: None,
1315 icann_root_failure: None,
1316 selected_namespace: None,
1317 selection_reason: None,
1318 decision_fingerprint: None,
1319 icann_tls_action: None,
1320 icann_dnssec_status: None,
1321 degraded_reason: None,
1322 revocation_reason: None,
1323 unsupported_evidence: Vec::new(),
1324 }
1325 }
1326
1327 #[test]
1328 fn exposes_every_required_status_dimension() {
1329 let status = BrowserStatus::new(input()).unwrap();
1330 assert_eq!(status.schema_version(), 2);
1331 assert_eq!(status.authority_state(), AuthorityState::Active);
1332 assert_eq!(status.policy_generation(), 7);
1333 assert_eq!(
1334 status.actual_transport(),
1335 ResolutionTransport::HandshakeP2pDnsRelay
1336 );
1337 assert_eq!(status.identities().peer.as_deref(), Some("peer-a"));
1338 assert_eq!(
1339 status.hnsr_mode(),
1340 HnsrPolicy::disabled().with_endpoint(true)
1341 );
1342 assert!(status.provider_roles().dns_relay);
1343 assert_eq!(status.provider_readiness().dns_relay, ReadinessState::Ready);
1344 assert!(status.evidence().fully_verified());
1345 }
1346
1347 #[test]
1348 fn runtime_tuple_is_bound_as_one_snapshot() {
1349 let input = input();
1350 let expected = input.runtime;
1351 let status = BrowserStatus::new(input).unwrap();
1352 assert_eq!(status.runtime_snapshot(), expected);
1353 assert_eq!(status.runtime_session(), expected.session_bytes());
1354 assert_eq!(status.runtime_generation(), expected.generation());
1355 assert_eq!(status.event_sequence(), expected.event_sequence());
1356 assert_eq!(status.authority_state(), expected.authority_state());
1357 }
1358
1359 #[test]
1360 fn p2p_transport_identity_and_protocol_context_fail_closed() {
1361 let mut status = input();
1362 status.actual_transport = ResolutionTransport::HandshakeP2pOdoh;
1363 assert_eq!(
1364 BrowserStatus::new(status.clone()),
1365 Err(StatusError::MissingIdentity)
1366 );
1367 status.identities = TransportIdentities {
1368 proxy: Some("same".to_owned()),
1369 target: Some("same".to_owned()),
1370 ..TransportIdentities::default()
1371 };
1372 assert_eq!(
1373 BrowserStatus::new(status),
1374 Err(StatusError::InvalidTransportContext)
1375 );
1376
1377 let mut status = input();
1378 status.registry_fingerprint = [0; 32];
1379 assert_eq!(
1380 BrowserStatus::new(status),
1381 Err(StatusError::MissingProtocolIdentity)
1382 );
1383 }
1384
1385 #[test]
1386 fn registry_identity_is_present_exactly_for_p2p_transport() {
1387 let mut status = input();
1388 status.actual_transport = ResolutionTransport::DirectAuthoritativeTcp;
1389 status.identities = TransportIdentities::default();
1390 assert_eq!(
1391 BrowserStatus::new(status.clone()),
1392 Err(StatusError::UnexpectedProtocolIdentity)
1393 );
1394 status.registry_fingerprint = [0; 32];
1395 status.protocol_version = 0;
1396 let status = BrowserStatus::new(status).unwrap();
1397 assert_eq!(
1398 status.actual_transport(),
1399 ResolutionTransport::DirectAuthoritativeTcp
1400 );
1401 assert_eq!(status.registry_fingerprint(), [0; 32]);
1402 assert_eq!(status.protocol_version(), 0);
1403 }
1404
1405 #[test]
1406 fn user_configured_recursive_hns_doh_is_non_p2p_status_provenance() {
1407 let mut status = input();
1408 status.actual_transport = ResolutionTransport::UserConfiguredRecursiveHnsDoh;
1409 status.identities = TransportIdentities::default();
1410 status.registry_fingerprint = [0; 32];
1411 status.protocol_version = 0;
1412
1413 let status = BrowserStatus::new(status).unwrap();
1414
1415 assert_eq!(
1416 status.actual_transport(),
1417 ResolutionTransport::UserConfiguredRecursiveHnsDoh
1418 );
1419 assert_eq!(status.identities(), &TransportIdentities::default());
1420 }
1421
1422 #[test]
1423 fn local_hns_proof_is_non_network_status_provenance() {
1424 let mut status = input();
1425 status.actual_transport = ResolutionTransport::LocalHnsProof;
1426 status.identities = TransportIdentities::default();
1427 status.registry_fingerprint = [0; 32];
1428 status.protocol_version = 0;
1429
1430 let status = BrowserStatus::new(status).unwrap();
1431
1432 assert_eq!(
1433 status.actual_transport(),
1434 ResolutionTransport::LocalHnsProof
1435 );
1436 assert_eq!(status.identities(), &TransportIdentities::default());
1437 }
1438
1439 #[test]
1440 fn explicit_unattempted_stale_unsupported_and_revoked_states_survive() {
1441 let mut status = input();
1442 let mut runtime = BrowserRuntime::new(RuntimeSessionId::new([12; 16]).unwrap());
1443 runtime.transition(AuthorityState::Degraded).unwrap();
1444 status.runtime = runtime.snapshot();
1445 status.actual_transport = ResolutionTransport::Unavailable;
1446 status.identities = TransportIdentities::default();
1447 status.registry_fingerprint = [0; 32];
1448 status.protocol_version = 0;
1449 status.chain_anchor = None;
1450 status.evidence = ValidationEvidence::not_attempted();
1451 status.evidence.hns_proof = EvidenceState::Stale;
1452 status.evidence.dnssec = EvidenceState::Unsupported;
1453 status.evidence.tlsa = EvidenceState::Unavailable;
1454 status.evidence.dane = EvidenceState::Revoked;
1455 status.evidence.origin_sni = EvidenceState::Failed;
1456 status.unsupported_evidence.push(UnsupportedEvidence {
1457 kind: EvidenceKind::Dnssec,
1458 code: 253,
1459 });
1460 status.degraded_reason = Some(DegradedReason::HeadersStale);
1461 let status = BrowserStatus::new(status).unwrap();
1462 assert_eq!(status.evidence().hns_proof, EvidenceState::Stale);
1463 assert_eq!(status.evidence().dnssec, EvidenceState::Unsupported);
1464 assert_eq!(status.evidence().dane, EvidenceState::Revoked);
1465 assert_eq!(status.unsupported_evidence().len(), 1);
1466 }
1467
1468 #[test]
1469 fn provider_readiness_is_policy_derived_and_disabled_roles_stay_disabled() {
1470 let mut config = policy().config();
1471 config.providers = ProviderPolicy {
1472 dns_relay: false,
1473 odoh_proxy: false,
1474 odoh_target: false,
1475 market_gossip: false,
1476 };
1477 config.hnsr = HnsrPolicy::disabled();
1478 let disabled_policy = PolicySnapshot::new(8, config).unwrap();
1479 let readiness = ProviderReadiness::from_policy(disabled_policy);
1480 assert_eq!(readiness, ProviderReadiness::default());
1481
1482 let mut status = input();
1483 status.policy = disabled_policy;
1484 status.provider_readiness = readiness;
1485 status.actual_transport = ResolutionTransport::Unavailable;
1486 status.identities = TransportIdentities::default();
1487 status.registry_fingerprint = [0; 32];
1488 status.protocol_version = 0;
1489 status.chain_anchor = None;
1490 status.evidence = ValidationEvidence::not_attempted();
1491 BrowserStatus::new(status.clone()).unwrap();
1492
1493 status.provider_readiness.odoh_proxy = ReadinessState::Ready;
1494 assert_eq!(
1495 BrowserStatus::new(status),
1496 Err(StatusError::InvalidProviderReadiness)
1497 );
1498 }
1499
1500 #[test]
1501 fn provider_and_rate_limit_invariants_reject_misreporting() {
1502 let mut status = input();
1503 status.provider_readiness.odoh_proxy = ReadinessState::Ready;
1504 assert_eq!(
1505 BrowserStatus::new(status),
1506 Err(StatusError::InvalidProviderReadiness)
1507 );
1508
1509 let mut status = input();
1510 status.rate_limits.in_flight = status.rate_limits.max_concurrency;
1511 assert_eq!(
1512 BrowserStatus::new(status),
1513 Err(StatusError::InvalidRateLimit)
1514 );
1515 }
1516
1517 #[test]
1518 fn authority_state_enforces_failure_reason_consistency() {
1519 let mut runtime = BrowserRuntime::new(RuntimeSessionId::new([9; 16]).unwrap());
1520 runtime.transition(AuthorityState::Degraded).unwrap();
1521 let mut status = input();
1522 status.runtime = runtime.snapshot();
1523 status.chain_anchor = None;
1524 status.actual_transport = ResolutionTransport::Unavailable;
1525 status.identities = TransportIdentities::default();
1526 status.registry_fingerprint = [0; 32];
1527 status.protocol_version = 0;
1528 status.evidence = ValidationEvidence::not_attempted();
1529 assert_eq!(
1530 BrowserStatus::new(status.clone()),
1531 Err(StatusError::MissingFailureReason)
1532 );
1533 status.degraded_reason = Some(DegradedReason::HeaderSyncUnavailable);
1534 BrowserStatus::new(status.clone()).unwrap();
1535
1536 status.revocation_reason = Some(RevocationReason::RuntimeChanged);
1537 assert_eq!(
1538 BrowserStatus::new(status),
1539 Err(StatusError::ConflictingFailureReasons)
1540 );
1541
1542 let mut stopped = BrowserRuntime::new(RuntimeSessionId::new([10; 16]).unwrap());
1543 stopped.transition(AuthorityState::Stopped).unwrap();
1544 let mut status = input();
1545 status.runtime = stopped.snapshot();
1546 status.chain_anchor = None;
1547 status.actual_transport = ResolutionTransport::Unavailable;
1548 status.identities = TransportIdentities::default();
1549 status.registry_fingerprint = [0; 32];
1550 status.protocol_version = 0;
1551 status.evidence = ValidationEvidence::revoked();
1552 status.revocation_reason = Some(RevocationReason::PolicyChanged);
1553 assert_eq!(
1554 BrowserStatus::new(status.clone()),
1555 Err(StatusError::FailureReasonMismatch)
1556 );
1557 status.revocation_reason = Some(RevocationReason::Stopped);
1558 BrowserStatus::new(status).unwrap();
1559 }
1560
1561 #[test]
1562 fn failure_reason_matrix_is_exhaustive_for_every_authority_state() {
1563 let states = [
1564 AuthorityState::Uninitialized,
1565 AuthorityState::LocalStateOpened,
1566 AuthorityState::HeaderSyncing,
1567 AuthorityState::HeaderCurrent,
1568 AuthorityState::ProofReady,
1569 AuthorityState::ResolutionTransportReady,
1570 AuthorityState::DnssecVerified,
1571 AuthorityState::DaneOriginVerified,
1572 AuthorityState::BrowserBridgeReady,
1573 AuthorityState::Active,
1574 AuthorityState::Degraded,
1575 AuthorityState::Revoked,
1576 AuthorityState::Stopped,
1577 ];
1578 let degraded_options = [None, Some(DegradedReason::ResolutionTransportUnavailable)];
1579 let revocation_options = [
1580 None,
1581 Some(RevocationReason::PolicyChanged),
1582 Some(RevocationReason::Stopped),
1583 ];
1584
1585 for authority in states {
1586 for degraded in degraded_options {
1587 for revoked in revocation_options {
1588 let expected = match authority {
1589 AuthorityState::Degraded => degraded.is_some() && revoked.is_none(),
1590 AuthorityState::Revoked => {
1591 degraded.is_none()
1592 && revoked.is_some()
1593 && revoked != Some(RevocationReason::Stopped)
1594 }
1595 AuthorityState::Stopped => {
1596 degraded.is_none() && revoked == Some(RevocationReason::Stopped)
1597 }
1598 _ => degraded.is_none() && revoked.is_none(),
1599 };
1600 assert_eq!(
1601 validate_failure_reasons(authority, degraded, revoked).is_ok(),
1602 expected,
1603 "unexpected reason result for {authority:?}, {degraded:?}, {revoked:?}"
1604 );
1605 }
1606 }
1607 }
1608 }
1609
1610 fn icann_input(action: IcannTlsAction) -> StatusInput {
1611 let mut status = input();
1612 status.runtime = active_runtime(11, action == IcannTlsAction::EnforceDane);
1613 status.actual_transport = ResolutionTransport::ValidatingIcannDoh;
1614 status.identities = TransportIdentities::default();
1615 status.registry_fingerprint = [0; 32];
1616 status.protocol_version = 0;
1617 status.chain_anchor = None;
1618 status.namespace_outcome = Some(OutcomeKind::IcannOnly);
1619 status.selected_namespace = Some(Namespace::Icann);
1620 status.selection_reason = Some(SelectionReason::SingleRoot);
1621 status.decision_fingerprint = Some([11; 32]);
1622 status.icann_tls_action = Some(action);
1623 status.icann_dnssec_status = Some(if action == IcannTlsAction::WebPkiInsecureDelegation {
1624 IcannDnssecStatus::InsecureDelegation
1625 } else {
1626 IcannDnssecStatus::Secure
1627 });
1628 status.evidence = ValidationEvidence::not_attempted();
1629 status
1630 }
1631
1632 fn failed_icann_input(
1633 failure: RootFailureKind,
1634 dnssec_status: Option<IcannDnssecStatus>,
1635 evidence: ValidationEvidence,
1636 ) -> StatusInput {
1637 let mut status = input();
1638 status.runtime = active_runtime(11, false);
1639 status.actual_transport = ResolutionTransport::ValidatingIcannDoh;
1640 status.identities = TransportIdentities::default();
1641 status.registry_fingerprint = [0; 32];
1642 status.protocol_version = 0;
1643 status.chain_anchor = None;
1644 status.namespace_outcome = None;
1645 status.hns_root_failure = None;
1646 status.icann_root_failure = Some(failure);
1647 status.selected_namespace = None;
1648 status.selection_reason = None;
1649 status.decision_fingerprint = None;
1650 status.icann_tls_action = Some(IcannTlsAction::FailClosed);
1651 status.icann_dnssec_status = dnssec_status;
1652 status.evidence = evidence;
1653 status
1654 }
1655
1656 #[test]
1657 fn reports_icann_dane_without_names_or_registry_metadata() {
1658 let mut status = icann_input(IcannTlsAction::EnforceDane);
1659 status.evidence.dnssec = EvidenceState::Verified;
1660 status.evidence.tlsa = EvidenceState::Verified;
1661 status.evidence.dane = EvidenceState::Verified;
1662 let status = BrowserStatus::new(status).unwrap();
1663 assert_eq!(
1664 status.actual_transport(),
1665 ResolutionTransport::ValidatingIcannDoh
1666 );
1667 assert_eq!(status.icann_tls_action(), Some(IcannTlsAction::EnforceDane));
1668 assert_eq!(status.selected_namespace(), Some(Namespace::Icann));
1669 assert_eq!(status.decision_fingerprint(), Some([11; 32]));
1670 }
1671
1672 #[test]
1673 fn webpki_authenticated_absence_becomes_active_without_claiming_dane() {
1674 let mut status = icann_input(IcannTlsAction::WebPkiAuthenticatedAbsence);
1675 status.evidence.dnssec = EvidenceState::Verified;
1676 status.evidence.tlsa = EvidenceState::Unavailable;
1677 status.evidence.dane = EvidenceState::NotAttempted;
1678 let status = BrowserStatus::new(status).unwrap();
1679 assert_eq!(status.authority_state(), AuthorityState::Active);
1680 assert_eq!(status.evidence().dane, EvidenceState::NotAttempted);
1681 assert_eq!(
1682 status.icann_tls_action(),
1683 Some(IcannTlsAction::WebPkiAuthenticatedAbsence)
1684 );
1685 }
1686
1687 #[test]
1688 fn bogus_icann_evidence_is_explicitly_fail_closed() {
1689 let mut evidence = ValidationEvidence::not_attempted();
1690 evidence.dnssec = EvidenceState::Failed;
1691 let mut status = failed_icann_input(
1692 RootFailureKind::BogusDnssec,
1693 Some(IcannDnssecStatus::Bogus),
1694 evidence,
1695 );
1696 status.icann_tls_action = None;
1697 assert_eq!(
1698 BrowserStatus::new(status.clone()),
1699 Err(StatusError::InvalidIcannTlsContext)
1700 );
1701 status.icann_tls_action = Some(IcannTlsAction::FailClosed);
1702 status.actual_transport = ResolutionTransport::Unavailable;
1703 assert_eq!(
1704 BrowserStatus::new(status.clone()),
1705 Err(StatusError::InvalidIcannTlsContext)
1706 );
1707 status.actual_transport = ResolutionTransport::ValidatingIcannDoh;
1708 let status = BrowserStatus::new(status).unwrap();
1709 assert_eq!(status.namespace_outcome(), None);
1710 assert_eq!(status.selected_namespace(), None);
1711 assert_eq!(
1712 status.icann_root_failure(),
1713 Some(RootFailureKind::BogusDnssec)
1714 );
1715 assert_eq!(status.icann_tls_action(), Some(IcannTlsAction::FailClosed));
1716 assert_ne!(status.evidence().dnssec, EvidenceState::Unavailable);
1717 }
1718
1719 #[test]
1720 fn indeterminate_icann_dnssec_remains_explicitly_fail_closed() {
1721 let mut evidence = ValidationEvidence::not_attempted();
1722 evidence.dnssec = EvidenceState::Unavailable;
1723 evidence.tlsa = EvidenceState::Unavailable;
1724 evidence.dane = EvidenceState::Unavailable;
1725 let status = failed_icann_input(
1726 RootFailureKind::IndeterminateDnssec,
1727 Some(IcannDnssecStatus::Indeterminate),
1728 evidence,
1729 );
1730 let status = BrowserStatus::new(status).unwrap();
1731 assert_eq!(status.evidence().dnssec, EvidenceState::Unavailable);
1732 assert_eq!(status.icann_tls_action(), Some(IcannTlsAction::FailClosed));
1733 }
1734
1735 #[test]
1736 fn hns_only_root_failure_clears_transport_provenance() {
1737 let mut status = input();
1738 status.chain_anchor = None;
1739 status.identities = TransportIdentities::default();
1740 status.registry_fingerprint = [0; 32];
1741 status.protocol_version = 0;
1742 status.evidence = ValidationEvidence::not_attempted();
1743 status.hns_root_failure = Some(RootFailureKind::StaleHnsAnchor);
1744 status.actual_transport = ResolutionTransport::DirectAuthoritativeTcp;
1745 assert_eq!(
1746 BrowserStatus::new(status.clone()),
1747 Err(StatusError::InvalidNamespaceContext)
1748 );
1749 status.actual_transport = ResolutionTransport::Unavailable;
1750 let status = BrowserStatus::new(status).unwrap();
1751 assert_eq!(status.actual_transport(), ResolutionTransport::Unavailable);
1752 }
1753
1754 #[test]
1755 fn post_selection_dane_failure_retains_the_namespace_outcome() {
1756 let mut status = icann_input(IcannTlsAction::FailClosed);
1757 status.evidence.dnssec = EvidenceState::Verified;
1758 status.evidence.tlsa = EvidenceState::Verified;
1759 status.evidence.dane = EvidenceState::Failed;
1760 let status = BrowserStatus::new(status).unwrap();
1761 assert_eq!(status.namespace_outcome(), Some(OutcomeKind::IcannOnly));
1762 assert_eq!(status.selected_namespace(), Some(Namespace::Icann));
1763 assert_eq!(status.icann_root_failure(), None);
1764 assert_eq!(
1765 status.icann_dnssec_status(),
1766 Some(IcannDnssecStatus::Secure)
1767 );
1768 }
1769
1770 #[test]
1771 fn stale_revoked_and_not_attempted_icann_evidence_can_fail_closed() {
1772 for (failure, evidence) in [
1773 (
1774 RootFailureKind::StaleEvidence,
1775 ValidationEvidence {
1776 dnssec: EvidenceState::Stale,
1777 tlsa: EvidenceState::Unavailable,
1778 dane: EvidenceState::Unavailable,
1779 ..ValidationEvidence::not_attempted()
1780 },
1781 ),
1782 (
1783 RootFailureKind::Cancelled,
1784 ValidationEvidence {
1785 dnssec: EvidenceState::Unavailable,
1786 tlsa: EvidenceState::Revoked,
1787 dane: EvidenceState::Unavailable,
1788 ..ValidationEvidence::not_attempted()
1789 },
1790 ),
1791 (
1792 RootFailureKind::Cancelled,
1793 ValidationEvidence::not_attempted(),
1794 ),
1795 ] {
1796 let status = failed_icann_input(failure, None, evidence);
1797 let status = BrowserStatus::new(status).unwrap();
1798 assert_eq!(status.icann_tls_action(), Some(IcannTlsAction::FailClosed));
1799 }
1800 }
1801
1802 #[test]
1803 fn icann_tls_actions_cannot_reinterpret_failure_or_fallback_evidence() {
1804 let mut authenticated_absence = icann_input(IcannTlsAction::WebPkiAuthenticatedAbsence);
1805 authenticated_absence.evidence.dnssec = EvidenceState::Verified;
1806 authenticated_absence.evidence.tlsa = EvidenceState::Unavailable;
1807 authenticated_absence.evidence.dane = EvidenceState::NotAttempted;
1808 BrowserStatus::new(authenticated_absence.clone()).unwrap();
1809
1810 let mut indeterminate = authenticated_absence.clone();
1811 indeterminate.evidence.dnssec = EvidenceState::Unavailable;
1812 indeterminate.evidence.dane = EvidenceState::Unavailable;
1813 assert_eq!(
1814 BrowserStatus::new(indeterminate.clone()),
1815 Err(StatusError::InvalidIcannTlsContext)
1816 );
1817 indeterminate.icann_tls_action = Some(IcannTlsAction::FailClosed);
1818 assert_eq!(
1819 BrowserStatus::new(indeterminate),
1820 Err(StatusError::InvalidIcannTlsContext)
1821 );
1822
1823 let mut failure_as_fallback = authenticated_absence.clone();
1824 failure_as_fallback.evidence.dnssec = EvidenceState::Failed;
1825 assert_eq!(
1826 BrowserStatus::new(failure_as_fallback),
1827 Err(StatusError::InvalidIcannTlsContext)
1828 );
1829
1830 let mut fallback_as_failure = authenticated_absence.clone();
1831 fallback_as_failure.icann_tls_action = Some(IcannTlsAction::FailClosed);
1832 assert_eq!(
1833 BrowserStatus::new(fallback_as_failure),
1834 Err(StatusError::InvalidIcannTlsContext)
1835 );
1836
1837 let mut absence_as_insecure = authenticated_absence;
1838 absence_as_insecure.icann_tls_action = Some(IcannTlsAction::WebPkiInsecureDelegation);
1839 assert_eq!(
1840 BrowserStatus::new(absence_as_insecure),
1841 Err(StatusError::InvalidIcannTlsContext)
1842 );
1843
1844 let mut dane = icann_input(IcannTlsAction::EnforceDane);
1845 dane.evidence.dnssec = EvidenceState::Verified;
1846 dane.evidence.tlsa = EvidenceState::Verified;
1847 dane.evidence.dane = EvidenceState::Verified;
1848 BrowserStatus::new(dane.clone()).unwrap();
1849 let mut dane_as_failure = dane.clone();
1850 dane_as_failure.icann_tls_action = Some(IcannTlsAction::FailClosed);
1851 assert_eq!(
1852 BrowserStatus::new(dane_as_failure),
1853 Err(StatusError::InvalidIcannTlsContext)
1854 );
1855 dane.evidence.dane = EvidenceState::Unavailable;
1856 assert_eq!(
1857 BrowserStatus::new(dane),
1858 Err(StatusError::InvalidIcannTlsContext)
1859 );
1860
1861 let mut insecure = icann_input(IcannTlsAction::WebPkiInsecureDelegation);
1862 insecure.evidence.dnssec = EvidenceState::Verified;
1863 insecure.evidence.tlsa = EvidenceState::Unavailable;
1864 insecure.evidence.dane = EvidenceState::Unavailable;
1865 BrowserStatus::new(insecure.clone()).unwrap();
1866 insecure.icann_tls_action = Some(IcannTlsAction::WebPkiAuthenticatedAbsence);
1867 assert_eq!(
1868 BrowserStatus::new(insecure),
1869 Err(StatusError::InvalidIcannTlsContext)
1870 );
1871 }
1872
1873 #[test]
1874 fn reports_divergent_root_selection_without_hostname_data() {
1875 let mut status = input();
1876 status.namespace_outcome = Some(OutcomeKind::BothDivergent);
1877 status.selected_namespace = Some(Namespace::Hns);
1878 status.selection_reason = Some(SelectionReason::ExplicitPin);
1879 status.decision_fingerprint = Some([12; 32]);
1880 status.icann_tls_action = None;
1881 let status = BrowserStatus::new(status).unwrap();
1882 assert_eq!(status.namespace_outcome(), Some(OutcomeKind::BothDivergent));
1883 assert_eq!(status.selected_namespace(), Some(Namespace::Hns));
1884 assert_eq!(
1885 status.selection_reason(),
1886 Some(SelectionReason::ExplicitPin)
1887 );
1888 }
1889
1890 #[test]
1891 fn selected_icann_cleartext_may_omit_tls_action() {
1892 let mut status = icann_input(IcannTlsAction::FailClosed);
1893 status.icann_tls_action = None;
1894 status.evidence = ValidationEvidence::not_attempted();
1895 status.evidence.dnssec = EvidenceState::Verified;
1896 BrowserStatus::new(status).unwrap();
1897 }
1898
1899 #[test]
1900 fn selected_icann_cleartext_still_requires_validated_dnssec() {
1901 for dnssec in [
1902 EvidenceState::Failed,
1903 EvidenceState::Unavailable,
1904 EvidenceState::Unsupported,
1905 EvidenceState::NotAttempted,
1906 EvidenceState::Stale,
1907 EvidenceState::Revoked,
1908 ] {
1909 let mut status = icann_input(IcannTlsAction::FailClosed);
1910 status.icann_tls_action = None;
1911 status.evidence = ValidationEvidence::not_attempted();
1912 status.evidence.dnssec = dnssec;
1913 assert_eq!(
1914 BrowserStatus::new(status),
1915 Err(StatusError::InvalidIcannTlsContext)
1916 );
1917 }
1918 }
1919
1920 #[test]
1921 fn namespace_selection_reason_matrix_matches_the_classifier() {
1922 let outcomes = [
1923 OutcomeKind::HnsOnly,
1924 OutcomeKind::IcannOnly,
1925 OutcomeKind::BothConvergent,
1926 OutcomeKind::BothDivergent,
1927 OutcomeKind::Neither,
1928 ];
1929 let selections = [None, Some(Namespace::Hns), Some(Namespace::Icann)];
1930 let reasons = [
1931 None,
1932 Some(SelectionReason::SingleRoot),
1933 Some(SelectionReason::ExplicitPin),
1934 Some(SelectionReason::StickyBinding),
1935 Some(SelectionReason::IcannDefault),
1936 ];
1937
1938 for outcome in outcomes {
1939 for selected in selections {
1940 for reason in reasons {
1941 let expected = matches!(
1942 (outcome, selected, reason),
1943 (OutcomeKind::Neither, None, None)
1944 | (
1945 OutcomeKind::HnsOnly,
1946 Some(Namespace::Hns),
1947 Some(
1948 SelectionReason::SingleRoot
1949 | SelectionReason::ExplicitPin
1950 | SelectionReason::StickyBinding,
1951 ),
1952 )
1953 | (
1954 OutcomeKind::IcannOnly,
1955 Some(Namespace::Icann),
1956 Some(
1957 SelectionReason::SingleRoot
1958 | SelectionReason::ExplicitPin
1959 | SelectionReason::StickyBinding,
1960 ),
1961 )
1962 | (
1963 OutcomeKind::BothConvergent | OutcomeKind::BothDivergent,
1964 Some(Namespace::Hns),
1965 Some(SelectionReason::ExplicitPin | SelectionReason::StickyBinding),
1966 )
1967 | (
1968 OutcomeKind::BothConvergent | OutcomeKind::BothDivergent,
1969 Some(Namespace::Icann),
1970 Some(
1971 SelectionReason::ExplicitPin
1972 | SelectionReason::StickyBinding
1973 | SelectionReason::IcannDefault,
1974 ),
1975 )
1976 );
1977 assert_eq!(
1978 valid_namespace_selection(Some(outcome), selected, reason),
1979 expected,
1980 "unexpected selection matrix result for {outcome:?}, {selected:?}, {reason:?}"
1981 );
1982 }
1983 }
1984 }
1985 }
1986
1987 #[test]
1988 fn namespace_decision_fields_are_structurally_bound() {
1989 let mut status = input();
1990 status.namespace_outcome = Some(OutcomeKind::IcannOnly);
1991 status.selected_namespace = Some(Namespace::Hns);
1992 status.selection_reason = Some(SelectionReason::SingleRoot);
1993 status.decision_fingerprint = Some([13; 32]);
1994 assert_eq!(
1995 BrowserStatus::new(status),
1996 Err(StatusError::InvalidNamespaceContext)
1997 );
1998
1999 let mut status = input();
2000 status.namespace_outcome = Some(OutcomeKind::Neither);
2001 status.decision_fingerprint = Some([0; 32]);
2002 assert_eq!(
2003 BrowserStatus::new(status),
2004 Err(StatusError::InvalidDecisionFingerprint)
2005 );
2006
2007 let mut status = input();
2008 status.namespace_outcome = Some(OutcomeKind::Neither);
2009 status.selected_namespace = None;
2010 status.selection_reason = None;
2011 status.decision_fingerprint = Some([15; 32]);
2012 assert_eq!(
2013 BrowserStatus::new(status),
2014 Err(StatusError::InvalidNamespaceContext)
2015 );
2016
2017 let mut status = input();
2018 status.namespace_outcome = Some(OutcomeKind::BothDivergent);
2019 status.selected_namespace = Some(Namespace::Hns);
2020 status.selection_reason = Some(SelectionReason::ExplicitPin);
2021 status.decision_fingerprint = Some([14; 32]);
2022 status.icann_tls_action = Some(IcannTlsAction::FailClosed);
2023 assert_eq!(
2024 BrowserStatus::new(status),
2025 Err(StatusError::InvalidIcannTlsContext)
2026 );
2027 }
2028
2029 #[test]
2030 fn effective_runtime_feature_state_preserves_wiring_layers() {
2031 let active = RuntimeFeatureState::active(Some(true));
2032 assert!(active.is_compiled());
2033 assert!(active.is_configured());
2034 assert!(active.is_active());
2035 assert_eq!(active.observed(), Some(true));
2036
2037 let disabled = RuntimeFeatureState::compiled_disabled();
2038 assert!(disabled.is_compiled());
2039 assert!(!disabled.is_configured());
2040 assert!(!disabled.is_active());
2041 assert_eq!(disabled.observed(), None);
2042
2043 let inactive = RuntimeFeatureState::configured_inactive();
2044 assert!(inactive.is_compiled());
2045 assert!(inactive.is_configured());
2046 assert!(!inactive.is_active());
2047 }
2048
2049 #[test]
2050 fn effective_runtime_feature_state_rejects_impossible_claims() {
2051 assert_eq!(
2052 RuntimeFeatureState::try_new(false, true, false, None),
2053 Err(RuntimeFeatureStateError::ConfiguredWithoutCapability),
2054 );
2055 assert_eq!(
2056 RuntimeFeatureState::try_new(true, false, true, None),
2057 Err(RuntimeFeatureStateError::ActiveWithoutConfiguration),
2058 );
2059 assert_eq!(
2060 RuntimeFeatureState::try_new(true, true, false, Some(true)),
2061 Err(RuntimeFeatureStateError::ObservedWithoutActivePath),
2062 );
2063 }
2064
2065 #[test]
2066 fn name_tree_authority_follows_hsd_commit_boundaries() {
2067 for network in [Network::Mainnet, Network::Testnet] {
2068 assert_eq!(name_tree_interval(network), 36);
2069 assert_eq!(name_tree_authority_height(network, 0), 0);
2070 assert_eq!(name_tree_authority_height(network, 1), 1);
2071 assert_eq!(name_tree_authority_height(network, 36), 1);
2072 assert_eq!(name_tree_authority_height(network, 37), 37);
2073 assert_eq!(name_tree_authority_height(network, 72), 37);
2074 assert_eq!(name_tree_authority_height(network, 73), 73);
2075 }
2076
2077 assert_eq!(name_tree_interval(Network::Regtest), 5);
2078 assert_eq!(name_tree_authority_height(Network::Regtest, 5), 1);
2079 assert_eq!(name_tree_authority_height(Network::Regtest, 6), 6);
2080 assert_eq!(name_tree_interval(Network::Simnet), 2);
2081 assert_eq!(name_tree_authority_height(Network::Simnet, 2), 1);
2082 assert_eq!(name_tree_authority_height(Network::Simnet, 3), 3);
2083 }
2084
2085 #[test]
2086 fn name_tree_currentness_waits_only_for_a_new_authority_epoch() {
2087 let same_epoch = NameTreeCurrentness::assess(Network::Mainnet, Some(1), Some(36));
2088 assert!(same_epoch.is_ready());
2089 assert_eq!(same_epoch.local_authority_height(), Some(1));
2090 assert_eq!(same_epoch.target_authority_height(), Some(1));
2091 assert_eq!(same_epoch.blocks_until_authority(), Some(0));
2092
2093 let boundary = NameTreeCurrentness::assess(Network::Mainnet, Some(36), Some(37));
2094 assert!(!boundary.is_ready());
2095 assert_eq!(boundary.target_authority_height(), Some(37));
2096 assert_eq!(boundary.blocks_until_authority(), Some(1));
2097
2098 let caught_up = NameTreeCurrentness::assess(Network::Mainnet, Some(37), Some(72));
2099 assert!(caught_up.is_ready());
2100 assert_eq!(caught_up.local_header_height(), Some(37));
2101 assert_eq!(caught_up.target_header_height(), Some(72));
2102
2103 assert!(!NameTreeCurrentness::assess(Network::Mainnet, Some(72), None).is_ready());
2104 assert!(!NameTreeCurrentness::assess(Network::Mainnet, Some(0), Some(1)).is_ready());
2105 }
2106}