Skip to main content

hns_dane/
lib.rs

1//! Local, fail-closed TLSA matching for HNS HTTPS certificates.
2//!
3//! This crate supports DANE-EE (usage 3), full-certificate and
4//! `SubjectPublicKeyInfo` selectors, and exact/SHA-256/SHA-512 matching. It
5//! does not contain a WebPKI or network fallback.
6
7#![forbid(unsafe_code)]
8#![allow(
9    clippy::doc_markdown,
10    clippy::missing_errors_doc,
11    clippy::module_name_repetitions,
12    reason = "protocol acronyms and the shared DaneError enum are documented at crate level"
13)]
14
15use std::fmt;
16
17use hns_dns_wire::Tlsa;
18use openssl::stack::Stack;
19use openssl::x509::store::X509StoreBuilder;
20use openssl::x509::verify::{X509CheckFlags, X509VerifyFlags, X509VerifyParam};
21use openssl::x509::{X509, X509StoreContext};
22use sha2::{Digest, Sha256, Sha512};
23
24/// Default maximum DER certificate size.
25pub const DEFAULT_MAX_CERTIFICATE_LEN: usize = 256 * 1024;
26/// Default maximum DER `SubjectPublicKeyInfo` size.
27pub const DEFAULT_MAX_SPKI_LEN: usize = 64 * 1024;
28/// Maximum TLSA association bytes representable by DNS RDATA after its prefix.
29pub const MAX_TLSA_ASSOCIATION_LEN: usize = 65_532;
30
31/// Bounded DANE verification inputs.
32#[derive(Clone, Copy, Debug, Eq, PartialEq)]
33pub struct DaneLimits {
34    /// Maximum leaf certificate DER bytes.
35    pub max_certificate_len: usize,
36    /// Maximum extracted SPKI DER bytes.
37    pub max_spki_len: usize,
38    /// Maximum number of alternative TLSA records.
39    pub max_tlsa_records: usize,
40    /// Maximum association bytes in one TLSA record.
41    pub max_association_len: usize,
42    /// Maximum certificates accepted from one TLS server.
43    pub max_chain_certificates: usize,
44}
45
46impl Default for DaneLimits {
47    fn default() -> Self {
48        Self {
49            max_certificate_len: DEFAULT_MAX_CERTIFICATE_LEN,
50            max_spki_len: DEFAULT_MAX_SPKI_LEN,
51            max_tlsa_records: 64,
52            max_association_len: MAX_TLSA_ASSOCIATION_LEN,
53            max_chain_certificates: 16,
54        }
55    }
56}
57
58/// Supported TLSA certificate usage.
59#[repr(u8)]
60#[derive(Clone, Copy, Debug, Eq, PartialEq)]
61pub enum CertificateUsage {
62    /// DANE trust anchor: a locally DNSSEC-authenticated record anchors a
63    /// complete private PKIX path without consulting WebPKI.
64    DaneTa = 2,
65    /// DANE end entity: the locally DNSSEC-authenticated record pins the leaf.
66    DaneEe = 3,
67}
68
69/// Supported TLSA selector.
70#[repr(u8)]
71#[derive(Clone, Copy, Debug, Eq, PartialEq)]
72pub enum Selector {
73    /// Entire leaf certificate DER.
74    FullCertificate = 0,
75    /// Entire DER `SubjectPublicKeyInfo` from the leaf certificate.
76    SubjectPublicKeyInfo = 1,
77}
78
79/// Supported TLSA matching type.
80#[repr(u8)]
81#[derive(Clone, Copy, Debug, Eq, PartialEq)]
82pub enum MatchingType {
83    /// Exact selected bytes.
84    Exact = 0,
85    /// SHA-256 of selected bytes.
86    Sha256 = 1,
87    /// SHA-512 of selected bytes.
88    Sha512 = 2,
89}
90
91/// Successful local match details.
92#[derive(Clone, Copy, Debug, Eq, PartialEq)]
93pub struct DaneMatch {
94    record_index: usize,
95    usage: CertificateUsage,
96    selector: Selector,
97    matching_type: MatchingType,
98}
99
100impl DaneMatch {
101    /// Index into the caller's TLSA RRset.
102    #[must_use]
103    pub const fn record_index(self) -> usize {
104        self.record_index
105    }
106
107    /// Matched certificate usage.
108    #[must_use]
109    pub const fn usage(self) -> CertificateUsage {
110        self.usage
111    }
112
113    /// Matched selector.
114    #[must_use]
115    pub const fn selector(self) -> Selector {
116        self.selector
117    }
118
119    /// Matched association algorithm.
120    #[must_use]
121    pub const fn matching_type(self) -> MatchingType {
122        self.matching_type
123    }
124}
125
126/// Local TLSA/DANE validation failure.
127#[derive(Clone, Debug, Eq, PartialEq)]
128#[non_exhaustive]
129pub enum DaneError {
130    /// No TLSA records were supplied.
131    MissingTlsa,
132    /// The RRset exceeds its configured record count.
133    TooManyTlsaRecords,
134    /// The leaf certificate is empty or exceeds its configured bound.
135    CertificateLength,
136    /// The certificate is not strict bounded DER with the expected X.509 shape.
137    MalformedCertificate,
138    /// The extracted SPKI exceeds its configured bound.
139    SpkiLength,
140    /// A TLSA usage is unsupported without another trust model.
141    UnsupportedUsage(u8),
142    /// A TLSA selector is unsupported.
143    UnsupportedSelector(u8),
144    /// A TLSA matching algorithm is unsupported.
145    UnsupportedMatchingType(u8),
146    /// Association data is empty, oversized, or has the wrong digest length.
147    InvalidAssociationLength,
148    /// Every record was valid but none matched the presented certificate.
149    Mismatch,
150    /// The supplied server certificate chain is empty or exceeds its bound.
151    ChainLength,
152    /// DANE-TA path, validity-time, or server-name validation failed.
153    ChainValidation,
154    /// The TLSA base domain is empty, contains NUL, or cannot be checked.
155    InvalidServerName,
156}
157
158impl fmt::Display for DaneError {
159    fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
160        match self {
161            Self::MissingTlsa => formatter.write_str("TLSA RRset is empty"),
162            Self::TooManyTlsaRecords => formatter.write_str("TLSA RRset exceeds configured limit"),
163            Self::CertificateLength => {
164                formatter.write_str("certificate DER is empty or exceeds configured limit")
165            }
166            Self::MalformedCertificate => formatter.write_str("certificate DER is malformed"),
167            Self::SpkiLength => formatter.write_str("SPKI DER exceeds configured limit"),
168            Self::UnsupportedUsage(value) => write!(formatter, "unsupported TLSA usage {value}"),
169            Self::UnsupportedSelector(value) => {
170                write!(formatter, "unsupported TLSA selector {value}")
171            }
172            Self::UnsupportedMatchingType(value) => {
173                write!(formatter, "unsupported TLSA matching type {value}")
174            }
175            Self::InvalidAssociationLength => {
176                formatter.write_str("invalid TLSA association-data length")
177            }
178            Self::Mismatch => formatter.write_str("TLSA records do not match certificate"),
179            Self::ChainLength => formatter.write_str("certificate chain exceeds configured bounds"),
180            Self::ChainValidation => {
181                formatter.write_str("DANE-TA certificate path validation failed")
182            }
183            Self::InvalidServerName => formatter.write_str("invalid DANE TLSA base domain"),
184        }
185    }
186}
187
188impl std::error::Error for DaneError {}
189
190/// Verify a leaf certificate against a strict DNSSEC-authenticated DANE-EE RRset.
191///
192/// All records are validated before matching. PKIX usages 0/1 are rejected
193/// because this engine has no WebPKI trust path. DANE-TA usage 2 is rejected
194/// until a local certificate-chain signature validator exists.
195pub fn verify_dane_ee(
196    certificate_der: &[u8],
197    records: &[Tlsa],
198    limits: DaneLimits,
199) -> Result<DaneMatch, DaneError> {
200    if certificate_der.is_empty() || certificate_der.len() > limits.max_certificate_len {
201        return Err(DaneError::CertificateLength);
202    }
203    if records.is_empty() {
204        return Err(DaneError::MissingTlsa);
205    }
206    if records.len() > limits.max_tlsa_records {
207        return Err(DaneError::TooManyTlsaRecords);
208    }
209
210    let parsed_records = records
211        .iter()
212        .map(|record| parse_record(record, limits))
213        .collect::<Result<Vec<_>, _>>()?;
214    if let Some(record) = parsed_records
215        .iter()
216        .find(|record| record.usage != CertificateUsage::DaneEe)
217    {
218        return Err(DaneError::UnsupportedUsage(record.usage as u8));
219    }
220    let spki = extract_subject_public_key_info(certificate_der)?;
221    if spki.len() > limits.max_spki_len {
222        return Err(DaneError::SpkiLength);
223    }
224
225    let material = MatchMaterial::new(certificate_der, spki);
226    for (record_index, record) in parsed_records.iter().enumerate() {
227        if material.matches(*record) {
228            return Ok(DaneMatch {
229                record_index,
230                usage: record.usage,
231                selector: record.selector,
232                matching_type: record.matching_type,
233            });
234        }
235    }
236    Err(DaneError::Mismatch)
237}
238
239/// Verify a TLS server certificate chain against DANE-EE or DANE-TA records.
240///
241/// DANE-EE matches only the leaf and, per RFC 7671, deliberately ignores
242/// certificate names, validity dates, and public trust stores. DANE-TA builds
243/// a private path rooted only in the matching TLSA trust anchor, validates at
244/// `validation_unix_time`, and requires the TLSA base domain in the leaf.
245/// WebPKI roots are never loaded.
246pub fn verify_dane_chain(
247    certificate_chain_der: &[&[u8]],
248    tlsa_base_domain: &str,
249    records: &[Tlsa],
250    validation_unix_time: i64,
251    limits: DaneLimits,
252) -> Result<DaneMatch, DaneError> {
253    validate_chain_inputs(certificate_chain_der, tlsa_base_domain, records, limits)?;
254
255    let parsed_records = records
256        .iter()
257        .map(|record| parse_record(record, limits))
258        .collect::<Result<Vec<_>, _>>()?;
259    let leaf = certificate_chain_der
260        .first()
261        .copied()
262        .ok_or(DaneError::ChainLength)?;
263    let leaf_spki = extract_subject_public_key_info(leaf)?;
264    if leaf_spki.len() > limits.max_spki_len {
265        return Err(DaneError::SpkiLength);
266    }
267    let leaf_material = MatchMaterial::new(leaf, leaf_spki);
268    for (record_index, record) in parsed_records.iter().copied().enumerate() {
269        if record.usage == CertificateUsage::DaneEe && leaf_material.matches(record) {
270            return Ok(DaneMatch {
271                record_index,
272                usage: record.usage,
273                selector: record.selector,
274                matching_type: record.matching_type,
275            });
276        }
277    }
278
279    let parsed_chain = certificate_chain_der
280        .iter()
281        .map(|certificate| X509::from_der(certificate).map_err(|_| DaneError::MalformedCertificate))
282        .collect::<Result<Vec<_>, _>>()?;
283    let leaf_certificate = parsed_chain.first().ok_or(DaneError::ChainLength)?;
284    let mut saw_ta_match = false;
285    for (record_index, record) in parsed_records.iter().copied().enumerate() {
286        if record.usage != CertificateUsage::DaneTa {
287            continue;
288        }
289        let anchor_der = if record.selector == Selector::FullCertificate
290            && record.matching_type == MatchingType::Exact
291        {
292            if !constant_time_eq(record.association_data, leaf)
293                && certificate_chain_der
294                    .iter()
295                    .all(|certificate| !constant_time_eq(record.association_data, certificate))
296            {
297                // RFC 7671 permits a full-certificate DANE-TA association to
298                // carry the trust anchor even when the server omits it.
299                record.association_data
300            } else {
301                certificate_chain_der
302                    .iter()
303                    .copied()
304                    .find(|certificate| constant_time_eq(record.association_data, certificate))
305                    .ok_or(DaneError::Mismatch)?
306            }
307        } else {
308            let mut matched = None;
309            for certificate in certificate_chain_der {
310                let spki = extract_subject_public_key_info(certificate)?;
311                if spki.len() > limits.max_spki_len {
312                    return Err(DaneError::SpkiLength);
313                }
314                if MatchMaterial::new(certificate, spki).matches(record) {
315                    matched = Some(*certificate);
316                    break;
317                }
318            }
319            let Some(matched) = matched else {
320                continue;
321            };
322            matched
323        };
324        let anchor = X509::from_der(anchor_der).map_err(|_| DaneError::MalformedCertificate)?;
325        saw_ta_match = true;
326        if validate_private_chain(
327            leaf_certificate,
328            &parsed_chain,
329            &anchor,
330            anchor_der,
331            tlsa_base_domain,
332            validation_unix_time,
333            limits,
334        ) {
335            return Ok(DaneMatch {
336                record_index,
337                usage: record.usage,
338                selector: record.selector,
339                matching_type: record.matching_type,
340            });
341        }
342    }
343    if saw_ta_match {
344        Err(DaneError::ChainValidation)
345    } else {
346        Err(DaneError::Mismatch)
347    }
348}
349
350fn validate_chain_inputs(
351    certificate_chain_der: &[&[u8]],
352    tlsa_base_domain: &str,
353    records: &[Tlsa],
354    limits: DaneLimits,
355) -> Result<(), DaneError> {
356    if certificate_chain_der.is_empty()
357        || certificate_chain_der.len() > limits.max_chain_certificates
358    {
359        return Err(DaneError::ChainLength);
360    }
361    if tlsa_base_domain.is_empty()
362        || tlsa_base_domain.len() > 253
363        || tlsa_base_domain.as_bytes().contains(&0)
364    {
365        return Err(DaneError::InvalidServerName);
366    }
367    if certificate_chain_der
368        .iter()
369        .any(|certificate| certificate.is_empty() || certificate.len() > limits.max_certificate_len)
370    {
371        return Err(DaneError::CertificateLength);
372    }
373    if records.is_empty() {
374        return Err(DaneError::MissingTlsa);
375    }
376    if records.len() > limits.max_tlsa_records {
377        return Err(DaneError::TooManyTlsaRecords);
378    }
379    Ok(())
380}
381
382/// Extract the exact DER `SubjectPublicKeyInfo` TLV from a leaf certificate.
383pub fn extract_subject_public_key_info(certificate_der: &[u8]) -> Result<&[u8], DaneError> {
384    let mut document = DerReader::new(certificate_der);
385    let certificate = document.read_expected(TAG_SEQUENCE)?;
386    if !document.is_empty() {
387        return Err(DaneError::MalformedCertificate);
388    }
389
390    let mut certificate_fields = DerReader::new(certificate.value);
391    let tbs = certificate_fields.read_expected(TAG_SEQUENCE)?;
392    let outer_algorithm = certificate_fields.read_expected(TAG_SEQUENCE)?;
393    validate_algorithm_identifier(outer_algorithm.value)?;
394    validate_bit_string(certificate_fields.read_expected(TAG_BIT_STRING)?.value)?;
395    if !certificate_fields.is_empty() {
396        return Err(DaneError::MalformedCertificate);
397    }
398
399    let mut fields = DerReader::new(tbs.value);
400    if fields.peek_tag() == Some(TAG_EXPLICIT_VERSION) {
401        validate_version(fields.read_expected(TAG_EXPLICIT_VERSION)?.value)?;
402    }
403    validate_integer(fields.read_expected(TAG_INTEGER)?.value)?;
404    let tbs_algorithm = fields.read_expected(TAG_SEQUENCE)?;
405    validate_algorithm_identifier(tbs_algorithm.value)?;
406    if !constant_time_eq(tbs_algorithm.full, outer_algorithm.full) {
407        return Err(DaneError::MalformedCertificate);
408    }
409    validate_name(fields.read_expected(TAG_SEQUENCE)?.value)?;
410    validate_validity(fields.read_expected(TAG_SEQUENCE)?.value)?;
411    validate_name(fields.read_expected(TAG_SEQUENCE)?.value)?;
412
413    let spki = fields.read_expected(TAG_SEQUENCE)?;
414    validate_spki(spki.value)?;
415    validate_tbs_tail(&mut fields)?;
416    Ok(spki.full)
417}
418
419#[derive(Clone, Copy)]
420struct ParsedRecord<'a> {
421    usage: CertificateUsage,
422    selector: Selector,
423    matching_type: MatchingType,
424    association_data: &'a [u8],
425}
426
427fn parse_record(record: &Tlsa, limits: DaneLimits) -> Result<ParsedRecord<'_>, DaneError> {
428    let usage = match record.usage {
429        2 => CertificateUsage::DaneTa,
430        3 => CertificateUsage::DaneEe,
431        value => return Err(DaneError::UnsupportedUsage(value)),
432    };
433    let selector = match record.selector {
434        0 => Selector::FullCertificate,
435        1 => Selector::SubjectPublicKeyInfo,
436        value => return Err(DaneError::UnsupportedSelector(value)),
437    };
438    let matching_type = match record.matching_type {
439        0 => MatchingType::Exact,
440        1 => MatchingType::Sha256,
441        2 => MatchingType::Sha512,
442        value => return Err(DaneError::UnsupportedMatchingType(value)),
443    };
444    let length = record.association_data.len();
445    if length == 0
446        || length > limits.max_association_len
447        || (matching_type == MatchingType::Sha256 && length != 32)
448        || (matching_type == MatchingType::Sha512 && length != 64)
449    {
450        return Err(DaneError::InvalidAssociationLength);
451    }
452    Ok(ParsedRecord {
453        usage,
454        selector,
455        matching_type,
456        association_data: &record.association_data,
457    })
458}
459
460struct MatchMaterial<'a> {
461    certificate: &'a [u8],
462    spki: &'a [u8],
463    certificate_sha256: [u8; 32],
464    certificate_sha512: [u8; 64],
465    spki_sha256: [u8; 32],
466    spki_sha512: [u8; 64],
467}
468
469impl<'a> MatchMaterial<'a> {
470    fn new(certificate: &'a [u8], spki: &'a [u8]) -> Self {
471        Self {
472            certificate,
473            spki,
474            certificate_sha256: Sha256::digest(certificate).into(),
475            certificate_sha512: Sha512::digest(certificate).into(),
476            spki_sha256: Sha256::digest(spki).into(),
477            spki_sha512: Sha512::digest(spki).into(),
478        }
479    }
480
481    fn matches(&self, record: ParsedRecord<'_>) -> bool {
482        let candidate = match (record.selector, record.matching_type) {
483            (Selector::FullCertificate, MatchingType::Exact) => self.certificate,
484            (Selector::FullCertificate, MatchingType::Sha256) => &self.certificate_sha256,
485            (Selector::FullCertificate, MatchingType::Sha512) => &self.certificate_sha512,
486            (Selector::SubjectPublicKeyInfo, MatchingType::Exact) => self.spki,
487            (Selector::SubjectPublicKeyInfo, MatchingType::Sha256) => &self.spki_sha256,
488            (Selector::SubjectPublicKeyInfo, MatchingType::Sha512) => &self.spki_sha512,
489        };
490        constant_time_eq(candidate, record.association_data)
491    }
492}
493
494fn validate_private_chain(
495    leaf: &X509,
496    presented_chain: &[X509],
497    anchor: &X509,
498    anchor_der: &[u8],
499    server_name: &str,
500    validation_unix_time: i64,
501    limits: DaneLimits,
502) -> bool {
503    let result = (|| {
504        let mut store_builder = X509StoreBuilder::new()?;
505        store_builder.add_cert(anchor.clone())?;
506        let mut parameters = X509VerifyParam::new()?;
507        parameters.set_flags(
508            X509VerifyFlags::PARTIAL_CHAIN
509                | X509VerifyFlags::TRUSTED_FIRST
510                | X509VerifyFlags::X509_STRICT,
511        )?;
512        parameters.set_depth(
513            i32::try_from(limits.max_chain_certificates)
514                .map_err(|_| openssl::error::ErrorStack::get())?,
515        );
516        parameters.set_hostflags(X509CheckFlags::NO_PARTIAL_WILDCARDS);
517        parameters.set_host(server_name)?;
518        parameters.set_time(validation_unix_time);
519        store_builder.set_param(&parameters)?;
520        let store = store_builder.build();
521
522        let mut untrusted = Stack::new()?;
523        for certificate in presented_chain.iter().skip(1) {
524            let der = certificate.to_der()?;
525            if !constant_time_eq(&der, anchor_der) {
526                untrusted.push(certificate.clone())?;
527            }
528        }
529        let mut context = X509StoreContext::new()?;
530        context.init(
531            &store,
532            leaf,
533            &untrusted,
534            openssl::x509::X509StoreContextRef::verify_cert,
535        )
536    })();
537    matches!(result, Ok(true))
538}
539
540fn constant_time_eq(left: &[u8], right: &[u8]) -> bool {
541    if left.len() != right.len() {
542        return false;
543    }
544    left.iter()
545        .zip(right)
546        .fold(0u8, |difference, (left, right)| difference | (left ^ right))
547        == 0
548}
549
550const TAG_INTEGER: u8 = 0x02;
551const TAG_BIT_STRING: u8 = 0x03;
552const TAG_OBJECT_IDENTIFIER: u8 = 0x06;
553const TAG_SEQUENCE: u8 = 0x30;
554const TAG_UTC_TIME: u8 = 0x17;
555const TAG_GENERALIZED_TIME: u8 = 0x18;
556const TAG_ISSUER_UNIQUE_ID: u8 = 0x81;
557const TAG_SUBJECT_UNIQUE_ID: u8 = 0x82;
558const TAG_EXTENSIONS: u8 = 0xa3;
559const TAG_EXPLICIT_VERSION: u8 = 0xa0;
560
561#[derive(Clone, Copy)]
562struct Tlv<'a> {
563    tag: u8,
564    full: &'a [u8],
565    value: &'a [u8],
566}
567
568struct DerReader<'a> {
569    input: &'a [u8],
570    cursor: usize,
571}
572
573impl<'a> DerReader<'a> {
574    const fn new(input: &'a [u8]) -> Self {
575        Self { input, cursor: 0 }
576    }
577
578    fn is_empty(&self) -> bool {
579        self.cursor == self.input.len()
580    }
581
582    fn peek_tag(&self) -> Option<u8> {
583        self.input.get(self.cursor).copied()
584    }
585
586    fn read_expected(&mut self, expected: u8) -> Result<Tlv<'a>, DaneError> {
587        let value = self.read_tlv()?;
588        if value.tag != expected {
589            return Err(DaneError::MalformedCertificate);
590        }
591        Ok(value)
592    }
593
594    fn read_tlv(&mut self) -> Result<Tlv<'a>, DaneError> {
595        let start = self.cursor;
596        let tag = *self
597            .input
598            .get(self.cursor)
599            .ok_or(DaneError::MalformedCertificate)?;
600        if tag & 0x1f == 0x1f {
601            return Err(DaneError::MalformedCertificate);
602        }
603        self.cursor = self
604            .cursor
605            .checked_add(1)
606            .ok_or(DaneError::MalformedCertificate)?;
607        let first_length = *self
608            .input
609            .get(self.cursor)
610            .ok_or(DaneError::MalformedCertificate)?;
611        self.cursor = self
612            .cursor
613            .checked_add(1)
614            .ok_or(DaneError::MalformedCertificate)?;
615
616        let length = if first_length & 0x80 == 0 {
617            usize::from(first_length)
618        } else {
619            let octets = usize::from(first_length & 0x7f);
620            if octets == 0 || octets > 4 {
621                return Err(DaneError::MalformedCertificate);
622            }
623            let length_end = self
624                .cursor
625                .checked_add(octets)
626                .ok_or(DaneError::MalformedCertificate)?;
627            let encoded = self
628                .input
629                .get(self.cursor..length_end)
630                .ok_or(DaneError::MalformedCertificate)?;
631            if encoded.first() == Some(&0) {
632                return Err(DaneError::MalformedCertificate);
633            }
634            self.cursor = length_end;
635            let mut length = 0usize;
636            for byte in encoded {
637                length = length
638                    .checked_mul(256)
639                    .and_then(|value| value.checked_add(usize::from(*byte)))
640                    .ok_or(DaneError::MalformedCertificate)?;
641            }
642            if length < 128 {
643                return Err(DaneError::MalformedCertificate);
644            }
645            length
646        };
647
648        let value_start = self.cursor;
649        let end = value_start
650            .checked_add(length)
651            .ok_or(DaneError::MalformedCertificate)?;
652        let value = self
653            .input
654            .get(value_start..end)
655            .ok_or(DaneError::MalformedCertificate)?;
656        let full = self
657            .input
658            .get(start..end)
659            .ok_or(DaneError::MalformedCertificate)?;
660        self.cursor = end;
661        Ok(Tlv { tag, full, value })
662    }
663}
664
665fn validate_version(input: &[u8]) -> Result<(), DaneError> {
666    let mut reader = DerReader::new(input);
667    let version = reader.read_expected(TAG_INTEGER)?;
668    if !reader.is_empty()
669        || version.value.len() != 1
670        || version.value.first().is_none_or(|value| *value > 2)
671    {
672        return Err(DaneError::MalformedCertificate);
673    }
674    Ok(())
675}
676
677fn validate_integer(input: &[u8]) -> Result<(), DaneError> {
678    if input.is_empty() {
679        return Err(DaneError::MalformedCertificate);
680    }
681    if input.len() > 1 {
682        let first = input
683            .first()
684            .copied()
685            .ok_or(DaneError::MalformedCertificate)?;
686        let second = input
687            .get(1)
688            .copied()
689            .ok_or(DaneError::MalformedCertificate)?;
690        if (first == 0 && second & 0x80 == 0) || (first == 0xff && second & 0x80 != 0) {
691            return Err(DaneError::MalformedCertificate);
692        }
693    }
694    Ok(())
695}
696
697fn validate_algorithm_identifier(input: &[u8]) -> Result<(), DaneError> {
698    let mut reader = DerReader::new(input);
699    let oid = reader.read_expected(TAG_OBJECT_IDENTIFIER)?;
700    if oid.value.is_empty() {
701        return Err(DaneError::MalformedCertificate);
702    }
703    if !reader.is_empty() {
704        reader.read_tlv()?;
705    }
706    if !reader.is_empty() {
707        return Err(DaneError::MalformedCertificate);
708    }
709    Ok(())
710}
711
712fn validate_bit_string(input: &[u8]) -> Result<(), DaneError> {
713    let unused_bits = input
714        .first()
715        .copied()
716        .ok_or(DaneError::MalformedCertificate)?;
717    if unused_bits > 7 || input.len() < 2 {
718        return Err(DaneError::MalformedCertificate);
719    }
720    if unused_bits != 0 {
721        let last = input
722            .last()
723            .copied()
724            .ok_or(DaneError::MalformedCertificate)?;
725        let mask = (1u8 << unused_bits) - 1;
726        if last & mask != 0 {
727            return Err(DaneError::MalformedCertificate);
728        }
729    }
730    Ok(())
731}
732
733fn validate_name(input: &[u8]) -> Result<(), DaneError> {
734    let mut reader = DerReader::new(input);
735    while !reader.is_empty() {
736        reader.read_tlv()?;
737    }
738    Ok(())
739}
740
741fn validate_validity(input: &[u8]) -> Result<(), DaneError> {
742    let mut reader = DerReader::new(input);
743    for _ in 0..2 {
744        let time = reader.read_tlv()?;
745        if !matches!(time.tag, TAG_UTC_TIME | TAG_GENERALIZED_TIME) || time.value.is_empty() {
746            return Err(DaneError::MalformedCertificate);
747        }
748    }
749    if !reader.is_empty() {
750        return Err(DaneError::MalformedCertificate);
751    }
752    Ok(())
753}
754
755fn validate_spki(input: &[u8]) -> Result<(), DaneError> {
756    let mut reader = DerReader::new(input);
757    validate_algorithm_identifier(reader.read_expected(TAG_SEQUENCE)?.value)?;
758    validate_bit_string(reader.read_expected(TAG_BIT_STRING)?.value)?;
759    if !reader.is_empty() {
760        return Err(DaneError::MalformedCertificate);
761    }
762    Ok(())
763}
764
765fn validate_tbs_tail(reader: &mut DerReader<'_>) -> Result<(), DaneError> {
766    let mut last_tag = 0u8;
767    while !reader.is_empty() {
768        let field = reader.read_tlv()?;
769        if !matches!(
770            field.tag,
771            TAG_ISSUER_UNIQUE_ID | TAG_SUBJECT_UNIQUE_ID | TAG_EXTENSIONS
772        ) || field.tag <= last_tag
773        {
774            return Err(DaneError::MalformedCertificate);
775        }
776        last_tag = field.tag;
777    }
778    Ok(())
779}
780
781#[cfg(test)]
782#[allow(
783    clippy::indexing_slicing,
784    clippy::unwrap_used,
785    reason = "tests intentionally fail immediately on malformed fixed fixtures"
786)]
787mod tests {
788    use openssl::asn1::Asn1Time;
789    use openssl::bn::BigNum;
790    use openssl::hash::MessageDigest;
791    use openssl::pkey::{PKey, Private};
792    use openssl::rsa::Rsa;
793    use openssl::x509::extension::{
794        AuthorityKeyIdentifier, BasicConstraints, ExtendedKeyUsage, KeyUsage,
795        SubjectAlternativeName, SubjectKeyIdentifier,
796    };
797    use openssl::x509::{X509, X509NameBuilder};
798
799    use super::*;
800
801    fn decode_hex(input: &str) -> Vec<u8> {
802        let compact: Vec<u8> = input
803            .bytes()
804            .filter(|byte| !byte.is_ascii_whitespace())
805            .collect();
806        assert!(compact.len().is_multiple_of(2));
807        compact
808            .chunks_exact(2)
809            .map(|pair| {
810                let high = (pair[0] as char).to_digit(16).unwrap();
811                let low = (pair[1] as char).to_digit(16).unwrap();
812                u8::try_from((high << 4) | low).unwrap()
813            })
814            .collect()
815    }
816
817    fn serial(value: u32) -> openssl::asn1::Asn1Integer {
818        BigNum::from_u32(value).unwrap().to_asn1_integer().unwrap()
819    }
820
821    fn certificate_chain() -> (Vec<u8>, Vec<u8>) {
822        let root_key = PKey::from_rsa(Rsa::generate(2048).unwrap()).unwrap();
823        let mut root_name = X509NameBuilder::new().unwrap();
824        root_name
825            .append_entry_by_text("CN", "DANE Test Root")
826            .unwrap();
827        let root_name = root_name.build();
828        let mut root_builder = X509::builder().unwrap();
829        root_builder.set_version(2).unwrap();
830        root_builder.set_serial_number(&serial(1)).unwrap();
831        root_builder.set_subject_name(&root_name).unwrap();
832        root_builder.set_issuer_name(&root_name).unwrap();
833        root_builder.set_pubkey(&root_key).unwrap();
834        root_builder
835            .set_not_before(&Asn1Time::from_unix(1_600_000_000).unwrap())
836            .unwrap();
837        root_builder
838            .set_not_after(&Asn1Time::from_unix(1_900_000_000).unwrap())
839            .unwrap();
840        root_builder
841            .append_extension(BasicConstraints::new().critical().ca().build().unwrap())
842            .unwrap();
843        root_builder
844            .append_extension(
845                KeyUsage::new()
846                    .critical()
847                    .key_cert_sign()
848                    .crl_sign()
849                    .build()
850                    .unwrap(),
851            )
852            .unwrap();
853        let root_subject_key = SubjectKeyIdentifier::new()
854            .build(&root_builder.x509v3_context(None, None))
855            .unwrap();
856        root_builder.append_extension(root_subject_key).unwrap();
857        root_builder
858            .sign(&root_key, MessageDigest::sha256())
859            .unwrap();
860        let root = root_builder.build();
861
862        let leaf_key: PKey<Private> = PKey::from_rsa(Rsa::generate(2048).unwrap()).unwrap();
863        let mut leaf_name = X509NameBuilder::new().unwrap();
864        leaf_name
865            .append_entry_by_text("CN", "service.example")
866            .unwrap();
867        let leaf_name = leaf_name.build();
868        let mut leaf_builder = X509::builder().unwrap();
869        leaf_builder.set_version(2).unwrap();
870        leaf_builder.set_serial_number(&serial(2)).unwrap();
871        leaf_builder.set_subject_name(&leaf_name).unwrap();
872        leaf_builder.set_issuer_name(root.subject_name()).unwrap();
873        leaf_builder.set_pubkey(&leaf_key).unwrap();
874        leaf_builder
875            .set_not_before(&Asn1Time::from_unix(1_600_000_000).unwrap())
876            .unwrap();
877        leaf_builder
878            .set_not_after(&Asn1Time::from_unix(1_900_000_000).unwrap())
879            .unwrap();
880        leaf_builder
881            .append_extension(BasicConstraints::new().critical().build().unwrap())
882            .unwrap();
883        leaf_builder
884            .append_extension(
885                KeyUsage::new()
886                    .critical()
887                    .digital_signature()
888                    .build()
889                    .unwrap(),
890            )
891            .unwrap();
892        leaf_builder
893            .append_extension(ExtendedKeyUsage::new().server_auth().build().unwrap())
894            .unwrap();
895        let subject_alternative_name = SubjectAlternativeName::new()
896            .dns("service.example")
897            .build(&leaf_builder.x509v3_context(Some(&root), None))
898            .unwrap();
899        leaf_builder
900            .append_extension(subject_alternative_name)
901            .unwrap();
902        let authority_key = AuthorityKeyIdentifier::new()
903            .keyid(true)
904            .build(&leaf_builder.x509v3_context(Some(&root), None))
905            .unwrap();
906        leaf_builder.append_extension(authority_key).unwrap();
907        let leaf_subject_key = SubjectKeyIdentifier::new()
908            .build(&leaf_builder.x509v3_context(Some(&root), None))
909            .unwrap();
910        leaf_builder.append_extension(leaf_subject_key).unwrap();
911        leaf_builder
912            .sign(&root_key, MessageDigest::sha256())
913            .unwrap();
914        (
915            leaf_builder.build().to_der().unwrap(),
916            root.to_der().unwrap(),
917        )
918    }
919
920    fn certificate() -> Vec<u8> {
921        decode_hex(include_str!("../fixtures/dane/self-signed-cert.der.hex"))
922    }
923
924    fn expected_spki() -> Vec<u8> {
925        decode_hex(include_str!("../fixtures/dane/self-signed-spki.der.hex"))
926    }
927
928    fn record(selector: Selector, matching_type: MatchingType, data: Vec<u8>) -> Tlsa {
929        Tlsa {
930            usage: CertificateUsage::DaneEe as u8,
931            selector: selector as u8,
932            matching_type: matching_type as u8,
933            association_data: data,
934        }
935    }
936
937    #[test]
938    fn extracts_exact_spki_from_real_certificate_fixture() {
939        let certificate = certificate();
940        assert_eq!(
941            extract_subject_public_key_info(&certificate).unwrap(),
942            expected_spki()
943        );
944    }
945
946    #[test]
947    fn matches_full_certificate_exact_sha256_and_sha512() {
948        let certificate = certificate();
949        for (matching_type, association_data) in [
950            (MatchingType::Exact, certificate.clone()),
951            (MatchingType::Sha256, Sha256::digest(&certificate).to_vec()),
952            (MatchingType::Sha512, Sha512::digest(&certificate).to_vec()),
953        ] {
954            let matched = verify_dane_ee(
955                &certificate,
956                &[record(
957                    Selector::FullCertificate,
958                    matching_type,
959                    association_data,
960                )],
961                DaneLimits::default(),
962            )
963            .unwrap();
964            assert_eq!(matched.selector(), Selector::FullCertificate);
965            assert_eq!(matched.matching_type(), matching_type);
966        }
967    }
968
969    #[test]
970    fn matches_spki_exact_sha256_and_sha512() {
971        let certificate = certificate();
972        let spki = expected_spki();
973        for (matching_type, association_data) in [
974            (MatchingType::Exact, spki.clone()),
975            (MatchingType::Sha256, Sha256::digest(&spki).to_vec()),
976            (MatchingType::Sha512, Sha512::digest(&spki).to_vec()),
977        ] {
978            let matched = verify_dane_ee(
979                &certificate,
980                &[record(
981                    Selector::SubjectPublicKeyInfo,
982                    matching_type,
983                    association_data,
984                )],
985                DaneLimits::default(),
986            )
987            .unwrap();
988            assert_eq!(matched.selector(), Selector::SubjectPublicKeyInfo);
989            assert_eq!(matched.matching_type(), matching_type);
990        }
991    }
992
993    #[test]
994    fn rejects_mismatch_and_mutated_certificate() {
995        let certificate = certificate();
996        let pin = Sha256::digest(&certificate).to_vec();
997        let tlsa = record(Selector::FullCertificate, MatchingType::Sha256, pin);
998        let mut mutated = certificate.clone();
999        let last = mutated.len() - 1;
1000        mutated[last] ^= 1;
1001
1002        assert_eq!(
1003            verify_dane_ee(&mutated, &[tlsa], DaneLimits::default()),
1004            Err(DaneError::Mismatch)
1005        );
1006    }
1007
1008    #[test]
1009    fn dane_ta_builds_only_the_dnssec_selected_private_chain() {
1010        let (leaf, root) = certificate_chain();
1011        let exact_anchor = Tlsa {
1012            usage: 2,
1013            selector: 0,
1014            matching_type: 0,
1015            association_data: root.clone(),
1016        };
1017        let matched = verify_dane_chain(
1018            &[&leaf],
1019            "service.example",
1020            std::slice::from_ref(&exact_anchor),
1021            1_750_000_000,
1022            DaneLimits::default(),
1023        )
1024        .unwrap();
1025        assert_eq!(matched.usage(), CertificateUsage::DaneTa);
1026        assert_eq!(matched.selector(), Selector::FullCertificate);
1027
1028        assert_eq!(
1029            verify_dane_chain(
1030                &[&leaf],
1031                "wrong.example",
1032                std::slice::from_ref(&exact_anchor),
1033                1_750_000_000,
1034                DaneLimits::default(),
1035            ),
1036            Err(DaneError::ChainValidation)
1037        );
1038        assert_eq!(
1039            verify_dane_chain(
1040                &[&leaf],
1041                "service.example",
1042                std::slice::from_ref(&exact_anchor),
1043                2_000_000_000,
1044                DaneLimits::default(),
1045            ),
1046            Err(DaneError::ChainValidation)
1047        );
1048    }
1049
1050    #[test]
1051    fn dane_ta_digest_requires_the_anchor_in_the_server_chain() {
1052        let (leaf, root) = certificate_chain();
1053        let root_spki = extract_subject_public_key_info(&root).unwrap();
1054        let digest_anchor = Tlsa {
1055            usage: 2,
1056            selector: 1,
1057            matching_type: 1,
1058            association_data: Sha256::digest(root_spki).to_vec(),
1059        };
1060        let matched = verify_dane_chain(
1061            &[&leaf, &root],
1062            "service.example",
1063            std::slice::from_ref(&digest_anchor),
1064            1_750_000_000,
1065            DaneLimits::default(),
1066        )
1067        .unwrap();
1068        assert_eq!(matched.usage(), CertificateUsage::DaneTa);
1069        assert_eq!(matched.selector(), Selector::SubjectPublicKeyInfo);
1070
1071        assert_eq!(
1072            verify_dane_chain(
1073                &[&leaf],
1074                "service.example",
1075                std::slice::from_ref(&digest_anchor),
1076                1_750_000_000,
1077                DaneLimits::default(),
1078            ),
1079            Err(DaneError::Mismatch)
1080        );
1081    }
1082
1083    #[test]
1084    fn dane_ee_ignores_pkix_name_time_and_public_roots() {
1085        let (leaf, _) = certificate_chain();
1086        let leaf_record = Tlsa {
1087            usage: 3,
1088            selector: 0,
1089            matching_type: 0,
1090            association_data: leaf.clone(),
1091        };
1092        let matched = verify_dane_chain(
1093            &[&leaf],
1094            "unrelated.example",
1095            std::slice::from_ref(&leaf_record),
1096            i64::MAX,
1097            DaneLimits::default(),
1098        )
1099        .unwrap();
1100        assert_eq!(matched.usage(), CertificateUsage::DaneEe);
1101
1102        let wrong_record = Tlsa {
1103            association_data: vec![0; leaf.len()],
1104            ..leaf_record
1105        };
1106        assert_eq!(
1107            verify_dane_chain(
1108                &[&leaf],
1109                "service.example",
1110                &[wrong_record],
1111                1_750_000_000,
1112                DaneLimits::default(),
1113            ),
1114            Err(DaneError::Mismatch)
1115        );
1116    }
1117
1118    #[test]
1119    fn rejects_unsupported_or_malformed_tlsa_before_matching() {
1120        let certificate = certificate();
1121        let valid_digest = Sha256::digest(&certificate).to_vec();
1122        for (tlsa, expected) in [
1123            (
1124                Tlsa {
1125                    usage: 0,
1126                    selector: 0,
1127                    matching_type: 1,
1128                    association_data: valid_digest.clone(),
1129                },
1130                DaneError::UnsupportedUsage(0),
1131            ),
1132            (
1133                Tlsa {
1134                    usage: 3,
1135                    selector: 2,
1136                    matching_type: 1,
1137                    association_data: valid_digest.clone(),
1138                },
1139                DaneError::UnsupportedSelector(2),
1140            ),
1141            (
1142                Tlsa {
1143                    usage: 3,
1144                    selector: 0,
1145                    matching_type: 3,
1146                    association_data: valid_digest.clone(),
1147                },
1148                DaneError::UnsupportedMatchingType(3),
1149            ),
1150            (
1151                Tlsa {
1152                    usage: 3,
1153                    selector: 0,
1154                    matching_type: 1,
1155                    association_data: vec![0; 31],
1156                },
1157                DaneError::InvalidAssociationLength,
1158            ),
1159        ] {
1160            assert_eq!(
1161                verify_dane_ee(&certificate, &[tlsa], DaneLimits::default()),
1162                Err(expected)
1163            );
1164        }
1165    }
1166
1167    #[test]
1168    fn enforces_certificate_record_and_association_bounds() {
1169        let certificate = certificate();
1170        assert_eq!(
1171            verify_dane_ee(&certificate, &[], DaneLimits::default()),
1172            Err(DaneError::MissingTlsa)
1173        );
1174
1175        let record = record(
1176            Selector::FullCertificate,
1177            MatchingType::Exact,
1178            certificate.clone(),
1179        );
1180        let limits = DaneLimits {
1181            max_certificate_len: certificate.len() - 1,
1182            ..DaneLimits::default()
1183        };
1184        assert_eq!(
1185            verify_dane_ee(&certificate, std::slice::from_ref(&record), limits),
1186            Err(DaneError::CertificateLength)
1187        );
1188
1189        let limits = DaneLimits {
1190            max_tlsa_records: 1,
1191            ..DaneLimits::default()
1192        };
1193        assert_eq!(
1194            verify_dane_ee(&certificate, &[record.clone(), record], limits),
1195            Err(DaneError::TooManyTlsaRecords)
1196        );
1197    }
1198
1199    #[test]
1200    fn rejects_truncated_and_non_minimal_der_lengths() {
1201        let certificate = certificate();
1202        for malformed in [
1203            certificate[..certificate.len() - 1].to_vec(),
1204            vec![0x30, 0x81, 0x01, 0x00],
1205            vec![0x30, 0x80, 0x00, 0x00],
1206        ] {
1207            assert_eq!(
1208                extract_subject_public_key_info(&malformed),
1209                Err(DaneError::MalformedCertificate)
1210            );
1211        }
1212    }
1213}