Skip to main content

hns_dnssec/
lib.rs

1//! Local, bounded DNSSEC RRset, delegation, and denial validation.
2//!
3//! This crate does not consult a recursive resolver and never trusts the DNS
4//! AD bit. Callers provide parsed records and an explicit validation time.
5
6#![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
30/// RSA/SHA-1.
31pub const ALGORITHM_RSASHA1: u8 = 5;
32/// RSA/SHA-1 with NSEC3.
33pub const ALGORITHM_RSASHA1_NSEC3: u8 = 7;
34/// RSA/SHA-256.
35pub const ALGORITHM_RSASHA256: u8 = 8;
36/// RSA/SHA-512.
37pub const ALGORITHM_RSASHA512: u8 = 10;
38/// ECDSA P-256/SHA-256.
39pub const ALGORITHM_ECDSA_P256_SHA256: u8 = 13;
40/// ECDSA P-384/SHA-384.
41pub const ALGORITHM_ECDSA_P384_SHA384: u8 = 14;
42/// Ed25519.
43pub const ALGORITHM_ED25519: u8 = 15;
44/// Ed448.
45pub const ALGORITHM_ED448: u8 = 16;
46
47/// Browser DNSSEC resource bounds.
48#[derive(Clone, Copy, Debug, Eq, PartialEq)]
49pub struct DnssecLimits {
50    /// Maximum records in one signed RRset.
51    pub max_rrset_records: usize,
52    /// Maximum signatures considered for one RRset.
53    pub max_signatures: usize,
54    /// Maximum candidate DNSKEY records.
55    pub max_keys: usize,
56    /// Maximum canonical signed bytes.
57    pub max_signed_data_len: usize,
58    /// Maximum NSEC3 iterations accepted.
59    pub max_nsec3_iterations: u16,
60    /// Maximum denial records considered.
61    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/// A locally verified RRset signature.
78#[derive(Clone, Debug, Eq, PartialEq)]
79pub struct VerifiedRrset {
80    /// Canonical RRset owner.
81    owner: Name,
82    /// Covered resource type.
83    record_type: RecordType,
84    /// DNSKEY tag.
85    key_tag: u16,
86    /// DNSSEC algorithm.
87    algorithm: u8,
88    /// Signature inception time.
89    inception: u32,
90    /// Signature expiration time.
91    expiration: u32,
92    /// Time at which this evidence was validated.
93    observed_at_unix: u64,
94    /// Earliest exclusive TTL or signature deadline.
95    expires_at_unix: u64,
96}
97
98impl VerifiedRrset {
99    /// Canonical RRset owner.
100    #[must_use]
101    pub const fn owner(&self) -> &Name {
102        &self.owner
103    }
104
105    /// Covered resource type.
106    #[must_use]
107    pub const fn record_type(&self) -> RecordType {
108        self.record_type
109    }
110
111    /// Authenticating DNSKEY tag.
112    #[must_use]
113    pub const fn key_tag(&self) -> u16 {
114        self.key_tag
115    }
116
117    /// Authenticating DNSSEC algorithm.
118    #[must_use]
119    pub const fn algorithm(&self) -> u8 {
120        self.algorithm
121    }
122
123    /// Signature inception time.
124    #[must_use]
125    pub const fn inception(&self) -> u32 {
126        self.inception
127    }
128
129    /// Signature expiration time.
130    #[must_use]
131    pub const fn expiration(&self) -> u32 {
132        self.expiration
133    }
134
135    /// Time at which the RRset was validated.
136    #[must_use]
137    pub const fn observed_at_unix(&self) -> u64 {
138        self.observed_at_unix
139    }
140
141    /// Earliest exclusive TTL or RRSIG deadline.
142    #[must_use]
143    pub const fn expires_at_unix(&self) -> u64 {
144        self.expires_at_unix
145    }
146
147    /// Whether the evidence is current at an absolute Unix time.
148    #[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/// A DNSKEY RRset authenticated through a local DS chain.
155///
156/// Fields are private so safe callers cannot manufacture local DNSSEC
157/// evidence. Use [`authenticate_dnskeys`] or [`authenticate_child_dnskeys`].
158#[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    /// Authenticated zone apex.
170    #[must_use]
171    pub const fn zone(&self) -> &Name {
172        &self.zone
173    }
174
175    /// DS-authenticated key tag.
176    #[must_use]
177    pub const fn delegation_key_tag(&self) -> u16 {
178        self.delegation_key_tag
179    }
180
181    /// DS-authenticated DNSSEC algorithm.
182    #[must_use]
183    pub const fn delegation_algorithm(&self) -> u8 {
184        self.delegation_algorithm
185    }
186
187    /// Time at which the keyset was authenticated.
188    #[must_use]
189    pub const fn observed_at_unix(&self) -> u64 {
190        self.observed_at_unix
191    }
192
193    /// Earliest exclusive DS, DNSKEY, or parent keyset deadline.
194    #[must_use]
195    pub const fn expires_at_unix(&self) -> u64 {
196        self.expires_at_unix
197    }
198
199    /// Whether the authenticated keyset is current at an absolute Unix time.
200    #[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/// Borrowed data records plus their covering RRSIG records.
207#[derive(Clone, Copy, Debug)]
208pub struct SignedRrset<'a> {
209    /// Data records.
210    pub records: &'a [ResourceRecord],
211    /// Covering RRSIG records.
212    pub signatures: &'a [ResourceRecord],
213}
214
215/// Authenticated denial result.
216#[derive(Clone, Copy, Debug, Eq, PartialEq)]
217pub enum Denial {
218    /// The queried owner exists, but the requested type does not.
219    NoData,
220    /// The queried owner does not exist.
221    NameError,
222}
223
224/// Local DNSSEC validation failure.
225#[derive(Clone, Debug, Eq, Error, PartialEq)]
226#[non_exhaustive]
227pub enum DnssecError {
228    /// No data records were supplied.
229    #[error("DNSSEC RRset is empty")]
230    EmptyRrset,
231    /// A configured count or byte bound was exceeded.
232    #[error("DNSSEC resource bound exceeded")]
233    Limit,
234    /// Records do not form one class-IN owner/type RRset.
235    #[error("records do not form one class-IN RRset")]
236    RrsetMismatch,
237    /// No covering RRSIG exists.
238    #[error("no covering RRSIG")]
239    MissingSignature,
240    /// No DNSKEY matches the signature.
241    #[error("no matching DNSKEY")]
242    MissingKey,
243    /// The matching key is revoked or has an invalid DNSSEC protocol value.
244    #[error("DNSKEY is revoked or malformed")]
245    InvalidKey,
246    /// The DNSSEC algorithm is unsupported.
247    #[error("unsupported DNSSEC algorithm {0}")]
248    UnsupportedAlgorithm(u8),
249    /// The DS digest algorithm is unsupported.
250    #[error("unsupported DS digest algorithm {0}")]
251    UnsupportedDigest(u8),
252    /// The signature is outside its inception/expiration window.
253    #[error("RRSIG is outside its validity window")]
254    SignatureTime,
255    /// No candidate signature verified.
256    #[error("DNSSEC signature mismatch")]
257    SignatureMismatch,
258    /// Typed RDATA cannot be canonically encoded for DNSSEC.
259    #[error("unsupported or mismatched canonical RDATA")]
260    UnsupportedRdata,
261    /// No DS record authenticates the DNSKEY.
262    #[error("DS digest mismatch")]
263    DsMismatch,
264    /// An NSEC or NSEC3 proof is malformed or does not prove the requested denial.
265    #[error("authenticated denial proof mismatch")]
266    DenialMismatch,
267}
268
269/// Verify one RRset against locally authenticated DNSKEY records.
270pub 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
372/// Produce RFC 4034 canonical bytes covered by an RRSIG.
373///
374/// This is exposed for deterministic fixture generation and authoritative
375/// tooling. Verification callers should normally use [`verify_rrset`].
376pub 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
384/// Authenticate a zone DNSKEY RRset from already trusted DS records.
385///
386/// The caller must obtain `trusted_ds` from a locally verified parent RRset
387/// or a locally verified Handshake name resource. For child delegations,
388/// prefer [`authenticate_child_dnskeys`], which verifies that parent step.
389pub 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
445/// Verify an RRset with a DS-authenticated zone keyset.
446pub 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
462/// Authenticate a child delegation and its DNSKEY RRset from parent keys.
463pub 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
500/// Verify that at least one class-IN DS record authenticates a DNSKEY.
501pub 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/// Compute the RFC 4034 DNSKEY key tag.
554#[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
569/// Verify an already signature-authenticated NSEC proof.
570pub 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
615/// Compute the RFC 5155 SHA-1 NSEC3 hash with bounded iterations.
616pub 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
637/// Verify an already signature-authenticated NSEC3 no-data or name-error proof.
638///
639/// Owner labels must use the ordinary base32hex NSEC3 owner representation.
640pub 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}