1#![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
24pub const DEFAULT_MAX_CERTIFICATE_LEN: usize = 256 * 1024;
26pub const DEFAULT_MAX_SPKI_LEN: usize = 64 * 1024;
28pub const MAX_TLSA_ASSOCIATION_LEN: usize = 65_532;
30
31#[derive(Clone, Copy, Debug, Eq, PartialEq)]
33pub struct DaneLimits {
34 pub max_certificate_len: usize,
36 pub max_spki_len: usize,
38 pub max_tlsa_records: usize,
40 pub max_association_len: usize,
42 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#[repr(u8)]
60#[derive(Clone, Copy, Debug, Eq, PartialEq)]
61pub enum CertificateUsage {
62 DaneTa = 2,
65 DaneEe = 3,
67}
68
69#[repr(u8)]
71#[derive(Clone, Copy, Debug, Eq, PartialEq)]
72pub enum Selector {
73 FullCertificate = 0,
75 SubjectPublicKeyInfo = 1,
77}
78
79#[repr(u8)]
81#[derive(Clone, Copy, Debug, Eq, PartialEq)]
82pub enum MatchingType {
83 Exact = 0,
85 Sha256 = 1,
87 Sha512 = 2,
89}
90
91#[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 #[must_use]
103 pub const fn record_index(self) -> usize {
104 self.record_index
105 }
106
107 #[must_use]
109 pub const fn usage(self) -> CertificateUsage {
110 self.usage
111 }
112
113 #[must_use]
115 pub const fn selector(self) -> Selector {
116 self.selector
117 }
118
119 #[must_use]
121 pub const fn matching_type(self) -> MatchingType {
122 self.matching_type
123 }
124}
125
126#[derive(Clone, Debug, Eq, PartialEq)]
128#[non_exhaustive]
129pub enum DaneError {
130 MissingTlsa,
132 TooManyTlsaRecords,
134 CertificateLength,
136 MalformedCertificate,
138 SpkiLength,
140 UnsupportedUsage(u8),
142 UnsupportedSelector(u8),
144 UnsupportedMatchingType(u8),
146 InvalidAssociationLength,
148 Mismatch,
150 ChainLength,
152 ChainValidation,
154 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
190pub 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
239pub 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 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
382pub 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(¶meters)?;
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}