1#![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
25pub use hns_icann_dane::TlsaTransport as ServiceTransport;
27
28pub const HTTPS_PORT: u16 = 443;
30pub const DEFAULT_MAX_CNAME_HOPS: usize = 16;
32pub const DEFAULT_MAX_TLSA_RECORDS: usize = 64;
34pub const HNS_RESOURCE_TTL: u32 = 21_600;
36
37#[derive(Clone, Debug, Eq, PartialEq)]
42pub struct HnsDnssecAuthority {
43 evidence: HnsAuthorityEvidence,
44 keys: AuthenticatedDnskeys,
45}
46
47impl HnsDnssecAuthority {
48 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 #[must_use]
107 pub const fn anchor(&self) -> HnsAnchor {
108 self.evidence.anchor
109 }
110
111 #[must_use]
113 pub const fn zone(&self) -> &Name {
114 &self.evidence.zone
115 }
116
117 #[must_use]
119 pub const fn validation_time(&self) -> u32 {
120 self.evidence.validation_time
121 }
122}
123
124#[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 #[must_use]
136 pub const fn anchor(&self) -> HnsAnchor {
137 self.anchor
138 }
139
140 #[must_use]
142 pub const fn zone(&self) -> &Name {
143 &self.zone
144 }
145
146 #[must_use]
148 pub const fn validation_time(&self) -> u32 {
149 self.validation_time
150 }
151
152 #[must_use]
154 pub const fn expires_at_unix(&self) -> u64 {
155 self.expires_at_unix
156 }
157}
158
159#[derive(Clone, Copy, Debug, Eq, PartialEq)]
161pub struct ResolverLimits {
162 pub max_cname_hops: usize,
164 pub max_tlsa_records: usize,
166 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#[derive(Clone, Debug, Eq, PartialEq)]
182pub struct VerifiedCname {
183 owner: Name,
184 target: Name,
185 rrset: VerifiedRrset,
186}
187
188impl VerifiedCname {
189 #[must_use]
191 pub const fn owner(&self) -> &Name {
192 &self.owner
193 }
194
195 #[must_use]
197 pub const fn target(&self) -> &Name {
198 &self.target
199 }
200
201 #[must_use]
203 pub const fn rrset(&self) -> &VerifiedRrset {
204 &self.rrset
205 }
206}
207
208#[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 #[must_use]
228 pub const fn requested_owner(&self) -> &Name {
229 &self.requested_owner
230 }
231
232 #[must_use]
234 pub const fn terminal_owner(&self) -> &Name {
235 &self.terminal_owner
236 }
237
238 #[must_use]
240 pub const fn base_domain(&self) -> &Name {
241 &self.base_domain
242 }
243
244 #[must_use]
246 pub fn base_domain_ascii(&self) -> &str {
247 &self.base_domain_ascii
248 }
249
250 #[must_use]
252 pub fn records(&self) -> &[Tlsa] {
253 &self.records
254 }
255
256 #[must_use]
258 pub fn cname_chain(&self) -> &[VerifiedCname] {
259 &self.cname_chain
260 }
261
262 #[must_use]
264 pub const fn rrset(&self) -> &VerifiedRrset {
265 &self.rrset
266 }
267
268 #[must_use]
270 pub const fn hns_authority(&self) -> Option<&HnsAuthorityEvidence> {
271 self.hns_authority.as_ref()
272 }
273
274 #[must_use]
276 pub const fn validated_at_unix(&self) -> u64 {
277 self.validated_at_unix
278 }
279
280 #[must_use]
282 pub const fn expires_at_unix(&self) -> u64 {
283 self.expires_at_unix
284 }
285
286 #[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#[derive(Clone, Debug, Eq, PartialEq)]
295pub enum ResolutionStep {
296 FollowCname(Name),
298 Complete(Box<ValidatedTlsa>),
300}
301
302#[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 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 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 #[must_use]
358 pub const fn current_owner(&self) -> &Name {
359 &self.current_owner
360 }
361
362 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 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 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#[derive(Clone, Debug, Eq, Error, PartialEq)]
518#[non_exhaustive]
519pub enum ResolverError {
520 #[error("DNS wire error: {0}")]
522 Wire(#[from] hns_dns_wire::Error),
523 #[error("DNSSEC error: {0}")]
525 Dnssec(#[from] DnssecError),
526 #[error("invalid TLS service name")]
528 InvalidServiceName,
529 #[error("response query does not match the current TLSA owner")]
531 WrongQuery,
532 #[error("TLSA response was unsuccessful")]
534 UnsuccessfulResponse,
535 #[error("secure TLSA RRset is missing")]
537 MissingTlsa,
538 #[error("CNAME coexists with TLSA data")]
540 CnameCoexistsWithData,
541 #[error("CNAME loop")]
543 CnameLoop,
544 #[error("CNAME hop limit exceeded")]
546 CnameLimit,
547 #[error("malformed TLSA or CNAME answer")]
549 MalformedAnswer,
550 #[error("resolver resource bound exceeded")]
552 Limit,
553 #[error("TLSA resolution is already complete")]
555 AlreadyComplete,
556 #[error("verified HNS resource has no DS record")]
558 MissingHnsDs,
559 #[error("verified HNS name is not a valid DNS zone")]
561 InvalidHnsZone,
562 #[error("DNSSEC time does not match current Handshake anchor time")]
564 AnchorTimeMismatch,
565 #[error("requested origin is outside the authenticated HNS zone")]
567 HnsZoneMismatch,
568 #[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}