1#![forbid(unsafe_code)]
7#![allow(
8 clippy::doc_markdown,
9 clippy::missing_errors_doc,
10 clippy::module_name_repetitions,
11 reason = "DNSSEC terminology and the public error type are documented at crate level"
12)]
13
14use std::cmp::Ordering;
15
16use hns_dns_wire::{
17 CLASS_IN, Dnskey, Ds, Name, Nsec, Nsec3, Rdata, RecordType, ResourceRecord, Rrsig,
18};
19use openssl::bn::{BigNum, BigNumContext};
20use openssl::ec::{EcGroup, EcKey, EcPoint};
21use openssl::ecdsa::EcdsaSig;
22use openssl::hash::{MessageDigest, hash};
23use openssl::memcmp;
24use openssl::nid::Nid;
25use openssl::pkey::{Id, PKey, Public};
26use openssl::rsa::{Padding, Rsa};
27use openssl::sign::Verifier;
28use thiserror::Error;
29
30pub const ALGORITHM_RSASHA1: u8 = 5;
32pub const ALGORITHM_RSASHA1_NSEC3: u8 = 7;
34pub const ALGORITHM_RSASHA256: u8 = 8;
36pub const ALGORITHM_RSASHA512: u8 = 10;
38pub const ALGORITHM_ECDSA_P256_SHA256: u8 = 13;
40pub const ALGORITHM_ECDSA_P384_SHA384: u8 = 14;
42pub const ALGORITHM_ED25519: u8 = 15;
44pub const ALGORITHM_ED448: u8 = 16;
46
47#[derive(Clone, Copy, Debug, Eq, PartialEq)]
49pub struct DnssecLimits {
50 pub max_rrset_records: usize,
52 pub max_signatures: usize,
54 pub max_keys: usize,
56 pub max_signed_data_len: usize,
58 pub max_nsec3_iterations: u16,
60 pub max_denial_records: usize,
62}
63
64impl Default for DnssecLimits {
65 fn default() -> Self {
66 Self {
67 max_rrset_records: 1_024,
68 max_signatures: 64,
69 max_keys: 64,
70 max_signed_data_len: 4 * 1024 * 1024,
71 max_nsec3_iterations: 500,
72 max_denial_records: 256,
73 }
74 }
75}
76
77#[derive(Clone, Debug, Eq, PartialEq)]
79pub struct VerifiedRrset {
80 owner: Name,
82 record_type: RecordType,
84 key_tag: u16,
86 algorithm: u8,
88 inception: u32,
90 expiration: u32,
92 observed_at_unix: u64,
94 expires_at_unix: u64,
96}
97
98impl VerifiedRrset {
99 #[must_use]
101 pub const fn owner(&self) -> &Name {
102 &self.owner
103 }
104
105 #[must_use]
107 pub const fn record_type(&self) -> RecordType {
108 self.record_type
109 }
110
111 #[must_use]
113 pub const fn key_tag(&self) -> u16 {
114 self.key_tag
115 }
116
117 #[must_use]
119 pub const fn algorithm(&self) -> u8 {
120 self.algorithm
121 }
122
123 #[must_use]
125 pub const fn inception(&self) -> u32 {
126 self.inception
127 }
128
129 #[must_use]
131 pub const fn expiration(&self) -> u32 {
132 self.expiration
133 }
134
135 #[must_use]
137 pub const fn observed_at_unix(&self) -> u64 {
138 self.observed_at_unix
139 }
140
141 #[must_use]
143 pub const fn expires_at_unix(&self) -> u64 {
144 self.expires_at_unix
145 }
146
147 #[must_use]
149 pub const fn is_fresh_at(&self, now: u64) -> bool {
150 self.observed_at_unix <= now && now < self.expires_at_unix
151 }
152}
153
154#[derive(Clone, Debug, Eq, PartialEq)]
159pub struct AuthenticatedDnskeys {
160 zone: Name,
161 records: Vec<ResourceRecord>,
162 delegation_key_tag: u16,
163 delegation_algorithm: u8,
164 observed_at_unix: u64,
165 expires_at_unix: u64,
166}
167
168impl AuthenticatedDnskeys {
169 #[must_use]
171 pub const fn zone(&self) -> &Name {
172 &self.zone
173 }
174
175 #[must_use]
177 pub const fn delegation_key_tag(&self) -> u16 {
178 self.delegation_key_tag
179 }
180
181 #[must_use]
183 pub const fn delegation_algorithm(&self) -> u8 {
184 self.delegation_algorithm
185 }
186
187 #[must_use]
189 pub const fn observed_at_unix(&self) -> u64 {
190 self.observed_at_unix
191 }
192
193 #[must_use]
195 pub const fn expires_at_unix(&self) -> u64 {
196 self.expires_at_unix
197 }
198
199 #[must_use]
201 pub const fn is_fresh_at(&self, now: u64) -> bool {
202 self.observed_at_unix <= now && now < self.expires_at_unix
203 }
204}
205
206#[derive(Clone, Copy, Debug)]
208pub struct SignedRrset<'a> {
209 pub records: &'a [ResourceRecord],
211 pub signatures: &'a [ResourceRecord],
213}
214
215#[derive(Clone, Copy, Debug, Eq, PartialEq)]
217pub enum Denial {
218 NoData,
220 NameError,
222}
223
224#[derive(Clone, Debug, Eq, Error, PartialEq)]
226#[non_exhaustive]
227pub enum DnssecError {
228 #[error("DNSSEC RRset is empty")]
230 EmptyRrset,
231 #[error("DNSSEC resource bound exceeded")]
233 Limit,
234 #[error("records do not form one class-IN RRset")]
236 RrsetMismatch,
237 #[error("no covering RRSIG")]
239 MissingSignature,
240 #[error("no matching DNSKEY")]
242 MissingKey,
243 #[error("DNSKEY is revoked or malformed")]
245 InvalidKey,
246 #[error("unsupported DNSSEC algorithm {0}")]
248 UnsupportedAlgorithm(u8),
249 #[error("unsupported DS digest algorithm {0}")]
251 UnsupportedDigest(u8),
252 #[error("RRSIG is outside its validity window")]
254 SignatureTime,
255 #[error("DNSSEC signature mismatch")]
257 SignatureMismatch,
258 #[error("unsupported or mismatched canonical RDATA")]
260 UnsupportedRdata,
261 #[error("DS digest mismatch")]
263 DsMismatch,
264 #[error("authenticated denial proof mismatch")]
266 DenialMismatch,
267}
268
269pub fn verify_rrset(
271 records: &[ResourceRecord],
272 signatures: &[ResourceRecord],
273 keys: &[ResourceRecord],
274 validation_time: u32,
275 limits: DnssecLimits,
276) -> Result<VerifiedRrset, DnssecError> {
277 if records.is_empty() {
278 return Err(DnssecError::EmptyRrset);
279 }
280 if records.len() > limits.max_rrset_records
281 || signatures.len() > limits.max_signatures
282 || keys.len() > limits.max_keys
283 {
284 return Err(DnssecError::Limit);
285 }
286 let first = records.first().ok_or(DnssecError::EmptyRrset)?;
287 if first.class != CLASS_IN
288 || matches!(first.record_type, RecordType::Rrsig | RecordType::Opt)
289 || records.iter().any(|record| {
290 record.name != first.name
291 || record.record_type != first.record_type
292 || record.class != CLASS_IN
293 })
294 {
295 return Err(DnssecError::RrsetMismatch);
296 }
297
298 let mut covering = 0usize;
299 let mut saw_current = false;
300 let mut saw_supported = false;
301 let mut saw_key = false;
302 let mut unsupported = None;
303 for signature_record in signatures {
304 let Some(signature) = rrsig_for(signature_record, &first.name, first.record_type) else {
305 continue;
306 };
307 if usize::from(signature.labels) != first.name.labels().len() {
308 continue;
309 }
310 covering = covering.saturating_add(1);
311 if !serial_in_window(validation_time, signature.inception, signature.expiration) {
312 continue;
313 }
314 saw_current = true;
315 if !supported_algorithm(signature.algorithm) {
316 unsupported.get_or_insert(signature.algorithm);
317 continue;
318 }
319 saw_supported = true;
320 let signed = rrsig_signed_data(records, signature, limits.max_signed_data_len)?;
321 for key_record in keys {
322 let Some(key) = dnskey_for(key_record, &signature.signer) else {
323 continue;
324 };
325 if key.protocol != 3 || key.flags & 0x0080 != 0 {
326 continue;
327 }
328 if key.algorithm != signature.algorithm || dnskey_tag(key) != signature.key_tag {
329 continue;
330 }
331 saw_key = true;
332 if verify_signature(
333 signature.algorithm,
334 &key.public_key,
335 &signed,
336 &signature.signature,
337 ) {
338 return Ok(VerifiedRrset {
339 owner: first.name.clone(),
340 record_type: first.record_type,
341 key_tag: signature.key_tag,
342 algorithm: signature.algorithm,
343 inception: signature.inception,
344 expiration: signature.expiration,
345 observed_at_unix: u64::from(validation_time),
346 expires_at_unix: rrset_expires_at(
347 records,
348 signature_record,
349 signature,
350 validation_time,
351 ),
352 });
353 }
354 }
355 }
356
357 if covering == 0 {
358 Err(DnssecError::MissingSignature)
359 } else if !saw_current {
360 Err(DnssecError::SignatureTime)
361 } else if !saw_supported {
362 Err(DnssecError::UnsupportedAlgorithm(
363 unsupported.unwrap_or_default(),
364 ))
365 } else if !saw_key {
366 Err(DnssecError::MissingKey)
367 } else {
368 Err(DnssecError::SignatureMismatch)
369 }
370}
371
372pub fn rrsig_signed_data(
377 records: &[ResourceRecord],
378 signature: &Rrsig,
379 maximum: usize,
380) -> Result<Vec<u8>, DnssecError> {
381 canonical_signed_data(records, signature, maximum)
382}
383
384pub fn authenticate_dnskeys(
390 zone: &Name,
391 trusted_ds: &[ResourceRecord],
392 dnskeys: &[ResourceRecord],
393 signatures: &[ResourceRecord],
394 validation_time: u32,
395 limits: DnssecLimits,
396) -> Result<AuthenticatedDnskeys, DnssecError> {
397 if dnskeys.is_empty() {
398 return Err(DnssecError::EmptyRrset);
399 }
400 let mut saw_ds_match = false;
401 for key_record in dnskeys {
402 let Some(key) = dnskey_for(key_record, zone) else {
403 continue;
404 };
405 if key.flags & 0x0100 == 0 || verify_ds(zone, key, trusted_ds).is_err() {
406 continue;
407 }
408 saw_ds_match = true;
409 let key_tag = dnskey_tag(key);
410 let covering = signatures
411 .iter()
412 .filter(|record| {
413 rrsig_for(record, zone, RecordType::Dnskey).is_some_and(|signature| {
414 signature.key_tag == key_tag && signature.algorithm == key.algorithm
415 })
416 })
417 .cloned()
418 .collect::<Vec<_>>();
419 if let Ok(verified) = verify_rrset(
420 dnskeys,
421 &covering,
422 std::slice::from_ref(key_record),
423 validation_time,
424 limits,
425 ) {
426 return Ok(AuthenticatedDnskeys {
427 zone: zone.clone(),
428 records: dnskeys.to_vec(),
429 delegation_key_tag: key_tag,
430 delegation_algorithm: key.algorithm,
431 observed_at_unix: u64::from(validation_time),
432 expires_at_unix: verified
433 .expires_at_unix
434 .min(records_expire_at(trusted_ds, validation_time)),
435 });
436 }
437 }
438 if saw_ds_match {
439 Err(DnssecError::SignatureMismatch)
440 } else {
441 Err(DnssecError::DsMismatch)
442 }
443}
444
445pub fn verify_rrset_with_keys(
447 keys: &AuthenticatedDnskeys,
448 records: &[ResourceRecord],
449 signatures: &[ResourceRecord],
450 validation_time: u32,
451 limits: DnssecLimits,
452) -> Result<VerifiedRrset, DnssecError> {
453 let now = u64::from(validation_time);
454 if !keys.is_fresh_at(now) {
455 return Err(DnssecError::SignatureTime);
456 }
457 let mut verified = verify_rrset(records, signatures, &keys.records, validation_time, limits)?;
458 verified.expires_at_unix = verified.expires_at_unix.min(keys.expires_at_unix);
459 Ok(verified)
460}
461
462pub fn authenticate_child_dnskeys(
464 parent: &AuthenticatedDnskeys,
465 child_zone: &Name,
466 child_ds: SignedRrset<'_>,
467 child_dnskeys: SignedRrset<'_>,
468 validation_time: u32,
469 limits: DnssecLimits,
470) -> Result<AuthenticatedDnskeys, DnssecError> {
471 let verified = verify_rrset_with_keys(
472 parent,
473 child_ds.records,
474 child_ds.signatures,
475 validation_time,
476 limits,
477 )?;
478 if verified.owner() != child_zone || verified.record_type() != RecordType::Ds {
479 return Err(DnssecError::RrsetMismatch);
480 }
481 let mut child = authenticate_dnskeys(
482 child_zone,
483 child_ds.records,
484 child_dnskeys.records,
485 child_dnskeys.signatures,
486 validation_time,
487 limits,
488 )?;
489 child.observed_at_unix = child
490 .observed_at_unix
491 .max(parent.observed_at_unix)
492 .max(verified.observed_at_unix);
493 child.expires_at_unix = child
494 .expires_at_unix
495 .min(parent.expires_at_unix)
496 .min(verified.expires_at_unix);
497 Ok(child)
498}
499
500pub fn verify_ds(
502 owner: &Name,
503 key: &Dnskey,
504 records: &[ResourceRecord],
505) -> Result<(), DnssecError> {
506 if key.protocol != 3 || key.flags & 0x0080 != 0 {
507 return Err(DnssecError::InvalidKey);
508 }
509 let key_tag = dnskey_tag(key);
510 let key_rdata = encode_dnskey(key);
511 let mut digest_input = Vec::with_capacity(owner.wire_len().saturating_add(key_rdata.len()));
512 owner
513 .encode(&mut digest_input)
514 .map_err(|_| DnssecError::UnsupportedRdata)?;
515 digest_input.extend_from_slice(&key_rdata);
516
517 let mut saw_candidate = false;
518 let mut unsupported = None;
519 for record in records {
520 let Rdata::Ds(ds) = &record.rdata else {
521 continue;
522 };
523 if record.name != *owner
524 || record.class != CLASS_IN
525 || record.record_type != RecordType::Ds
526 || ds.key_tag != key_tag
527 || ds.algorithm != key.algorithm
528 {
529 continue;
530 }
531 saw_candidate = true;
532 let digest = match digest_ds(ds.digest_type, &digest_input) {
533 Ok(digest) => digest,
534 Err(DnssecError::UnsupportedDigest(value)) => {
535 unsupported.get_or_insert(value);
536 continue;
537 }
538 Err(error) => return Err(error),
539 };
540 if memcmp::eq(&digest, &ds.digest) {
541 return Ok(());
542 }
543 }
544 if saw_candidate && unsupported.is_some() {
545 Err(DnssecError::UnsupportedDigest(
546 unsupported.unwrap_or_default(),
547 ))
548 } else {
549 Err(DnssecError::DsMismatch)
550 }
551}
552
553#[must_use]
555pub fn dnskey_tag(key: &Dnskey) -> u16 {
556 let rdata = encode_dnskey(key);
557 let mut accumulator = 0_u32;
558 for (index, byte) in rdata.iter().copied().enumerate() {
559 accumulator = accumulator.wrapping_add(if index & 1 == 0 {
560 u32::from(byte) << 8
561 } else {
562 u32::from(byte)
563 });
564 }
565 accumulator = accumulator.wrapping_add((accumulator >> 16) & 0xffff);
566 (accumulator & 0xffff) as u16
567}
568
569pub fn verify_nsec_denial(
571 qname: &Name,
572 qtype: RecordType,
573 records: &[ResourceRecord],
574 response_is_name_error: bool,
575 limits: DnssecLimits,
576) -> Result<Denial, DnssecError> {
577 if records.len() > limits.max_denial_records {
578 return Err(DnssecError::Limit);
579 }
580 let nsecs = records.iter().filter_map(valid_nsec).collect::<Vec<_>>();
581 for (record, nsec) in &nsecs {
582 if record.name == *qname
583 && !response_is_name_error
584 && !bitmap_contains(&nsec.type_bitmaps, qtype.code())?
585 && (qtype == RecordType::Cname
586 || !bitmap_contains(&nsec.type_bitmaps, RecordType::Cname.code())?)
587 {
588 return Ok(Denial::NoData);
589 }
590 }
591 if !response_is_name_error {
592 return Err(DnssecError::DenialMismatch);
593 }
594
595 let closest_start = (1..=qname.labels().len())
596 .find(|start| {
597 ancestor(qname, *start)
598 .is_some_and(|candidate| nsecs.iter().any(|(record, _)| record.name == candidate))
599 })
600 .ok_or(DnssecError::DenialMismatch)?;
601 let next_closer =
602 ancestor(qname, closest_start.saturating_sub(1)).ok_or(DnssecError::DenialMismatch)?;
603 let closest = ancestor(qname, closest_start).ok_or(DnssecError::DenialMismatch)?;
604 let wildcard = wildcard_of(&closest)?;
605 if nsecs.iter().any(|(record, nsec)| {
606 canonical_interval_contains(&record.name, &nsec.next_domain, &next_closer)
607 }) && nsecs.iter().any(|(record, nsec)| {
608 canonical_interval_contains(&record.name, &nsec.next_domain, &wildcard)
609 }) {
610 return Ok(Denial::NameError);
611 }
612 Err(DnssecError::DenialMismatch)
613}
614
615pub fn nsec3_hash(
617 name: &Name,
618 salt: &[u8],
619 iterations: u16,
620 limits: DnssecLimits,
621) -> Result<[u8; 20], DnssecError> {
622 if iterations > limits.max_nsec3_iterations || salt.len() > u8::MAX as usize {
623 return Err(DnssecError::Limit);
624 }
625 let mut canonical_name = Vec::with_capacity(name.wire_len());
626 name.encode(&mut canonical_name)
627 .map_err(|_| DnssecError::UnsupportedRdata)?;
628 let mut value = digest_sha1_many(&[&canonical_name, salt])?;
629 for _ in 0..iterations {
630 value = digest_sha1_many(&[&value, salt])?;
631 }
632 value
633 .try_into()
634 .map_err(|_| DnssecError::UnsupportedDigest(1))
635}
636
637pub fn verify_nsec3_denial(
641 zone: &Name,
642 qname: &Name,
643 qtype: RecordType,
644 records: &[ResourceRecord],
645 response_is_name_error: bool,
646 limits: DnssecLimits,
647) -> Result<Denial, DnssecError> {
648 if records.len() > limits.max_denial_records {
649 return Err(DnssecError::Limit);
650 }
651 if !is_suffix(qname, zone) {
652 return Err(DnssecError::DenialMismatch);
653 }
654 let mut entries = Vec::new();
655 for record in records {
656 let Some(nsec3) = valid_nsec3_record(record) else {
657 continue;
658 };
659 validate_nsec3(nsec3, limits)?;
660 let Some(owner_hash) = nsec3_owner_hash(&record.name, zone) else {
661 continue;
662 };
663 entries.push((owner_hash, nsec3));
664 }
665 let first = entries.first().ok_or(DnssecError::DenialMismatch)?.1;
666 if entries.iter().any(|(_, record)| {
667 record.hash_algorithm != first.hash_algorithm
668 || record.iterations != first.iterations
669 || record.salt != first.salt
670 }) {
671 return Err(DnssecError::DenialMismatch);
672 }
673
674 let query_hash = nsec3_hash(qname, &first.salt, first.iterations, limits)?;
675 for (owner_hash, nsec3) in &entries {
676 if *owner_hash == query_hash
677 && !response_is_name_error
678 && !bitmap_contains(&nsec3.type_bitmaps, qtype.code())?
679 && (qtype == RecordType::Cname
680 || !bitmap_contains(&nsec3.type_bitmaps, RecordType::Cname.code())?)
681 {
682 return Ok(Denial::NoData);
683 }
684 }
685 if !response_is_name_error {
686 return Err(DnssecError::DenialMismatch);
687 }
688
689 let maximum_start = qname.labels().len().saturating_sub(zone.labels().len());
690 let closest_start = (1..=maximum_start)
691 .find(|start| {
692 ancestor(qname, *start).is_some_and(|candidate| {
693 nsec3_hash(&candidate, &first.salt, first.iterations, limits)
694 .is_ok_and(|hash| entries.iter().any(|(owner_hash, _)| *owner_hash == hash))
695 })
696 })
697 .ok_or(DnssecError::DenialMismatch)?;
698 let next_closer =
699 ancestor(qname, closest_start.saturating_sub(1)).ok_or(DnssecError::DenialMismatch)?;
700 let closest = ancestor(qname, closest_start).ok_or(DnssecError::DenialMismatch)?;
701 let wildcard = wildcard_of(&closest)?;
702 let next_hash = nsec3_hash(&next_closer, &first.salt, first.iterations, limits)?;
703 let wildcard_hash = nsec3_hash(&wildcard, &first.salt, first.iterations, limits)?;
704 if entries.iter().any(|(owner, record)| {
705 record.flags == 0 && hash_interval_contains(owner, &record.next_hashed_owner, &next_hash)
706 }) && entries.iter().any(|(owner, record)| {
707 record.flags == 0
708 && hash_interval_contains(owner, &record.next_hashed_owner, &wildcard_hash)
709 }) {
710 return Ok(Denial::NameError);
711 }
712 Err(DnssecError::DenialMismatch)
713}
714
715fn valid_nsec(record: &ResourceRecord) -> Option<(&ResourceRecord, &Nsec)> {
716 if record.class != CLASS_IN || record.record_type != RecordType::Nsec {
717 return None;
718 }
719 let Rdata::Nsec(nsec) = &record.rdata else {
720 return None;
721 };
722 Some((record, nsec))
723}
724
725fn valid_nsec3_record(record: &ResourceRecord) -> Option<&Nsec3> {
726 if record.class != CLASS_IN || record.record_type != RecordType::Nsec3 {
727 return None;
728 }
729 let Rdata::Nsec3(nsec3) = &record.rdata else {
730 return None;
731 };
732 Some(nsec3)
733}
734
735fn ancestor(name: &Name, start: usize) -> Option<Name> {
736 Name::from_labels(name.labels().get(start..)?.to_vec()).ok()
737}
738
739fn wildcard_of(name: &Name) -> Result<Name, DnssecError> {
740 let mut labels = Vec::with_capacity(name.labels().len().saturating_add(1));
741 labels.push(vec![b'*']);
742 labels.extend_from_slice(name.labels());
743 Name::from_labels(labels).map_err(|_| DnssecError::DenialMismatch)
744}
745
746fn is_suffix(name: &Name, suffix: &Name) -> bool {
747 name.labels()
748 .get(name.labels().len().saturating_sub(suffix.labels().len())..)
749 == Some(suffix.labels())
750}
751
752fn rrsig_for<'a>(
753 record: &'a ResourceRecord,
754 owner: &Name,
755 record_type: RecordType,
756) -> Option<&'a Rrsig> {
757 if record.name != *owner || record.class != CLASS_IN || record.record_type != RecordType::Rrsig
758 {
759 return None;
760 }
761 let Rdata::Rrsig(signature) = &record.rdata else {
762 return None;
763 };
764 (signature.type_covered == record_type).then_some(signature)
765}
766
767fn dnskey_for<'a>(record: &'a ResourceRecord, owner: &Name) -> Option<&'a Dnskey> {
768 if record.name != *owner || record.class != CLASS_IN || record.record_type != RecordType::Dnskey
769 {
770 return None;
771 }
772 let Rdata::Dnskey(key) = &record.rdata else {
773 return None;
774 };
775 Some(key)
776}
777
778fn supported_algorithm(algorithm: u8) -> bool {
779 matches!(
780 algorithm,
781 ALGORITHM_RSASHA1
782 | ALGORITHM_RSASHA1_NSEC3
783 | ALGORITHM_RSASHA256
784 | ALGORITHM_RSASHA512
785 | ALGORITHM_ECDSA_P256_SHA256
786 | ALGORITHM_ECDSA_P384_SHA384
787 | ALGORITHM_ED25519
788 | ALGORITHM_ED448
789 )
790}
791
792fn serial_in_window(now: u32, inception: u32, expiration: u32) -> bool {
793 serial_le(inception, now) && serial_le(now, expiration)
794}
795
796fn serial_le(left: u32, right: u32) -> bool {
797 left == right || right.wrapping_sub(left) < 0x8000_0000
798}
799
800fn records_expire_at(records: &[ResourceRecord], observed_at: u32) -> u64 {
801 let minimum_ttl = records.iter().map(|record| record.ttl).min().unwrap_or(0);
802 u64::from(observed_at) + u64::from(minimum_ttl)
803}
804
805fn rrset_expires_at(
806 records: &[ResourceRecord],
807 signature_record: &ResourceRecord,
808 signature: &Rrsig,
809 validation_time: u32,
810) -> u64 {
811 let ttl_deadline = u64::from(validation_time)
812 + u64::from(
813 records
814 .iter()
815 .map(|record| record.ttl)
816 .chain([signature_record.ttl, signature.original_ttl])
817 .min()
818 .unwrap_or(0),
819 );
820 let signature_deadline = u64::from(validation_time)
821 + u64::from(signature.expiration.wrapping_sub(validation_time))
822 + 1;
823 ttl_deadline.min(signature_deadline)
824}
825
826fn canonical_signed_data(
827 records: &[ResourceRecord],
828 signature: &Rrsig,
829 maximum: usize,
830) -> Result<Vec<u8>, DnssecError> {
831 let mut output = Vec::new();
832 write_u16(&mut output, signature.type_covered.code());
833 output.push(signature.algorithm);
834 output.push(signature.labels);
835 write_u32(&mut output, signature.original_ttl);
836 write_u32(&mut output, signature.expiration);
837 write_u32(&mut output, signature.inception);
838 write_u16(&mut output, signature.key_tag);
839 signature
840 .signer
841 .encode(&mut output)
842 .map_err(|_| DnssecError::UnsupportedRdata)?;
843
844 let mut canonical = records
845 .iter()
846 .map(|record| canonical_record(record, signature))
847 .collect::<Result<Vec<_>, _>>()?;
848 canonical.sort();
849 for record in canonical {
850 if output.len().saturating_add(record.len()) > maximum {
851 return Err(DnssecError::Limit);
852 }
853 output.extend_from_slice(&record);
854 }
855 Ok(output)
856}
857
858fn canonical_record(record: &ResourceRecord, signature: &Rrsig) -> Result<Vec<u8>, DnssecError> {
859 let mut output = canonical_owner(&record.name, usize::from(signature.labels))?;
860 write_u16(&mut output, record.record_type.code());
861 write_u16(&mut output, record.class);
862 write_u32(&mut output, signature.original_ttl);
863 let rdata = canonical_rdata(record)?;
864 let length = u16::try_from(rdata.len()).map_err(|_| DnssecError::Limit)?;
865 write_u16(&mut output, length);
866 output.extend_from_slice(&rdata);
867 Ok(output)
868}
869
870fn canonical_owner(owner: &Name, labels: usize) -> Result<Vec<u8>, DnssecError> {
871 let owner_labels = owner.labels();
872 if labels > owner_labels.len() {
873 return Err(DnssecError::RrsetMismatch);
874 }
875 let mut output = Vec::with_capacity(owner.wire_len().saturating_add(2));
876 if labels < owner_labels.len() {
877 output.extend_from_slice(&[1, b'*']);
878 }
879 let start = owner_labels.len().saturating_sub(labels);
880 for label in owner_labels
881 .get(start..)
882 .ok_or(DnssecError::RrsetMismatch)?
883 {
884 output.push(u8::try_from(label.len()).map_err(|_| DnssecError::UnsupportedRdata)?);
885 output.extend_from_slice(label);
886 }
887 output.push(0);
888 Ok(output)
889}
890
891fn canonical_rdata(record: &ResourceRecord) -> Result<Vec<u8>, DnssecError> {
892 let mut output = Vec::new();
893 match (&record.record_type, &record.rdata) {
894 (RecordType::A, Rdata::A(address)) => output.extend_from_slice(&address.octets()),
895 (RecordType::Aaaa, Rdata::Aaaa(address)) => output.extend_from_slice(&address.octets()),
896 (RecordType::Ns, Rdata::Ns(name)) | (RecordType::Cname, Rdata::Cname(name)) => {
897 encode_name(name, &mut output)?;
898 }
899 (RecordType::Soa, Rdata::Soa(soa)) => {
900 encode_name(&soa.mname, &mut output)?;
901 encode_name(&soa.rname, &mut output)?;
902 write_u32(&mut output, soa.serial);
903 write_u32(&mut output, soa.refresh);
904 write_u32(&mut output, soa.retry);
905 write_u32(&mut output, soa.expire);
906 write_u32(&mut output, soa.minimum);
907 }
908 (RecordType::Mx, Rdata::Mx(mx)) => {
909 write_u16(&mut output, mx.preference);
910 encode_name(&mx.exchange, &mut output)?;
911 }
912 (RecordType::Txt, Rdata::Txt(strings)) => {
913 for string in strings {
914 output.push(u8::try_from(string.len()).map_err(|_| DnssecError::UnsupportedRdata)?);
915 output.extend_from_slice(string);
916 }
917 }
918 (RecordType::Srv, Rdata::Srv(srv)) => {
919 write_u16(&mut output, srv.priority);
920 write_u16(&mut output, srv.weight);
921 write_u16(&mut output, srv.port);
922 encode_name(&srv.target, &mut output)?;
923 }
924 (RecordType::Ds, Rdata::Ds(ds)) => output.extend_from_slice(&encode_ds(ds)),
925 (RecordType::Dnskey, Rdata::Dnskey(key)) => output.extend_from_slice(&encode_dnskey(key)),
926 (RecordType::Rrsig, Rdata::Rrsig(signature)) => {
927 output.extend_from_slice(&encode_rrsig(signature)?);
928 }
929 (RecordType::Nsec, Rdata::Nsec(nsec)) => {
930 encode_name(&nsec.next_domain, &mut output)?;
931 output.extend_from_slice(&nsec.type_bitmaps);
932 }
933 (RecordType::Nsec3, Rdata::Nsec3(nsec3)) => {
934 output.push(nsec3.hash_algorithm);
935 output.push(nsec3.flags);
936 write_u16(&mut output, nsec3.iterations);
937 output.push(u8::try_from(nsec3.salt.len()).map_err(|_| DnssecError::UnsupportedRdata)?);
938 output.extend_from_slice(&nsec3.salt);
939 output.push(
940 u8::try_from(nsec3.next_hashed_owner.len())
941 .map_err(|_| DnssecError::UnsupportedRdata)?,
942 );
943 output.extend_from_slice(&nsec3.next_hashed_owner);
944 output.extend_from_slice(&nsec3.type_bitmaps);
945 }
946 (RecordType::Tlsa, Rdata::Tlsa(tlsa)) => {
947 output.push(tlsa.usage);
948 output.push(tlsa.selector);
949 output.push(tlsa.matching_type);
950 output.extend_from_slice(&tlsa.association_data);
951 }
952 (RecordType::Svcb | RecordType::Https | RecordType::Unknown(_), Rdata::Opaque(raw)) => {
953 output.extend_from_slice(raw);
954 }
955 _ => return Err(DnssecError::UnsupportedRdata),
956 }
957 Ok(output)
958}
959
960fn encode_name(name: &Name, output: &mut Vec<u8>) -> Result<(), DnssecError> {
961 name.encode(output)
962 .map_err(|_| DnssecError::UnsupportedRdata)
963}
964
965fn encode_ds(ds: &Ds) -> Vec<u8> {
966 let mut output = Vec::with_capacity(4usize.saturating_add(ds.digest.len()));
967 write_u16(&mut output, ds.key_tag);
968 output.push(ds.algorithm);
969 output.push(ds.digest_type);
970 output.extend_from_slice(&ds.digest);
971 output
972}
973
974fn encode_dnskey(key: &Dnskey) -> Vec<u8> {
975 let mut output = Vec::with_capacity(4usize.saturating_add(key.public_key.len()));
976 write_u16(&mut output, key.flags);
977 output.push(key.protocol);
978 output.push(key.algorithm);
979 output.extend_from_slice(&key.public_key);
980 output
981}
982
983fn encode_rrsig(signature: &Rrsig) -> Result<Vec<u8>, DnssecError> {
984 let mut output = Vec::new();
985 write_u16(&mut output, signature.type_covered.code());
986 output.push(signature.algorithm);
987 output.push(signature.labels);
988 write_u32(&mut output, signature.original_ttl);
989 write_u32(&mut output, signature.expiration);
990 write_u32(&mut output, signature.inception);
991 write_u16(&mut output, signature.key_tag);
992 encode_name(&signature.signer, &mut output)?;
993 output.extend_from_slice(&signature.signature);
994 Ok(output)
995}
996
997fn digest_ds(digest_type: u8, data: &[u8]) -> Result<Vec<u8>, DnssecError> {
998 let digest = match digest_type {
999 1 => MessageDigest::sha1(),
1000 2 => MessageDigest::sha256(),
1001 4 => MessageDigest::sha384(),
1002 value => return Err(DnssecError::UnsupportedDigest(value)),
1003 };
1004 hash(digest, data)
1005 .map(|digest| digest.to_vec())
1006 .map_err(|_| DnssecError::UnsupportedDigest(digest_type))
1007}
1008
1009fn verify_signature(algorithm: u8, public_key: &[u8], data: &[u8], signature: &[u8]) -> bool {
1010 match algorithm {
1011 ALGORITHM_RSASHA1 | ALGORITHM_RSASHA1_NSEC3 => {
1012 verify_rsa(MessageDigest::sha1(), public_key, data, signature)
1013 }
1014 ALGORITHM_RSASHA256 => verify_rsa(MessageDigest::sha256(), public_key, data, signature),
1015 ALGORITHM_RSASHA512 => verify_rsa(MessageDigest::sha512(), public_key, data, signature),
1016 ALGORITHM_ECDSA_P256_SHA256 => verify_ecdsa(
1017 Nid::X9_62_PRIME256V1,
1018 32,
1019 MessageDigest::sha256(),
1020 public_key,
1021 data,
1022 signature,
1023 ),
1024 ALGORITHM_ECDSA_P384_SHA384 => verify_ecdsa(
1025 Nid::SECP384R1,
1026 48,
1027 MessageDigest::sha384(),
1028 public_key,
1029 data,
1030 signature,
1031 ),
1032 ALGORITHM_ED25519 => verify_ed(Id::ED25519, public_key, data, signature),
1033 ALGORITHM_ED448 => verify_ed(Id::ED448, public_key, data, signature),
1034 _ => false,
1035 }
1036}
1037
1038fn verify_rsa(digest: MessageDigest, public_key: &[u8], data: &[u8], signature: &[u8]) -> bool {
1039 let Some((exponent, modulus)) = rsa_components(public_key) else {
1040 return false;
1041 };
1042 let key = (|| {
1043 let exponent = BigNum::from_slice(exponent)?;
1044 let modulus = BigNum::from_slice(modulus)?;
1045 let rsa = Rsa::from_public_components(modulus, exponent)?;
1046 PKey::from_rsa(rsa)
1047 })();
1048 let Ok(key) = key else {
1049 return false;
1050 };
1051 verify_digest(digest, &key, data, signature, true)
1052}
1053
1054fn rsa_components(raw: &[u8]) -> Option<(&[u8], &[u8])> {
1055 let first = *raw.first()?;
1056 let (exponent_size, offset) = if first == 0 {
1057 let length = u16::from_be_bytes([*raw.get(1)?, *raw.get(2)?]);
1058 (usize::from(length), 3usize)
1059 } else {
1060 (usize::from(first), 1usize)
1061 };
1062 if exponent_size == 0 {
1063 return None;
1064 }
1065 let exponent_end = offset.checked_add(exponent_size)?;
1066 let exponent = raw.get(offset..exponent_end)?;
1067 let modulus = raw.get(exponent_end..)?;
1068 (!modulus.is_empty()).then_some((exponent, modulus))
1069}
1070
1071fn verify_ecdsa(
1072 curve: Nid,
1073 coordinate_size: usize,
1074 digest: MessageDigest,
1075 public_key: &[u8],
1076 data: &[u8],
1077 signature: &[u8],
1078) -> bool {
1079 if public_key.len() != coordinate_size.saturating_mul(2)
1080 || signature.len() != coordinate_size.saturating_mul(2)
1081 {
1082 return false;
1083 }
1084 let key = (|| {
1085 let group = EcGroup::from_curve_name(curve)?;
1086 let mut context = BigNumContext::new()?;
1087 let mut encoded = Vec::with_capacity(1usize.saturating_add(public_key.len()));
1088 encoded.push(4);
1089 encoded.extend_from_slice(public_key);
1090 let point = EcPoint::from_bytes(&group, &encoded, &mut context)?;
1091 let key = EcKey::from_public_key(&group, &point)?;
1092 PKey::from_ec_key(key)
1093 })();
1094 let Ok(key) = key else {
1095 return false;
1096 };
1097 let der = (|| {
1098 let r = BigNum::from_slice(signature.get(..coordinate_size).unwrap_or_default())?;
1099 let s = BigNum::from_slice(signature.get(coordinate_size..).unwrap_or_default())?;
1100 EcdsaSig::from_private_components(r, s)?.to_der()
1101 })();
1102 let Ok(der) = der else {
1103 return false;
1104 };
1105 verify_digest(digest, &key, data, &der, false)
1106}
1107
1108fn verify_ed(id: Id, public_key: &[u8], data: &[u8], signature: &[u8]) -> bool {
1109 let Ok(key) = PKey::public_key_from_raw_bytes(public_key, id) else {
1110 return false;
1111 };
1112 let Ok(mut verifier) = Verifier::new_without_digest(&key) else {
1113 return false;
1114 };
1115 verifier.verify_oneshot(signature, data).unwrap_or(false)
1116}
1117
1118fn verify_digest(
1119 digest: MessageDigest,
1120 key: &PKey<Public>,
1121 data: &[u8],
1122 signature: &[u8],
1123 rsa: bool,
1124) -> bool {
1125 let Ok(mut verifier) = Verifier::new(digest, key) else {
1126 return false;
1127 };
1128 if rsa && verifier.set_rsa_padding(Padding::PKCS1).is_err() {
1129 return false;
1130 }
1131 verifier
1132 .update(data)
1133 .and_then(|()| verifier.verify(signature))
1134 .unwrap_or(false)
1135}
1136
1137fn validate_nsec3(record: &Nsec3, limits: DnssecLimits) -> Result<(), DnssecError> {
1138 if record.hash_algorithm != 1
1139 || record.flags & !1 != 0
1140 || record.iterations > limits.max_nsec3_iterations
1141 || record.salt.len() > u8::MAX as usize
1142 || record.next_hashed_owner.len() != 20
1143 {
1144 return Err(DnssecError::DenialMismatch);
1145 }
1146 Ok(())
1147}
1148
1149fn nsec3_owner_hash(owner: &Name, zone: &Name) -> Option<[u8; 20]> {
1150 let owner_labels = owner.labels();
1151 let zone_labels = zone.labels();
1152 if owner_labels.len() != zone_labels.len().checked_add(1)?
1153 || owner_labels.get(1..)? != zone_labels
1154 {
1155 return None;
1156 }
1157 let decoded = decode_base32hex(owner_labels.first()?)?;
1158 decoded.try_into().ok()
1159}
1160
1161fn decode_base32hex(input: &[u8]) -> Option<Vec<u8>> {
1162 let mut output = Vec::with_capacity(input.len().saturating_mul(5) / 8);
1163 let mut accumulator = 0_u32;
1164 let mut bits = 0_u8;
1165 for byte in input {
1166 let value = match byte.to_ascii_uppercase() {
1167 b'0'..=b'9' => byte - b'0',
1168 b'A'..=b'V' => byte.to_ascii_uppercase() - b'A' + 10,
1169 _ => return None,
1170 };
1171 accumulator = (accumulator << 5) | u32::from(value);
1172 bits = bits.saturating_add(5);
1173 while bits >= 8 {
1174 bits -= 8;
1175 output.push(u8::try_from((accumulator >> bits) & 0xff).ok()?);
1176 accumulator &= (1_u32 << bits).saturating_sub(1);
1177 }
1178 }
1179 if bits != 0 && accumulator != 0 {
1180 return None;
1181 }
1182 Some(output)
1183}
1184
1185fn bitmap_contains(bitmap: &[u8], record_type: u16) -> Result<bool, DnssecError> {
1186 let window = (record_type >> 8) as u8;
1187 let low = (record_type & 0xff) as usize;
1188 let mut cursor = 0usize;
1189 while cursor < bitmap.len() {
1190 let block_window = *bitmap.get(cursor).ok_or(DnssecError::DenialMismatch)?;
1191 let length = usize::from(
1192 *bitmap
1193 .get(cursor.saturating_add(1))
1194 .ok_or(DnssecError::DenialMismatch)?,
1195 );
1196 if length == 0 || length > 32 {
1197 return Err(DnssecError::DenialMismatch);
1198 }
1199 let start = cursor.saturating_add(2);
1200 let end = start.checked_add(length).ok_or(DnssecError::Limit)?;
1201 let block = bitmap.get(start..end).ok_or(DnssecError::DenialMismatch)?;
1202 if block_window == window {
1203 let byte_index = low / 8;
1204 return Ok(block
1205 .get(byte_index)
1206 .is_some_and(|byte| byte & (0x80 >> (low % 8)) != 0));
1207 }
1208 cursor = end;
1209 }
1210 Ok(false)
1211}
1212
1213fn canonical_interval_contains(owner: &Name, next: &Name, candidate: &Name) -> bool {
1214 let owner_to_next = canonical_name_cmp(owner, next);
1215 let owner_to_candidate = canonical_name_cmp(owner, candidate);
1216 let candidate_to_next = canonical_name_cmp(candidate, next);
1217 if owner_to_next == Ordering::Less {
1218 owner_to_candidate == Ordering::Less && candidate_to_next == Ordering::Less
1219 } else {
1220 owner_to_candidate == Ordering::Less || candidate_to_next == Ordering::Less
1221 }
1222}
1223
1224fn canonical_name_cmp(left: &Name, right: &Name) -> Ordering {
1225 let mut left_labels = left.labels().iter().rev();
1226 let mut right_labels = right.labels().iter().rev();
1227 loop {
1228 match (left_labels.next(), right_labels.next()) {
1229 (Some(left), Some(right)) => match left.cmp(right) {
1230 Ordering::Equal => {}
1231 ordering => return ordering,
1232 },
1233 (None, Some(_)) => return Ordering::Less,
1234 (Some(_), None) => return Ordering::Greater,
1235 (None, None) => return Ordering::Equal,
1236 }
1237 }
1238}
1239
1240fn hash_interval_contains(owner: &[u8], next: &[u8], candidate: &[u8]) -> bool {
1241 if owner < next {
1242 owner < candidate && candidate < next
1243 } else {
1244 owner < candidate || candidate < next
1245 }
1246}
1247
1248fn digest_sha1_many(parts: &[&[u8]]) -> Result<Vec<u8>, DnssecError> {
1249 let mut input = Vec::new();
1250 for part in parts {
1251 input
1252 .try_reserve(part.len())
1253 .map_err(|_| DnssecError::Limit)?;
1254 input.extend_from_slice(part);
1255 }
1256 hash(MessageDigest::sha1(), &input)
1257 .map(|digest| digest.to_vec())
1258 .map_err(|_| DnssecError::UnsupportedDigest(1))
1259}
1260
1261fn write_u16(output: &mut Vec<u8>, value: u16) {
1262 output.extend_from_slice(&value.to_be_bytes());
1263}
1264
1265fn write_u32(output: &mut Vec<u8>, value: u32) {
1266 output.extend_from_slice(&value.to_be_bytes());
1267}
1268
1269#[cfg(test)]
1270#[allow(
1271 clippy::unwrap_used,
1272 reason = "tests intentionally fail immediately when local cryptographic fixtures are invalid"
1273)]
1274mod tests {
1275 use openssl::hash::MessageDigest;
1276 use openssl::pkey::PKey;
1277 use openssl::rsa::Rsa;
1278 use openssl::sign::Signer;
1279
1280 use super::*;
1281 use hns_dns_wire::{Flags, Header, Message, Nsec, Question, Tlsa};
1282
1283 fn name(value: &str) -> Name {
1284 Name::from_ascii(value).unwrap()
1285 }
1286
1287 fn a_record(owner: &Name) -> ResourceRecord {
1288 ResourceRecord {
1289 name: owner.clone(),
1290 record_type: RecordType::A,
1291 class: CLASS_IN,
1292 ttl: 300,
1293 rdata: Rdata::A("192.0.2.1".parse().unwrap()),
1294 }
1295 }
1296
1297 fn rsa_dnskey(rsa: &Rsa<openssl::pkey::Private>) -> Dnskey {
1298 let exponent = rsa.e().to_vec();
1299 let modulus = rsa.n().to_vec();
1300 let mut public_key = Vec::new();
1301 public_key.push(u8::try_from(exponent.len()).unwrap());
1302 public_key.extend_from_slice(&exponent);
1303 public_key.extend_from_slice(&modulus);
1304 Dnskey {
1305 flags: 257,
1306 protocol: 3,
1307 algorithm: ALGORITHM_RSASHA256,
1308 public_key,
1309 }
1310 }
1311
1312 fn sign_rrset(
1313 records: &[ResourceRecord],
1314 signer_name: Name,
1315 key: &Dnskey,
1316 key_pair: &PKey<openssl::pkey::Private>,
1317 ) -> ResourceRecord {
1318 sign_rrset_with_labels(
1319 records,
1320 signer_name,
1321 key,
1322 key_pair,
1323 u8::try_from(records.first().unwrap().name.labels().len()).unwrap(),
1324 )
1325 }
1326
1327 fn sign_rrset_with_labels(
1328 records: &[ResourceRecord],
1329 signer_name: Name,
1330 key: &Dnskey,
1331 key_pair: &PKey<openssl::pkey::Private>,
1332 labels: u8,
1333 ) -> ResourceRecord {
1334 let owner = records.first().unwrap().name.clone();
1335 let mut signature = Rrsig {
1336 type_covered: records.first().unwrap().record_type,
1337 algorithm: key.algorithm,
1338 labels,
1339 original_ttl: records.first().unwrap().ttl,
1340 expiration: 2_000,
1341 inception: 1_000,
1342 key_tag: dnskey_tag(key),
1343 signer: signer_name,
1344 signature: Vec::new(),
1345 };
1346 let signed = rrsig_signed_data(
1347 records,
1348 &signature,
1349 DnssecLimits::default().max_signed_data_len,
1350 )
1351 .unwrap();
1352 let mut crypto_signer = Signer::new(MessageDigest::sha256(), key_pair).unwrap();
1353 crypto_signer.update(&signed).unwrap();
1354 signature.signature = crypto_signer.sign_to_vec().unwrap();
1355 ResourceRecord {
1356 name: owner,
1357 record_type: RecordType::Rrsig,
1358 class: CLASS_IN,
1359 ttl: signature.original_ttl,
1360 rdata: Rdata::Rrsig(signature),
1361 }
1362 }
1363
1364 fn signed_fixture() -> (
1365 Vec<ResourceRecord>,
1366 Vec<ResourceRecord>,
1367 Vec<ResourceRecord>,
1368 ) {
1369 let owner = name("www.example.");
1370 let signer_name = name("example.");
1371 let records = vec![a_record(&owner)];
1372 let rsa = Rsa::generate(1024).unwrap();
1373 let key = rsa_dnskey(&rsa);
1374 let key_pair = PKey::from_rsa(rsa).unwrap();
1375 let signatures = vec![sign_rrset(&records, signer_name.clone(), &key, &key_pair)];
1376 let keys = vec![ResourceRecord {
1377 name: signer_name,
1378 record_type: RecordType::Dnskey,
1379 class: CLASS_IN,
1380 ttl: 300,
1381 rdata: Rdata::Dnskey(key),
1382 }];
1383 (records, signatures, keys)
1384 }
1385
1386 #[test]
1387 fn authenticated_keyset_verifies_terminal_rrsets() {
1388 let zone = name("example.");
1389 let rsa = Rsa::generate(1024).unwrap();
1390 let key = rsa_dnskey(&rsa);
1391 let key_pair = PKey::from_rsa(rsa).unwrap();
1392 let dnskeys = vec![ResourceRecord {
1393 name: zone.clone(),
1394 record_type: RecordType::Dnskey,
1395 class: CLASS_IN,
1396 ttl: 300,
1397 rdata: Rdata::Dnskey(key.clone()),
1398 }];
1399 let dnskey_signatures = vec![sign_rrset(&dnskeys, zone.clone(), &key, &key_pair)];
1400 let mut digest_input = Vec::new();
1401 zone.encode(&mut digest_input).unwrap();
1402 digest_input.extend_from_slice(&encode_dnskey(&key));
1403 let ds = vec![ResourceRecord {
1404 name: zone.clone(),
1405 record_type: RecordType::Ds,
1406 class: CLASS_IN,
1407 ttl: 300,
1408 rdata: Rdata::Ds(Ds {
1409 key_tag: dnskey_tag(&key),
1410 algorithm: key.algorithm,
1411 digest_type: 2,
1412 digest: hash(MessageDigest::sha256(), &digest_input)
1413 .unwrap()
1414 .to_vec(),
1415 }),
1416 }];
1417 let authenticated = authenticate_dnskeys(
1418 &zone,
1419 &ds,
1420 &dnskeys,
1421 &dnskey_signatures,
1422 1_500,
1423 DnssecLimits::default(),
1424 )
1425 .unwrap();
1426 assert_eq!(authenticated.zone(), &zone);
1427 assert_eq!(authenticated.delegation_key_tag(), dnskey_tag(&key));
1428 assert_eq!(authenticated.observed_at_unix(), 1_500);
1429 assert_eq!(authenticated.expires_at_unix(), 1_800);
1430 assert!(authenticated.is_fresh_at(1_799));
1431 assert!(!authenticated.is_fresh_at(1_800));
1432
1433 let records = vec![a_record(&name("www.example."))];
1434 let signatures = vec![sign_rrset(&records, zone, &key, &key_pair)];
1435 let verified = verify_rrset_with_keys(
1436 &authenticated,
1437 &records,
1438 &signatures,
1439 1_500,
1440 DnssecLimits::default(),
1441 )
1442 .unwrap();
1443 assert_eq!(verified.record_type(), RecordType::A);
1444 assert_eq!(verified.owner(), &name("www.example."));
1445 assert_eq!(
1446 verify_rrset_with_keys(
1447 &authenticated,
1448 &records,
1449 &signatures,
1450 1_800,
1451 DnssecLimits::default(),
1452 ),
1453 Err(DnssecError::SignatureTime),
1454 );
1455 }
1456
1457 #[test]
1458 fn rejects_dnskey_rrset_signed_by_a_same_tag_substitute() {
1459 let zone = name("example.");
1460 let delegation_rsa = Rsa::generate(1024).unwrap();
1461 let delegation_key = rsa_dnskey(&delegation_rsa);
1462 let delegation_tag = dnskey_tag(&delegation_key);
1463
1464 let (attacker_key, attacker_key_pair) = loop {
1465 let attacker_rsa = Rsa::generate(1024).unwrap();
1466 let mut attacker_key = rsa_dnskey(&attacker_rsa);
1467 let colliding_flags = (0..=u16::MAX).find(|flags| {
1468 flags & 0x0100 != 0 && flags & 0x0080 == 0 && {
1469 attacker_key.flags = *flags;
1470 dnskey_tag(&attacker_key) == delegation_tag
1471 }
1472 });
1473 if let Some(flags) = colliding_flags {
1474 attacker_key.flags = flags;
1475 break (attacker_key, PKey::from_rsa(attacker_rsa).unwrap());
1476 }
1477 };
1478 assert_eq!(dnskey_tag(&attacker_key), delegation_tag);
1479
1480 let dnskeys = vec![
1481 ResourceRecord {
1482 name: zone.clone(),
1483 record_type: RecordType::Dnskey,
1484 class: CLASS_IN,
1485 ttl: 300,
1486 rdata: Rdata::Dnskey(delegation_key.clone()),
1487 },
1488 ResourceRecord {
1489 name: zone.clone(),
1490 record_type: RecordType::Dnskey,
1491 class: CLASS_IN,
1492 ttl: 300,
1493 rdata: Rdata::Dnskey(attacker_key.clone()),
1494 },
1495 ];
1496 let dnskey_signatures = vec![sign_rrset(
1497 &dnskeys,
1498 zone.clone(),
1499 &attacker_key,
1500 &attacker_key_pair,
1501 )];
1502 let mut digest_input = Vec::new();
1503 zone.encode(&mut digest_input).unwrap();
1504 digest_input.extend_from_slice(&encode_dnskey(&delegation_key));
1505 let ds = vec![ResourceRecord {
1506 name: zone.clone(),
1507 record_type: RecordType::Ds,
1508 class: CLASS_IN,
1509 ttl: 300,
1510 rdata: Rdata::Ds(Ds {
1511 key_tag: delegation_tag,
1512 algorithm: delegation_key.algorithm,
1513 digest_type: 2,
1514 digest: hash(MessageDigest::sha256(), &digest_input)
1515 .unwrap()
1516 .to_vec(),
1517 }),
1518 }];
1519
1520 assert_eq!(
1521 authenticate_dnskeys(
1522 &zone,
1523 &ds,
1524 &dnskeys,
1525 &dnskey_signatures,
1526 1_500,
1527 DnssecLimits::default(),
1528 ),
1529 Err(DnssecError::SignatureMismatch),
1530 );
1531 }
1532
1533 #[test]
1534 fn validates_rrset_and_rejects_mutation_or_time_failure() {
1535 let (records, signatures, keys) = signed_fixture();
1536 let verified =
1537 verify_rrset(&records, &signatures, &keys, 1_500, DnssecLimits::default()).unwrap();
1538 assert_eq!(verified.owner(), &name("www.example."));
1539 assert_eq!(verified.record_type(), RecordType::A);
1540 assert_eq!(verified.observed_at_unix(), 1_500);
1541 assert_eq!(verified.expires_at_unix(), 1_800);
1542 assert!(verified.is_fresh_at(1_799));
1543 assert!(!verified.is_fresh_at(1_800));
1544
1545 let signature_limited =
1546 verify_rrset(&records, &signatures, &keys, 1_999, DnssecLimits::default()).unwrap();
1547 assert_eq!(signature_limited.expires_at_unix(), 2_001);
1548
1549 let mut short_data_ttl = records.clone();
1550 short_data_ttl.first_mut().unwrap().ttl = 7;
1551 let data_limited = verify_rrset(
1552 &short_data_ttl,
1553 &signatures,
1554 &keys,
1555 1_500,
1556 DnssecLimits::default(),
1557 )
1558 .unwrap();
1559 assert_eq!(data_limited.expires_at_unix(), 1_507);
1560
1561 let mut short_signature_ttl = signatures.clone();
1562 short_signature_ttl.first_mut().unwrap().ttl = 5;
1563 let signature_ttl_limited = verify_rrset(
1564 &records,
1565 &short_signature_ttl,
1566 &keys,
1567 1_500,
1568 DnssecLimits::default(),
1569 )
1570 .unwrap();
1571 assert_eq!(signature_ttl_limited.expires_at_unix(), 1_505);
1572
1573 let mut mutated = records.clone();
1574 let record = mutated.first_mut().unwrap();
1575 record.rdata = Rdata::A("192.0.2.2".parse().unwrap());
1576 assert!(matches!(
1577 verify_rrset(&mutated, &signatures, &keys, 1_500, DnssecLimits::default()),
1578 Err(DnssecError::SignatureMismatch)
1579 ));
1580 assert_eq!(
1581 verify_rrset(&records, &signatures, &keys, 999, DnssecLimits::default()),
1582 Err(DnssecError::SignatureTime)
1583 );
1584 }
1585
1586 #[test]
1587 fn rejects_wildcard_expansion_without_authenticated_applicability_proof() {
1588 let owner = name("www.example.");
1589 let signer_name = name("example.");
1590 let records = vec![a_record(&owner)];
1591 let rsa = Rsa::generate(1024).unwrap();
1592 let key = rsa_dnskey(&rsa);
1593 let key_pair = PKey::from_rsa(rsa).unwrap();
1594 let signatures = vec![sign_rrset_with_labels(
1595 &records,
1596 signer_name.clone(),
1597 &key,
1598 &key_pair,
1599 1,
1600 )];
1601 let keys = vec![ResourceRecord {
1602 name: signer_name,
1603 record_type: RecordType::Dnskey,
1604 class: CLASS_IN,
1605 ttl: 300,
1606 rdata: Rdata::Dnskey(key),
1607 }];
1608
1609 assert_eq!(
1610 verify_rrset(&records, &signatures, &keys, 1_500, DnssecLimits::default(),),
1611 Err(DnssecError::MissingSignature),
1612 );
1613 }
1614
1615 #[test]
1616 fn verifies_ds_and_rejects_wrong_digest() {
1617 let owner = name("example.");
1618 let rsa = Rsa::generate(1024).unwrap();
1619 let key = rsa_dnskey(&rsa);
1620 let mut input = Vec::new();
1621 owner.encode(&mut input).unwrap();
1622 input.extend_from_slice(&encode_dnskey(&key));
1623 let digest = hash(MessageDigest::sha256(), &input).unwrap().to_vec();
1624 let record = ResourceRecord {
1625 name: owner.clone(),
1626 record_type: RecordType::Ds,
1627 class: CLASS_IN,
1628 ttl: 300,
1629 rdata: Rdata::Ds(Ds {
1630 key_tag: dnskey_tag(&key),
1631 algorithm: key.algorithm,
1632 digest_type: 2,
1633 digest,
1634 }),
1635 };
1636 verify_ds(&owner, &key, std::slice::from_ref(&record)).unwrap();
1637 let mut wrong = record;
1638 let Rdata::Ds(ds) = &mut wrong.rdata else {
1639 unreachable!()
1640 };
1641 let first = ds.digest.first_mut().unwrap();
1642 *first ^= 1;
1643 assert_eq!(
1644 verify_ds(&owner, &key, &[wrong]),
1645 Err(DnssecError::DsMismatch)
1646 );
1647 }
1648
1649 #[test]
1650 fn validates_nsec_nodata_and_wrapped_name_error() {
1651 let owner = name("present.example.");
1652 let nsec = ResourceRecord {
1653 name: owner.clone(),
1654 record_type: RecordType::Nsec,
1655 class: CLASS_IN,
1656 ttl: 300,
1657 rdata: Rdata::Nsec(Nsec {
1658 next_domain: name("zzz.example."),
1659 type_bitmaps: vec![0, 1, 0x40],
1660 }),
1661 };
1662 let closest_encloser = ResourceRecord {
1663 name: name("example."),
1664 record_type: RecordType::Nsec,
1665 class: CLASS_IN,
1666 ttl: 300,
1667 rdata: Rdata::Nsec(Nsec {
1668 next_domain: owner.clone(),
1669 type_bitmaps: vec![0, 1, 0x02],
1670 }),
1671 };
1672 assert_eq!(
1673 verify_nsec_denial(
1674 &owner,
1675 RecordType::Tlsa,
1676 std::slice::from_ref(&nsec),
1677 false,
1678 DnssecLimits::default()
1679 )
1680 .unwrap(),
1681 Denial::NoData
1682 );
1683 assert_eq!(
1684 verify_nsec_denial(
1685 &name("target.example."),
1686 RecordType::A,
1687 &[nsec, closest_encloser],
1688 true,
1689 DnssecLimits::default()
1690 )
1691 .unwrap(),
1692 Denial::NameError
1693 );
1694 }
1695
1696 #[test]
1697 fn nsec3_hash_matches_rfc_5155_example() {
1698 assert_eq!(
1699 nsec3_hash(
1700 &name("example."),
1701 &[0xaa, 0xbb, 0xcc, 0xdd],
1702 12,
1703 DnssecLimits::default()
1704 )
1705 .unwrap(),
1706 [
1707 0x06, 0x53, 0x68, 0xab, 0xee, 0xd7, 0xec, 0x6e, 0x9f, 0xeb, 0xa9, 0x6b, 0x8c, 0x8b,
1708 0xc3, 0xe8, 0xb7, 0x91, 0xf7, 0x16,
1709 ]
1710 );
1711 assert_eq!(
1712 decode_base32hex(b"0p9mhaveqvm6t7vbl5lop2u3t2rp3tom")
1713 .unwrap()
1714 .as_slice(),
1715 [
1716 0x06, 0x53, 0x68, 0xab, 0xee, 0xd7, 0xec, 0x6e, 0x9f, 0xeb, 0xa9, 0x6b, 0x8c, 0x8b,
1717 0xc3, 0xe8, 0xb7, 0x91, 0xf7, 0x16,
1718 ]
1719 );
1720 }
1721
1722 #[test]
1723 fn ad_bit_is_never_an_input_to_dnssec_verification() {
1724 let (records, signatures, keys) = signed_fixture();
1725 let message = Message {
1726 header: Header {
1727 id: 1,
1728 flags: Flags::from_bits(0x8020),
1729 question_count: 1,
1730 answer_count: u16::try_from(records.len() + signatures.len()).unwrap(),
1731 authority_count: 0,
1732 additional_count: 0,
1733 },
1734 questions: vec![Question {
1735 name: name("www.example."),
1736 record_type: RecordType::A,
1737 class: CLASS_IN,
1738 }],
1739 answers: records.iter().chain(&signatures).cloned().collect(),
1740 authorities: Vec::new(),
1741 additionals: Vec::new(),
1742 };
1743 assert!(message.header.flags.authenticated_data_claim());
1744 verify_rrset(&records, &signatures, &keys, 1_500, DnssecLimits::default()).unwrap();
1745
1746 let tlsa = Tlsa {
1747 usage: 3,
1748 selector: 1,
1749 matching_type: 1,
1750 association_data: vec![0; 32],
1751 };
1752 assert_eq!(tlsa.association_data.len(), 32);
1753 }
1754}