Skip to main content

hns_resolver/
lib.rs

1//! Locally validated TLSA resolution with bounded, DNSSEC-verified CNAME chasing.
2//!
3//! This crate is transport-neutral. Callers fetch each exact query over a
4//! policy-admitted transport, correlate the response, and feed it here.
5
6#![forbid(unsafe_code)]
7#![allow(
8    clippy::doc_markdown,
9    clippy::missing_errors_doc,
10    clippy::module_name_repetitions,
11    reason = "DNSSEC and TLSA protocol terminology is documented at crate level"
12)]
13
14use std::collections::HashSet;
15
16use hns_dns_wire::{CLASS_IN, Ds, Message, Name, Query, Rdata, RecordType, ResourceRecord, Tlsa};
17use hns_dnssec::{
18    AuthenticatedDnskeys, DnssecError, DnssecLimits, VerifiedRrset, authenticate_dnskeys,
19    verify_rrset_with_keys,
20};
21use hns_icann_dane::TlsaOwner;
22use hns_light_chain::{HnsAnchor, VerifiedHnsResource};
23use thiserror::Error;
24
25/// TLSA service transport shared with automatic ICANN DANE discovery.
26pub use hns_icann_dane::TlsaTransport as ServiceTransport;
27
28/// HTTPS uses TCP TLSA service labels.
29pub const HTTPS_PORT: u16 = 443;
30/// Default maximum CNAME indirections.
31pub const DEFAULT_MAX_CNAME_HOPS: usize = 16;
32/// Default maximum TLSA alternatives.
33pub const DEFAULT_MAX_TLSA_RECORDS: usize = 64;
34/// HSD's default TTL for records projected from a name resource.
35pub const HNS_RESOURCE_TTL: u32 = 21_600;
36
37/// HNS resource, DS, DNSKEY, and signature evidence for one TLD authority.
38///
39/// Construction starts from a non-forgeable [`VerifiedHnsResource`]. This
40/// keeps arbitrary caller-provided DS records out of the HNS browser path.
41#[derive(Clone, Debug, Eq, PartialEq)]
42pub struct HnsDnssecAuthority {
43    evidence: HnsAuthorityEvidence,
44    keys: AuthenticatedDnskeys,
45}
46
47impl HnsDnssecAuthority {
48    /// Authenticate a TLD DNSKEY RRset from its current on-chain HNS resource.
49    pub fn authenticate(
50        resource: &VerifiedHnsResource,
51        dnskeys: &[ResourceRecord],
52        signatures: &[ResourceRecord],
53        validation_time: u32,
54        limits: DnssecLimits,
55    ) -> Result<Self, ResolverError> {
56        let anchor = resource.anchor();
57        if anchor.validated_at().get() != u64::from(validation_time)
58            || u64::from(validation_time) > anchor.valid_until().get()
59        {
60            return Err(ResolverError::AnchorTimeMismatch);
61        }
62        let zone = Name::from_labels(vec![resource.name().to_vec()])
63            .map_err(|_| ResolverError::InvalidHnsZone)?;
64        let trusted_ds = resource
65            .resource()
66            .delegation_signers()
67            .map(|ds| ResourceRecord {
68                name: zone.clone(),
69                record_type: RecordType::Ds,
70                class: CLASS_IN,
71                ttl: HNS_RESOURCE_TTL,
72                rdata: Rdata::Ds(Ds {
73                    key_tag: ds.key_tag,
74                    algorithm: ds.algorithm,
75                    digest_type: ds.digest_type,
76                    digest: ds.digest.clone(),
77                }),
78            })
79            .collect::<Vec<_>>();
80        if trusted_ds.is_empty() {
81            return Err(ResolverError::MissingHnsDs);
82        }
83        let keys = authenticate_dnskeys(
84            &zone,
85            &trusted_ds,
86            dnskeys,
87            signatures,
88            validation_time,
89            limits,
90        )?;
91        let expires_at_unix = keys
92            .expires_at_unix()
93            .min(anchor.valid_until().get().saturating_add(1));
94        Ok(Self {
95            evidence: HnsAuthorityEvidence {
96                anchor,
97                zone,
98                validation_time,
99                expires_at_unix,
100            },
101            keys,
102        })
103    }
104
105    /// Current Handshake chain anchor.
106    #[must_use]
107    pub const fn anchor(&self) -> HnsAnchor {
108        self.evidence.anchor
109    }
110
111    /// Authenticated HNS TLD zone.
112    #[must_use]
113    pub const fn zone(&self) -> &Name {
114        &self.evidence.zone
115    }
116
117    /// Shared local DNSSEC/currency validation time.
118    #[must_use]
119    pub const fn validation_time(&self) -> u32 {
120        self.evidence.validation_time
121    }
122}
123
124/// HNS authority lineage retained by a validated TLSA result.
125#[derive(Clone, Debug, Eq, PartialEq)]
126pub struct HnsAuthorityEvidence {
127    anchor: HnsAnchor,
128    zone: Name,
129    validation_time: u32,
130    expires_at_unix: u64,
131}
132
133impl HnsAuthorityEvidence {
134    /// Current Handshake header and name-tree anchor.
135    #[must_use]
136    pub const fn anchor(&self) -> HnsAnchor {
137        self.anchor
138    }
139
140    /// On-chain DS-authenticated TLD zone.
141    #[must_use]
142    pub const fn zone(&self) -> &Name {
143        &self.zone
144    }
145
146    /// Time used for chain currency and every DNSSEC signature check.
147    #[must_use]
148    pub const fn validation_time(&self) -> u32 {
149        self.validation_time
150    }
151
152    /// Earliest exclusive HNS currency, resource, DS, or DNSKEY deadline.
153    #[must_use]
154    pub const fn expires_at_unix(&self) -> u64 {
155        self.expires_at_unix
156    }
157}
158
159/// Bounded resolution policy.
160#[derive(Clone, Copy, Debug, Eq, PartialEq)]
161pub struct ResolverLimits {
162    /// Maximum followed CNAME records.
163    pub max_cname_hops: usize,
164    /// Maximum TLSA alternatives at the terminal owner.
165    pub max_tlsa_records: usize,
166    /// DNSSEC resource limits.
167    pub dnssec: DnssecLimits,
168}
169
170impl Default for ResolverLimits {
171    fn default() -> Self {
172        Self {
173            max_cname_hops: DEFAULT_MAX_CNAME_HOPS,
174            max_tlsa_records: DEFAULT_MAX_TLSA_RECORDS,
175            dnssec: DnssecLimits::default(),
176        }
177    }
178}
179
180/// One DNSSEC-verified CNAME edge.
181#[derive(Clone, Debug, Eq, PartialEq)]
182pub struct VerifiedCname {
183    owner: Name,
184    target: Name,
185    rrset: VerifiedRrset,
186}
187
188impl VerifiedCname {
189    /// Alias owner.
190    #[must_use]
191    pub const fn owner(&self) -> &Name {
192        &self.owner
193    }
194
195    /// Canonical target.
196    #[must_use]
197    pub const fn target(&self) -> &Name {
198        &self.target
199    }
200
201    /// Local DNSSEC signature evidence.
202    #[must_use]
203    pub const fn rrset(&self) -> &VerifiedRrset {
204        &self.rrset
205    }
206}
207
208/// Locally DNSSEC-validated TLSA result.
209///
210/// Fields are private so safe callers cannot manufacture browser trust.
211#[derive(Clone, Debug, Eq, PartialEq)]
212pub struct ValidatedTlsa {
213    requested_owner: Name,
214    terminal_owner: Name,
215    base_domain: Name,
216    base_domain_ascii: String,
217    records: Vec<Tlsa>,
218    cname_chain: Vec<VerifiedCname>,
219    rrset: VerifiedRrset,
220    hns_authority: Option<HnsAuthorityEvidence>,
221    validated_at_unix: u64,
222    expires_at_unix: u64,
223}
224
225impl ValidatedTlsa {
226    /// Original service-prefixed TLSA owner.
227    #[must_use]
228    pub const fn requested_owner(&self) -> &Name {
229        &self.requested_owner
230    }
231
232    /// Owner that supplied the terminal TLSA RRset after CNAME expansion.
233    #[must_use]
234    pub const fn terminal_owner(&self) -> &Name {
235        &self.terminal_owner
236    }
237
238    /// Original TLS service base domain.
239    #[must_use]
240    pub const fn base_domain(&self) -> &Name {
241        &self.base_domain
242    }
243
244    /// Original TLS service base domain as an ASCII SNI host.
245    #[must_use]
246    pub fn base_domain_ascii(&self) -> &str {
247        &self.base_domain_ascii
248    }
249
250    /// Terminal TLSA alternatives.
251    #[must_use]
252    pub fn records(&self) -> &[Tlsa] {
253        &self.records
254    }
255
256    /// DNSSEC-verified CNAME path.
257    #[must_use]
258    pub fn cname_chain(&self) -> &[VerifiedCname] {
259        &self.cname_chain
260    }
261
262    /// Terminal local DNSSEC evidence.
263    #[must_use]
264    pub const fn rrset(&self) -> &VerifiedRrset {
265        &self.rrset
266    }
267
268    /// On-chain HNS authority lineage, if this used the HNS-only path.
269    #[must_use]
270    pub const fn hns_authority(&self) -> Option<&HnsAuthorityEvidence> {
271        self.hns_authority.as_ref()
272    }
273
274    /// Time shared by the DNSSEC and chain-currency checks.
275    #[must_use]
276    pub const fn validated_at_unix(&self) -> u64 {
277        self.validated_at_unix
278    }
279
280    /// Earliest exclusive authority, DNSKEY, CNAME, TLSA TTL, or RRSIG deadline.
281    #[must_use]
282    pub const fn expires_at_unix(&self) -> u64 {
283        self.expires_at_unix
284    }
285
286    /// Whether every retained trust input is current at an absolute Unix time.
287    #[must_use]
288    pub const fn is_fresh_at(&self, now: u64) -> bool {
289        self.validated_at_unix <= now && now < self.expires_at_unix
290    }
291}
292
293/// Result of admitting one correlated DNS response.
294#[derive(Clone, Debug, Eq, PartialEq)]
295pub enum ResolutionStep {
296    /// Fetch another class-IN TLSA query for this CNAME target.
297    FollowCname(Name),
298    /// Terminal local DNSSEC and TLSA evidence.
299    Complete(Box<ValidatedTlsa>),
300}
301
302/// Mutable bounded CNAME/TLSA resolution.
303#[derive(Clone, Debug)]
304pub struct TlsaResolution {
305    requested_owner: Name,
306    current_owner: Name,
307    base_domain: Name,
308    base_domain_ascii: String,
309    visited: HashSet<Name>,
310    cname_chain: Vec<VerifiedCname>,
311    completed: bool,
312    limits: ResolverLimits,
313    authority_binding: AuthorityBinding,
314}
315
316#[derive(Clone, Debug, Eq, PartialEq)]
317enum AuthorityBinding {
318    Unset,
319    Generic,
320    Hns(HnsAuthorityEvidence),
321}
322
323impl TlsaResolution {
324    /// Begin a TLSA lookup for one explicit service.
325    pub fn for_service(
326        base_domain: Name,
327        port: u16,
328        transport: ServiceTransport,
329        limits: ResolverLimits,
330    ) -> Result<Self, ResolverError> {
331        let base_domain_ascii = ascii_host(&base_domain)?;
332        let service_owner = TlsaOwner::derive(&base_domain_ascii, port, transport)
333            .map_err(|_| ResolverError::InvalidServiceName)?;
334        let requested_owner = Name::from_ascii(service_owner.resolver_name())
335            .map_err(|_| ResolverError::InvalidServiceName)?;
336        let mut visited = HashSet::new();
337        visited.insert(requested_owner.clone());
338        Ok(Self {
339            current_owner: requested_owner.clone(),
340            requested_owner,
341            base_domain,
342            base_domain_ascii,
343            visited,
344            cname_chain: Vec::new(),
345            completed: false,
346            limits,
347            authority_binding: AuthorityBinding::Unset,
348        })
349    }
350
351    /// Begin the usual HTTPS-over-TCP lookup.
352    pub fn for_https(base_domain: Name, limits: ResolverLimits) -> Result<Self, ResolverError> {
353        Self::for_service(base_domain, HTTPS_PORT, ServiceTransport::Tcp, limits)
354    }
355
356    /// Current owner that must be queried for TLSA.
357    #[must_use]
358    pub const fn current_owner(&self) -> &Name {
359        &self.current_owner
360    }
361
362    /// Build a current class-IN TLSA query.
363    pub fn query(&self, id: u16) -> Result<Query, ResolverError> {
364        Query::new(id, self.current_owner.clone(), RecordType::Tlsa).map_err(ResolverError::Wire)
365    }
366
367    /// Validate and consume one exactly correlated response.
368    pub fn accept_response(
369        &mut self,
370        query: &Query,
371        message: &Message,
372        keysets: &[&AuthenticatedDnskeys],
373        validation_time: u32,
374    ) -> Result<ResolutionStep, ResolverError> {
375        self.accept_response_inner(
376            query,
377            message,
378            keysets,
379            validation_time,
380            AuthorityBinding::Generic,
381        )
382    }
383
384    /// Validate a response using only an on-chain HNS DS-authenticated keyset.
385    pub fn accept_hns_response(
386        &mut self,
387        query: &Query,
388        message: &Message,
389        authority: &HnsDnssecAuthority,
390    ) -> Result<ResolutionStep, ResolverError> {
391        if !is_suffix(&self.base_domain, authority.zone()) {
392            return Err(ResolverError::HnsZoneMismatch);
393        }
394        self.accept_response_inner(
395            query,
396            message,
397            &[&authority.keys],
398            authority.validation_time(),
399            AuthorityBinding::Hns(authority.evidence.clone()),
400        )
401    }
402
403    fn accept_response_inner(
404        &mut self,
405        query: &Query,
406        message: &Message,
407        keysets: &[&AuthenticatedDnskeys],
408        validation_time: u32,
409        authority_binding: AuthorityBinding,
410    ) -> Result<ResolutionStep, ResolverError> {
411        if self.completed {
412            return Err(ResolverError::AlreadyComplete);
413        }
414        if query.question.name != self.current_owner
415            || query.question.record_type != RecordType::Tlsa
416            || query.question.class != CLASS_IN
417        {
418            return Err(ResolverError::WrongQuery);
419        }
420        query.correlate(message)?;
421        if message.header.flags.rcode() != 0 {
422            return Err(ResolverError::UnsuccessfulResponse);
423        }
424        match &self.authority_binding {
425            AuthorityBinding::Unset => self.authority_binding = authority_binding,
426            existing if *existing == authority_binding => {}
427            _ => return Err(ResolverError::AuthorityChanged),
428        }
429
430        loop {
431            let tlsa_records = matching_records(message, &self.current_owner, RecordType::Tlsa);
432            let cname_records = matching_records(message, &self.current_owner, RecordType::Cname);
433            if !tlsa_records.is_empty() && !cname_records.is_empty() {
434                return Err(ResolverError::CnameCoexistsWithData);
435            }
436            if !tlsa_records.is_empty() {
437                if tlsa_records.len() > self.limits.max_tlsa_records {
438                    return Err(ResolverError::Limit);
439                }
440                let signatures =
441                    matching_signatures(message, &self.current_owner, RecordType::Tlsa);
442                let verified = verify_with_any_keyset(
443                    keysets,
444                    &tlsa_records,
445                    &signatures,
446                    validation_time,
447                    self.limits.dnssec,
448                )?;
449                let records = tlsa_records
450                    .iter()
451                    .map(|record| match &record.rdata {
452                        Rdata::Tlsa(tlsa) => Ok(tlsa.clone()),
453                        _ => Err(ResolverError::MalformedAnswer),
454                    })
455                    .collect::<Result<Vec<_>, _>>()?;
456                let hns_authority = retained_hns_authority(&self.authority_binding);
457                let expires_at_unix =
458                    validated_tlsa_expiry(&self.cname_chain, &verified, hns_authority.as_ref());
459                self.completed = true;
460                return Ok(ResolutionStep::Complete(Box::new(ValidatedTlsa {
461                    requested_owner: self.requested_owner.clone(),
462                    terminal_owner: self.current_owner.clone(),
463                    base_domain: self.base_domain.clone(),
464                    base_domain_ascii: self.base_domain_ascii.clone(),
465                    records,
466                    cname_chain: self.cname_chain.clone(),
467                    rrset: verified,
468                    hns_authority,
469                    validated_at_unix: u64::from(validation_time),
470                    expires_at_unix,
471                })));
472            }
473            if cname_records.len() != 1 {
474                return Err(if cname_records.is_empty() {
475                    ResolverError::MissingTlsa
476                } else {
477                    ResolverError::MalformedAnswer
478                });
479            }
480            if self.cname_chain.len() >= self.limits.max_cname_hops {
481                return Err(ResolverError::CnameLimit);
482            }
483            let signatures = matching_signatures(message, &self.current_owner, RecordType::Cname);
484            let verified = verify_with_any_keyset(
485                keysets,
486                &cname_records,
487                &signatures,
488                validation_time,
489                self.limits.dnssec,
490            )?;
491            let target = match &cname_records
492                .first()
493                .ok_or(ResolverError::MalformedAnswer)?
494                .rdata
495            {
496                Rdata::Cname(target) => target.clone(),
497                _ => return Err(ResolverError::MalformedAnswer),
498            };
499            if !self.visited.insert(target.clone()) {
500                return Err(ResolverError::CnameLoop);
501            }
502            self.cname_chain.push(VerifiedCname {
503                owner: self.current_owner.clone(),
504                target: target.clone(),
505                rrset: verified,
506            });
507            self.current_owner = target;
508
509            if !has_owner_data(message, &self.current_owner) {
510                return Ok(ResolutionStep::FollowCname(self.current_owner.clone()));
511            }
512        }
513    }
514}
515
516/// Resolution validation failure.
517#[derive(Clone, Debug, Eq, Error, PartialEq)]
518#[non_exhaustive]
519pub enum ResolverError {
520    /// DNS wire or response-correlation failure.
521    #[error("DNS wire error: {0}")]
522    Wire(#[from] hns_dns_wire::Error),
523    /// Local DNSSEC failure.
524    #[error("DNSSEC error: {0}")]
525    Dnssec(#[from] DnssecError),
526    /// Service-prefixed owner or ASCII SNI host is invalid.
527    #[error("invalid TLS service name")]
528    InvalidServiceName,
529    /// Response does not correspond to the resolver's current query.
530    #[error("response query does not match the current TLSA owner")]
531    WrongQuery,
532    /// DNS response code is not NOERROR.
533    #[error("TLSA response was unsuccessful")]
534    UnsuccessfulResponse,
535    /// No TLSA or CNAME answer exists at the current owner.
536    #[error("secure TLSA RRset is missing")]
537    MissingTlsa,
538    /// CNAME and other owner data coexist.
539    #[error("CNAME coexists with TLSA data")]
540    CnameCoexistsWithData,
541    /// CNAME path repeated an owner.
542    #[error("CNAME loop")]
543    CnameLoop,
544    /// CNAME path exceeded its bound.
545    #[error("CNAME hop limit exceeded")]
546    CnameLimit,
547    /// An answer RRset is malformed or ambiguous.
548    #[error("malformed TLSA or CNAME answer")]
549    MalformedAnswer,
550    /// A configured resource bound was exceeded.
551    #[error("resolver resource bound exceeded")]
552    Limit,
553    /// Resolution already produced terminal evidence.
554    #[error("TLSA resolution is already complete")]
555    AlreadyComplete,
556    /// A current HNS resource has no DNSSEC DS record.
557    #[error("verified HNS resource has no DS record")]
558    MissingHnsDs,
559    /// The on-chain HNS label cannot form a DNS zone.
560    #[error("verified HNS name is not a valid DNS zone")]
561    InvalidHnsZone,
562    /// DNSSEC validation time does not equal the chain-currency check time.
563    #[error("DNSSEC time does not match current Handshake anchor time")]
564    AnchorTimeMismatch,
565    /// Requested origin is outside the HNS TLD authority.
566    #[error("requested origin is outside the authenticated HNS zone")]
567    HnsZoneMismatch,
568    /// A multi-response resolution attempted to change its trust authority.
569    #[error("resolution authority changed during CNAME processing")]
570    AuthorityChanged,
571}
572
573fn matching_records(
574    message: &Message,
575    owner: &Name,
576    record_type: RecordType,
577) -> Vec<ResourceRecord> {
578    message
579        .answers
580        .iter()
581        .filter(|record| {
582            record.name == *owner && record.record_type == record_type && record.class == CLASS_IN
583        })
584        .cloned()
585        .collect()
586}
587
588fn validated_tlsa_expiry(
589    cname_chain: &[VerifiedCname],
590    terminal: &VerifiedRrset,
591    hns_authority: Option<&HnsAuthorityEvidence>,
592) -> u64 {
593    cname_chain
594        .iter()
595        .map(|edge| edge.rrset.expires_at_unix())
596        .chain(std::iter::once(terminal.expires_at_unix()))
597        .chain(
598            hns_authority
599                .into_iter()
600                .map(HnsAuthorityEvidence::expires_at_unix),
601        )
602        .min()
603        .unwrap_or(terminal.expires_at_unix())
604}
605
606fn retained_hns_authority(binding: &AuthorityBinding) -> Option<HnsAuthorityEvidence> {
607    match binding {
608        AuthorityBinding::Hns(evidence) => Some(evidence.clone()),
609        AuthorityBinding::Unset | AuthorityBinding::Generic => None,
610    }
611}
612
613fn matching_signatures(
614    message: &Message,
615    owner: &Name,
616    record_type: RecordType,
617) -> Vec<ResourceRecord> {
618    message
619        .answers
620        .iter()
621        .chain(&message.authorities)
622        .filter(|record| {
623            record.name == *owner
624                && record.record_type == RecordType::Rrsig
625                && record.class == CLASS_IN
626                && matches!(
627                    &record.rdata,
628                    Rdata::Rrsig(signature) if signature.type_covered == record_type
629                )
630        })
631        .cloned()
632        .collect()
633}
634
635fn verify_with_any_keyset(
636    keysets: &[&AuthenticatedDnskeys],
637    records: &[ResourceRecord],
638    signatures: &[ResourceRecord],
639    validation_time: u32,
640    limits: DnssecLimits,
641) -> Result<VerifiedRrset, ResolverError> {
642    let owner = records
643        .first()
644        .map(|record| &record.name)
645        .ok_or(ResolverError::MalformedAnswer)?;
646    let mut last_error = DnssecError::MissingKey;
647    for keyset in keysets {
648        if !is_suffix(owner, keyset.zone()) {
649            continue;
650        }
651        match verify_rrset_with_keys(keyset, records, signatures, validation_time, limits) {
652            Ok(verified) => return Ok(verified),
653            Err(error) => last_error = error,
654        }
655    }
656    Err(last_error.into())
657}
658
659fn has_owner_data(message: &Message, owner: &Name) -> bool {
660    message
661        .answers
662        .iter()
663        .any(|record| record.name == *owner && record.class == CLASS_IN)
664}
665
666fn ascii_host(name: &Name) -> Result<String, ResolverError> {
667    if name.is_root() {
668        return Err(ResolverError::InvalidServiceName);
669    }
670    let mut output = String::new();
671    for (index, label) in name.labels().iter().enumerate() {
672        if label.is_empty()
673            || label.len() > 63
674            || !label.first().is_some_and(u8::is_ascii_alphanumeric)
675            || !label.last().is_some_and(u8::is_ascii_alphanumeric)
676            || label
677                .iter()
678                .any(|byte| !byte.is_ascii_alphanumeric() && *byte != b'-')
679        {
680            return Err(ResolverError::InvalidServiceName);
681        }
682        if index != 0 {
683            output.push('.');
684        }
685        for byte in label {
686            output.push(char::from(*byte));
687        }
688    }
689    Ok(output)
690}
691
692fn is_suffix(name: &Name, suffix: &Name) -> bool {
693    name.labels()
694        .get(name.labels().len().saturating_sub(suffix.labels().len())..)
695        == Some(suffix.labels())
696}
697
698#[cfg(test)]
699#[allow(
700    clippy::unwrap_used,
701    reason = "tests intentionally fail immediately on invalid local cryptographic fixtures"
702)]
703mod tests {
704    use blake2::Blake2bVar;
705    use blake2::digest::{Update, VariableOutput};
706    use hns_dns_wire::{Dnskey, Ds, Flags, Header, Question, Rrsig};
707    use hns_dnssec::{ALGORITHM_RSASHA256, authenticate_dnskeys, dnskey_tag, rrsig_signed_data};
708    use hns_header_consensus::{Header as ConsensusHeader, Network as ConsensusNetwork};
709    use hns_light_chain::{ChainLimits, CurrencyPolicy, LightChain};
710    use hns_primitives::{BlockTime, Chainwork, Height, TreeRoot};
711    use openssl::hash::{MessageDigest, hash};
712    use openssl::pkey::{PKey, Private};
713    use openssl::rsa::Rsa;
714    use openssl::sign::Signer;
715
716    use super::*;
717
718    fn name(value: &str) -> Name {
719        Name::from_ascii(value).unwrap()
720    }
721
722    fn rsa_dnskey(rsa: &Rsa<Private>) -> Dnskey {
723        let exponent = rsa.e().to_vec();
724        let modulus = rsa.n().to_vec();
725        let mut public_key = Vec::new();
726        public_key.push(u8::try_from(exponent.len()).unwrap());
727        public_key.extend_from_slice(&exponent);
728        public_key.extend_from_slice(&modulus);
729        Dnskey {
730            flags: 257,
731            protocol: 3,
732            algorithm: ALGORITHM_RSASHA256,
733            public_key,
734        }
735    }
736
737    fn encode_dnskey(key: &Dnskey) -> Vec<u8> {
738        let mut output = Vec::new();
739        output.extend_from_slice(&key.flags.to_be_bytes());
740        output.push(key.protocol);
741        output.push(key.algorithm);
742        output.extend_from_slice(&key.public_key);
743        output
744    }
745
746    fn sign_rrset(
747        records: &[ResourceRecord],
748        signer_name: Name,
749        key: &Dnskey,
750        key_pair: &PKey<Private>,
751    ) -> ResourceRecord {
752        sign_rrset_window(records, signer_name, key, key_pair, 1_000, 2_000)
753    }
754
755    fn sign_rrset_window(
756        records: &[ResourceRecord],
757        signer_name: Name,
758        key: &Dnskey,
759        key_pair: &PKey<Private>,
760        inception: u32,
761        expiration: u32,
762    ) -> ResourceRecord {
763        let first = records.first().unwrap();
764        let mut signature = Rrsig {
765            type_covered: first.record_type,
766            algorithm: key.algorithm,
767            labels: u8::try_from(first.name.labels().len()).unwrap(),
768            original_ttl: first.ttl,
769            expiration,
770            inception,
771            key_tag: dnskey_tag(key),
772            signer: signer_name,
773            signature: Vec::new(),
774        };
775        let signed = rrsig_signed_data(records, &signature, 1024 * 1024).unwrap();
776        let mut crypto_signer = Signer::new(MessageDigest::sha256(), key_pair).unwrap();
777        crypto_signer.update(&signed).unwrap();
778        signature.signature = crypto_signer.sign_to_vec().unwrap();
779        ResourceRecord {
780            name: first.name.clone(),
781            record_type: RecordType::Rrsig,
782            class: CLASS_IN,
783            ttl: first.ttl,
784            rdata: Rdata::Rrsig(signature),
785        }
786    }
787
788    fn blake2b_256(parts: &[&[u8]]) -> [u8; 32] {
789        let mut hasher = Blake2bVar::new(32).unwrap();
790        for part in parts {
791            hasher.update(part);
792        }
793        let mut output = [0_u8; 32];
794        hasher.finalize_variable(&mut output).unwrap();
795        output
796    }
797
798    fn verified_hns_resource(ds: &Ds) -> (VerifiedHnsResource, u32) {
799        let genesis_time = ConsensusNetwork::Regtest.parameters().genesis_time;
800        let validation_time = u32::try_from(genesis_time.get() + 100).unwrap();
801        let mut resource = vec![0, 0];
802        resource.extend_from_slice(&ds.key_tag.to_be_bytes());
803        resource.extend_from_slice(&[ds.algorithm, ds.digest_type]);
804        resource.push(u8::try_from(ds.digest.len()).unwrap());
805        resource.extend_from_slice(&ds.digest);
806
807        let mut state = Vec::new();
808        state.push(5);
809        state.extend_from_slice(b"alpha");
810        state.extend_from_slice(&u16::try_from(resource.len()).unwrap().to_le_bytes());
811        state.extend_from_slice(&resource);
812        state.extend_from_slice(&1_u32.to_le_bytes());
813        state.extend_from_slice(&1_u32.to_le_bytes());
814        state.extend_from_slice(&0_u16.to_le_bytes());
815
816        let key = hns_covenants::hash_name(b"alpha").unwrap();
817        let value_hash = blake2b_256(&[&state]);
818        let tree_root = TreeRoot::new(blake2b_256(&[&[0], key.as_bytes(), &value_hash]));
819        let mut proof = Vec::new();
820        proof.extend_from_slice(&0xc000_u16.to_le_bytes());
821        proof.extend_from_slice(&0_u16.to_le_bytes());
822        proof.extend_from_slice(&u16::try_from(state.len()).unwrap().to_le_bytes());
823        proof.extend_from_slice(&state);
824
825        let now = BlockTime::new(u64::from(validation_time));
826        let mut chain =
827            LightChain::from_genesis(ConsensusNetwork::Regtest, now, ChainLimits::default())
828                .unwrap();
829        let mut header = ConsensusHeader {
830            time: BlockTime::new(genesis_time.get() + 1),
831            previous_block: chain.tip().hash(),
832            tree_root,
833            bits: ConsensusNetwork::Regtest.parameters().pow.bits,
834            ..ConsensusHeader::default()
835        };
836        while !header.verify_pow() {
837            header.nonce = header.nonce.checked_add(1).unwrap();
838        }
839        chain.append(&header, now).unwrap();
840        let current = chain
841            .require_current(CurrencyPolicy {
842                now,
843                maximum_tip_age_seconds: 3_600,
844                minimum_height: Height::new(1),
845                minimum_chainwork: Chainwork::ZERO,
846            })
847            .unwrap();
848        (
849            current.verify_name_resource(b"alpha", &proof).unwrap(),
850            validation_time,
851        )
852    }
853
854    fn keyset() -> (AuthenticatedDnskeys, PKey<Private>, Dnskey) {
855        let zone = name("example.");
856        let rsa = Rsa::generate(1024).unwrap();
857        let key = rsa_dnskey(&rsa);
858        let key_pair = PKey::from_rsa(rsa).unwrap();
859        let dnskeys = vec![ResourceRecord {
860            name: zone.clone(),
861            record_type: RecordType::Dnskey,
862            class: CLASS_IN,
863            ttl: 300,
864            rdata: Rdata::Dnskey(key.clone()),
865        }];
866        let signatures = vec![sign_rrset(&dnskeys, zone.clone(), &key, &key_pair)];
867        let mut digest_input = Vec::new();
868        zone.encode(&mut digest_input).unwrap();
869        digest_input.extend_from_slice(&encode_dnskey(&key));
870        let ds = vec![ResourceRecord {
871            name: zone.clone(),
872            record_type: RecordType::Ds,
873            class: CLASS_IN,
874            ttl: 300,
875            rdata: Rdata::Ds(Ds {
876                key_tag: dnskey_tag(&key),
877                algorithm: key.algorithm,
878                digest_type: 2,
879                digest: hash(MessageDigest::sha256(), &digest_input)
880                    .unwrap()
881                    .to_vec(),
882            }),
883        }];
884        (
885            authenticate_dnskeys(
886                &zone,
887                &ds,
888                &dnskeys,
889                &signatures,
890                1_500,
891                DnssecLimits::default(),
892            )
893            .unwrap(),
894            key_pair,
895            key,
896        )
897    }
898
899    fn cname(owner: Name, target: Name) -> ResourceRecord {
900        ResourceRecord {
901            name: owner,
902            record_type: RecordType::Cname,
903            class: CLASS_IN,
904            ttl: 300,
905            rdata: Rdata::Cname(target),
906        }
907    }
908
909    fn tlsa(owner: Name, association: u8) -> ResourceRecord {
910        ResourceRecord {
911            name: owner,
912            record_type: RecordType::Tlsa,
913            class: CLASS_IN,
914            ttl: 300,
915            rdata: Rdata::Tlsa(Tlsa {
916                usage: 3,
917                selector: 1,
918                matching_type: 1,
919                association_data: vec![association; 32],
920            }),
921        }
922    }
923
924    fn response(query: &Query, answers: Vec<ResourceRecord>) -> Message {
925        Message {
926            header: Header {
927                id: query.id,
928                flags: Flags::from_bits(0x8420),
929                question_count: 1,
930                answer_count: u16::try_from(answers.len()).unwrap(),
931                authority_count: 0,
932                additional_count: 0,
933            },
934            questions: vec![Question {
935                name: query.question.name.clone(),
936                record_type: query.question.record_type,
937                class: query.question.class,
938            }],
939            answers,
940            authorities: Vec::new(),
941            additionals: Vec::new(),
942        }
943    }
944
945    #[test]
946    fn validates_cname_and_terminal_tlsa_in_one_response() {
947        let (keys, key_pair, key) = keyset();
948        let mut resolution =
949            TlsaResolution::for_https(name("service.example."), ResolverLimits::default()).unwrap();
950        let query = resolution.query(7).unwrap();
951        let target = name("tlsa.provider.example.");
952        let cname_records = vec![cname(query.question.name.clone(), target.clone())];
953        let tlsa_records = vec![tlsa(target.clone(), 9)];
954        let message = response(
955            &query,
956            vec![
957                cname_records.first().unwrap().clone(),
958                sign_rrset(&cname_records, name("example."), &key, &key_pair),
959                tlsa_records.first().unwrap().clone(),
960                sign_rrset(&tlsa_records, name("example."), &key, &key_pair),
961            ],
962        );
963        assert!(message.header.flags.authenticated_data_claim());
964        let step = resolution
965            .accept_response(&query, &message, &[&keys], 1_500)
966            .unwrap();
967        let validated = match step {
968            ResolutionStep::Complete(validated) => Some(validated),
969            ResolutionStep::FollowCname(_) => None,
970        }
971        .unwrap();
972        assert_eq!(validated.base_domain_ascii(), "service.example");
973        assert_eq!(validated.terminal_owner(), &target);
974        assert_eq!(validated.cname_chain().len(), 1);
975        assert_eq!(validated.records().len(), 1);
976    }
977
978    #[test]
979    fn validates_cname_across_correlated_responses_and_rejects_loops() {
980        let (keys, key_pair, key) = keyset();
981        let mut resolution =
982            TlsaResolution::for_https(name("service.example."), ResolverLimits::default()).unwrap();
983        let first_query = resolution.query(10).unwrap();
984        let target = name("tlsa.example.");
985        let first_rrset = vec![cname(first_query.question.name.clone(), target.clone())];
986        let first_message = response(
987            &first_query,
988            vec![
989                first_rrset.first().unwrap().clone(),
990                sign_rrset(&first_rrset, name("example."), &key, &key_pair),
991            ],
992        );
993        assert_eq!(
994            resolution
995                .accept_response(&first_query, &first_message, &[&keys], 1_500)
996                .unwrap(),
997            ResolutionStep::FollowCname(target.clone())
998        );
999
1000        let second_query = resolution.query(11).unwrap();
1001        let second_rrset = vec![tlsa(target.clone(), 4)];
1002        let second_message = response(
1003            &second_query,
1004            vec![
1005                second_rrset.first().unwrap().clone(),
1006                sign_rrset(&second_rrset, name("example."), &key, &key_pair),
1007            ],
1008        );
1009        assert!(matches!(
1010            resolution
1011                .accept_response(&second_query, &second_message, &[&keys], 1_500)
1012                .unwrap(),
1013            ResolutionStep::Complete(_)
1014        ));
1015
1016        let mut looping =
1017            TlsaResolution::for_https(name("loop.example."), ResolverLimits::default()).unwrap();
1018        let loop_query = looping.query(12).unwrap();
1019        let alias = name("alias.example.");
1020        let first_loop = vec![cname(loop_query.question.name.clone(), alias.clone())];
1021        let first_loop_message = response(
1022            &loop_query,
1023            vec![
1024                first_loop.first().unwrap().clone(),
1025                sign_rrset(&first_loop, name("example."), &key, &key_pair),
1026            ],
1027        );
1028        looping
1029            .accept_response(&loop_query, &first_loop_message, &[&keys], 1_500)
1030            .unwrap();
1031        let alias_query = looping.query(13).unwrap();
1032        let second_loop = vec![cname(alias, name("_443._tcp.loop.example."))];
1033        let second_loop_message = response(
1034            &alias_query,
1035            vec![
1036                second_loop.first().unwrap().clone(),
1037                sign_rrset(&second_loop, name("example."), &key, &key_pair),
1038            ],
1039        );
1040        assert_eq!(
1041            looping.accept_response(&alias_query, &second_loop_message, &[&keys], 1_500),
1042            Err(ResolverError::CnameLoop)
1043        );
1044    }
1045
1046    #[test]
1047    fn rejects_unsigned_or_mutated_tlsa_even_when_ad_is_set() {
1048        let (keys, key_pair, key) = keyset();
1049        let mut resolution =
1050            TlsaResolution::for_https(name("service.example."), ResolverLimits::default()).unwrap();
1051        let query = resolution.query(15).unwrap();
1052        let original = vec![tlsa(query.question.name.clone(), 1)];
1053        let signature = sign_rrset(&original, name("example."), &key, &key_pair);
1054        let mutated = tlsa(query.question.name.clone(), 2);
1055        let message = response(&query, vec![mutated, signature]);
1056        assert!(message.header.flags.authenticated_data_claim());
1057        assert!(matches!(
1058            resolution.accept_response(&query, &message, &[&keys], 1_500),
1059            Err(ResolverError::Dnssec(DnssecError::SignatureMismatch))
1060        ));
1061    }
1062
1063    #[test]
1064    fn service_name_rejects_non_host_labels() {
1065        assert_eq!(
1066            TlsaResolution::for_https(name("_hidden.example."), ResolverLimits::default())
1067                .unwrap_err(),
1068            ResolverError::InvalidServiceName
1069        );
1070        assert!(
1071            TlsaResolution::for_https(
1072                Name::from_labels(vec![vec![0xff], b"example".to_vec()]).unwrap(),
1073                ResolverLimits::default()
1074            )
1075            .is_err()
1076        );
1077    }
1078
1079    #[test]
1080    fn binds_hns_header_resource_ds_dnskey_and_tlsa_evidence() {
1081        let zone = name("alpha.");
1082        let rsa = Rsa::generate(1024).unwrap();
1083        let key = rsa_dnskey(&rsa);
1084        let key_pair = PKey::from_rsa(rsa).unwrap();
1085        let dnskeys = vec![ResourceRecord {
1086            name: zone.clone(),
1087            record_type: RecordType::Dnskey,
1088            class: CLASS_IN,
1089            ttl: 300,
1090            rdata: Rdata::Dnskey(key.clone()),
1091        }];
1092        let mut digest_input = Vec::new();
1093        zone.encode(&mut digest_input).unwrap();
1094        digest_input.extend_from_slice(&encode_dnskey(&key));
1095        let ds = Ds {
1096            key_tag: dnskey_tag(&key),
1097            algorithm: key.algorithm,
1098            digest_type: 2,
1099            digest: hash(MessageDigest::sha256(), &digest_input)
1100                .unwrap()
1101                .to_vec(),
1102        };
1103        let (resource, validation_time) = verified_hns_resource(&ds);
1104        let dnskey_signatures = vec![sign_rrset_window(
1105            &dnskeys,
1106            zone.clone(),
1107            &key,
1108            &key_pair,
1109            validation_time - 10,
1110            validation_time + 10,
1111        )];
1112        let authority = HnsDnssecAuthority::authenticate(
1113            &resource,
1114            &dnskeys,
1115            &dnskey_signatures,
1116            validation_time,
1117            DnssecLimits::default(),
1118        )
1119        .unwrap();
1120
1121        let mut resolution =
1122            TlsaResolution::for_https(name("www.alpha."), ResolverLimits::default()).unwrap();
1123        let query = resolution.query(31).unwrap();
1124        let tlsa_records = vec![tlsa(query.question.name.clone(), 0x44)];
1125        let message = response(
1126            &query,
1127            vec![
1128                tlsa_records.first().unwrap().clone(),
1129                sign_rrset_window(
1130                    &tlsa_records,
1131                    zone.clone(),
1132                    &key,
1133                    &key_pair,
1134                    validation_time - 10,
1135                    validation_time + 10,
1136                ),
1137            ],
1138        );
1139        let validated = match resolution
1140            .accept_hns_response(&query, &message, &authority)
1141            .unwrap()
1142        {
1143            ResolutionStep::Complete(validated) => Some(validated),
1144            ResolutionStep::FollowCname(_) => None,
1145        }
1146        .unwrap();
1147        let evidence = validated.hns_authority().unwrap();
1148        assert_eq!(evidence.zone(), &zone);
1149        assert_eq!(evidence.validation_time(), validation_time);
1150        assert_eq!(evidence.anchor(), resource.anchor());
1151        assert_eq!(evidence.expires_at_unix(), u64::from(validation_time) + 11);
1152        assert_eq!(validated.validated_at_unix(), u64::from(validation_time));
1153        assert_eq!(validated.expires_at_unix(), u64::from(validation_time) + 11);
1154        assert!(validated.is_fresh_at(u64::from(validation_time) + 10));
1155        assert!(!validated.is_fresh_at(u64::from(validation_time) + 11));
1156
1157        let mut outside =
1158            TlsaResolution::for_https(name("www.other."), ResolverLimits::default()).unwrap();
1159        let outside_query = outside.query(32).unwrap();
1160        assert_eq!(
1161            outside.accept_hns_response(&outside_query, &message, &authority),
1162            Err(ResolverError::HnsZoneMismatch)
1163        );
1164    }
1165}